protected ImportingItem(ContractBasedImportDefinition definition, ImportType importType)
{
ArgumentNullException.ThrowIfNull(definition);
_definition = definition;
_importType = importType;
}
public ImportingMember(ContractBasedImportDefinition definition, ReflectionWritableMember member, ImportType importType)
: base(definition, importType)
{
Assumes.NotNull(definition, member);
this._member = member;
}
protected ImportingItem(ContractBasedImportDefinition definition, ImportType importType)
{
Assumes.NotNull(definition);
this._definition = definition;
this._importType = importType;
}
protected ImportingItem(ContractBasedImportDefinition definition, ImportType importType)
{
Assumes.NotNull(definition);
this._definition = definition;
this._importType = importType;
}
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);
}
}
protected ImportingItem(ContractBasedImportDefinition definition, ImportType importType)
{
if (definition == null)
{
throw new ArgumentNullException(nameof(definition));
}
_definition = definition;
_importType = importType;
}
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();
IAttributedImport attributedImport = AttributedModelDiscovery.GetAttributedImport(reflectionMember, member);
ImportType importType = new ImportType(reflectionMember.ReturnType, attributedImport.Cardinality);
#if SILVERLIGHT
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
#endif
{
return new ReflectionMemberImportDefinition(
new LazyMemberInfo(member),
attributedImport.GetContractNameFromImport(importType),
attributedImport.GetTypeIdentityFromImport(importType),
CompositionServices.GetRequiredMetadata(importType.MetadataViewType),
attributedImport.Cardinality,
attributedImport.AllowRecomposition,
attributedImport.RequiredCreationPolicy,
origin);
}
}
public ImportingParameter(ContractBasedImportDefinition definition, ImportType importType)
: base(definition, importType)
{
}
public ImportingMember(ContractBasedImportDefinition definition, ReflectionWritableMember member, ImportType importType)
: base(definition, importType)
{
Assumes.NotNull(definition, member);
this._member = member;
}
public ImportingParameter(ContractBasedImportDefinition definition, ImportType importType)
: base(definition, importType)
{
}
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 ImportingMember(ContractBasedImportDefinition definition, ReflectionWritableMember member, ImportType importType)
: base(definition, importType)
{
if (member == null)
{
throw new ArgumentNullException(nameof(member));
}
_member = member;
}
//
// 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 static void DisplayDebugWarnings(ImportCardinality cardinality, ReflectionItem item, ImportType importType)
{
if ((importType.ElementType == ExportType) || (importType.Type == ExportType))
{
System.Diagnostics.Debug.WriteLine(string.Format(System.Globalization.CultureInfo.CurrentCulture, "{0} : Imports of type Export are no longer supported", item.GetDisplayName()));
}
// Output a debug warning if someone is using ImportAttribute where it looks like they might want to use ImportMany
if (cardinality != ImportCardinality.ZeroOrMore && CollectionServices.GetEnumerableElementType(importType.Type) != null)
{
System.Diagnostics.Debug.WriteLine("May want to use ImportMany on " + item.GetDisplayName());
}
}
public ImportingMember(ContractBasedImportDefinition definition, ReflectionWritableMember member, ImportType importType)
: base(definition, importType)
{
ArgumentNullException.ThrowIfNull(member);
_member = member;
}
