/// <summary>
/// Register a MEF part definition.
/// </summary>
/// <param name="builder">The container builder.</param>
/// <param name="partDefinition">The part definition to register.</param>
/// <param name="exposedServicesMapper">A mapping function to transform ExportDefinitions into Services.</param>
public static void RegisterComposablePartDefinition(this ContainerBuilder builder, ComposablePartDefinition partDefinition, Func <ExportDefinition, IEnumerable <Service> > exposedServicesMapper)
{
if (builder == null)
{
throw new ArgumentNullException("builder");
}
if (partDefinition == null)
{
throw new ArgumentNullException("partDefinition");
}
if (exposedServicesMapper == null)
{
throw new ArgumentNullException("exposedServicesMapper");
}
var partId = new UniqueService();
var partRegistration = builder.Register(c => partDefinition.CreatePart())
.OnActivating(e => SetPrerequisiteImports(e.Context, e.Instance))
.OnActivated(e => SetNonPrerequisiteImports(e.Context, e.Instance))
.As(partId);
if (IsSharedInstance(partDefinition))
{
partRegistration.SingleInstance();
}
foreach (var iterExportDef in partDefinition.ExportDefinitions)
{
var exportDef = iterExportDef;
var contractService = new ContractBasedService(exportDef.ContractName, GetTypeIdentity(exportDef));
var exportId = new UniqueService();
builder.Register(c =>
{
var p = ((ComposablePart)c.ResolveService(partId));
return(new Export(exportDef, () => p.GetExportedValue(exportDef)));
})
.As(exportId, contractService)
.ExternallyOwned()
.WithMetadata(exportDef.Metadata);
var additionalServices = exposedServicesMapper(exportDef).ToArray();
if (additionalServices.Length > 0)
{
builder.Register(c => ((Export)c.ResolveService(exportId)).Value)
.As(additionalServices)
.ExternallyOwned()
.WithMetadata(exportDef.Metadata);
}
}
}
static void AttachExport(IComponentRegistry registry, IComponentRegistration registration, ExportConfigurationBuilder exportConfiguration)
{
var contractService = new ContractBasedService(exportConfiguration.ContractName, exportConfiguration.ExportTypeIdentity);
var service = registration.Services.FirstOrDefault();
var rb =
RegistrationBuilder.ForDelegate((c, p) =>
new Export(
new ExportDefinition(exportConfiguration.ContractName, exportConfiguration.Metadata),
() => c.ResolveComponent(service, registration, new Parameter[0])))
.As(contractService)
.ExternallyOwned()
.WithMetadata(exportConfiguration.Metadata);
registry.Register(rb.CreateRegistration());
}
static List <IComponentRegistration> ComponentsForContract(this IComponentContext context, ContractBasedImportDefinition cbid)
{
var contractService = new ContractBasedService(cbid.ContractName, cbid.RequiredTypeIdentity);
var componentsForContract = context
.ComponentRegistry
.RegistrationsFor(contractService)
.Where(cpt =>
!cbid.RequiredMetadata
.Except(cpt.Metadata.Select(m => new KeyValuePair <string, Type>(m.Key, m.Value.GetType())))
.Any())
.ToList();
if (cbid.Cardinality == ImportCardinality.ExactlyOne && componentsForContract.Count == 0)
{
throw new ComponentNotRegisteredException(contractService);
}
return(componentsForContract);
}
