public void Ctor_ThrowsArgumentNull()
{
assert.Throws <ArgumentNullException>(() =>
{
_ = new ReflectionParameter(null);
});
}
public static ReflectionParameterImportDefinition CreateParameterImportDefinition(ParameterInfo parameter, ICompositionElement origin)
{
Requires.NotNull(parameter, "parameter");
ReflectionParameter reflectionParameter = parameter.ToReflectionParameter();
IAttributedImport attributedImport = AttributedModelDiscovery.GetAttributedImport(reflectionParameter, parameter);
ImportType importType = new ImportType(reflectionParameter.ReturnType, attributedImport.Cardinality);
if (importType.IsPartCreator)
{
return(new PartCreatorParameterImportDefinition(
new Lazy <ParameterInfo>(() => parameter),
origin,
new ContractBasedImportDefinition(
attributedImport.GetContractNameFromImport(importType),
attributedImport.GetTypeIdentityFromImport(importType),
CompositionServices.GetRequiredMetadata(importType.MetadataViewType),
attributedImport.Cardinality,
false,
true,
CreationPolicy.NonShared)));
}
else
{
return(new ReflectionParameterImportDefinition(
new Lazy <ParameterInfo>(() => parameter),
attributedImport.GetContractNameFromImport(importType),
attributedImport.GetTypeIdentityFromImport(importType),
CompositionServices.GetRequiredMetadata(importType.MetadataViewType),
attributedImport.Cardinality,
attributedImport.RequiredCreationPolicy,
origin));
}
}
public static void AreSame(ReflectionItem expected, ReflectionItem actual)
{
switch (expected.ItemType)
{
case ReflectionItemType.Property:
{
ReflectionProperty expectedProperty = (ReflectionProperty)expected;
ReflectionProperty actualProperty = (ReflectionProperty)actual;
ReflectionAssert.AreSame(expectedProperty.UnderlyingGetMethod, actualProperty.UnderlyingGetMethod);
ReflectionAssert.AreSame(expectedProperty.UnderlyingSetMethod, actualProperty.UnderlyingSetMethod);
return;
}
case ReflectionItemType.Parameter:
{
ReflectionParameter expectedParameter = (ReflectionParameter)expected;
ReflectionParameter actualParameter = (ReflectionParameter)actual;
ReflectionAssert.AreSame(expectedParameter.UnderlyingParameter, actualParameter.UnderlyingParameter);
return;
}
default:
{
ReflectionMember expectedMember = (ReflectionMember)expected;
ReflectionMember actualMember = (ReflectionMember)actual;
ReflectionAssert.AreSame(expectedMember.UnderlyingMember, actualMember.UnderlyingMember);
return;
}
}
}
public void ReflectionParameterTest()
{
var intPropertyClassInstance = EnvironmentManager.CreateInstanceWithProperty(4);
var intPrivatePropertyClassInstance = EnvironmentManager.CreateInstanceWithPrivateProperty(8);
var intFieldClassInstance = EnvironmentManager.CreateInstanceWithField(6);
var intPrivateFieldClassInstance = EnvironmentManager.CreateInstanceWithPrivateField(7);
var stringPropertyClassInstance = EnvironmentManager.CreateInstanceWithProperty("qwerty1");
var stringPrivatePropertyClassInstance = EnvironmentManager.CreateInstanceWithPrivateProperty("qwerty2");
var stringFieldClassInstance = EnvironmentManager.CreateInstanceWithField("qwerty3");
var stringPrivateFieldClassInstance = EnvironmentManager.CreateInstanceWithPrivateField("qwerty4");
var intParameter = new ReflectionParameter <int>();
var stringParameter = new ReflectionParameter <string>();
intParameter.Target = intPropertyClassInstance;
intParameter.SourceName = nameof(intPropertyClassInstance.Property);
intParameter.GetParamType().Should().BeAssignableTo <int>();
intParameter.GetValue().Should().Be(4);
intParameter.Target = intPrivatePropertyClassInstance;
intParameter.SourceName = nameof(intPropertyClassInstance.Property);
intParameter.GetParamType().Should().BeAssignableTo <int>();
intParameter.GetValue().Should().Be(null);
intParameter.Target = intFieldClassInstance;
intParameter.SourceName = nameof(intFieldClassInstance.Field);
intParameter.GetParamType().Should().BeAssignableTo <int>();
intParameter.GetValue().Should().Be(6);
intParameter.Target = intPrivateFieldClassInstance;
intParameter.SourceName = nameof(intFieldClassInstance.Field);
intParameter.GetParamType().Should().BeAssignableTo <int>();
intParameter.GetValue().Should().Be(7);
stringParameter.Target = stringPropertyClassInstance;
stringParameter.SourceName = nameof(stringPropertyClassInstance.Property);
stringParameter.GetParamType().Should().BeAssignableTo <string>();
stringParameter.GetValue().Should().Be("qwerty1");
stringParameter.Target = stringPrivatePropertyClassInstance;
stringParameter.SourceName = nameof(stringPropertyClassInstance.Property);
stringParameter.GetParamType().Should().BeAssignableTo <string>();
stringParameter.GetValue().Should().Be(null);
stringParameter.Target = stringFieldClassInstance;
stringParameter.SourceName = nameof(stringFieldClassInstance.Field);
stringParameter.GetParamType().Should().BeAssignableTo <string>();
stringParameter.GetValue().Should().Be("qwerty3");
stringParameter.Target = stringPrivateFieldClassInstance;
stringParameter.SourceName = nameof(stringFieldClassInstance.Field);
stringParameter.GetParamType().Should().BeAssignableTo <string>();
stringParameter.GetValue().Should().Be("qwerty4");
}
public void FindAttribute()
{
var first = ReflectData
.GetParameters("GetUser")
.FirstOrDefault();
var reflectionParameter = new ReflectionParameter(first);
var attr = reflectionParameter.FindAttribute <DecoratorAttribute>();
assert.NotNull(attr);
}
public void FindAttributes()
{
var first = ReflectData
.GetParameters("GetUser")
.FirstOrDefault();
var reflectionParameter = new ReflectionParameter(first);
var attrs = reflectionParameter.FindAttributes <DecoratorAttribute>();
assert.NotNull(attrs);
assert.Equal(1, attrs.Count);
}
public static ImportDefinition CreateParameterImport(ParameterInfo parameter, ICompositionElement origin)
{
ReflectionParameter reflectionParameter = new ReflectionParameter(parameter);
IAttributedImport attributedImport = ReflectionPartCreation.GetAttributedImport((ICustomAttributeProvider)parameter);
if (string.IsNullOrEmpty(attributedImport.ContractName))
{
return(new ImportDefinition(parameter.Name, parameter.ParameterType));
}
return(new ContractBasedImportDefinition(parameter.Name, parameter.ParameterType, attributedImport.ContractName));
}
public void Ctor()
{
var first = ReflectData
.GetParameters("GetUser")
.FirstOrDefault();
var reflectionParameter = new ReflectionParameter(first);
assert.Equal(first.Name, reflectionParameter.Name);
assert.Equal(first.ParameterType, reflectionParameter.ClrType);
assert.Equal(first.Position, reflectionParameter.Position);
assert.Equal(first.IsOut, reflectionParameter.IsOut);
assert.Equal(first.IsOptional, reflectionParameter.IsOptional);
assert.Equal(first.DefaultValue, reflectionParameter.DefaultValue);
assert.NotNull(reflectionParameter.Attributes);
}
public static ReflectionParameterImportDefinition CreateParameterImportDefinition(ParameterInfo parameter, ICompositionElement origin)
{
Requires.NotNull(parameter, "parameter");
ReflectionParameter reflectionParameter = parameter.ToReflectionParameter();
AttributedImportDefinitionCreationInfo importCreationInfo = AttributedModelDiscovery.GetImportDefinitionCreationInfo(reflectionParameter, parameter);
return(new ReflectionParameterImportDefinition(
parameter.AsLazy(),
importCreationInfo.ContractName,
importCreationInfo.RequiredTypeIdentity,
importCreationInfo.RequiredMetadata,
importCreationInfo.Cardinality,
importCreationInfo.RequiredCreationPolicy,
origin));
}
public static ReflectionParameterImportDefinition CreateParameterImportDefinition(ParameterInfo parameter, ICompositionElement origin)
{
Requires.NotNull(parameter, "parameter");
ReflectionParameter reflectionParameter = parameter.ToReflectionParameter();
IAttributedImport attributedImport = AttributedModelDiscovery.GetAttributedImport(reflectionParameter, parameter);
ImportType importType = new ImportType(reflectionParameter.ReturnType, attributedImport.Cardinality);
if (importType.IsPartCreator)
{
return(new PartCreatorParameterImportDefinition(
new Lazy <ParameterInfo>(() => parameter),
origin,
new ContractBasedImportDefinition(
attributedImport.GetContractNameFromImport(importType),
attributedImport.GetTypeIdentityFromImport(importType),
CompositionServices.GetRequiredMetadata(importType.MetadataViewType),
attributedImport.Cardinality,
false,
true,
(attributedImport.RequiredCreationPolicy != CreationPolicy.NewScope) ? CreationPolicy.NonShared : CreationPolicy.NewScope,
CompositionServices.GetImportMetadata(importType, attributedImport))));
}
else
{
// A Standard import is not allowed to be marked as requiring NewScope at this time.
if (attributedImport.RequiredCreationPolicy == CreationPolicy.NewScope)
{
throw new ComposablePartException(
String.Format(CultureInfo.CurrentCulture,
Strings.InvalidPartCreationPolicyOnImport,
attributedImport.RequiredCreationPolicy),
origin);
}
return(new ReflectionParameterImportDefinition(
new Lazy <ParameterInfo>(() => parameter),
attributedImport.GetContractNameFromImport(importType),
attributedImport.GetTypeIdentityFromImport(importType),
CompositionServices.GetRequiredMetadata(importType.MetadataViewType),
attributedImport.Cardinality,
attributedImport.RequiredCreationPolicy,
CompositionServices.GetImportMetadata(importType, attributedImport),
origin));
}
}
public CommonParameter(MonoCecilParameter monoCecilParameter, ReflectionParameter reflectionParameter)
{
MonoCecilParameter = monoCecilParameter;
ReflectionParameter = reflectionParameter;
}
public override IEnumerable <T> GetCustomAttributes <T>()
{
return(ReflectionParameter.GetCustomAttributes <T>());
}
