static ExportDescriptorPromise GetDictionaryDefinition <TKey, TValue>(CompositionContract dictionaryContract, CompositionContract valueContract, DependencyAccessor definitionAccessor, string keyByMetadataName)
{
return(new ExportDescriptorPromise(
dictionaryContract,
typeof(IDictionary <TKey, TValue>).Name,
false,
() => definitionAccessor.ResolveDependencies("value", valueContract, true),
deps => {
var items = deps.Select(d => Tuple.Create(d.Target.Origin, d.Target.GetDescriptor())).ToArray();
var isValidated = false;
return ExportDescriptor.Create((c, o) =>
{
if (!isValidated)
{
Validate <TKey>(items, keyByMetadataName);
isValidated = true;
}
return items.ToDictionary(
item => (TKey)item.Item2.Metadata[keyByMetadataName],
item => (TValue)item.Item2.Activator(c, o));
},
NoMetadata);
}));
}
static ExportDescriptorPromise[] GetExportFactoryDescriptors <TProduct>(CompositionContract exportFactoryContract, DependencyAccessor definitionAccessor)
{
var productContract = exportFactoryContract.ChangeType(typeof(TProduct));
var boundaries = new string[0];
IEnumerable <string> specifiedBoundaries;
CompositionContract unwrapped;
if (exportFactoryContract.TryUnwrapMetadataConstraint(Constants.SharingBoundaryImportMetadataConstraintName, out specifiedBoundaries, out unwrapped))
{
productContract = unwrapped.ChangeType(typeof(TProduct));
boundaries = (specifiedBoundaries ?? new string[0]).ToArray();
}
return(definitionAccessor.ResolveDependencies("product", productContract, false)
.Select(d => new ExportDescriptorPromise(
exportFactoryContract,
Formatters.Format(typeof(ExportFactory <TProduct>)),
false,
() => new[] { d },
_ =>
{
var dsc = d.Target.GetDescriptor();
var da = dsc.Activator;
return ExportDescriptor.Create((c, o) =>
{
return new ExportFactory <TProduct>(() => {
var lifetimeContext = new LifetimeContext(c, boundaries);
return Tuple.Create <TProduct, Action>((TProduct)CompositionOperation.Run(lifetimeContext, da), lifetimeContext.Dispose);
});
},
dsc.Metadata);
}))
.ToArray());
}
public override IEnumerable <ExportDescriptorPromise> GetExportDescriptors(CompositionContract contract, DependencyAccessor definitionAccessor)
{
if (contract.ContractType.IsAbstract ||
!contract.ContractType.IsClass ||
!contract.Equals(new CompositionContract(contract.ContractType)))
{
return(NoExportDescriptors);
}
if (!definitionAccessor.ResolveDependencies("test", contract, false).Any())
{
return(NoExportDescriptors);
}
return(new[] { new ExportDescriptorPromise(
contract,
contract.ContractType.Name,
false,
NoDependencies,
_ => ExportDescriptor.Create((c, o) => {
var instance = Activator.CreateInstance(contract.ContractType);
if (instance is IDisposable)
{
c.AddBoundInstance((IDisposable)instance);
}
return instance;
}, NoMetadata)) });
}
public override IEnumerable <ExportDescriptorPromise> GetExportDescriptors(CompositionContract contract, DependencyAccessor descriptorAccessor)
{
var implementations = descriptorAccessor.ResolveDependencies("test", contract, false);
if (!implementations.Any())
{
var promise = new ExportDescriptorPromise(
contract,
contract.ContractType.Name,
false,
NoDependencies,
_ => ExportDescriptor.Create((c, o) =>
{
object export;
if ((c.ToString() != "Root Lifetime Context" && c.TryGetExport(typeof(MefServiceScopeFallback), out export) ||
c.TryGetExport(typeof(MefServiceRootFallback), out export)) &&
export is IMefServiceFallback serviceProvider)
{
return(serviceProvider.FallbackServiceProvider?.GetService(contract.ContractType));
}
return(null);
}, NoMetadata));
return(new[] { promise });
}
return(NoExportDescriptors);
}
internal IEnumerable <CompositionDependency> Resolve()
{
const string site = "configuration";
const bool isPrerequisite = true;
var metadata = new Dictionary <string, object>()
{
["Key"] = key
};
var contract = new CompositionContract(typeof(string), key, metadata);
return(descriptorAccessor.ResolveDependencies(site, contract, isPrerequisite));
}
static ExportDescriptorPromise GetImportManyDescriptor <TElement>(CompositionContract importManyContract, CompositionContract elementContract, DependencyAccessor definitionAccessor)
{
return(new ExportDescriptorPromise(
importManyContract,
typeof(TElement[]).Name,
false,
() => definitionAccessor.ResolveDependencies("item", elementContract, true),
d =>
{
var dependentDescriptors = d
.Select(el => el.Target.GetDescriptor())
.ToArray();
return ExportDescriptor.Create((c, o) => dependentDescriptors.Select(e => (TElement)e.Activator(c, o)).ToArray(), NoMetadata);
}));
}
public override IEnumerable <ExportDescriptorPromise> GetExportDescriptors(CompositionContract contract, DependencyAccessor descriptorAccessor)
{
if (!contract.Equals(_supportedContract))
{
return(NoExportDescriptors);
}
var implementations = descriptorAccessor.ResolveDependencies("test for existing", contract, false);
if (implementations.Any())
{
return(NoExportDescriptors);
}
return(new[] { new ExportDescriptorPromise(contract, "test metadataProvider", false, NoDependencies, _ => ExportDescriptor.Create((c, o) => DefaultObject, NoMetadata)) });
}
private static ExportDescriptorPromise[] GetLazyDefinitions <TValue>(CompositionContract lazyContract, DependencyAccessor definitionAccessor)
{
return(definitionAccessor.ResolveDependencies("value", lazyContract.ChangeType(typeof(TValue)), false)
.Select(d => new ExportDescriptorPromise(
lazyContract,
Formatters.Format(typeof(Lazy <TValue>)),
false,
() => new[] { d },
_ =>
{
var dsc = d.Target.GetDescriptor();
var da = dsc.Activator;
return ExportDescriptor.Create((c, o) => new Lazy <TValue>(() => (TValue)CompositionOperation.Run(c, da)), dsc.Metadata);
}))
.ToArray());
}
public override IEnumerable <ExportDescriptorPromise> GetExportDescriptors(CompositionContract contract, DependencyAccessor descriptorAccessor)
{
// Avoid trying to create defaults-of-defaults-of...
if (contract.ContractName != null && contract.ContractName.StartsWith(DefaultContractNamePrefix))
{
return(NoExportDescriptors);
}
var implementations = descriptorAccessor.ResolveDependencies("test for default", contract, false);
if (implementations.Any())
{
return(NoExportDescriptors);
}
var defaultImplementationDiscriminator = DefaultContractNamePrefix + (contract.ContractName ?? "");
IDictionary <string, object> copiedConstraints = null;
if (contract.MetadataConstraints != null)
{
copiedConstraints = contract.MetadataConstraints.ToDictionary(k => k.Key, k => k.Value);
}
var defaultImplementationContract = new CompositionContract(contract.ContractType, defaultImplementationDiscriminator, copiedConstraints);
CompositionDependency defaultImplementation;
if (!descriptorAccessor.TryResolveOptionalDependency("default", defaultImplementationContract, true, out defaultImplementation))
{
return(NoExportDescriptors);
}
return(new[] { new ExportDescriptorPromise(
contract,
"Default Implementation",
false,
() => new[] { defaultImplementation },
_ => {
var defaultDescriptor = defaultImplementation.Target.GetDescriptor();
return ExportDescriptor.Create((c, o) => defaultDescriptor.Activator(c, o), defaultDescriptor.Metadata);
}) });
}
IEnumerable <CompositionDependency> ImportDefinitionToDependency(ImportDefinition def, DependencyAccessor descriptorAccessor)
{
var cbid = def as ContractBasedImportDefinition;
if (cbid == null)
{
throw new CompositionFailedException("Only typed (contract-based) import definitions are supported.");
}
var contract = ImportDefinitionToContract(cbid);
switch (cbid.Cardinality)
{
case ImportCardinality.ExactlyOne:
yield return(descriptorAccessor.ResolveRequiredDependency(def, contract, def.IsPrerequisite));
break;
case ImportCardinality.ZeroOrOne:
CompositionDependency result;
if (descriptorAccessor.TryResolveOptionalDependency(def, contract, def.IsPrerequisite, out result))
{
yield return(result);
}
break;
case ImportCardinality.ZeroOrMore:
foreach (var item in descriptorAccessor.ResolveDependencies(def, contract, def.IsPrerequisite))
{
yield return(item);
}
break;
default:
throw new CompositionFailedException("Unsupported cardinality.");
}
}
