private static bool ShouldUseSharedPart(CreationPolicy partPolicy, CreationPolicy importPolicy) { // Matrix that details which policy to use for a given part to satisfy a given import. // Part.Any Part.Shared Part.NonShared // Import.Any Shared Shared NonShared // Import.Shared Shared Shared N/A // Import.NonShared NonShared N/A NonShared switch (partPolicy) { case CreationPolicy.Any: { if (importPolicy == CreationPolicy.Any || importPolicy == CreationPolicy.Shared) { return true; } return false; } case CreationPolicy.NonShared: { Assumes.IsTrue(importPolicy != CreationPolicy.Shared); return false; } default: { Assumes.IsTrue(partPolicy == CreationPolicy.Shared); Assumes.IsTrue(importPolicy != CreationPolicy.NonShared); return true; } } }
public static Expression<Func<ExportDefinition, bool>> CreateConstraint(string contractName, string requiredTypeIdentity, IEnumerable<KeyValuePair<string, Type>> requiredMetadata, CreationPolicy requiredCreationPolicy) { ParameterExpression parameter = Expression.Parameter(typeof(ExportDefinition), "exportDefinition"); Expression constraintBody = ConstraintServices.CreateContractConstraintBody(contractName, parameter); if (!string.IsNullOrEmpty(requiredTypeIdentity)) { Expression typeIdentityConstraintBody = ConstraintServices.CreateTypeIdentityContraint(requiredTypeIdentity, parameter); constraintBody = Expression.AndAlso(constraintBody, typeIdentityConstraintBody); } if (requiredMetadata != null) { Expression metadataConstraintBody = ConstraintServices.CreateMetadataConstraintBody(requiredMetadata, parameter); if (metadataConstraintBody != null) { constraintBody = Expression.AndAlso(constraintBody, metadataConstraintBody); } } if (requiredCreationPolicy != CreationPolicy.Any) { Expression policyConstraintBody = ConstraintServices.CreateCreationPolicyContraint(requiredCreationPolicy, parameter); constraintBody = Expression.AndAlso(constraintBody, policyConstraintBody); } Expression<Func<ExportDefinition, bool>> constraint = Expression.Lambda<Func<ExportDefinition, bool>>(constraintBody, parameter); return constraint; }
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 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, ICompositionElement origin) { return(CreateImportDefinition(parameter, contractName, requiredTypeIdentity, requiredMetadata, cardinality, requiredCreationPolicy, MetadataServices.EmptyMetadata, false, origin)); }
public ConstraintInstance( string contractName, string requiredTypeIdentity, IEnumerable<KeyValuePair<string, Type>> requiredMetadata, CreationPolicy requiredCreationPolicy) : this(requiredMetadata) { _contractName = contractName; _requiredTypeIdentity = requiredTypeIdentity; _requiredCreationPolicy = requiredCreationPolicy; }
internal PartBuilder(Predicate <Type> selectType) { SelectType = selectType; _setCreationPolicy = false; _creationPolicy = CreationPolicy.Any; _typeExportBuilders = new List <ExportBuilder>(); _constructorImportBuilders = new List <ImportBuilder>(); _propertyExports = new List <Tuple <Predicate <PropertyInfo>, Action <PropertyInfo, ExportBuilder>, Type> >(); _propertyImports = new List <Tuple <Predicate <PropertyInfo>, Action <PropertyInfo, ImportBuilder>, Type> >(); _interfaceExports = new List <Tuple <Predicate <Type>, Action <Type, ExportBuilder> > >(); }
private bool MatchRequiredMatadata(ExportDefinition definition) { if (!string.IsNullOrEmpty(this.RequiredTypeIdentity)) { string exportTypeIdentity = definition.Metadata.GetValue <string>(CompositionConstants.ExportTypeIdentityMetadataName); if (!StringComparers.ContractName.Equals(this.RequiredTypeIdentity, exportTypeIdentity)) { return(false); } } foreach (KeyValuePair <string, Type> metadataItem in this.RequiredMetadata) { string metadataKey = metadataItem.Key; Type metadataValueType = metadataItem.Value; object metadataValue = null; if (!definition.Metadata.TryGetValue(metadataKey, out metadataValue)) { return(false); } if (metadataValue != null) { // the metadata value is not null, we can rely on IsInstanceOfType to do the right thing if (!metadataValueType.IsInstanceOfType(metadataValue)) { return(false); } } else { // this is an unfortunate special case - typeof(object).IsInstanceofType(null) == false // basically nulls are not considered valid values for anything // We want them to match anything that is a reference type if (metadataValueType.IsValueType) { // this is a pretty expensive check, but we only invoke it when metadata values are null, which is very rare return(false); } } } if (this.RequiredCreationPolicy == CreationPolicy.Any) { return(true); } CreationPolicy exportPolicy = definition.Metadata.GetValue <CreationPolicy>(CompositionConstants.PartCreationPolicyMetadataName); return(exportPolicy == CreationPolicy.Any || exportPolicy == this.RequiredCreationPolicy); }
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 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, MetadataServices.EmptyMetadata, false, origin)); }
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); }
/// <summary> /// Gets a dictionary of metadata to include in an <see cref="ExportDefinition"/> to signify the exporting part's CreationPolicy. /// </summary> /// <param name="partCreationPolicy">The <see cref="CreationPolicy"/> of the exporting <see cref="ComposablePartDefinition"/>.</param> /// <returns>A dictionary of metadata.</returns> public static ImmutableDictionary <string, object?> GetExportMetadata(CreationPolicy partCreationPolicy) { var result = ImmutableDictionary.Create <string, object?>(); // As an optimization, only specify the export metadata if the policy isn't Any. // This matches our logic in IsSatisfiedBy that interprets no metadata as no part creation policy. if (partCreationPolicy != CreationPolicy.Any) { result = result.Add(CompositionConstants.PartCreationPolicyMetadataName, partCreationPolicy); } return(result); }
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 static ContractBasedImportDefinition CreateImportDefinition( Lazy <ParameterInfo> parameter, string contractName, string requiredTypeIdentity, IEnumerable <KeyValuePair <string, Type> > requiredMetadata, ImportCardinality cardinality, CreationPolicy requiredCreationPolicy, IDictionary <string, object> metadata, bool isExportFactory, ICompositionElement origin) { return(ReflectionModelServices.CreateImportDefinition(parameter, contractName, requiredTypeIdentity, requiredMetadata, cardinality, requiredCreationPolicy, metadata, isExportFactory, origin)); }
public ReflectionImportDefinition( string contractName, string requiredTypeIdentity, IEnumerable <string> requiredMetadata, ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite, CreationPolicy requiredCreationPolicy, ICompositionElement origin) : base(contractName, requiredTypeIdentity, requiredMetadata, cardinality, isRecomposable, isPrerequisite, requiredCreationPolicy) { this._origin = origin; }
public static ContractBasedImportDefinition CreateImportDefinition( LazyMemberInfo importingMember, string contractName, string requiredTypeIdentity, IEnumerable <KeyValuePair <string, Type> > requiredMetadata, ImportCardinality cardinality, bool isRecomposable, CreationPolicy requiredCreationPolicy, bool isExportFactory, ICompositionElement origin) { return(ReflectionModelServices.CreateImportDefinition(importingMember, contractName, requiredTypeIdentity, requiredMetadata, cardinality, isRecomposable, requiredCreationPolicy, isExportFactory, origin)); }
public ReflectionImportDefinition( 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 = origin; }
public ReflectionParameterImportDefinition( Lazy <ParameterInfo> importingLazyParameter, string contractName, string requiredTypeIdentity, IEnumerable <string> requiredMetadata, ImportCardinality cardinality, CreationPolicy requiredCreationPolicy, ICompositionElement origin) : base(contractName, requiredTypeIdentity, requiredMetadata, cardinality, false, true, requiredCreationPolicy, origin) { Assumes.NotNull(importingLazyParameter); this._importingLazyParameter = importingLazyParameter; }
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 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; }
/// <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> /// <param name="metadata">The metadata associated with this import.</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 <KeyValuePair <string, Type> >?requiredMetadata, ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite, CreationPolicy requiredCreationPolicy, IDictionary <string, object?> metadata) : base(contractName, cardinality, isRecomposable, isPrerequisite, metadata) { Requires.NotNullOrEmpty(contractName, nameof(contractName)); _requiredTypeIdentity = requiredTypeIdentity; if (requiredMetadata != null) { _requiredMetadata = requiredMetadata; } _requiredCreationPolicy = requiredCreationPolicy; }
/// <summary> /// Creates a new instance of the <see cref="ConstructorBasedImportDefinition"/> class /// based on the given <see cref="ParameterInfo"/>. /// </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="parameter">The method for which the current object stores the serialized data.</param> /// <returns>The serialized definition for the given parameter.</returns> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="parameter"/> is <see langword="null" />. /// </exception> public static ConstructorBasedImportDefinition CreateDefinition( string contractName, TypeIdentity requiredTypeIdentity, ImportCardinality cardinality, CreationPolicy creationPolicy, ParameterInfo parameter) { return(CreateDefinition( contractName, requiredTypeIdentity, cardinality, creationPolicy, parameter, t => TypeIdentity.CreateDefinition(t))); }
public static CatalogExport CreateExport(CatalogExportProvider catalogExportProvider, ComposablePartDefinition partDefinition, ExportDefinition definition, CreationPolicy importCreationPolicy) { CreationPolicy partPolicy = partDefinition.Metadata.GetValue<CreationPolicy>(CompositionConstants.PartCreationPolicyMetadataName); bool isSharedPart = ShouldUseSharedPart(partPolicy, importCreationPolicy); if (isSharedPart) { return new CatalogExport(catalogExportProvider, partDefinition, definition); } else { return new NonSharedCatalogExport(catalogExportProvider, partDefinition, definition); } }
public ContractBasedImportDefinition(string contractName, string requiredTypeIdentity, IEnumerable <KeyValuePair <string, Type> > requiredMetadata, ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite, CreationPolicy requiredCreationPolicy) : base(contractName, cardinality, isRecomposable, isPrerequisite) { Requires.NotNullOrEmpty(contractName, "contractName"); this._requiredTypeIdentity = requiredTypeIdentity; if (requiredMetadata != null) { this._requiredMetadata = requiredMetadata; } this._requiredCreationPolicy = requiredCreationPolicy; }
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; }
private static Expression CreateCreationPolicyContraint(CreationPolicy policy, ParameterExpression parameter) { Assumes.IsTrue(policy != CreationPolicy.Any); Assumes.NotNull(parameter); // !definition.Metadata.ContainsKey(CompositionConstants.PartCreationPolicyMetadataName) || // CreationPolicy.Any.Equals(definition.Metadata[CompositionConstants.PartCreationPolicyMetadataName]) || // policy.Equals(definition.Metadata[CompositionConstants.PartCreationPolicyMetadataName]); return(Expression.MakeBinary(ExpressionType.OrElse, Expression.MakeBinary(ExpressionType.OrElse, Expression.Not(CreateMetadataContainsKeyExpression(parameter, CompositionConstants.PartCreationPolicyMetadataName)), CreateMetadataValueEqualsExpression(parameter, CreationPolicy.Any, CompositionConstants.PartCreationPolicyMetadataName)), CreateMetadataValueEqualsExpression(parameter, policy, CompositionConstants.PartCreationPolicyMetadataName))); }
public ReflectionParameterImportDefinition( Lazy <ParameterInfo> importingLazyParameter, string contractName, string?requiredTypeIdentity, IEnumerable <KeyValuePair <string, Type> >?requiredMetadata, ImportCardinality cardinality, CreationPolicy requiredCreationPolicy, IDictionary <string, object?> metadata, ICompositionElement?origin) : base(contractName, requiredTypeIdentity, requiredMetadata, cardinality, false, true, requiredCreationPolicy, metadata, origin) { ArgumentNullException.ThrowIfNull(importingLazyParameter); _importingLazyParameter = importingLazyParameter; }
public static CatalogExport CreateExport(CatalogExportProvider catalogExportProvider, ComposablePartDefinition partDefinition, ExportDefinition definition, CreationPolicy importCreationPolicy) { CreationPolicy partPolicy = partDefinition.Metadata.GetValue <CreationPolicy>(CompositionConstants.PartCreationPolicyMetadataName); bool isSharedPart = ShouldUseSharedPart(partPolicy, importCreationPolicy); if (isSharedPart) { return(new CatalogExport(catalogExportProvider, partDefinition, definition)); } else { return(new NonSharedCatalogExport(catalogExportProvider, partDefinition, definition)); } }
public static ContractBasedImportDefinition CreateImportDefinition( LazyMemberInfo importingMember, string contractName, string requiredTypeIdentity, IEnumerable <KeyValuePair <string, Type> > requiredMetadata, ImportCardinality cardinality, bool isRecomposable, bool isPreRequisite, CreationPolicy requiredCreationPolicy, IDictionary <string, object> metadata, bool isExportFactory, ICompositionElement origin) { Requires.NotNullOrEmpty(contractName, "contractName"); Requires.IsInMembertypeSet(importingMember.MemberType, "importingMember", MemberTypes.Property | MemberTypes.Field); Contract.Ensures(Contract.Result <ContractBasedImportDefinition>() != null); if (isExportFactory) { return(new PartCreatorMemberImportDefinition( importingMember, origin, new ContractBasedImportDefinition( contractName, requiredTypeIdentity, requiredMetadata, cardinality, isRecomposable, isPreRequisite, CreationPolicy.NonShared, metadata))); } else { return(new ReflectionMemberImportDefinition( importingMember, contractName, requiredTypeIdentity, requiredMetadata, cardinality, isRecomposable, isPreRequisite, requiredCreationPolicy, metadata, origin)); } }
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 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 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)); } }
private static MefV1.CreationPolicy UnwrapCreationPolicy(CreationPolicy creationPolicy) { switch (creationPolicy) { case CreationPolicy.Any: return(MefV1.CreationPolicy.Any); case CreationPolicy.Shared: return(MefV1.CreationPolicy.Shared); case CreationPolicy.NonShared: return(MefV1.CreationPolicy.NonShared); default: throw new ArgumentException(); } }
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 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 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 PropertyBasedImportDefinition CreateDefinition( string contractName, TypeIdentity requiredTypeIdentity, ImportCardinality cardinality, bool isRecomposable, CreationPolicy creationPolicy, PropertyInfo property) { return(CreateDefinition( contractName, requiredTypeIdentity, cardinality, isRecomposable, creationPolicy, property, t => TypeIdentity.CreateDefinition(t))); }
/// <summary> /// Returns all exports that match the conditions of the specified import. /// </summary> /// <param name="definition">The <see cref="ImportDefinition"/> that defines the conditions of the /// <see cref="Export"/> to get.</param> /// <returns></returns> /// <result> /// An <see cref="IEnumerable{T}"/> of <see cref="Export"/> objects that match /// the conditions defined by <see cref="ImportDefinition"/>, if found; otherwise, an /// empty <see cref="IEnumerable{T}"/>. /// </result> /// <remarks> /// <note type="inheritinfo"> /// The implementers should not treat the cardinality-related mismatches as errors, and are not /// expected to throw exceptions in those cases. /// For instance, if the import requests exactly one export and the provider has no matching exports or more than one, /// it should return an empty <see cref="IEnumerable{T}"/> of <see cref="Export"/>. /// </note> /// </remarks> protected override IEnumerable <Export> GetExportsCore(ImportDefinition definition, AtomicComposition atomicComposition) { this.ThrowIfDisposed(); this.EnsureRunning(); // Use the version of the catalog appropriate to this atomicComposition ComposablePartCatalog currentCatalog = atomicComposition.GetValueAllowNull(this._catalog); #if SILVERLIGHT IPartCreatorImportDefinition partCreatorDefinition = definition as IPartCreatorImportDefinition; bool isPartCreator = false; if (partCreatorDefinition != null) { definition = partCreatorDefinition.ProductImportDefinition; isPartCreator = true; } #endif CreationPolicy importPolicy = definition.GetRequiredCreationPolicy(); List <Export> exports = new List <Export>(); foreach (var partDefinitionAndExportDefinition in currentCatalog.GetExports(definition)) { if (!IsRejected(partDefinitionAndExportDefinition.Item1, atomicComposition)) { #if SILVERLIGHT if (isPartCreator) { exports.Add(new PartCreatorExport(this, partDefinitionAndExportDefinition.Item1, partDefinitionAndExportDefinition.Item2)); } else #endif { exports.Add(CatalogExport.CreateExport(this, partDefinitionAndExportDefinition.Item1, partDefinitionAndExportDefinition.Item2, importPolicy)); } } } return(exports); }
private static Expression CreateCreationPolicyContraint(CreationPolicy policy, ParameterExpression parameter) { ArgumentNullException.ThrowIfNull(parameter); if (policy == CreationPolicy.Any) { throw new Exception(SR.Diagnostic_InternalExceptionMessage); } // !definition.Metadata.ContainsKey(CompositionConstants.PartCreationPolicyMetadataName) || // CreationPolicy.Any.Equals(definition.Metadata[CompositionConstants.PartCreationPolicyMetadataName]) || // policy.Equals(definition.Metadata[CompositionConstants.PartCreationPolicyMetadataName]); return(Expression.MakeBinary(ExpressionType.OrElse, Expression.MakeBinary(ExpressionType.OrElse, Expression.Not(CreateMetadataContainsKeyExpression(parameter, CompositionConstants.PartCreationPolicyMetadataName)), CreateMetadataValueEqualsExpression(parameter, CreationPolicy.Any, CompositionConstants.PartCreationPolicyMetadataName)), CreateMetadataValueEqualsExpression(parameter, policy, CompositionConstants.PartCreationPolicyMetadataName))); }
public MetadataContract(string contractName, IEnumerable <KeyValuePair <string, Type> > metadata, List <Expression <Func <TMetadata, TMetadata, bool> > > constraints, Func <TMetadata, ExportDefinition, bool> constraint, ImportCardinality importCardinality, CreationPolicy creationPolicy, TMetadata contract) : base(contractName, AttributedModelServices.GetContractName(typeof(T)), metadata, importCardinality, false, false, creationPolicy) { this._constraints = constraints.ToArray(); this._constraint = constraint; this._contract = contract; }
public static ContractBasedImportDefinition CreateImportDefinition( Lazy <ParameterInfo> parameter, string contractName, string requiredTypeIdentity, IEnumerable <KeyValuePair <string, Type> > requiredMetadata, ImportCardinality cardinality, CreationPolicy requiredCreationPolicy, IDictionary <string, object> metadata, bool isExportFactory, ICompositionElement origin) { Requires.NotNull(parameter, "parameter"); Requires.NotNullOrEmpty(contractName, "contractName"); Contract.Ensures(Contract.Result <ContractBasedImportDefinition>() != null); if (isExportFactory) { return(new PartCreatorParameterImportDefinition( parameter, origin, new ContractBasedImportDefinition( contractName, requiredTypeIdentity, requiredMetadata, cardinality, false, true, CreationPolicy.NonShared, metadata))); } else { return(new ReflectionParameterImportDefinition( parameter, contractName, requiredTypeIdentity, requiredMetadata, cardinality, requiredCreationPolicy, metadata, origin)); } }
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) { if (contractName == null) { throw new ArgumentNullException(nameof(contractName)); } _importingLazyMember = importingLazyMember; }
public static Func <ExportDefinition, bool> CreateConstraint( string contractName, string requiredTypeIdentity, IEnumerable <KeyValuePair <string, Type> > requiredMetadata, CreationPolicy requiredCreationPolicy) { var constraintInstance = new ConstraintInstance(contractName, requiredTypeIdentity, requiredMetadata, requiredCreationPolicy); var constraint = constraintInstance.GetExportDefinitionConstraint(); return(constraint); //ParameterExpression parameter = Expression.Parameter(typeof(ExportDefinition), "exportDefinition"); //Expression constraintBody = ConstraintServices.CreateContractConstraintBody(contractName, parameter); //if (!string.IsNullOrEmpty(requiredTypeIdentity)) //{ // Expression typeIdentityConstraintBody = ConstraintServices.CreateTypeIdentityContraint(requiredTypeIdentity, parameter); // constraintBody = Expression.AndAlso(constraintBody, typeIdentityConstraintBody); //} //if (requiredMetadata != null) //{ // Expression metadataConstraintBody = ConstraintServices.CreateMetadataConstraintBody(requiredMetadata, parameter); // if (metadataConstraintBody != null) // { // constraintBody = Expression.AndAlso(constraintBody, metadataConstraintBody); // } //} //if (requiredCreationPolicy != CreationPolicy.Any) //{ // Expression policyConstraintBody = ConstraintServices.CreateCreationPolicyContraint(requiredCreationPolicy, parameter); // constraintBody = Expression.AndAlso(constraintBody, policyConstraintBody); //} //Expression<Func<ExportDefinition, bool>> constraint = Expression.Lambda<Func<ExportDefinition, bool>>(constraintBody, parameter); //return constraint; }
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); }
public CreationPolicyAttribute(CreationPolicy policy) { this.Policy = policy; }
public PartCreationPolicyFilter(CreationPolicy creationPolicy) { CreationPolicy = creationPolicy; }
public virtual ImportDefinition BuildImportDefinition(ParameterInfo parameterInfo, string contractName, string requiredTypeIdentity, IEnumerable<KeyValuePair<string, Type>> requiredMetadata, ImportCardinality cardinality, CreationPolicy requiredCreationPolicy) { // TODO: IsCollection call return ReflectionModelServices.CreateImportDefinition( new Lazy<ParameterInfo>(() => parameterInfo), contractName, requiredTypeIdentity, requiredMetadata, cardinality, requiredCreationPolicy, null); }
/// <include file='Composition.xdoc' path='docs/doc[@for="PartCreationPolicyAttribute.ctor"]/*'/> public PartCreationPolicyAttribute(CreationPolicy creationPolicy) { this.CreationPolicy = creationPolicy; }
internal static ContractBasedImportDefinition CreateImportDefinition( LazyMemberInfo importingMember, string contractName, string requiredTypeIdentity, IEnumerable<KeyValuePair<string, Type>> requiredMetadata, ImportCardinality cardinality, bool isRecomposable, CreationPolicy requiredCreationPolicy, bool isExportFactory, ICompositionElement origin) { Requires.NotNullOrEmpty(contractName, "contractName"); Requires.IsInMembertypeSet(importingMember.MemberType, "importingMember", MemberTypes.Property | MemberTypes.Field); Contract.Ensures(Contract.Result<ContractBasedImportDefinition>() != null); if (isExportFactory) { return new PartCreatorMemberImportDefinition( importingMember, origin, new ContractBasedImportDefinition( contractName, requiredTypeIdentity, requiredMetadata, cardinality, isRecomposable, false, CreationPolicy.NonShared)); } else { return new ReflectionMemberImportDefinition( importingMember, contractName, requiredTypeIdentity, requiredMetadata, cardinality, isRecomposable, requiredCreationPolicy, origin); } }
internal static ContractBasedImportDefinition CreateImportDefinition( Lazy<ParameterInfo> parameter, string contractName, string requiredTypeIdentity, IEnumerable<KeyValuePair<string, Type>> requiredMetadata, ImportCardinality cardinality, CreationPolicy requiredCreationPolicy, bool isExportFactory, ICompositionElement origin) { Requires.NotNull(parameter, "parameter"); Requires.NotNullOrEmpty(contractName, "contractName"); Contract.Ensures(Contract.Result<ContractBasedImportDefinition>() != null); if (isExportFactory) { return new PartCreatorParameterImportDefinition( parameter, origin, new ContractBasedImportDefinition( contractName, requiredTypeIdentity, requiredMetadata, cardinality, false, true, CreationPolicy.NonShared)); } else { return new ReflectionParameterImportDefinition( parameter, contractName, requiredTypeIdentity, requiredMetadata, cardinality, requiredCreationPolicy, origin); } }
public Export(Type type, CreationPolicy creationPolicy) { this._creationPolicy = creationPolicy; this._contractType = type; }
private static Expression CreateCreationPolicyContraint(CreationPolicy policy, ParameterExpression parameter) { Assumes.IsTrue(policy != CreationPolicy.Any); Assumes.NotNull(parameter); // !definition.Metadata.ContainsKey(CompositionConstants.PartCreationPolicyMetadataName) || // CreationPolicy.Any.Equals(definition.Metadata[CompositionConstants.PartCreationPolicyMetadataName]) || // policy.Equals(definition.Metadata[CompositionConstants.PartCreationPolicyMetadataName]); return Expression.MakeBinary(ExpressionType.OrElse, Expression.MakeBinary(ExpressionType.OrElse, Expression.Not(CreateMetadataContainsKeyExpression(parameter, CompositionConstants.PartCreationPolicyMetadataName)), CreateMetadataValueEqualsExpression(parameter, CreationPolicy.Any, CompositionConstants.PartCreationPolicyMetadataName)), CreateMetadataValueEqualsExpression(parameter, policy, CompositionConstants.PartCreationPolicyMetadataName)); }
/// <summary> /// Creates a new instance of the <see cref="ConstructorBasedImportDefinition"/> class /// based on the given <see cref="ParameterInfo"/>. /// </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="parameter">The method for which the current object stores the serialized data.</param> /// <returns>The serialized definition for the given parameter.</returns> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="parameter"/> is <see langword="null" />. /// </exception> public static ConstructorBasedImportDefinition CreateDefinition( string contractName, TypeIdentity requiredTypeIdentity, ImportCardinality cardinality, CreationPolicy creationPolicy, ParameterInfo parameter) { return CreateDefinition( contractName, requiredTypeIdentity, cardinality, creationPolicy, parameter, t => TypeIdentity.CreateDefinition(t)); }
/// <summary> /// Creates a new instance of the <see cref="ConstructorBasedImportDefinition"/> class based /// on the given <see cref="ParameterInfo"/>. /// </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="parameter">The method for which the current object stores the serialized data.</param> /// <param name="identityGenerator">The function that creates type identities.</param> /// <returns>The serialized definition for the given parameter.</returns> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="parameter"/> is <see langword="null" />. /// </exception> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="identityGenerator"/> is <see langword="null" />. /// </exception> public static ConstructorBasedImportDefinition CreateDefinition( string contractName, TypeIdentity requiredTypeIdentity, ImportCardinality cardinality, CreationPolicy creationPolicy, ParameterInfo parameter, Func<Type, TypeIdentity> identityGenerator) { { Lokad.Enforce.Argument(() => parameter); Lokad.Enforce.Argument(() => identityGenerator); } return new ConstructorBasedImportDefinition( contractName, requiredTypeIdentity, cardinality, creationPolicy, identityGenerator(parameter.Member.DeclaringType), ConstructorDefinition.CreateDefinition(parameter.Member as ConstructorInfo, identityGenerator), ParameterDefinition.CreateDefinition(parameter, identityGenerator)); }
public virtual ImportDefinition BuildImportDefinition(MemberInfo member, string contractName, string requiredTypeIdentity, IEnumerable<KeyValuePair<string, Type>> requiredMetadata, ImportCardinality cardinality, bool isRecomposable, CreationPolicy requiredCreationPolicy) { return ReflectionModelServices.CreateImportDefinition( new LazyMemberInfo(member), contractName, requiredTypeIdentity, requiredMetadata, cardinality, isRecomposable, requiredCreationPolicy, null); }
/// <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; }
/// <summary>Creates attribute.</summary> <param name="policy"><see cref="CreationPolicy"/></param> public PartCreationPolicyAttribute(CreationPolicy policy) { CreationPolicy = policy; }