public void Complete(Exception error)
{
_logger.LogDebug("DrainWrites(" + _connectionId + ")");
var context = new LifetimeContext(_transport, _lifetimeTcs, error);
_transport.ApplyState(TransportConnectionStates.QueueDrained);
// Drain the task queue for pending write operations so we don't end the request and then try to write
// to a corrupted request object.
_writeQueue.Drain().Catch(_logger).Finally(state =>
{
// Ensure delegate continues to use the C# Compiler static delegate caching optimization.
((LifetimeContext)state).Complete();
},
context);
if (error != null)
{
_logger.LogError("CompleteRequest (" + _connectionId + ") failed: " + error.GetBaseException());
}
else
{
_logger.LogInformation("CompleteRequest (" + _connectionId + ")");
}
}
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);
}
}
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());
}
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));
}
}
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 Complete(Exception error)
{
_logger.WriteVerbose("DrainWrites(" + _connectionId + ")");
var context = new LifetimeContext(_transport, _lifetimeTcs, error);
_transport.ApplyState(TransportConnectionStates.QueueDrained);
// Drain the task queue for pending write operations so we don't end the request and then try to write
// to a corrupted request object.
_writeQueue.Drain().Catch(_logger).Finally(state =>
{
// Ensure delegate continues to use the C# Compiler static delegate caching optimization.
((LifetimeContext)state).Complete();
},
context);
if (error != null)
{
_logger.WriteError("CompleteRequest (" + _connectionId + ") failed: " + error.GetBaseException());
}
else
{
_logger.WriteInformation("CompleteRequest (" + _connectionId + ")");
}
}
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));
}
public void AddBoundInstance_NullInstance_ThrowsNullReferenceExceptionOnDisposal()
{
CompositionHost host = CompositionHost.CreateCompositionHost(new ExportDescriptorProvider[0]);
Assert.True(host.TryGetExport(new CompositionContract(typeof(CompositionContext)), out object export));
LifetimeContext context = Assert.IsType<LifetimeContext>(export);
context.AddBoundInstance(null);
Assert.Throws<NullReferenceException>(() => context.Dispose());
}
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);
});
}
private CompositionHost(LifetimeContext rootLifetimeContext)
{
if (rootLifetimeContext == null)
{
throw new ArgumentNullException(nameof(rootLifetimeContext));
}
_rootLifetimeContext = rootLifetimeContext;
}
public void ToString_NoParent_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);
Assert.Equal("Root Lifetime Context", context.ToString());
}
}
public void FindContextWithin_UnknownSharingBoundary_ThrowsCompositionFailedException()
{
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);
Assert.Throws<CompositionFailedException>(() => context.FindContextWithin("sharingBoundary"));
}
}
public void FindContextWithin_NullSharingBoundary_ReturnsRoot()
{
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);
Assert.Same(context, context.FindContextWithin(null));
}
}
public void GetOrCreate_NullOperation_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);
Assert.Throws<NullReferenceException>(() => context.GetOrCreate(1, null, Activator));
}
}
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 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));
}
}
public void AddBoundInstance_Disposed_ThrowsObjectDisposedException()
{
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);
context.Dispose();
Assert.Throws<ObjectDisposedException>(() => context.AddBoundInstance(null));
}
}
private object CreateStronglyTypedExportFactoryOfT <T>(Export export)
{
Type[] typeArgs = { typeof(T) };
Type constructed = _exportFactoryType.MakeGenericType(typeArgs);
Func <Tuple <T, Action> > exportLifetimeContextCreator = () => LifetimeContext.GetExportLifetimeContextFromExport <T>(export);
object[] args = { exportLifetimeContextCreator };
var instance = Activator.CreateInstance(constructed, args);
return(instance !);
}
private object CreateStronglyTypedExportFactoryOfTM <T, M>(Export export)
{
Type[] typeArgs = { typeof(T), typeof(M) };
Type constructed = _exportFactoryType.MakeGenericType(typeArgs);
Func <Tuple <T, Action> > exportLifetimeContextCreator = () => LifetimeContext.GetExportLifetimeContextFromExport <T>(export);
var metadataView = AttributedModelServices.GetMetadataView <M>(export.Metadata);
object?[] args = { exportLifetimeContextCreator, metadataView };
var instance = Activator.CreateInstance(constructed, args);
return(instance !);
}
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 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);
}
}
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 AddBoundInstance_NonNullInstance_DisposesInstanceOnDisposal()
{
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 instance = new DisposableInstance();
context.AddBoundInstance(instance);
Assert.Equal(0, instance.CalledDisposed);
context.Dispose();
Assert.Equal(1, instance.CalledDisposed);
context.Dispose();
Assert.Equal(1, instance.CalledDisposed);
}
}
/// <summary>
/// Create the composition host.
/// </summary>
/// <returns>The container as an <see cref="CompositionHost"/>.</returns>
public static CompositionHost CreateCompositionHost(IEnumerable <ExportDescriptorProvider> providers)
{
Requires.NotNull(providers, "providers");
var allProviders = new ExportDescriptorProvider[] {
new LazyExportDescriptorProvider(),
new ExportFactoryExportDescriptorProvider(),
new ImportManyExportDescriptorProvider(),
new LazyWithMetadataExportDescriptorProvider(),
new CurrentScopeExportDescriptorProvider(),
new ExportFactoryWithMetadataExportDescriptorProvider()
}
.Concat(providers)
.ToArray();
var container = new LifetimeContext(new ExportDescriptorRegistry(allProviders), s_noBoundaries);
return(new CompositionHost(container));
}
/// <summary>
/// Create the composition host.
/// </summary>
/// <returns>The container as an <see cref="CompositionHost"/>.</returns>
public static CompositionHost CreateCompositionHost(IEnumerable <ExportDescriptorProvider> providers)
{
if (providers == null)
{
throw new ArgumentNullException(nameof(providers));
}
var allProviders = new ExportDescriptorProvider[] {
new LazyExportDescriptorProvider(),
new ExportFactoryExportDescriptorProvider(),
new ImportManyExportDescriptorProvider(),
new LazyWithMetadataExportDescriptorProvider(),
new CurrentScopeExportDescriptorProvider(),
new ExportFactoryWithMetadataExportDescriptorProvider()
}
.Concat(providers)
.ToArray();
var container = new LifetimeContext(new ExportDescriptorRegistry(allProviders), s_noBoundaries);
return(new CompositionHost(container));
}
public void Complete(Exception error)
{
_trace.TraceEvent(TraceEventType.Verbose, 0, "DrainWrites(" + _connectionId + ")");
var context = new LifetimeContext(_lifetimeTcs, error);
// Drain the task queue for pending write operations so we don't end the request and then try to write
// to a corrupted request object.
_writeQueue.Drain().Catch().Finally(state =>
{
// Ensure delegate continues to use the C# Compiler static delegate caching optimization.
((LifetimeContext)state).Complete();
},
context);
if (error != null)
{
_trace.TraceEvent(TraceEventType.Error, 0, "CompleteRequest (" + _connectionId + ") failed: " + error.GetBaseException());
}
else
{
_trace.TraceInformation("CompleteRequest (" + _connectionId + ")");
}
}
private CompositionHost(LifetimeContext rootLifetimeContext)
{
Requires.NotNull(rootLifetimeContext, "rootLifetimeContext");
_rootLifetimeContext = rootLifetimeContext;
}
public object CompositeActivator(LifetimeContext context, CompositionOperation operation)
{
CalledCompositeActivator++;
return(Result);
}
private static object Activator(LifetimeContext context, CompositionOperation operation) => null;
public static object Run(LifetimeContext outermostLifetimeContext, CompositeActivator compositionRootActivator);
public void AllocateSharingId_InvokeMultipleTimes_ReturnsDifferentValue()
{
Assert.NotEqual(LifetimeContext.AllocateSharingId(), LifetimeContext.AllocateSharingId());
}
