internal static ComposablePartDefinition CreateComposablePartDefinition(SerializableComposablePartDefinition serializableComposablePartDefinition)
{
return(ReflectionModelServices.CreatePartDefinition(
new Lazy <Type>(() => Type.GetType(serializableComposablePartDefinition.PartTypeAssemblyQualifiedName)),
serializableComposablePartDefinition.IsDisposalRequired,
new Lazy <IEnumerable <ImportDefinition> >(() => serializableComposablePartDefinition.ImportDefinitions.Select(CreateImportDefinition)),
new Lazy <IEnumerable <ExportDefinition> >(() => serializableComposablePartDefinition.ExportDefinitions.Select(CreateExportDefinition)),
new Lazy <IDictionary <string, object> >(() => serializableComposablePartDefinition.Metadata),
null)); // TODO: Is it OK to have null for origin?
}
/// <summary>
/// Create a <see cref="ComposablePartDefinition"/> for a specified type using the provided <see cref="IPartConvention"/>.
/// </summary>
/// <param name="convention">The <see cref="IPartConvention"/> instance which is used to create the <see cref="ComposablePartDefinition"/>.</param>
/// <param name="type">The <see cref="Type"/> for which the <see cref="ComposablePartDefinition"/> should be created.</param>
/// <returns>A <see cref="ComposablePartDefinition"/> instance.</returns>
private ComposablePartDefinition CreatePartDefinition(IPartConvention convention, Type type)
{
return(ReflectionModelServices.CreatePartDefinition(
new Lazy <Type>(() => type),
false,
new Lazy <IEnumerable <ImportDefinition> >(() => CreateImportDefinitions(convention.Imports, type)),
new Lazy <IEnumerable <ExportDefinition> >(() => CreateExportDefinitions(convention.Exports, type)),
new Lazy <IDictionary <string, object> >(() => GetPartDefinitionMetadata(convention)),
null));
}
private static ComposablePartDefinition CreatePartDefinition(Type type, IList <ImportDefinition> imports, IList <ExportDefinition> exports, IDictionary <string, object> metadata)
{
return(ReflectionModelServices.CreatePartDefinition(
new Lazy <Type>(() => type, LazyThreadSafetyMode.PublicationOnly),
false,
new Lazy <IEnumerable <ImportDefinition> >(() => imports),
new Lazy <IEnumerable <ExportDefinition> >(() => exports),
new Lazy <IDictionary <string, object> >(() => metadata),
null));
}
public void RegisterType(Type implementation, Type contract, string key = null)
{
var part = ReflectionModelServices.CreatePartDefinition(
new Lazy <Type>(() => implementation),
false,
new Lazy <IEnumerable <ImportDefinition> >(() => GetImportDefinitions(implementation)),
new Lazy <IEnumerable <ExportDefinition> >(() => GetExportDefinitions(implementation, contract, key)),
new Lazy <IDictionary <string, object> >(() => new Dictionary <string, object>()),
null
);
parts.Add(part);
}
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));
}
/// <summary>
/// Clones the non-shared to avoid object instance reuse,
/// which happens if you cache the part definition.
/// </summary>
private IEnumerable <ComposablePartDefinition> CloneNonSharedParts()
{
return(this.nonSharedParts
.AsParallel()
.Where(part => part != null)
.Select(def => ReflectionModelServices.CreatePartDefinition(
ReflectionModelServices.GetPartType(def),
true,
new Lazy <IEnumerable <ImportDefinition> >(() => def.ImportDefinitions),
new Lazy <IEnumerable <ExportDefinition> >(() => def.ExportDefinitions),
new Lazy <IDictionary <string, object> >(() => def.Metadata),
this)));
}
private IEnumerable <ComposablePartDefinition> BuildParts(IQueryable <ComposablePartDefinition> parts)
{
return(parts.Select(def => ReflectionModelServices.CreatePartDefinition(
ReflectionModelServices.GetPartType(def),
true,
new Lazy <IEnumerable <ImportDefinition> >(() => def.ImportDefinitions),
new Lazy <IEnumerable <ExportDefinition> >(() => def.ExportDefinitions.Select(export =>
ReflectionModelServices.CreateExportDefinition(
ReflectionModelServices.GetExportingMember(export),
export.ContractName,
new Lazy <IDictionary <string, object> >(() => VisitExport(def, export)),
this))),
new Lazy <IDictionary <string, object> >(() => VisitPart(def)),
this)));
}
/// <summary>
/// 注册一个指定协定类型的实现类型。
/// </summary>
/// <param name="contractType">协定类型。</param>
/// <param name="implType">实现类型。</param>
/// <param name="replace">是否替换已有的部件定义。</param>
/// <returns>当前的 <see cref="ConventionalCatalog"/> 对象。</returns>
public ConventionalCatalog Register(Type contractType, Type implType, bool replace = true)
{
Guard.ArgumentNull(contractType, "contractType");
Guard.ArgumentNull(implType, "implType");
if (!IsRegisted(contractType) || replace)
{
var part = ReflectionModelServices.CreatePartDefinition(
new Lazy <Type>(() => implType),
false,
new Lazy <IEnumerable <ImportDefinition> >(() => GetImportDefinitions(implType)),
new Lazy <IEnumerable <ExportDefinition> >(() => GetExportDefinitions(implType, contractType)), null, null);
partDictionary.AddOrReplace(contractType, part);
}
return(this);
}
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;
}
public static ComposablePartDefinition ReadPartDefinition(IDictionary <string, object> cache, Func <ComposablePartDefinition, IEnumerable <ImportDefinition> > importsCreator, Func <ComposablePartDefinition, IEnumerable <ExportDefinition> > exportsCreator, Func <Assembly> assemblyLoader)
{
Assumes.NotNull(cache);
Lazy <Type> partType = cache.ReadLazyTypeForPart(assemblyLoader);
ComposablePartDefinition part = null;
part = ReflectionModelServices.CreatePartDefinition(
partType,
cache.ReadValue <bool>(AttributedCacheServices.CacheKeys.IsDisposalRequired, false),
LazyServices.MakeLazy(() => importsCreator(part)),
LazyServices.MakeLazy(() => exportsCreator(part)),
cache.ReadLazyMetadata(),
null);
return(part);
}
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);
}