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));
}
