public void Run_ValidContextAndAction_ReturnsExpected()
{
using (CompositionHost host = CompositionHost.CreateCompositionHost(new ExportDescriptorProvider[0]))
{
Assert.True(host.TryGetExport(new CompositionContract(typeof(CompositionContext)), out object export));
LifetimeContext context = Assert.IsType <LifetimeContext>(export);
var results = new List <string>();
void NonPrequisiteAction1() => results.Add("NonPrequisiteAction1");
void NonPrequisiteAction2() => results.Add("NonPrequisiteAction2");
void PostCompositionAction1() => results.Add("PostCompositionAction1");
void PostCompositionAction2() => results.Add("PostCompositionAction2");
object Activator(LifetimeContext activatorContext, CompositionOperation activatorOperation)
{
Assert.Same(context, activatorContext);
activatorOperation.AddNonPrerequisiteAction(NonPrequisiteAction1);
activatorOperation.AddNonPrerequisiteAction(NonPrequisiteAction2);
activatorOperation.AddPostCompositionAction(PostCompositionAction1);
activatorOperation.AddPostCompositionAction(PostCompositionAction2);
return("Hi");
}
Assert.Equal("Hi", CompositionOperation.Run(context, Activator));
Assert.Equal(new string[] { "NonPrequisiteAction1", "NonPrequisiteAction2", "PostCompositionAction1", "PostCompositionAction2" }, results);
}
}
public override CompositeActivator RewriteActivator(
TypeInfo partType,
CompositeActivator activatorBody,
IDictionary <string, object> partMetadata,
IEnumerable <CompositionDependency> dependencies)
{
if (!ContractHelpers.IsShared(partMetadata))
{
return(activatorBody);
}
object sharingBoundaryMetadata;
if (!partMetadata.TryGetValue(SharingBoundaryPartMetadataName, out sharingBoundaryMetadata))
{
sharingBoundaryMetadata = null;
}
var sharingBoundary = (string)sharingBoundaryMetadata;
var sharingKey = LifetimeContext.AllocateSharingId();
return((c, o) =>
{
var scope = c.FindContextWithin(sharingBoundary);
if (object.ReferenceEquals(scope, c))
{
return scope.GetOrCreate(sharingKey, o, activatorBody);
}
else
{
return CompositionOperation.Run(scope, (c1, o1) => c1.GetOrCreate(sharingKey, o1, activatorBody));
}
});
}
public void GetOrCreate_ValidActivatorAfterInitialization_Success()
{
using (CompositionHost host = CompositionHost.CreateCompositionHost(new ExportDescriptorProvider[0]))
{
Assert.True(host.TryGetExport(new CompositionContract(typeof(CompositionContext)), out object export));
LifetimeContext context = Assert.IsType<LifetimeContext>(export);
CompositionOperation operation = null;
var value = new object();
object GetOrCreateActivate(LifetimeContext getOrCreateContext, CompositionOperation getOrCreateOperator)
{
Assert.Same(context, getOrCreateContext);
Assert.Same(operation, getOrCreateOperator);
return value;
}
object Activator(LifetimeContext activatorContext, CompositionOperation activatorOperation)
{
operation = activatorOperation;
Assert.Same(value, context.GetOrCreate(1, operation, GetOrCreateActivate));
return "Hi";
}
Assert.Equal("Hi", CompositionOperation.Run(context, Activator));
Assert.Same(value, context.GetOrCreate(1, operation, GetOrCreateActivate));
}
}
static object SubscriptionIdActivator(LifetimeContext context, CompositionOperation operation, IEnumerable <CompositionDependency> dependencies)
{
var dependency = dependencies.Single().Target.GetDescriptor();
var subscriptionId = (string)Run(context, dependency.Activator);
return(new Guid(subscriptionId));
}
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());
}
static object PersistenceActivator(LifetimeContext context, CompositionOperation operation, IEnumerable <CompositionDependency> dependencies)
{
var map = dependencies.ToDictionary(d => d.Contract.ContractType, d => d.Target.GetDescriptor().Activator);
var queueConfiguration = (SqlMessageQueueConfiguration)Run(context, map[typeof(SqlMessageQueueConfiguration)]);
var eventStoreConfiguration = (SqlEventStoreConfiguration)Run(context, map[typeof(SqlEventStoreConfiguration)]);
var sagaConfiguration = (SqlSagaStorageConfiguration)Run(context, map[typeof(SqlSagaStorageConfiguration)]);
return(new SqlPersistence(queueConfiguration, eventStoreConfiguration, sagaConfiguration));
}
CompositeActivator CreateActivator(IEnumerable <CompositionDependency> dependencies)
{
var dependenciesByImport = dependencies.GroupBy(d => (ContractBasedImportDefinition)d.Site, d => d.Target.GetDescriptor());
var prereqs = dependenciesByImport.Where(d => d.Key.IsPrerequisite).ToArray();
var nonprereqs = dependenciesByImport.Where(d => !d.Key.IsPrerequisite).ToArray();
var unset = _part.ImportDefinitions.Where(id => !prereqs.Concat(nonprereqs).Any(k => k.Key.Equals((ContractBasedImportDefinition)id))).ToArray();
CompositeActivator construct = (c, o) =>
{
var result = _part.CreatePart();
if (result is IDisposable)
{
c.AddBoundInstance((IDisposable)result);
}
foreach (var pre in prereqs)
{
result.SetImport(pre.Key, DependenciesToExports(c, pre));
}
foreach (var un in unset)
{
result.SetImport(un, Enumerable.Empty <Export>());
}
o.AddNonPrerequisiteAction(() =>
{
foreach (var np in nonprereqs)
{
result.SetImport(np.Key, DependenciesToExports(c, np));
}
});
o.AddPostCompositionAction(() =>
{
result.Activate();
});
return(result);
};
if (!IsShared)
{
return(construct);
}
var sharingId = LifetimeContext.AllocateSharingId();
CompositeActivator constructAndShare = (c, o) => c.GetOrCreate(sharingId, o, construct);
return((c, o) =>
{
var scope = c.FindContextWithin(_boundary);
return scope.Equals(c) ?
constructAndShare(scope, o) :
CompositionOperation.Run(scope, constructAndShare);
});
}
static object SagaStorageConfigurationActivator(LifetimeContext context, CompositionOperation operation, IEnumerable <CompositionDependency> dependencies)
{
var dependency = dependencies.Single().Target.GetDescriptor();
var connectionString = (string)Run(context, dependency.Activator);
var builder = new SqlSagaStorageConfigurationBuilder();
builder.HasConnectionString(connectionString);
return(builder.CreateConfiguration());
}
public DelegateExportDescriptorProvider(Func <object> exportedInstanceFactory, Type contractType, string contractName, IDictionary <string, object> metadata, bool isShared)
: base(contractType, contractName, metadata)
{
if (exportedInstanceFactory == null)
{
throw new ArgumentNullException("exportedInstanceFactory");
}
// Runs the factory method, validates the result and registers it for disposal if necessary.
CompositeActivator constructor = (c, o) =>
{
var result = exportedInstanceFactory();
if (result == null)
{
throw new InvalidOperationException("Delegate factory returned null.");
}
if (result is IDisposable)
{
c.AddBoundInstance((IDisposable)result);
}
return(result);
};
if (isShared)
{
var sharingId = LifetimeContext.AllocateSharingId();
_activator = (c, o) =>
{
// Find the root composition scope.
var scope = c.FindContextWithin(null);
if (scope == c)
{
// We're already in the root scope, create the instance
return(scope.GetOrCreate(sharingId, o, constructor));
}
else
{
// Composition is moving up the hierarchy of scopes; run
// a new operation in the root scope.
return(CompositionOperation.Run(scope, (c1, o1) => c1.GetOrCreate(sharingId, o1, constructor)));
}
};
}
else
{
_activator = constructor;
}
}
static object EventStoreConfigurationActivator(LifetimeContext context, CompositionOperation operation, IEnumerable <CompositionDependency> dependencies, string entityName)
{
var dependency = dependencies.Single().Target.GetDescriptor();
var connectionString = (string)Run(context, dependency.Activator);
var builder = new SqlEventStoreConfigurationBuilder();
builder.HasConnectionString(connectionString);
if (!string.IsNullOrEmpty(entityName))
{
builder.HasEntityName(entityName);
}
return(builder.CreateConfiguration());
}
public void GetOrCreate_NullActivator_ThrowsNullReferenceException()
{
using (CompositionHost host = CompositionHost.CreateCompositionHost(new ExportDescriptorProvider[0]))
{
Assert.True(host.TryGetExport(new CompositionContract(typeof(CompositionContext)), out object export));
LifetimeContext context = Assert.IsType<LifetimeContext>(export);
object Activator(LifetimeContext activatorContext, CompositionOperation activatorOperation)
{
Assert.Throws<NullReferenceException>(() => activatorContext.GetOrCreate(1, activatorOperation, null));
return "Hi";
}
Assert.Equal("Hi", CompositionOperation.Run(context, Activator));
}
}
public void AddPostCompositionAction_NullAction_ThrowsArgumentNullException()
{
object Activator(LifetimeContext context, CompositionOperation operation)
{
AssertExtensions.Throws <ArgumentNullException>("action", () => operation.AddPostCompositionAction(null));
return(null);
}
using (CompositionHost host = CompositionHost.CreateCompositionHost(new ExportDescriptorProvider[0]))
{
Assert.True(host.TryGetExport(new CompositionContract(typeof(CompositionContext)), out object export));
LifetimeContext context = Assert.IsType <LifetimeContext>(export);
CompositionOperation.Run(context, Activator);
}
}
static ExportDescriptorPromise[] GetLazyDefinitions <TValue, TMetadata>(CompositionContract lazyContract, DependencyAccessor definitionAccessor)
{
var metadataProvider = MetadataViewProvider.GetMetadataViewProvider <TMetadata>();
return(definitionAccessor.ResolveDependencies("value", lazyContract.ChangeType(typeof(TValue)), false)
.Select(d => new ExportDescriptorPromise(
lazyContract,
Formatters.Format(typeof(Lazy <TValue, TMetadata>)),
false,
() => new[] { d },
_ =>
{
var dsc = d.Target.GetDescriptor();
var da = dsc.Activator;
return ExportDescriptor.Create((c, o) => {
return new Lazy <TValue, TMetadata>(() => (TValue)CompositionOperation.Run(c, da), metadataProvider(dsc.Metadata));
}, dsc.Metadata);
}))
.ToArray());
}
public object GetOrCreate(int sharingId, CompositionOperation operation, CompositeActivator creator);
public void Run_NullActivator_ThrowsArgumentNullException()
{
using (CompositionHost host = CompositionHost.CreateCompositionHost(new ExportDescriptorProvider[0]))
{
Assert.True(host.TryGetExport(new CompositionContract(typeof(CompositionContext)), out object export));
LifetimeContext context = Assert.IsType <LifetimeContext>(export);
AssertExtensions.Throws <ArgumentNullException>("compositionRootActivator", () => CompositionOperation.Run(context, null));
}
}
private object activator(LifetimeContext context, CompositionOperation operation) => Factory();
private static object Activator(LifetimeContext context, CompositionOperation operation) => null;
public object CompositeActivator(LifetimeContext context, CompositionOperation operation)
{
CalledCompositeActivator++;
return(Result);
}
public void Run_NullOutmostContext_ThrowsArgumentNullException()
{
AssertExtensions.Throws <ArgumentNullException>("outermostLifetimeContext", () => CompositionOperation.Run(null, Activator));
}
// 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);
}));
}
}
}
static IEnumerable <Export> DependenciesToExports(LifetimeContext c, IGrouping <ContractBasedImportDefinition, ExportDescriptor> dependenciesByImport)
{
return(dependenciesByImport
.Where(d => RequiredMetadataKeysArePresent(d.Metadata, dependenciesByImport.Key))
.Select(d => new Export(dependenciesByImport.Key.ContractName, d.Metadata, () => CompositionOperation.Run(c, d.Activator))));
}
