private bool IsRejected(ComposablePartDefinition definition, AtomicComposition atomicComposition)
{
// Check to see if we're currently working on the definition in question.
// Recursive queries always answer optimistically, as if the definition hasn't
// been rejected - because if it is we can discard all decisions that were based
// on the faulty assumption in the first place.
var forceRejectionTest = false;
if (atomicComposition != null)
{
AtomicCompositionQueryState state = QueryPartState(atomicComposition, definition);
switch (state)
{
case AtomicCompositionQueryState.TreatAsRejected:
return(true);
case AtomicCompositionQueryState.TreatAsValidated:
return(false);
case AtomicCompositionQueryState.NeedsTesting:
forceRejectionTest = true;
break;
default:
if (state != AtomicCompositionQueryState.Unknown)
{
throw new Exception(SR.Diagnostic_InternalExceptionMessage);
}
// Need to do the work to determine the state
break;
}
}
if (!forceRejectionTest)
{
// Next, anything that has been activated is not rejected
using (_lock.LockStateForRead())
{
if (_activatedParts.ContainsKey(definition))
{
return(false);
}
// Last stop before doing the hard work: check a specific registry of rejected parts
if (_rejectedParts.Contains(definition))
{
return(true);
}
}
}
// Determine whether or not the definition's imports can be satisfied
return(DetermineRejection(definition, atomicComposition));
}
internal static void PartDefinitionResurrected(ComposablePartDefinition definition)
{
Assumes.NotNull(definition);
if (CompositionTraceSource.CanWriteInformation)
{
CompositionTraceSource.WriteInformation(CompositionTraceId.Rejection_DefinitionResurrected,
Strings.CompositionTrace_Rejection_DefinitionResurrected,
definition.GetDisplayName());
}
}
private static Type ComposablePartExportType <T>(ComposablePartDefinition part, string contractName)
{
if (part.ExportDefinitions.Any(def =>
def.Metadata.ContainsKey("ExportTypeIdentity") &&
String.Equals(def.ContractName, contractName, StringComparison.OrdinalIgnoreCase) &&
def.Metadata["ExportTypeIdentity"].Equals(typeof(T).FullName)))
{
return(ReflectionModelServices.GetPartType(part).Value);
}
return(null);
}
private ComposablePartDefinition GetPartDefinition(IntPtr funcPtr)
{
ComposablePartDefinition partDefinition = null;
if (!this._createdPartDefinitions.TryGetValue(funcPtr, out partDefinition))
{
partDefinition = this._getPartFactory.Invoke(funcPtr);
this._createdPartDefinitions.Add(funcPtr, partDefinition);
}
return(partDefinition);
}
public void ExportsGeneric()
{
ComposablePartDefinition part1 = typeof(PartExportingContract1).AsPart();
ComposablePartDefinition part2 = typeof(PartExportingContract2).AsPart();
Assert.True(part1.Exports <IContract1>());
Assert.True(part2.Exports <IContract2>());
Assert.False(part2.Exports <IContract1>());
Assert.False(part1.Exports <IContract2>());
}
internal static void PartDefinitionResurrected(ComposablePartDefinition definition)
{
ArgumentNullException.ThrowIfNull(definition);
if (CompositionTraceSource.CanWriteInformation)
{
CompositionTraceSource.WriteInformation(CompositionTraceId.Rejection_DefinitionResurrected,
SR.CompositionTrace_Rejection_DefinitionResurrected,
definition.GetDisplayName());
}
}
public void Imports()
{
ComposablePartDefinition part1 = typeof(PartImportingContract1).AsPart();
ComposablePartDefinition part2 = typeof(PartImportingContract2).AsPart();
Assert.True(part1.Imports("Contract1"));
Assert.True(part2.Imports("Contract2"));
Assert.False(part2.Imports("Contract1"));
Assert.False(part1.Imports("Contract2"));
}
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);
}
private static Type ComposablePartExportType <T>(ComposablePartDefinition part)
{
if (part.ExportDefinitions.Any(def => def.Metadata.ContainsKey("ExportTypeIdentity") &&
def.Metadata["ExportTypeIdentity"].Equals(typeof(T).FullName)
))
{
return(ReflectionModelServices.GetPartType(part).Value);
}
return(null);
}
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);
}
}
private CustomComposablePartDefinition GetCustomPart(ComposablePartDefinition part)
{
if (_partDefinitions.ContainsKey(part))
{
return(_partDefinitions[part]);
}
var customPart = new CustomComposablePartDefinition(part);
_partDefinitions[part] = customPart;
return(customPart);
}
internal bool TryMakeGenericPartDefinition(Type[] genericTypeParameters, out ComposablePartDefinition genericPartDefinition)
{
genericPartDefinition = null;
if (!GenericSpecializationPartCreationInfo.CanSpecialize(Metadata, genericTypeParameters))
{
return(false);
}
genericPartDefinition = new ReflectionComposablePartDefinition(new GenericSpecializationPartCreationInfo(_creationInfo, this, genericTypeParameters));
return(true);
}
public static Lazy <Type> GetPartType(ComposablePartDefinition partDefinition)
{
Requires.NotNull(partDefinition, nameof(partDefinition));
ReflectionComposablePartDefinition?reflectionPartDefinition = partDefinition as ReflectionComposablePartDefinition;
if (reflectionPartDefinition == null)
{
throw ExceptionBuilder.CreateReflectionModelInvalidPartDefinition(nameof(partDefinition), partDefinition.GetType());
}
return(reflectionPartDefinition.GetLazyPartType());
}
private ComposablePartDefinition CreateWrapped(ComposablePartDefinition partDefinition, Type type)
{
IEnumerable <ExportDefinition> exports = partDefinition.ExportDefinitions.Select(e => this.CreateWrapped(e, type)).ToArray();
IEnumerable <ImportDefinition> imports = partDefinition.ImportDefinitions.Cast <ContractBasedImportDefinition>().Select(i => this.CreateWrapped(i, type)).ToArray();
return(ReflectionModelServices.CreatePartDefinition(
this.CreateWrapped(ReflectionModelServices.GetPartType(partDefinition), type),
ReflectionModelServices.IsDisposalRequired(partDefinition),
imports.AsLazy(),
exports.AsLazy(),
partDefinition.Metadata.AsLazy(),
null));
}
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);
}
public static bool IsPartDefinitionCacheUpToDate(this ComposablePartDefinition partDefinition)
{
IDictionary <string, object> cache = ReflectionModelServices.GetPartType(partDefinition).GetMetadata();
if (cache != null)
{
return(cache.IsAssemblyCacheUpToDate());
}
else
{
return(false);
}
}
public static IDictionary <string, object> WritePartDefinition(ComposablePartDefinition part, bool writeAssembly)
{
Assumes.NotNull(part);
IDictionary <string, object> cache = new Dictionary <string, object>();
Lazy <Type> partType = ReflectionModelServices.GetPartType(part);
cache.WriteMetadata(part.Metadata);
cache.WriteLazyTypeForPart(partType, writeAssembly);
cache.WriteValue <bool>(AttributedCacheServices.CacheKeys.IsDisposalRequired, ReflectionModelServices.IsDisposalRequired(part), false);
return(cache);
}
/// <summary>
/// Initializes a new instance of the <see cref="InterceptingComposablePartDefinition"/> class.
/// </summary>
/// <param name="interceptedPartDefinition">The <see cref="ComposablePartDefinition"/> being intercepted.</param>
/// <param name="valueInterceptor">The <see cref="IExportedValueInterceptor"/> instance.</param>
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>
/// Initializes a new instance of the <see cref="PartNode"/> class.
/// </summary>
/// <param name="definition">The definition of the part associated with the node.</param>
/// <param name="message">Initialize rejection message in error stack.</param>
/// <param name="currLevel">The depth of the part in the stack.</param>
internal PartNode(ComposablePartDefinition definition, string message, int currLevel)
{
this.Part = definition;
this.IsRejectionExpected = false;
this.VerboseMessages.Add(message);
this.Level = currLevel;
this.IsRejectionExpected = false;
this.ExportingContracts = new List <string>();
foreach (var export in this.Part.ExportDefinitions)
{
this.ExportingContracts.Add(export.Value.ContractName);
}
}
internal static void PartDefinitionResurrected(ComposablePartDefinition definition)
{
if (definition == null)
{
throw new ArgumentNullException(nameof(definition));
}
if (CompositionTraceSource.CanWriteInformation)
{
CompositionTraceSource.WriteInformation(CompositionTraceId.Rejection_DefinitionResurrected,
SR.CompositionTrace_Rejection_DefinitionResurrected,
definition.GetDisplayName());
}
}
/// <summary>
/// Determines whether the specified part exports the specified contract.
/// </summary>
/// <param name="part">The part.</param>
/// <param name="contractName">Name of the contract.</param>
/// <returns>
/// <c>true</c> if the specified part exports the specified contract; otherwise, <c>false</c>.
/// </returns>
public static bool Exports(this ComposablePartDefinition part, string contractName)
{
Requires.NotNull(part, nameof(part));
Requires.NotNull(contractName, nameof(contractName));
foreach (ExportDefinition export in part.ExportDefinitions)
{
if (StringComparers.ContractName.Equals(contractName, export.ContractName))
{
return(true);
}
}
return(false);
}
public static bool TryMakeGenericPartDefinition(ComposablePartDefinition partDefinition, IEnumerable <Type> genericParameters, out ComposablePartDefinition specialization)
{
Requires.NotNull(partDefinition, "partDefinition");
specialization = null;
ReflectionComposablePartDefinition reflectionPartDefinition = partDefinition as ReflectionComposablePartDefinition;
if (reflectionPartDefinition == null)
{
throw ExceptionBuilder.CreateReflectionModelInvalidPartDefinition("partDefinition", partDefinition.GetType());
}
return(reflectionPartDefinition.TryMakeGenericPartDefinition(genericParameters.ToArray(), out specialization));
}
public static ComposablePart CreatePart(ComposablePartDefinition partDefinition, object attributedPart)
{
Requires.NotNull(partDefinition, nameof(partDefinition));
Requires.NotNull(attributedPart, nameof(attributedPart));
var reflectionComposablePartDefinition = partDefinition as ReflectionComposablePartDefinition;
if (reflectionComposablePartDefinition == null)
{
throw ExceptionBuilder.CreateReflectionModelInvalidPartDefinition(nameof(partDefinition), partDefinition.GetType());
}
return(AttributedModelDiscovery.CreatePart(reflectionComposablePartDefinition, attributedPart));
}
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);
}
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 ReflectionComposablePart CreatePart(ComposablePartDefinition partDefinition, object attributedPart)
{
if (partDefinition == null)
{
throw new ArgumentNullException(nameof(partDefinition));
}
if (attributedPart == null)
{
throw new ArgumentNullException(nameof(attributedPart));
}
return(new ReflectionComposablePart((ReflectionComposablePartDefinition)partDefinition, attributedPart));
}
public InnerPartDefinition(ComposablePartDefinition original, ComposablePartDefinition intercepting)
{
if (original == null)
{
throw new ArgumentNullException("original");
}
if (intercepting == null)
{
throw new ArgumentNullException("intercepting");
}
Original = original;
Intercepting = intercepting;
}
/// <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);
}
private ComposablePartDefinition GetComposablePartDefinition(Type type, ICompositionElement origin)
{
ICompositionElement creationInfo = (ICompositionElement)
attributedPartCreationInfoCtor.Invoke(new object[] { type, null, false, origin });
// This is where we inject our own imports and exports into the AttributedPartCreationInfo
// Fortunately for us they're lazy loaded in there, so we manage to squeeze our stuff in
// before they're defaulted to their expensive initialization codepaths.
HackCreationInfo(type, creationInfo);
ComposablePartDefinition result = (ComposablePartDefinition)
reflectionComposablePartDefinitionCtor.Invoke(new object[] { creationInfo });
return(result);
}
