public static ReflectionMemberImportDefinition CreateMemberImportDefinition(MemberInfo member, ICompositionElement origin) { Requires.NotNull(member, "member"); ReflectionWritableMember reflectionMember = member.ToReflectionWritableMember(); IAttributedImport attributedImport = AttributedModelDiscovery.GetAttributedImport(reflectionMember, member); ImportType importType = new ImportType(reflectionMember.ReturnType, attributedImport.Cardinality); if (importType.IsPartCreator) { return(new PartCreatorMemberImportDefinition( new LazyMemberInfo(member), origin, new ContractBasedImportDefinition( attributedImport.GetContractNameFromImport(importType), attributedImport.GetTypeIdentityFromImport(importType), CompositionServices.GetRequiredMetadata(importType.MetadataViewType), attributedImport.Cardinality, attributedImport.AllowRecomposition, false, CreationPolicy.NonShared))); } else { return(new ReflectionMemberImportDefinition( new LazyMemberInfo(member), attributedImport.GetContractNameFromImport(importType), attributedImport.GetTypeIdentityFromImport(importType), CompositionServices.GetRequiredMetadata(importType.MetadataViewType), attributedImport.Cardinality, attributedImport.AllowRecomposition, attributedImport.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, 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)); } }
private ReflectionComposablePartDefinition CreateDefinition(Type type) { var definition = AttributedModelDiscovery.CreatePartDefinition(type, null, false, ElementFactory.Create()); Assert.Equal(type, definition.GetPartType()); return(definition); }
public static ReflectionComposablePart CreatePart(object attributedPart) { Assumes.NotNull(attributedPart); // If given an instance then we want to pass the default composition options because we treat it as a shared part ReflectionComposablePartDefinition definition = AttributedModelDiscovery.CreatePartDefinition(attributedPart.GetType(), PartCreationPolicyAttribute.Shared, true, (ICompositionElement)null); return(new ReflectionComposablePart(definition, attributedPart)); }
public static ReflectionComposablePart CreatePart(object attributedPart) { Assumes.NotNull(attributedPart); // If given an instance then we want to pass the default composition options because we treat it as a shared part // TODO: ICompositionElement Give this def an origin indicating that it was added directly to the MutableExportProvider. ReflectionComposablePartDefinition definition = AttributedModelDiscovery.CreatePartDefinition(attributedPart.GetType(), PartCreationPolicyAttribute.Shared, true, (ICompositionElement)null); return(new ReflectionComposablePart(definition, attributedPart)); }
public static ReflectionMemberImportDefinition CreateMemberImportDefinition(MemberInfo member, ICompositionElement origin) { Requires.NotNull(member, "member"); ReflectionWritableMember reflectionMember = member.ToReflectionWritableMember(); IAttributedImport attributedImport = AttributedModelDiscovery.GetAttributedImport(reflectionMember, member); ImportType importType = new ImportType(reflectionMember.ReturnType, attributedImport.Cardinality); if (importType.IsPartCreator) { return(new PartCreatorMemberImportDefinition( new LazyMemberInfo(member), origin, new ContractBasedImportDefinition( attributedImport.GetContractNameFromImport(importType), attributedImport.GetTypeIdentityFromImport(importType), CompositionServices.GetRequiredMetadata(importType.MetadataViewType), attributedImport.Cardinality, attributedImport.AllowRecomposition, false, (attributedImport.RequiredCreationPolicy != CreationPolicy.NewScope) ? CreationPolicy.NonShared : CreationPolicy.NewScope, CompositionServices.GetImportMetadata(importType, attributedImport)))); } else { // A Standard parameter 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); } //Does this Import re-export the value if so, make it a rpe-requisite bool isPrerequisite = member.GetAttributes <ExportAttribute>().Length > 0; return(new ReflectionMemberImportDefinition( new LazyMemberInfo(member), attributedImport.GetContractNameFromImport(importType), attributedImport.GetTypeIdentityFromImport(importType), CompositionServices.GetRequiredMetadata(importType.MetadataViewType), attributedImport.Cardinality, attributedImport.AllowRecomposition, isPrerequisite, attributedImport.RequiredCreationPolicy, CompositionServices.GetImportMetadata(importType, attributedImport), origin)); } }
public static ReflectionComposablePart CreatePart(object attributedPart, ReflectionContext reflectionContext) { Assumes.NotNull(attributedPart); Assumes.NotNull(reflectionContext); // If given an instance then we want to pass the default composition options because we treat it as a shared part var mappedType = reflectionContext.MapType(IntrospectionExtensions.GetTypeInfo(attributedPart.GetType())); if (mappedType.Assembly.ReflectionOnly) { throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, SR.Argument_ReflectionContextReturnsReflectionOnlyType, nameof(reflectionContext)), nameof(reflectionContext)); } ReflectionComposablePartDefinition definition = AttributedModelDiscovery.CreatePartDefinition(mappedType, PartCreationPolicyAttribute.Shared, true, (ICompositionElement)null); return(CreatePart(definition, attributedPart)); }
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 static ReflectionMemberImportDefinition CreateMemberImportDefinition(MemberInfo member, ICompositionElement origin) { Requires.NotNull(member, "member"); ReflectionWritableMember reflectionMember = member.ToReflectionWritableMember(); AttributedImportDefinitionCreationInfo importCreationInfo = AttributedModelDiscovery.GetImportDefinitionCreationInfo(reflectionMember, member); return(new ReflectionMemberImportDefinition( new LazyMemberInfo(member), importCreationInfo.ContractName, importCreationInfo.RequiredTypeIdentity, importCreationInfo.RequiredMetadata, importCreationInfo.Cardinality, importCreationInfo.IsRecomposable, importCreationInfo.RequiredCreationPolicy, origin)); }
public static ReflectionMemberImportDefinition CreateMemberImportDefinition(MemberInfo member, ICompositionElement origin) { Requires.NotNull(member, nameof(member)); ReflectionWritableMember reflectionMember = member.ToReflectionWritableMember(); IAttributedImport attributedImport = AttributedModelDiscovery.GetAttributedImport(reflectionMember, member); ImportType importType = new ImportType(reflectionMember.ReturnType, attributedImport.Cardinality); if (importType.IsPartCreator) { return(new PartCreatorMemberImportDefinition( new LazyMemberInfo(member), origin, new ContractBasedImportDefinition( attributedImport.GetContractNameFromImport(importType), attributedImport.GetTypeIdentityFromImport(importType), CompositionServices.GetRequiredMetadata(importType.MetadataViewType), attributedImport.Cardinality, attributedImport.AllowRecomposition, false, CreationPolicy.NonShared, CompositionServices.GetImportMetadata(importType, attributedImport)))); } else { //Does this Import re-export the value if so, make it a rpe-requisite bool isPrerequisite = member.GetAttributes <ExportAttribute>().Length > 0; return(new ReflectionMemberImportDefinition( new LazyMemberInfo(member), attributedImport.GetContractNameFromImport(importType), attributedImport.GetTypeIdentityFromImport(importType), CompositionServices.GetRequiredMetadata(importType.MetadataViewType), attributedImport.Cardinality, attributedImport.AllowRecomposition, isPrerequisite, attributedImport.RequiredCreationPolicy, CompositionServices.GetImportMetadata(importType, attributedImport), origin)); } }
// // Import definition creation helpers // private static AttributedImportDefinitionCreationInfo GetImportDefinitionCreationInfo(ReflectionItem item, ICustomAttributeProvider attributeProvider) { Assumes.NotNull(item, attributeProvider); AttributedImportDefinitionCreationInfo importCreationInfo = new AttributedImportDefinitionCreationInfo(); IAttributedImport attributedImport = AttributedModelDiscovery.GetAttributedImport(item, attributeProvider); ImportType importType = new ImportType(item.ReturnType, attributedImport.Cardinality); DisplayDebugWarnings(attributedImport.Cardinality, item, importType); importCreationInfo.RequiredMetadata = importType.IsLazy ? CompositionServices.GetRequiredMetadata(importType.LazyType.MetadataViewType) : Enumerable.Empty <string>(); importCreationInfo.Cardinality = attributedImport.Cardinality; importCreationInfo.ContractName = attributedImport.GetContractNameFromImport(importType); importCreationInfo.RequiredTypeIdentity = attributedImport.GetTypeIdentityFromImport(importType); importCreationInfo.IsRecomposable = (item.ItemType == ReflectionItemType.Parameter) ? false : attributedImport.AllowRecomposition; importCreationInfo.RequiredCreationPolicy = attributedImport.RequiredCreationPolicy; return(importCreationInfo); }
private IEnumerable <ImportDefinition> GetImportDefinitions() { List <ImportDefinition> imports = new List <ImportDefinition>(); foreach (MemberInfo member in GetImportMembers(_type)) { ReflectionMemberImportDefinition importDefinition = AttributedModelDiscovery.CreateMemberImportDefinition(member, this); imports.Add(importDefinition); } ConstructorInfo?constructor = GetConstructor(); if (constructor != null) { foreach (ParameterInfo parameter in constructor.GetParameters()) { ReflectionParameterImportDefinition importDefinition = AttributedModelDiscovery.CreateParameterImportDefinition(parameter, this); imports.Add(importDefinition); } } return(imports); }
public void IsDiscoverable() { var expectations = new ExpectationCollection <Type, bool>(); expectations.Add(typeof(ClassWithTwoZeroParameterConstructors), true); expectations.Add(typeof(SimpleConstructorInjectedObject), true); expectations.Add(typeof(StaticExportClass), true); expectations.Add(typeof(PublicComponentWithPublicExports), true); expectations.Add(typeof(ClassWithMultipleMarkedConstructors), true); expectations.Add(typeof(ClassWithNoMarkedOrDefaultConstructor), true); expectations.Add(typeof(ClassWhichOnlyHasDefaultConstructor), false); expectations.Add(typeof(ClassWithOnlyHasImportingConstructorButInherits), true); expectations.Add(typeof(ClassWithOnlyHasMultipleImportingConstructorButInherits), true); foreach (var e in expectations) { var definition = AttributedModelDiscovery.CreatePartDefinitionIfDiscoverable(e.Input, (ICompositionElement)null); bool result = (definition != null); Assert.Equal(e.Output, result); } }