/// <summary>
/// Creates a new instance of a part that the <see cref="T:System.ComponentModel.Composition.Primitives.ComposablePartDefinition"/> describes.
/// </summary>
/// <returns>The created part.</returns>
public override ComposablePart CreatePart()
{
ComposablePart part = null;
ComposablePart tempPart = null;
try
{
tempPart = ReflectionModelServices.IsDisposalRequired(this._sourcePart)
? new DisposableIsolatingComposablePart(this._sourcePart, this._isolationMetadata)
: new IsolatingComposablePart(this._sourcePart, this._isolationMetadata);
part = tempPart;
tempPart = null;
}
finally
{
if (tempPart != null)
{
var disposablePart = (tempPart as IDisposable);
if (disposablePart != null)
{
disposablePart.Dispose();
}
}
}
return(part);
}
public override ComposablePart CreatePart()
{
var interceptedPart = InterceptedPartDefinition.CreatePart();
return(ReflectionModelServices.IsDisposalRequired(InterceptedPartDefinition)
? new DisposableInterceptingComposablePart(interceptedPart, this.valueInterceptor)
: new InterceptingComposablePart(interceptedPart, this.valueInterceptor));
}
public static SerializableComposablePartDefinition FromComposablePartDefinition(ComposablePartDefinition composablePartDefinition)
{
return(new SerializableComposablePartDefinition()
{
PartTypeAssemblyQualifiedName = ReflectionModelServices.GetPartType(composablePartDefinition).Value.AssemblyQualifiedName,
IsDisposalRequired = ReflectionModelServices.IsDisposalRequired(composablePartDefinition),
ImportDefinitions = composablePartDefinition.ImportDefinitions.Select(importDefinition => new SerializableImportDefinition(importDefinition)).ToList(),
ExportDefinitions = composablePartDefinition.ExportDefinitions.Select(exportDefinition => new SerializableExportDefinition(exportDefinition)).ToList(),
Metadata = new SerializableDictionary <string, object>(composablePartDefinition.Metadata),
});
}
public override ComposablePart CreatePart()
{
var innerPart = _innerPartDefinition.CreatePart();
if (ReflectionModelServices.IsDisposalRequired(_innerPartDefinition) &&
_innerPartDefinition.Metadata.ContainsKey(CompositionConstants.PartCreationPolicyMetadataName) &&
(CreationPolicy)_innerPartDefinition.Metadata[CompositionConstants.PartCreationPolicyMetadataName] == CreationPolicy.NonShared)
{
return(new NonDisposableComposablePart(innerPart));
}
return(innerPart);
}
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));
}
private void ComposeDecoration()
{
if (myParts.Any())
{
return;
}
var contracts = new List <string>();
foreach (var type in myDecoratorChain)
{
var originalPart = AttributedModelServices.CreatePartDefinition(type, null);
var importDefs = originalPart.ImportDefinitions.ToList();
if (type != myDecoratorChain.First())
{
RewriteContract(type, importDefs, contracts.Last());
}
var exportDefs = originalPart.ExportDefinitions.ToList();
if (type != myDecoratorChain.Last())
{
contracts.Add(Guid.NewGuid().ToString());
RewriteContract(type, exportDefs, type, contracts.Last());
}
// as we pass it to lazy below we have to copy it to local variable - otherwise we create a closure with the loop iterator variable
// and this will cause the actual part type to be changed
var partType = type;
var part = ReflectionModelServices.CreatePartDefinition(
new Lazy <Type>(() => partType),
ReflectionModelServices.IsDisposalRequired(originalPart),
new Lazy <IEnumerable <ImportDefinition> >(() => importDefs),
new Lazy <IEnumerable <ExportDefinition> >(() => exportDefs),
new Lazy <IDictionary <string, object> >(() => new Dictionary <string, object>()),
null);
myParts.Add(part);
}
// no add possible any longer
myDecoratorChain = null;
}
private ComposablePartDefinition RewritePart(ComposablePartDefinition definition)
{
var closedGenericContractType = ContractType.MakeGenericType(ExportingType.GetGenericArguments());
var closedGenericTypeIdentity = AttributedModelServices.GetTypeIdentity(closedGenericContractType);
var openGenericTypeIdentity = AttributedModelServices.GetTypeIdentity(ContractType);
var openGenericContractName = AttributedModelServices.GetContractName(ContractType);
var exports = new List <ExportDefinition>();
var hasRewrittenExports = false;
foreach (var exportDefinition in definition.ExportDefinitions)
{
// Rewrite only exports having open-generics type identity of the contract type we do care about
if (openGenericTypeIdentity == (string)exportDefinition.Metadata[CompositionConstants.ExportTypeIdentityMetadataName])
{
// If both open-generic contract name and the present contract name are equal,
// contract name has to be rewritten to form a closed-generic contract
var contractName = openGenericContractName == exportDefinition.ContractName
? AttributedModelServices.GetContractName(closedGenericContractType)
: exportDefinition.ContractName;
// Preserve all the metadata except the type identity as it has to be rewritten
var metadata = new Dictionary <string, object>
{
{ CompositionConstants.ExportTypeIdentityMetadataName, closedGenericTypeIdentity }
};
foreach (var key in exportDefinition.Metadata.Keys.Where(key => key != CompositionConstants.ExportTypeIdentityMetadataName))
{
metadata.Add(key, exportDefinition.Metadata[key]);
}
// Rewrite the export
var rewrittenExport = ReflectionModelServices.CreateExportDefinition(
ReflectionModelServices.GetExportingMember(exportDefinition),
contractName,
new Lazy <IDictionary <string, object> >(() => metadata),
exportDefinition as ICompositionElement);
exports.Add(rewrittenExport);
hasRewrittenExports = true;
}
else
{
// This export is ok, copy the original
exports.Add(exportDefinition);
}
}
// If the part has any rewritten exports, we have to rewrite the part itself
if (hasRewrittenExports)
{
return(ReflectionModelServices.CreatePartDefinition(
ReflectionModelServices.GetPartType(definition),
ReflectionModelServices.IsDisposalRequired(definition),
new Lazy <IEnumerable <ImportDefinition> >(() => definition.ImportDefinitions),
new Lazy <IEnumerable <ExportDefinition> >(() => exports),
new Lazy <IDictionary <string, object> >(() => definition.Metadata),
definition as ICompositionElement));
}
return(definition);
}
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);
}