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)); } }
internal static Type GetContractTypeFromImport(this IAttributedImport import, ImportType importType) { if (import.ContractType != null) { return(import.ContractType); } return(importType.ContractType); }
internal static Type GetContractTypeFromImport(this IAttributedImport import, ImportType importType) { if (import.ContractType != null) { return(import.ContractType.AdjustSpecifiedTypeIdentityType(importType.ContractType)); } return(importType.ContractType); }
internal static string GetContractNameFromImport(this IAttributedImport import, ImportType importType) { if (!string.IsNullOrEmpty(import.ContractName)) { return(import.ContractName); } Type contractType = import.GetContractTypeFromImport(importType); return(AttributedModelServices.GetContractName(contractType)); }
public static ImportDefinition CreateMemberImport(MemberInfo member, ICompositionElement origin) { IAttributedImport attributedImport = ReflectionPartCreation.GetAttributedImport((ICustomAttributeProvider)member); if (string.IsNullOrEmpty(attributedImport.ContractName)) { return(new ImportDefinition(member.Name, member.GetDefaultTypeFromMember())); } return(new ContractBasedImportDefinition(member.Name, member.GetDefaultTypeFromMember(), attributedImport.ContractName)); }
internal static string GetTypeIdentityFromImport(this IAttributedImport import, ImportType importType) { Type contractType = import.GetContractTypeFromImport(importType); // For our importers we treat object as not having a type identity if (contractType == CompositionServices.ObjectType) { return(null); } return(AttributedModelServices.GetTypeIdentity(contractType)); }
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 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 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)); } }
internal static Type GetContractTypeFromImport(this IAttributedImport import, ImportType importType) { if (import.ContractType != null) { return(import.ContractType); } Type contractType = importType.Type; if (importType.IsLazy) { contractType = importType.LazyType.ElementType; } else if (importType.ElementType != null) { contractType = importType.ElementType; } return(contractType); }
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); }
internal static IDictionary <string, object> GetImportMetadata(Type type, IAttributedImport attributedImport) { Dictionary <string, object> metadata = null; //Prior to V4.5 MEF did not support ImportMetadata if (type.IsGenericType) { metadata = new Dictionary <string, object>(); if (type.ContainsGenericParameters) { metadata[CompositionConstants.GenericImportParametersOrderMetadataName] = GenericServices.GetGenericParametersOrder(type); } else { metadata[CompositionConstants.GenericContractMetadataName] = ContractNameServices.GetTypeIdentity(type.GetGenericTypeDefinition()); metadata[CompositionConstants.GenericParametersMetadataName] = type.GetGenericArguments(); } } // Default value is ImportSource.Any if (attributedImport != null && attributedImport.Source != ImportSource.Any) { if (metadata == null) { metadata = new Dictionary <string, object>(); } metadata[CompositionConstants.ImportSourceMetadataName] = attributedImport.Source; } if (metadata != null) { return(metadata.AsReadOnly()); } else { return(MetadataServices.EmptyMetadata); } }
internal static IDictionary <string, object?> GetImportMetadata(ImportType importType, IAttributedImport attributedImport) { return(GetImportMetadata(importType.ContractType, attributedImport)); }