public override IEnumerable<CompositionDependency> GetDependencies(TypeInfo partType, DependencyAccessor definitionAccessor)
{
var partTypeAsType = partType.AsType();
var imports = (from pi in partTypeAsType.GetRuntimeProperties()
.Where(pi => pi.CanWrite && pi.SetMethod.IsPublic && !(pi.SetMethod.IsStatic))
let attrs = _attributeContext.GetDeclaredAttributes(pi.DeclaringType, pi).ToArray()
let site = new PropertyImportSite(pi)
where attrs.Any(a => a is ImportAttribute || a is ImportManyAttribute)
select new { Site = site, ImportInfo = ContractHelpers.GetImportInfo(pi.PropertyType, attrs, site) }).ToArray();
if (imports.Length == 0)
return NoDependencies;
var result = new List<CompositionDependency>();
foreach (var i in imports)
{
if (!i.ImportInfo.AllowDefault)
{
result.Add(definitionAccessor.ResolveRequiredDependency(i.Site, i.ImportInfo.Contract, false));
}
else
{
CompositionDependency optional;
if (definitionAccessor.TryResolveOptionalDependency(i.Site, i.ImportInfo.Contract, false, out optional))
result.Add(optional);
// Variation from CompositionContainer behaviour: we don't have to support recomposition
// so we don't require that defaultable imports be set to null.
}
}
return result;
}
public override IEnumerable<ExportDescriptorPromise> GetExportDescriptors(CompositionContract contract, DependencyAccessor descriptorAccessor)
{
// Avoid trying to create defaults-of-defaults-of...
if (contract.ContractName != null && contract.ContractName.StartsWith(Constants.DefaultContractNamePrefix))
return NoExportDescriptors;
var implementations = descriptorAccessor.ResolveDependencies("test for default", contract, false);
if (implementations.Any())
return NoExportDescriptors;
var defaultImplementationDiscriminator = Constants.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);
})
};
}
private IEnumerable<CompositionDependency> GetPartActivatorDependencies(DependencyAccessor definitionAccessor)
{
var partTypeAsType = _partType.AsType();
if (_constructor == null)
{
foreach (var c in _partType.DeclaredConstructors.Where(ci => ci.IsPublic && !(ci.IsStatic)))
{
if (_attributeContext.GetDeclaredAttribute<ImportingConstructorAttribute>(partTypeAsType, c) != null)
{
if (_constructor != null)
{
var message = string.Format(Properties.Resources.DiscoveredPart_MultipleImportingConstructorsFound, _partType);
throw new CompositionFailedException(message);
}
_constructor = c;
}
}
if (_constructor == null)
_constructor = _partType.DeclaredConstructors
.FirstOrDefault(ci => ci.IsPublic && !(ci.IsStatic || ci.GetParameters().Any()));
if (_constructor == null)
{
var message = string.Format(Properties.Resources.DiscoveredPart_NoImportingConstructorsFound, _partType);
throw new CompositionFailedException(message);
}
}
var cps = _constructor.GetParameters();
for (var i = 0; i < cps.Length; ++i)
{
var pi = cps[i];
var site = new ParameterImportSite(pi);
var importInfo = ContractHelpers.GetImportInfo(pi.ParameterType, _attributeContext.GetDeclaredAttributes(partTypeAsType, pi), site);
if (!importInfo.AllowDefault)
{
yield return definitionAccessor.ResolveRequiredDependency(site, importInfo.Contract, true);
}
else
{
CompositionDependency optional;
if (definitionAccessor.TryResolveOptionalDependency(site, importInfo.Contract, true, out optional))
yield return optional;
}
}
}
