public CatalogExport(CatalogExportProvider catalogExportProvider, ComposablePartDefinition partDefinition, ExportDefinition definition) { this._catalogExportProvider = catalogExportProvider; this._partDefinition = partDefinition; this._definition = definition; }
private void CheckName(ComposablePartDefinition def) { if (!def.Metadata.ContainsKey(Keys.PluginId)) { var msg = string.Format("There's a plugin without id. Check you've set the attribute Metadata to the plugin with the key '{0}'", Keys.PluginId); #if DEBUG throw new NotImplementedException(msg); #else Logger.Warn(msg); #endif } else { Guid id; if (!(Guid.TryParse(def.Metadata[Keys.PluginId].ToString(), out id))) { throw new Exception(string.Format( "The plugin doen't have a valid id. Check you've set the attribute Metadata to the plugin with the key '{0}'", Keys.PluginId)); } if (this.IdCollection.Contains(id)) { throw new Exception(string.Format( "A plugin with the same id already exist in the repository [id: {0}]", id.ToString())); } } }
public IDictionary<string, object> CacheImportDefinition(ComposablePartDefinition owner, ImportDefinition importDefinition) { ContractBasedImportDefinition contractBasedImport = importDefinition as ContractBasedImportDefinition; Assumes.NotNull(contractBasedImport); return CompositionCacheServices.WriteImportDefinition(owner, contractBasedImport); }
public static IDictionary<string, object> WriteImportDefinition(ComposablePartDefinition owner, ContractBasedImportDefinition importDefinition) { Assumes.NotNull(owner); Assumes.NotNull(importDefinition); Lazy<Type> partType = ReflectionModelServices.GetPartType(owner); IDictionary<string, object> cache = new Dictionary<string, object>(); cache.WriteContractName(importDefinition.ContractName); cache.WriteValue(AttributedCacheServices.CacheKeys.RequiredTypeIdentity, importDefinition.RequiredTypeIdentity, null); cache.WriteRequiredMetadata(importDefinition.RequiredMetadata); cache.WriteValue(AttributedCacheServices.CacheKeys.RequiredCreationPolicy, importDefinition.RequiredCreationPolicy, CreationPolicy.Any); cache.WriteValue(AttributedCacheServices.CacheKeys.Cardinality, importDefinition.Cardinality, ImportCardinality.ExactlyOne); if (ReflectionModelServices.IsImportingParameter(importDefinition)) { cache.WriteValue(AttributedCacheServices.CacheKeys.ImportType, AttributedCacheServices.ImportTypes.Parameter); cache.WriteLazyParameter( ReflectionModelServices.GetImportingParameter(importDefinition), partType); } else { // don't write anything for import type - member assumed LazyMemberInfo importingMemberInfo = ReflectionModelServices.GetImportingMember(importDefinition); cache.WriteValue(AttributedCacheServices.CacheKeys.IsRecomposable, importDefinition.IsRecomposable, false); cache.WriteValue(AttributedCacheServices.CacheKeys.MemberType, importingMemberInfo.MemberType , MemberTypes.Property); cache.WriteLazyAccessors( importingMemberInfo.GetAccessors(), partType); } return cache; }
public PartCreatorExport(CatalogExportProvider catalogExportProvider, ComposablePartDefinition partDefinition, ExportDefinition exportDefinition) { this._catalogExportProvider = catalogExportProvider; this._partDefinition = partDefinition; this._exportDefinition = exportDefinition; this._partCreatorExportDefinition = new PartCreatorExportDefinition(this._exportDefinition); }
public AddInComposablePartDefinition(AddInCatalog catalog, ComposablePartDefinition composablePartDefinition) { this._composablePartDefinition = composablePartDefinition; List<KeyValuePair<string, object>> injectedMetadata = new List<KeyValuePair<string, object>>(); injectedMetadata.Add(new KeyValuePair<string, object>(AddInCatalog.PackageIdMetadataName, catalog.PackageId)); injectedMetadata.Add(new KeyValuePair<string, object>(AddInCatalog.PackageVersionMetadataName, catalog.PackageVersion)); List<ExportDefinition> interceptedExports = new List<ExportDefinition>(); foreach (ExportDefinition export in composablePartDefinition.ExportDefinitions) { ICompositionElement compositionElement = export as ICompositionElement; if (compositionElement == null) throw new InvalidOperationException("ExportDefinition doesn't implement ICompositionElement"); Dictionary<string, object> metadata = injectedMetadata.Concat(export.Metadata) .ToDictionary(kvp => kvp.Key, kvp => kvp.Value); // TODO this will fail if export isn't a ReflectionMemberExportDefinition (Internal, so I can't check) LazyMemberInfo lazyMember = ReflectionModelServices.GetExportingMember(export); ExportDefinition interceptedExport = ReflectionModelServices.CreateExportDefinition(lazyMember, export.ContractName, new Lazy<IDictionary<string, object>>(() => metadata), compositionElement.Origin); interceptedExports.Add(interceptedExport); } this._exportDefinitions = interceptedExports.ToArray(); }
/// <summary> /// Decides whether given part satisfies a filter. /// </summary> /// <param name="part"><see cref="ComposablePartDefinition"/> being filtered.</param> /// <returns>True if a given <see cref="ComposablePartDefinition"/> satisfies the filter. /// False otherwise.</returns> public bool Filter(ComposablePartDefinition part) { // Fetch all metadata Dictionary<string, object> metadata = new Dictionary<string, object>(StringComparer.InvariantCultureIgnoreCase); foreach (var md in part.Metadata) { metadata.Add(md.Key, md.Value); } var additionalMetadata = from ed in part.ExportDefinitions from md in ed.Metadata select md; foreach (var md in additionalMetadata) { if (!metadata.ContainsKey(md.Key)) { metadata.Add(md.Key, md.Value); } } // Fetch "Scope" var key = "Scope"; if (metadata.ContainsKey(key)) { PartCreationScope scope = PartCreationScope.Default; Enum.TryParse(metadata[key].ToString(), out scope); return scope == _partCreationScope; } else if (_partCreationScope == PartCreationScope.Default) { return true; } return false; }
private static ImportDefinition TranslateImport(ImportDefinition import, ComposablePartDefinition part) { ContractBasedImportDefinition contractBasedImport = import as ContractBasedImportDefinition; if (contractBasedImport == null) { return import; } int[] importParametersOrder = contractBasedImport.Metadata.GetValue<int[]>(CompositionConstants.GenericImportParametersOrderMetadataName); if (importParametersOrder == null) { return import; } int partArity = part.Metadata.GetValue<int>(CompositionConstants.GenericPartArityMetadataName); if (partArity == 0) { return import; } string contractName = GenericServices.GetGenericName(contractBasedImport.ContractName, importParametersOrder, partArity); string requiredTypeIdentity = GenericServices.GetGenericName(contractBasedImport.RequiredTypeIdentity, importParametersOrder, partArity); return new ContractBasedImportDefinition( contractName, requiredTypeIdentity, contractBasedImport.RequiredMetadata, contractBasedImport.Cardinality, contractBasedImport.IsRecomposable, false, contractBasedImport.RequiredCreationPolicy, contractBasedImport.Metadata); }
/// <summary> /// Create a PartDefinitionInfo representing partDefinition. /// </summary> /// <param name="partDefinition">The part to be analyzed.</param> public PartDefinitionInfo(ComposablePartDefinition partDefinition) { PartDefinition = partDefinition; ImportDefinitions = Enumerable.Empty<ImportDefinitionInfo>(); _isRejected = new Lazy<bool>(() => ImportDefinitions .Any(idi => idi.Exception is ImportCardinalityMismatchException)); }
private static bool GetAllWithinAppScope(ComposablePartDefinition def) { return def.ExportDefinitions. Any(ed => !ed.Metadata.ContainsKey(ModeKey) || (ed.Metadata.ContainsKey(ModeKey) && ((WebScopeMode)ed.Metadata[ModeKey]) == WebScopeMode.Application)); }
protected override bool IsMatch(ComposablePartDefinition composablePartDefinition) { var element = composablePartDefinition as ICompositionElement; if (element == null) return true; return element.DisplayName.StartsWith("Raven.Database") == false; }
public bool TryTraverse(ComposablePartDefinition part, out IEnumerable<ComposablePartDefinition> reachableParts) { reachableParts = null; List<ComposablePartDefinition> reachablePartList = null; // Go through all part exports foreach (ExportDefinition export in part.ExportDefinitions) { // Find all parts that we know will import each export List<ComposablePartDefinition> candidateReachableParts = null; if (this._importersIndex.TryGetValue(export.ContractName, out candidateReachableParts)) { // find if they actually match foreach (var candidateReachablePart in candidateReachableParts) { foreach (ImportDefinition import in candidateReachablePart.ImportDefinitions.Where(this._importFilter)) { if (import.IsImportDependentOnPart(part, export, part.IsGeneric() != candidateReachablePart.IsGeneric())) { if (reachablePartList == null) { reachablePartList = new List<ComposablePartDefinition>(); } reachablePartList.Add(candidateReachablePart); } } } } } reachableParts = reachablePartList; return (reachableParts != null); }
public static ReflectionComposablePart CreatePart(ComposablePartDefinition partDefinition, object attributedPart) { Assumes.NotNull(partDefinition); Assumes.NotNull(attributedPart); return new ReflectionComposablePart((ReflectionComposablePartDefinition)partDefinition, attributedPart); }
/// <summary> /// Initializes the context from a part and the export. /// </summary> internal DecoratedExport(ComposablePartDefinition part, ExportDefinition export) { this.ExportDefinition = export; this.ExportingMember = ReflectionModelServices.GetExportingMember(export); this.ExportingType = ReflectionModelServices.GetPartType(part); this.NewMetadata = new Dictionary<string, object>(export.Metadata); }
public void When_calling_create_part_it_should_create_a_disposable_intercepting_part() { var mockInterceptor = new Mock<IExportedValueInterceptor>(); interceptedPartDefinition = AttributedModelServices.CreatePartDefinition(typeof(DisposablePart), null); interceptingPartDefinition = new InterceptingComposablePartDefinition(interceptedPartDefinition, mockInterceptor.Object); var part = interceptingPartDefinition.CreatePart(); part.ShouldBeOfType<DisposableInterceptingComposablePart>(); }
public InterceptingComposablePartDefinition(ComposablePartDefinition interceptedPartDefinition, IExportedValueInterceptor valueInterceptor) { interceptedPartDefinition.ShouldNotBeNull("interceptedPartDefinition"); valueInterceptor.ShouldNotBeNull("valueInterceptor"); InterceptedPartDefinition = interceptedPartDefinition; _valueInterceptor = valueInterceptor; }
public InterceptingComposablePartDefinition(ComposablePartDefinition interceptedPartDefinition, IExportedValueInterceptor valueInterceptor) { if (interceptedPartDefinition == null) throw new ArgumentNullException("interceptedPartDefinition"); if (valueInterceptor == null) throw new ArgumentNullException("valueInterceptor"); InterceptedPartDefinition = interceptedPartDefinition; this.valueInterceptor = valueInterceptor; }
/// <summary> /// Decides whether given part satisfies a filter. /// </summary> /// <param name="part"><see cref="ComposablePartDefinition"/> being filtered.</param> /// <returns>True if a given <see cref="ComposablePartDefinition"/> satisfies the filter. /// False otherwise.</returns> public bool Filter(ComposablePartDefinition part) { if (creationPolicy == CreationPolicy.Any && !part.Metadata.ContainsKey(CompositionConstants.PartCreationPolicyMetadataName)) return true; return part.Metadata.ContainsKey(CompositionConstants.PartCreationPolicyMetadataName) && ((CreationPolicy)part.Metadata[CompositionConstants.PartCreationPolicyMetadataName]) == creationPolicy; }
public IDictionary<string, object> CachePartDefinition(ComposablePartDefinition partDefinition) { ComposablePartDefinition reflectionPartDefition = partDefinition as ComposablePartDefinition; Assumes.NotNull(reflectionPartDefition); IDictionary<string, object> cache = CompositionCacheServices.WritePartDefinition(reflectionPartDefition, this.WriteAssemblyForTypes); return cache; }
public static Lazy<Type> GetPartType(ComposablePartDefinition partDefinition) { AddInComposablePartDefinition addinPartDef = partDefinition as AddInComposablePartDefinition; if (addinPartDef == null) throw new ArgumentException("Must be of type AddInComposablePartDefinition", "partDefinition"); return ReflectionModelServices.GetPartType(addinPartDef.Definition); }
public static void TouchPart(ComposablePartDefinition part) { foreach (var export in part.ExportDefinitions) { } foreach (var import in part.ImportDefinitions) { } }
public DisposableWrapperPartDefinition(ComposablePartDefinition innerPartDefinition, bool isNonSharedDisposable) { if (innerPartDefinition == null) throw new ArgumentNullException(nameof(innerPartDefinition)); InnerPartDefinition = innerPartDefinition; _isNonSharedDisposable = isNonSharedDisposable; _compositionOrigin = innerPartDefinition as ICompositionElement; }
private void AddToExportersIndex(string contractName, ComposablePartDefinition part) { List<ComposablePartDefinition> parts = null; if (!this._exportersIndex.TryGetValue(contractName, out parts)) { parts = new List<ComposablePartDefinition>(); this._exportersIndex.Add(contractName, parts); } parts.Add(part); }
public static bool IsContained(ComposablePartDefinition definition, object value = null) { if (value == null) { return definition.Metadata.ContainsKey(Name); } else { return definition.Metadata.ContainsKey(Name) && definition.Metadata[Name].Equals(value); } }
internal static void PartDefinitionResurrected(ComposablePartDefinition definition) { Assumes.NotNull(definition); if (CompositionTraceSource.CanWriteInformation) { CompositionTraceSource.WriteInformation(CompositionTraceId.Rejection_DefinitionResurrected, Strings.CompositionTrace_Rejection_DefinitionResurrected, definition.GetDisplayName()); } }
internal static bool IsImportDependentOnPart(this ImportDefinition import, ComposablePartDefinition part, ExportDefinition export, bool expandGenerics) { import = import.GetProductImportDefinition(); if (expandGenerics) { return(part.TryGetExports(import, out _, out _)); } else { return(TranslateImport(import, part).IsConstraintSatisfiedBy(export)); } }
public static bool IsDisposalRequired(ComposablePartDefinition partDefinition) { Requires.NotNull(partDefinition, "partDefinition"); ReflectionComposablePartDefinition reflectionPartDefinition = partDefinition as ReflectionComposablePartDefinition; if (reflectionPartDefinition == null) { throw ExceptionBuilder.CreateReflectionModelInvalidPartDefinition("partDefinition", partDefinition.GetType()); } return reflectionPartDefinition.IsDisposalRequired; }
internal static bool IsImportDependentOnPart(this ImportDefinition import, ComposablePartDefinition part, ExportDefinition export, bool expandGenerics) { import = import.GetProductImportDefinition(); if (expandGenerics) { return part.GetExports(import).Any(); } else { return TranslateImport(import, part).IsConstraintSatisfiedBy(export); } }
internal static void PartDefinitionRejected(ComposablePartDefinition definition, ChangeRejectedException exception) { Assumes.NotNull(definition, exception); if (CompositionTraceSource.CanWriteWarning) { CompositionTraceSource.WriteWarning(CompositionTraceId.Rejection_DefinitionRejected, Strings.CompositionTrace_Rejection_DefinitionRejected, definition.GetDisplayName(), exception.Message); } }
internal static bool IsImportDependentOnPart(this ImportDefinition import, ComposablePartDefinition part, ExportDefinition export, bool expandGenerics) { import = import.GetProductImportDefinition(); if (expandGenerics) { return(part.TryGetExports(import, out Tuple <ComposablePartDefinition, ExportDefinition>?singleMatch, out IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> >?multipleMatches)); } else { return(TranslateImport(import, part).IsConstraintSatisfiedBy(export)); } }
public static Lazy<Type> GetPartType(ComposablePartDefinition partDefinition) { Requires.NotNull(partDefinition, "partDefinition"); Contract.Ensures(Contract.Result<Lazy<Type>>() != null); ReflectionComposablePartDefinition reflectionPartDefinition = partDefinition as ReflectionComposablePartDefinition; if (reflectionPartDefinition == null) { throw ExceptionBuilder.CreateReflectionModelInvalidPartDefinition("partDefinition", partDefinition.GetType()); } return reflectionPartDefinition.GetLazyPartType(); }
public static bool IsDisposalRequired(ComposablePartDefinition partDefinition) { Requires.NotNull(partDefinition, "partDefinition"); ReflectionComposablePartDefinition reflectionPartDefinition = partDefinition as ReflectionComposablePartDefinition; if (reflectionPartDefinition == null) { throw new ArgumentException( string.Format(CultureInfo.CurrentCulture, Strings.ReflectionModel_InvalidPartDefinition, partDefinition.GetType()), "partDefinition"); } return reflectionPartDefinition.IsDisposalRequired; }
internal static IEnumerable <string> GetCandidateContractNames(this ImportDefinition import, ComposablePartDefinition part) { import = import.GetProductImportDefinition(); string contractName = import.ContractName; string genericContractName = import.Metadata.GetValue <string>(CompositionConstants.GenericContractMetadataName); int[] importParametersOrder = import.Metadata.GetValue <int[]>(CompositionConstants.GenericImportParametersOrderMetadataName); if (importParametersOrder != null) { int partArity = part.Metadata.GetValue <int>(CompositionConstants.GenericPartArityMetadataName); if (partArity > 0) { contractName = GenericServices.GetGenericName(contractName, importParametersOrder, partArity); } } yield return(contractName); if (!string.IsNullOrEmpty(genericContractName)) { yield return(genericContractName); } }
public static bool IsGeneric(this ComposablePartDefinition part) { return(part.Metadata.GetValue <bool>(CompositionConstants.IsGenericPartMetadataName)); }
public static ICompositionElement ToElement(this ComposablePartDefinition definition) { return(ToElementCore(definition)); }
public static string GetDisplayName(this ComposablePartDefinition definition) { return(GetDisplayNameCore(definition)); }