public ImportDefinition(Type contractType, ImportCardinality cardinality, Action<Export[], object> action, Func<Export, bool> constraint)
{
ContractType = contractType;
Cardinality = cardinality;
_action = action;
_constraint = constraint;
}
public ImportDefinition(Expression<Func<ExportDefinition, bool>> constraint, string contractName, ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite)
: this(contractName, cardinality, isRecomposable, isPrerequisite)
{
Requires.NotNull(constraint, "constraint");
this._constraint = constraint;
}
public ImportDefinition AddImport(string contractName, ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite)
{
var import = ImportDefinitionFactory.CreateDefault(contractName, cardinality, isRecomposable, isPrerequisite);
this.AddImport(import);
return import;
}
public DerivedImportDefinition(Expression<Func<ExportDefinition, bool>> constraint, ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite)
{
_constraint = constraint ?? (export => false);
_cardinality = cardinality;
_isRecomposable = isRecomposable;
_isPrerequisite = isPrerequisite;
}
public DerivedContractBasedImportDefinition(string contractName, IEnumerable<KeyValuePair<string, Type>> requiredMetadata, ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite)
{
_contractName = contractName;
_cardinality = cardinality;
_isRecomposable = isRecomposable;
_isPrerequisite = isPrerequisite;
_requiredMetadata = requiredMetadata;
}
public IronPythonImportDefinition(string methodName, Type type, string cardinality, bool isRecomposable, bool isPrerequisite)
{
MethodName = methodName;
Type = type;
_cardinality = Cardinality;
if (!Enum.TryParse(cardinality, true, out _cardinality))
throw new InvalidOperationException("Cardinality not convertable : {0}");
IsRecomposable = isRecomposable;
IsPrerequisite = isPrerequisite;
}
public IronPythonContractBasedImportDefinition(string methodName, string contractName,
string requiredTypeIdentity,
IEnumerable<KeyValuePair<string, Type>> requiredMetadata,
ImportCardinality cardinality, bool isRecomposable,
bool isPrerequisite, CreationPolicy requiredCreationPolicy)
: base(contractName, requiredTypeIdentity, requiredMetadata, cardinality, isRecomposable, isPrerequisite,
requiredCreationPolicy)
{
MethodName = methodName;
}
public static ContractBasedImportDefinition CreateImportDefinition(
Lazy<ParameterInfo> parameter,
string contractName,
string requiredTypeIdentity,
IEnumerable<KeyValuePair<string, Type>> requiredMetadata,
ImportCardinality cardinality,
CreationPolicy requiredCreationPolicy,
bool isExportFactory,
ICompositionElement origin)
{
return ReflectionModelServices.CreateImportDefinition(parameter, contractName, requiredTypeIdentity, requiredMetadata, cardinality, requiredCreationPolicy, isExportFactory, origin);
}
public static ContractBasedImportDefinition CreateImportDefinition(
LazyMemberInfo importingMember,
string contractName,
string requiredTypeIdentity,
IEnumerable<KeyValuePair<string, Type>> requiredMetadata,
ImportCardinality cardinality,
bool isRecomposable,
CreationPolicy requiredCreationPolicy,
ICompositionElement origin)
{
return CreateImportDefinition(importingMember, contractName, requiredTypeIdentity, requiredMetadata, cardinality, isRecomposable, requiredCreationPolicy, false, origin);
}
public ReflectionImportDefinition(
string contractName,
string requiredTypeIdentity,
IEnumerable<KeyValuePair<string, Type>> requiredMetadata,
ImportCardinality cardinality,
bool isRecomposable,
bool isPrerequisite,
CreationPolicy requiredCreationPolicy,
ICompositionElement origin)
: base(contractName, requiredTypeIdentity, requiredMetadata, cardinality, isRecomposable, isPrerequisite, requiredCreationPolicy)
{
this._origin = origin;
}
public ReflectionParameterImportDefinition(
Lazy<ParameterInfo> importingLazyParameter,
string contractName,
string requiredTypeIdentity,
IEnumerable<KeyValuePair<string,Type>> requiredMetadata,
ImportCardinality cardinality,
CreationPolicy requiredCreationPolicy,
ICompositionElement origin)
: base(contractName, requiredTypeIdentity, requiredMetadata, cardinality, false, true, requiredCreationPolicy, origin)
{
Assumes.NotNull(importingLazyParameter);
this._importingLazyParameter = importingLazyParameter;
}
public ImportType(Type type, ImportCardinality cardinality)
{
Assumes.NotNull(type);
this._type = type;
this._isAssignableCollectionType = IsTypeAssignableCollectionType(type);
if (cardinality == ImportCardinality.ZeroOrMore)
{
this._elementType = CollectionServices.GetEnumerableElementType(type);
}
this._lazyType = CreateLazyType(this._elementType ?? this._type);
}
public ImportType(Type type, ImportCardinality cardinality)
{
Assumes.NotNull(type);
this._type = type;
this._contractType = type;
if (cardinality == ImportCardinality.ZeroOrMore)
{
this._isAssignableCollectionType = IsTypeAssignableCollectionType(type);
this._contractType = CheckForCollection(type);
}
this._contractType = CheckForLazyAndPartCreator(this._contractType);
}
public ReflectionMemberImportDefinition(
LazyMemberInfo importingLazyMember,
string contractName,
string requiredTypeIdentity,
IEnumerable<string> requiredMetadata,
ImportCardinality cardinality,
bool isRecomposable,
CreationPolicy requiredCreationPolicy,
ICompositionElement origin)
: base(contractName, requiredTypeIdentity, requiredMetadata, cardinality, isRecomposable, false, requiredCreationPolicy, origin)
{
Assumes.NotNull(contractName);
this._importingLazyMember = importingLazyMember;
}
internal ImportDefinition(string contractName, ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite)
{
if (
(cardinality != ImportCardinality.ExactlyOne) &&
(cardinality != ImportCardinality.ZeroOrMore) &&
(cardinality != ImportCardinality.ZeroOrOne)
)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Strings.ArgumentOutOfRange_InvalidEnum, "cardinality", cardinality, typeof(ImportCardinality).Name), "cardinality");
}
this._contractName = contractName ?? EmptyContractName;
this._cardinality = cardinality;
this._isRecomposable = isRecomposable;
this._isPrerequisite = isPrerequisite;
}
public ReflectionMemberImportDefinition(
LazyMemberInfo importingLazyMember,
string contractName,
string requiredTypeIdentity,
IEnumerable<KeyValuePair<string, Type>> requiredMetadata,
ImportCardinality cardinality,
bool isRecomposable,
bool isPrerequisite,
CreationPolicy requiredCreationPolicy,
IDictionary<string, object> metadata,
ICompositionElement origin)
: base(contractName, requiredTypeIdentity, requiredMetadata, cardinality, isRecomposable, isPrerequisite, requiredCreationPolicy, metadata, origin)
{
Assumes.NotNull(contractName);
this._importingLazyMember = importingLazyMember;
}
public MetadataContractBasedImportDefinition(Type contractType,
string requiredTypeIdentity,
IEnumerable<Tuple<string, object, IEqualityComparer>> requiredMetadata,
ImportCardinality cardinality,
bool isRecomposable,
bool isPrerequisite,
CreationPolicy requiredCreationPolicy)
: base(AttributedModelServices.GetContractName(contractType),
requiredTypeIdentity,
requiredMetadata.Select(t => new KeyValuePair<string, Type>(t.Item1, t.Item2.GetType())),
cardinality,
isRecomposable,
isPrerequisite,
requiredCreationPolicy)
{
this.RequiredMetadataValues = requiredMetadata.ToArray();
}
public static ContractBasedImportDefinition CreateImportDefinition(
LazyMemberInfo importingMember,
string contractName,
string requiredTypeIdentity,
IEnumerable<KeyValuePair<string, Type>> requiredMetadata,
ImportCardinality cardinality,
bool isRecomposable,
CreationPolicy requiredCreationPolicy,
bool isPartCreator,
ICompositionElement origin)
{
Requires.NotNullOrEmpty(contractName, "contractName");
Requires.NullOrNotNullElements(requiredMetadata, "requiredMetadata");
Requires.IsInMembertypeSet(importingMember.MemberType, "importingMember", MemberTypes.Property | MemberTypes.Field);
if (isPartCreator)
{
#if SILVERLIGHT
return new PartCreatorMemberImportDefinition(
importingMember,
origin,
new ContractBasedImportDefinition(
contractName,
requiredTypeIdentity,
requiredMetadata,
cardinality,
isRecomposable,
false,
CreationPolicy.NonShared));
#else
throw new ArgumentException("PartCreator is only support in Silverlight version of MEF", "isPartCreator");
#endif
}
else
{
return new ReflectionMemberImportDefinition(
importingMember,
contractName,
requiredTypeIdentity,
requiredMetadata,
cardinality,
isRecomposable,
requiredCreationPolicy,
origin);
}
}
public ImportingComposablePart(string exportContractName, ImportCardinality cardinality, bool isRecomposable, params string[] contractNames)
{
if (exportContractName != null)
{
var definition = ExportDefinitionFactory.Create(exportContractName);
_exportDefinitions.Add(definition);
}
foreach (string contractName in contractNames)
{
var definition = ImportDefinitionFactory.Create(contractName,
cardinality,
isRecomposable,
false);
_importDefinitions.Add(definition);
}
}
public static ContractBasedImportDefinition CreateImportDefinition(
Lazy<ParameterInfo> parameter,
string contractName,
string requiredTypeIdentity,
IEnumerable<string> requiredMetadata,
ImportCardinality cardinality,
CreationPolicy requiredCreationPolicy,
ICompositionElement origin)
{
Requires.NotNull(parameter, "parameter");
Requires.NotNullOrEmpty(contractName, "contractName");
Requires.NotNullOrNullElements(requiredMetadata, "requiredMetadata");
return new ReflectionParameterImportDefinition(
parameter,
contractName,
requiredTypeIdentity,
requiredMetadata,
cardinality,
requiredCreationPolicy,
origin);
}
/// <summary>
/// Initializes a new instance of the <see cref="PropertyBasedImportDefinition"/> class.
/// </summary>
/// <param name="contractName">The contract name that is used to identify the current import.</param>
/// <param name="requiredTypeIdentity">The type identity of the export type expected.</param>
/// <param name="cardinality">
/// One of the enumeration values that indicates the cardinality of the export object required by the import definition.
/// </param>
/// <param name="isRecomposable">
/// <see langword="true" /> to specify that the import definition can be satisfied multiple times throughout the lifetime of a parts;
/// otherwise, <see langword="false" />.
/// </param>
/// <param name="creationPolicy">
/// A value that indicates that the importer requires a specific creation policy for the exports used to satisfy this import.
/// </param>
/// <param name="declaringType">The type that defines the property.</param>
/// <param name="property">The property for which the current object stores the serialized data.</param>
private PropertyBasedImportDefinition(
string contractName,
TypeIdentity requiredTypeIdentity,
ImportCardinality cardinality,
bool isRecomposable,
CreationPolicy creationPolicy,
TypeIdentity declaringType,
PropertyDefinition property)
: base(contractName,
requiredTypeIdentity,
cardinality,
isRecomposable,
false,
creationPolicy,
declaringType)
{
{
Lokad.Enforce.Argument(() => property);
}
m_Property = property;
}
/// <summary>
/// Initializes a new instance of the <see cref="ConstructorBasedImportDefinition"/> class.
/// </summary>
/// <param name="contractName">The contract name that is used to identify the current import.</param>
/// <param name="requiredTypeIdentity">The type identity of the export type expected.</param>
/// <param name="cardinality">
/// One of the enumeration values that indicates the cardinality of the export object required by the import definition.
/// </param>
/// <param name="creationPolicy">
/// A value that indicates that the importer requires a specific creation policy for the exports used to satisfy this import.
/// </param>
/// <param name="declaringType">The type that declares the constructor on which the import is placed.</param>
/// <param name="constructor">The constructor that declares the import.</param>
/// <param name="parameter">The parameter on which the import is defined.</param>
private ConstructorBasedImportDefinition(
string contractName,
TypeIdentity requiredTypeIdentity,
ImportCardinality cardinality,
CreationPolicy creationPolicy,
TypeIdentity declaringType,
ConstructorDefinition constructor,
ParameterDefinition parameter)
: base(contractName,
requiredTypeIdentity,
cardinality,
false,
true,
creationPolicy,
declaringType)
{
{
Lokad.Enforce.Argument(() => parameter);
}
m_Constructor = constructor;
m_Parameter = parameter;
}
public static ContractBasedImportDefinition CreateImportDefinition(
LazyMemberInfo importingMember,
string contractName,
string requiredTypeIdentity,
IEnumerable<string> requiredMetadata,
ImportCardinality cardinality,
bool isRecomposable,
CreationPolicy requiredCreationPolicy,
ICompositionElement origin)
{
Requires.NotNullOrEmpty(contractName, "contractName");
Requires.NotNullOrNullElements(requiredMetadata, "requiredMetadata");
Requires.IsInMembertypeSet(importingMember.MemberType, "importingMember", MemberTypes.Property | MemberTypes.Field);
return new ReflectionMemberImportDefinition(
importingMember,
contractName,
requiredTypeIdentity,
requiredMetadata,
cardinality,
isRecomposable,
requiredCreationPolicy,
origin);
}
/// <summary>
/// Determines whether the specified part imports the specified contract with the given cardinality.
/// </summary>
/// <param name="part">The part.</param>
/// <typeparam name="T">Type of the contract.</typeparam>
/// <param name="importCardinality">The import cardinality.</param>
/// <returns>
/// <c>true</c> if the specified part imports the specified contract with the given cardinality; otherwise, <c>false</c>.
/// </returns>
public static bool Imports <T>(this ComposablePartDefinition part, ImportCardinality importCardinality)
{
Requires.NotNull(part, nameof(part));
return(part.Imports(typeof(T), importCardinality));
}
private static void AddContractMetadata(Dictionary <string, ContractMetadata> contracts, string name, ProjectSystemContractScope scope, ProjectSystemContractProvider provider, ImportCardinality cardinality)
{
Requires.NotNull(contracts, nameof(contracts));
Requires.NotNullOrEmpty(name, nameof(name));
if (!contracts.TryGetValue(name, out ContractMetadata metadata))
{
metadata = new ContractMetadata
{
Provider = provider,
Scope = scope,
Cardinality = cardinality
};
contracts.Add(name, metadata);
}
else
{
// We don't support using the contract name with different interfaces, so we don't verify those contracts.
if (metadata.Scope != scope)
{
metadata.Scope = null;
}
if (metadata.Provider != provider)
{
metadata.Provider = null;
}
if (metadata.Cardinality != cardinality)
{
metadata.Cardinality = null;
}
}
}
private static Action <Export[], object> EagerSetterFor(Type elementType, Action <object, object> setter, ImportCardinality cardinality)
{
if (cardinality == ImportCardinality.Many)
{
return((exports, part) => setter(part, ArrayOf(elementType, exports.Select(e => e.Value))));
}
return((exports, part) => setter(part, exports.Single().Value));
}
public static ImportDefinition Create(string contractName, ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite)
{
return(Create(contractName, (IEnumerable <KeyValuePair <string, Type> >)null, cardinality, isRecomposable, isPrerequisite));
}
public static ImportDefinition Create(string contractName, IEnumerable <KeyValuePair <string, Type> > requiredMetadata, ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite)
{
return(new DerivedContractBasedImportDefinition(contractName, requiredMetadata, cardinality, isRecomposable, isPrerequisite));
}
public ImportDefinition(Expression <Func <ExportDefinition, bool> > constraint, string?contractName, ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite, IDictionary <string, object?>?metadata)
: this(contractName, cardinality, isRecomposable, isPrerequisite, metadata)
{
Requires.NotNull(constraint, nameof(constraint));
_constraint = constraint;
}
public static ImportDefinition Create(string contractName, IEnumerable<KeyValuePair<string, Type>> requiredMetadata, ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite)
{
return new DerivedContractBasedImportDefinition(contractName, requiredMetadata, cardinality, isRecomposable, isPrerequisite);
}
private static ExportCardinalityCheckResult MatchCardinality(EnumerableCardinality actualCardinality, ImportCardinality importCardinality)
{
switch (actualCardinality)
{
case EnumerableCardinality.Zero:
if (importCardinality == ImportCardinality.ExactlyOne)
{
return(ExportCardinalityCheckResult.NoExports);
}
break;
case EnumerableCardinality.TwoOrMore:
if (importCardinality.IsAtMostOne())
{
return(ExportCardinalityCheckResult.TooManyExports);
}
break;
default:
if (actualCardinality != EnumerableCardinality.One)
{
throw new Exception(SR.Diagnostic_InternalExceptionMessage);
}
break;
}
return(ExportCardinalityCheckResult.Match);
}
public RuntimeImport(ParameterRef importingParameterRef, TypeRef importingSiteTypeRef, TypeRef importingSiteTypeWithoutCollectionRef, ImportCardinality cardinality, IReadOnlyList <RuntimeExport> satisfyingExports, bool isNonSharedInstanceRequired, bool isExportFactory, IReadOnlyDictionary <string, object> metadata, IReadOnlyCollection <string> exportFactorySharingBoundaries)
: this(importingSiteTypeRef, importingSiteTypeWithoutCollectionRef, cardinality, satisfyingExports, isNonSharedInstanceRequired, isExportFactory, metadata, exportFactorySharingBoundaries)
{
this.ImportingParameterRef = importingParameterRef;
}
private RuntimeImport(TypeRef importingSiteTypeRef, TypeRef importingSiteTypeWithoutCollectionRef, ImportCardinality cardinality, IReadOnlyList <RuntimeExport> satisfyingExports, bool isNonSharedInstanceRequired, bool isExportFactory, IReadOnlyDictionary <string, object> metadata, IReadOnlyCollection <string> exportFactorySharingBoundaries)
{
Requires.NotNull(importingSiteTypeRef, nameof(importingSiteTypeRef));
Requires.NotNull(importingSiteTypeWithoutCollectionRef, nameof(importingSiteTypeWithoutCollectionRef));
Requires.NotNull(satisfyingExports, nameof(satisfyingExports));
this.Cardinality = cardinality;
this.SatisfyingExports = satisfyingExports;
this.IsNonSharedInstanceRequired = isNonSharedInstanceRequired;
this.IsExportFactory = isExportFactory;
this.Metadata = metadata;
this.ImportingSiteTypeRef = importingSiteTypeRef;
this.ImportingSiteTypeWithoutCollectionRef = importingSiteTypeWithoutCollectionRef;
this.ExportFactorySharingBoundaries = exportFactorySharingBoundaries;
}
private static ImportDefinition BuildImportDefinition(Type type, Type metadataViewType, string contractName, ImportCardinality cardinality)
{
Assumes.NotNull(type, metadataViewType, contractName);
IEnumerable <KeyValuePair <string, Type> > requiredMetadata = CompositionServices.GetRequiredMetadata(metadataViewType);
string requiredTypeIdentity = null;
if (type != typeof(object))
{
requiredTypeIdentity = AttributedModelServices.GetTypeIdentity(type);
}
return(new ContractBasedImportDefinition(contractName, requiredTypeIdentity, requiredMetadata, cardinality, false, true, CreationPolicy.Any));
}
public ImportingComposablePart(ImportCardinality cardinality, bool isRecomposable, params string[] contractNames)
: this((string)null, cardinality, isRecomposable, contractNames)
{
}
public static ImportingComposablePart CreateImporter(string contractName, ImportCardinality cardinality, bool isRecomposable)
{
return(new ImportingComposablePart(cardinality, isRecomposable, contractName));
}
public static ImportDefinition Create(string contractName, ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite)
{
return Create(contractName, (IEnumerable<KeyValuePair<string, Type>>)null, cardinality, isRecomposable, isPrerequisite);
}
public static ImportDefinition Create(Expression<Func<ExportDefinition, bool>> constraint, ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite)
{
return new DerivedImportDefinition(constraint, cardinality, isRecomposable, isPrerequisite);
}
public static ImportDefinition Create(Expression <Func <ExportDefinition, bool> > constraint, ImportCardinality cardinality)
{
return(Create(constraint, cardinality, true, false));
}
public static ImportDefinition CreateDefault(string contractName, ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite)
{
return(new ContractBasedImportDefinition(contractName, (string)null, (IEnumerable <KeyValuePair <string, Type> >)null, cardinality, isRecomposable, isPrerequisite, CreationPolicy.Any));
}
public static ImportDefinition Create(string contractName, ImportCardinality cardinality)
{
return(Create(contractName, (IEnumerable <KeyValuePair <string, Type> >)null, cardinality, false, false));
}
/// <summary>
/// Determines whether the specified part imports the specified contract with the given cardinality.
/// </summary>
/// <param name="part">The part.</param>
/// <param name="contractName">Name of the contract.</param>
/// <param name="importCardinality">The import cardinality.</param>
/// <returns>
/// <c>true</c> if the specified part imports the specified contract with the given cardinality; otherwise, <c>false</c>.
/// </returns>
public static bool Imports(this ComposablePartDefinition part, string contractName, ImportCardinality importCardinality)
{
Requires.NotNull(part, nameof(part));
Requires.NotNull(contractName, nameof(contractName));
foreach (ImportDefinition import in part.ImportDefinitions)
{
if (StringComparers.ContractName.Equals(contractName, import.ContractName) && (import.Cardinality == importCardinality))
{
return(true);
}
}
return(false);
}
public static ImportDefinition Create(Type contractType, ImportCardinality cardinality)
{
return(Create(AttributedModelServices.GetContractName(contractType), cardinality));
}
public DerivedImportDefinition(Expression <Func <ExportDefinition, bool> > constraint, ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite)
{
_constraint = constraint ?? (export => false);
_cardinality = cardinality;
_isRecomposable = isRecomposable;
_isPrerequisite = isPrerequisite;
}
private static Action <Export[], object> LazySetterFor(Type elementType, Action <object, object> setter, ImportCardinality cardinality, Type metadataType)
{
if (cardinality == ImportCardinality.Many)
{
return((exports, part) => setter(part, ArrayOf(elementType, exports.Select(e => LazyInstanceFor(elementType, metadataType, e)))));
}
return((exports, part) => setter(part, LazyInstanceFor(elementType, metadataType, exports.Single())));
}
public ImportDefinitionImpl(Expression <Func <ExportDefinition, bool> > constraint, string contractName, ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite, IDictionary <string, object> metadata)
: base(constraint, contractName, cardinality, isRecomposable, isPrerequisite, metadata)
{
}
public ImportDefinition(Expression <Func <ExportDefinition, bool> > constraint, string contractName, ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite)
: this(contractName, cardinality, isRecomposable, isPrerequisite)
{
Requires.NotNull(constraint, "constraint");
this._constraint = constraint;
}
public ContractBasedImportDefinition(string contractName, string requiredTypeIdentity, IEnumerable <KeyValuePair <string, Type> > requiredMetadata,
ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite, CreationPolicy requiredCreationPolicy)
: this(contractName, requiredTypeIdentity, requiredMetadata, cardinality, isRecomposable, isPrerequisite, requiredCreationPolicy, MetadataServices.EmptyMetadata)
{
}
/// <summary>
/// Determines whether the specified part imports the specified contract with the given cardinality.
/// </summary>
/// <param name="part">The part.</param>
/// <param name="contractType">Type of the contract.</param>
/// <param name="importCardinality">The import cardinality.</param>
/// <returns>
/// <c>true</c> if the specified part imports the specified contract with the given cardinality; otherwise, <c>false</c>.
/// </returns>
public static bool Imports(this ComposablePartDefinition part, Type contractType, ImportCardinality importCardinality)
{
Requires.NotNull(part, nameof(part));
Requires.NotNull(contractType, nameof(contractType));
return(part.Imports(AttributedModelServices.GetContractName(contractType), importCardinality));
}
/// <summary>
/// Returns a value indicating whether cardinality is
/// <see cref="ImportCardinality.ZeroOrOne"/> or
/// <see cref="ImportCardinality.ExactlyOne"/>.
/// </summary>
internal static bool IsAtMostOne(this ImportCardinality cardinality)
{
return(cardinality == ImportCardinality.ZeroOrOne || cardinality == ImportCardinality.ExactlyOne);
}
private HTMLImportDefinition(string toString, Expression <Func <ExportDefinition, bool> > constraint, string contractName, ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite) : base(constraint, contractName, cardinality, isRecomposable, isPrerequisite)
{
this.toString = toString;
}
public static ImportingComposablePart CreateImporter(string contractName, ImportCardinality cardinality)
{
return(CreateImporter(contractName, cardinality, false));
}
/// <summary>
/// Initializes a new instance of the <see cref="ContractBasedImportDefinition"/> class
/// with the specified contract name, required metadataq, cardinality, value indicating
/// if the import definition is recomposable and a value indicating if the import definition
/// is a prerequisite.
/// </summary>
/// <param name="contractName">
/// A <see cref="String"/> containing the contract name of the
/// <see cref="Export"/> required by the <see cref="ContractBasedImportDefinition"/>.
/// </param>
/// <param name="requiredTypeIdentity">
/// The type identity of the export type expected. Use <see cref="AttributedModelServices.GetTypeIdentity(Type)"/>
/// to generate a type identity for a given type. If no specific type is required pass <see langword="null"/>.
/// </param>
/// <param name="requiredMetadata">
/// An <see cref="IEnumerable{T}"/> of <see cref="String"/> objects containing
/// the metadata names of the <see cref="Export"/> required by the
/// <see cref="ContractBasedImportDefinition"/>; or <see langword="null"/> to
/// set the <see cref="RequiredMetadata"/> property to an empty <see cref="IEnumerable{T}"/>.
/// </param>
/// <param name="cardinality">
/// One of the <see cref="ImportCardinality"/> values indicating the
/// cardinality of the <see cref="Export"/> objects required by the
/// <see cref="ContractBasedImportDefinition"/>.
/// </param>
/// <param name="isRecomposable">
/// <see langword="true"/> if the <see cref="ContractBasedImportDefinition"/> can be satisfied
/// multiple times throughout the lifetime of a <see cref="ComposablePart"/>, otherwise,
/// <see langword="false"/>.
/// </param>
/// <param name="isPrerequisite">
/// <see langword="true"/> if the <see cref="ContractBasedImportDefinition"/> is required to be
/// satisfied before a <see cref="ComposablePart"/> can start producing exported
/// objects; otherwise, <see langword="false"/>.
/// </param>
/// <param name="requiredCreationPolicy">
/// A value indicating that the importer requires a specific <see cref="CreationPolicy"/> for
/// the exports used to satisfy this import. If no specific <see cref="CreationPolicy"/> is needed
/// pass the default <see cref="CreationPolicy.Any"/>.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="contractName"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="ArgumentException">
/// <paramref name="contractName"/> is an empty string ("").
/// <para>
/// -or-
/// </para>
/// <paramref name="requiredMetadata"/> contains an element that is <see langword="null"/>.
/// <para>
/// -or-
/// </para>
/// <paramref name="cardinality"/> is not one of the <see cref="ImportCardinality"/>
/// values.
/// </exception>
public ContractBasedImportDefinition(string contractName, string requiredTypeIdentity, IEnumerable<string> requiredMetadata,
ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite, CreationPolicy requiredCreationPolicy)
: base(contractName, cardinality, isRecomposable, isPrerequisite)
{
Requires.NotNullOrEmpty(contractName, "contractName");
Requires.NullOrNotNullElements(requiredMetadata, "requiredMetadata");
this._requiredTypeIdentity = requiredTypeIdentity;
if (requiredMetadata != null)
{
this._requiredMetadata = requiredMetadata;
}
this._requiredCreationPolicy = requiredCreationPolicy;
}
public static ImportDefinition Create(Expression <Func <ExportDefinition, bool> > constraint, ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite)
{
return(new DerivedImportDefinition(constraint, cardinality, isRecomposable, isPrerequisite));
}
public static ImportDefinition Create(string contractName, ImportCardinality cardinality)
{
return Create(contractName, (IEnumerable<KeyValuePair<string, Type>>)null, cardinality, false, false);
}
/// <summary>
/// Initializes a new instance of the <see cref="ImportDefinition"/> class
/// with the specified constraint, cardinality, value indicating if the import
/// definition is recomposable and a value indicating if the import definition
/// is a prerequisite.
/// </summary>
/// <param name="constraint">
/// A <see cref="Expression{TDelegate}"/> containing a <see cref="Func{T, TResult}"/>
/// that defines the conditions that must be matched for the <see cref="ImportDefinition"/>
/// to be satisfied by an <see cref="Export"/>.
/// </param>
/// <param name="contractName">
/// The contract name of the export that this import is interested in. The contract name
/// property is used as guidance and not automatically enforced in the constraint. If
/// the contract name is a required in the constraint then it should be added to the constraint
/// by the caller of this constructor.
/// </param>
/// <param name="cardinality">
/// One of the <see cref="ImportCardinality"/> values indicating the
/// cardinality of the <see cref="Export"/> objects required by the
/// <see cref="ImportDefinition"/>.
/// </param>
/// <param name="isRecomposable">
/// <see langword="true"/> if the <see cref="ImportDefinition"/> can be satisfied
/// multiple times throughout the lifetime of a <see cref="ComposablePart"/>, otherwise,
/// <see langword="false"/>.
/// </param>
/// <param name="isPrerequisite">
/// <see langword="true"/> if the <see cref="ImportDefinition"/> is required to be
/// satisfied before a <see cref="ComposablePart"/> can start producing exported
/// objects; otherwise, <see langword="false"/>.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="constraint"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="ArgumentException">
/// <paramref name="cardinality"/> is not one of the <see cref="ImportCardinality"/>
/// values.
/// </exception>
public ImportDefinition(Expression <Func <ExportDefinition, bool> > constraint, string?contractName, ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite)
: this(contractName, cardinality, isRecomposable, isPrerequisite, MetadataServices.EmptyMetadata)
{
Requires.NotNull(constraint, nameof(constraint));
_constraint = constraint;
}
public static ImportDefinition Create(Expression<Func<ExportDefinition, bool>> constraint, ImportCardinality cardinality)
{
return Create(constraint, cardinality, true, false);
}
private IEnumerable <Export> GetExportsCore(Type type, Type metadataViewType, string contractName, ImportCardinality cardinality)
{
// Only 'type' cannot be null - the other parameters have sensible defaults.
Requires.NotNull(type, nameof(type));
if (string.IsNullOrEmpty(contractName))
{
contractName = AttributedModelServices.GetContractName(type);
}
if (metadataViewType == null)
{
metadataViewType = ExportServices.DefaultMetadataViewType;
}
if (!MetadataViewProvider.IsViewTypeValid(metadataViewType))
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, SR.InvalidMetadataView, metadataViewType.Name));
}
ImportDefinition importDefinition = BuildImportDefinition(type, metadataViewType, contractName, cardinality);
return(GetExports(importDefinition, null));
}
public static ImportDefinition CreateDefault(string contractName, ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite)
{
return new ContractBasedImportDefinition(contractName, (string)null, (IEnumerable<KeyValuePair<string, Type>>)null, cardinality, isRecomposable, isPrerequisite, CreationPolicy.Any);
}
private static ImportDefinition BuildImportDefinition(Type type, Type metadataViewType, string contractName, ImportCardinality cardinality)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (metadataViewType == null)
{
throw new ArgumentNullException(nameof(metadataViewType));
}
if (contractName == null)
{
throw new ArgumentNullException(nameof(contractName));
}
IEnumerable <KeyValuePair <string, Type> > requiredMetadata = CompositionServices.GetRequiredMetadata(metadataViewType);
IDictionary <string, object> metadata = CompositionServices.GetImportMetadata(type, null);
string requiredTypeIdentity = null;
if (type != typeof(object))
{
requiredTypeIdentity = AttributedModelServices.GetTypeIdentity(type);
}
return(new ContractBasedImportDefinition(contractName, requiredTypeIdentity, requiredMetadata, cardinality, false, true, CreationPolicy.Any, metadata));
}
