internal IEnumerable <CompositionDependency> Resolve()
{
const string site = "configuration";
const bool isPrerequisite = true;
var queueContract = new CompositionContract(typeof(SqlMessageQueueConfiguration));
var eventStoreContract = new CompositionContract(typeof(SqlEventStoreConfiguration), entityName);
var sagaContract = new CompositionContract(typeof(SqlSagaStorageConfiguration));
yield return(descriptorAccessor.ResolveRequiredDependency(site, queueContract, isPrerequisite));
yield return(descriptorAccessor.ResolveRequiredDependency(site, eventStoreContract, isPrerequisite));
yield return(descriptorAccessor.ResolveRequiredDependency(site, sagaContract, isPrerequisite));
}
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 && _partType.IsGenericType)
{
_constructor = GetConstructorInfoFromGenericType(_partType);
}
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 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);
}
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.");
}
}
// The source will only be asked for parts once per exportKey, but it is the
// source's responsibility to return the same part multiple times when that part
// has more than one export (not shown here.)
//
public override IEnumerable <ExportDescriptorPromise> GetExportDescriptors(CompositionContract contract, DependencyAccessor definitionAccessor)
{
if (contract.Equals(new CompositionContract(typeof(RequestListener))))
{
return new[] { RequestListenerPart(contract, definitionAccessor) }
}
;
if (contract.Equals(new CompositionContract(typeof(ConsoleLog))))
{
return new[] { ConsoleLogPart(contract, definitionAccessor) }
}
;
return(NoExportDescriptors);
}
// Console log is a disposable singleton (no boundaries)
// that exports itself under its own concrete type.
//
ExportDescriptorPromise ConsoleLogPart(CompositionContract contract, DependencyAccessor definitionAccessor)
{
return(new ExportDescriptorPromise(
contract,
typeof(ConsoleLog).Name,
true,
NoDependencies,
_ =>
{
var sharingId = LifetimeContext.AllocateSharingId();
return ExportDescriptor.Create((c, o) =>
{
CompositeActivator activatorBody = (sc, so) =>
{
var result = new ConsoleLog();
c.AddBoundInstance(result);
return result;
};
var scope = c.FindContextWithin(null);
if (object.ReferenceEquals(scope, c))
{
return scope.GetOrCreate(sharingId, o, activatorBody);
}
else
{
return CompositionOperation.Run(scope, (c1, o1) => c1.GetOrCreate(sharingId, o1, activatorBody));
}
}, NoMetadata);
}));
}
// Non-shared part that exports itself and has a dependency on ConsoleLog.
//
ExportDescriptorPromise RequestListenerPart(CompositionContract contract, DependencyAccessor definitionAccessor)
{
return(new ExportDescriptorPromise(
contract,
typeof(RequestListener).Name,
false,
() => new[] { definitionAccessor.ResolveRequiredDependency("log", new CompositionContract(typeof(Lazy <ConsoleLog>)), true) },
dependencies =>
{
var logActivator = dependencies.Single().Target.GetDescriptor().Activator;
return ExportDescriptor.Create((c, o) =>
{
var log = (Lazy <ConsoleLog>)logActivator(c, o);
return new RequestListener(log);
}, NoMetadata);
}));
}
}
}
