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)
{
string message = SR.Format(SR.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)
{
string message = SR.Format(SR.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);
}
}
}
}
public bool InspectTypeForPart(TypeInfo type, out DiscoveredPart part)
{
part = null;
if (type.IsAbstract || !type.IsClass || _attributeContext.GetDeclaredAttribute <PartNotDiscoverableAttribute>(type.AsType(), type) != null)
{
return(false);
}
foreach (var export in DiscoverExports(type))
{
part = part ?? new DiscoveredPart(type, _attributeContext, _activationFeatures);
part.AddDiscoveredExport(export);
}
return(part != null);
}
public override CompositeActivator RewriteActivator(
TypeInfo partType,
CompositeActivator activator,
IDictionary <string, object> partMetadata,
IEnumerable <CompositionDependency> dependencies)
{
var result = activator;
var partTypeAsType = partType.AsType();
var importsSatisfiedMethods = partTypeAsType.GetRuntimeMethods()
.Where(mi => _attributeContext.GetDeclaredAttribute <OnImportsSatisfiedAttribute>(mi.DeclaringType, mi) != null);
foreach (var m in importsSatisfiedMethods)
{
if (!(m.IsPublic || m.IsAssembly) | m.IsStatic || m.ReturnType != typeof(void) ||
m.IsGenericMethodDefinition || m.GetParameters().Length != 0)
{
var message = string.Format(
Properties.Resources.OnImportsSatisfiedFeature_AttributeError,
partType, m.Name);
throw new CompositionFailedException(message);
}
var ois = Expression.Parameter(typeof(object), "ois");
var call = Expression.Lambda <Action <object> >(
Expression.Call(Expression.Convert(ois, partType.AsType()), m), ois).Compile();
var prev = result;
result = (c, o) =>
{
var psn = prev(c, o);
o.AddPostCompositionAction(() => call(psn));
return(psn);
};
}
return(result);
}