private object Activate(LifetimeContext context, CompositionOperation operation)
{
Assumes.IsTrue(_exportDescriptor.IsValueCreated, "Activation in progress before all descriptors fully initialized.");
Debug.WriteLine("[System.Composition] Activating via cycle-breaking proxy.");
return _exportDescriptor.Value.Activator(context, operation);
}
private object Activate(LifetimeContext context, CompositionOperation operation)
{
Assumes.IsTrue(_exportDescriptor.IsValueCreated, "Activation in progress before all descriptors fully initialized.");
Debug.WriteLine("[System.Composition] Activating via cycle-breaking proxy.");
return(_exportDescriptor.Value.Activator(context, operation));
}
private object Activate(LifetimeContext context, CompositionOperation operation)
{
if (!_exportDescriptor.IsValueCreated)
{
throw ThrowHelper.NotImplemented_MetadataCycles();
}
Debug.WriteLine("[System.Composition] Activating via cycle-breaking proxy.");
return(_exportDescriptor.Value.Activator(context, operation));
}
/// <summary>
/// Execute a new composition operation starting within the specified lifetime
/// context, for the specified activator.
/// </summary>
/// <param name="outermostLifetimeContext">Context in which to begin the operation (the operation can flow
/// to the parents of the context if requried).</param>
/// <param name="compositionRootActivator">Activator that will drive the operation.</param>
/// <returns>The composed object graph.</returns>
public static object Run(LifetimeContext outermostLifetimeContext, CompositeActivator compositionRootActivator)
{
Requires.NotNull(outermostLifetimeContext, nameof(outermostLifetimeContext));
Requires.NotNull(compositionRootActivator, nameof(compositionRootActivator));
using (var operation = new CompositionOperation())
{
var result = compositionRootActivator(outermostLifetimeContext, operation);
operation.Complete();
return result;
}
}
/// <summary>
/// Execute a new composition operation starting within the specified lifetime
/// context, for the specified activator.
/// </summary>
/// <param name="outermostLifetimeContext">Context in which to begin the operation (the operation can flow
/// to the parents of the context if requried).</param>
/// <param name="compositionRootActivator">Activator that will drive the operation.</param>
/// <returns>The composed object graph.</returns>
public static object Run(LifetimeContext outermostLifetimeContext, CompositeActivator compositionRootActivator)
{
Requires.ArgumentNotNull(outermostLifetimeContext, "outermostLifetimeContext");
Requires.ArgumentNotNull(compositionRootActivator, "compositionRootActivator");
using (var operation = new CompositionOperation())
{
var result = compositionRootActivator(outermostLifetimeContext, operation);
operation.Complete();
return(result);
}
}
private object Activate(LifetimeContext context, CompositionOperation operation)
{
if (!_exportDescriptor.IsValueCreated)
{
var ex = new NotImplementedException(SR.NotImplemented_MetadataCycles);
Debug.WriteLine(SR.Diagnostic_ThrowingException, ex.ToString());
throw ex;
}
Debug.WriteLine("[System.Composition] Activating via cycle-breaking proxy.");
return(_exportDescriptor.Value.Activator(context, operation));
}
/// <summary>
/// Retrieve the single <paramref name="contract"/> instance from the
/// <see cref="CompositionContext"/>.
/// </summary>
/// <param name="contract">The contract to retrieve.</param>
/// <returns>An instance of the export.</returns>
/// <param name="export">The export if available, otherwise, null.</param>
/// <exception cref="CompositionFailedException" />
public override bool TryGetExport(CompositionContract contract, out object export)
{
ExportDescriptor defaultForExport;
if (!_partRegistry.TryGetSingleForExport(contract, out defaultForExport))
{
export = null;
return(false);
}
export = CompositionOperation.Run(this, defaultForExport.Activator);
return(true);
}
/// <summary>
/// Execute a new composition operation starting within the specified lifetime
/// context, for the specified activator.
/// </summary>
/// <param name="outermostLifetimeContext">Context in which to begin the operation (the operation can flow
/// to the parents of the context if required).</param>
/// <param name="compositionRootActivator">Activator that will drive the operation.</param>
/// <returns>The composed object graph.</returns>
public static object Run(LifetimeContext outermostLifetimeContext, CompositeActivator compositionRootActivator)
{
if (outermostLifetimeContext is null)
{
throw new ArgumentNullException(nameof(outermostLifetimeContext));
}
if (compositionRootActivator is null)
{
throw new ArgumentNullException(nameof(compositionRootActivator));
}
using (var operation = new CompositionOperation())
{
var result = compositionRootActivator(outermostLifetimeContext, operation);
operation.Complete();
return(result);
}
}
/// <summary>
/// Either retrieve an existing part instance with the specified sharing id, or
/// create and share a new part instance using <paramref name="creator"/> within
/// <paramref name="operation"/>.
/// </summary>
/// <param name="sharingId">Sharing id for the part in question.</param>
/// <param name="operation">Operation in which to activate a new part instance if necessary.</param>
/// <param name="creator">Activator that can activate a new part instance if necessary.</param>
/// <returns>The part instance corresponding to <paramref name="sharingId"/> within this lifetime context.</returns>
/// <remarks>This method is lock-free if the part instance already exists. If the part instance must be created,
/// a lock will be taken that will serialize other writes via this method (concurrent reads will continue to
/// be safe and lock-free). It is important that the composition, and thus lock acquisition, is strictly
/// leaf-to-root in the lifetime tree.</remarks>
public object GetOrCreate(int sharingId, CompositionOperation operation, CompositeActivator creator)
{
object result;
if (_sharedPartInstances != null && _sharedPartInstances.TryGetValue(sharingId, out result))
{
return(result);
}
// Remains locked for the rest of the operation.
operation.EnterSharingLock(_sharingLock);
if (_sharedPartInstances == null)
{
_sharedPartInstances = new SmallSparseInitonlyArray();
_instancesUndergoingInitialization = new SmallSparseInitonlyArray();
}
else if (_sharedPartInstances.TryGetValue(sharingId, out result))
{
return(result);
}
// Already being initialized _on the same thread_.
if (_instancesUndergoingInitialization.TryGetValue(sharingId, out result))
{
return(result);
}
result = creator(this, operation);
_instancesUndergoingInitialization.Add(sharingId, result);
operation.AddPostCompositionAction(() =>
{
_sharedPartInstances.Add(sharingId, result);
});
return(result);
}
/// <summary>
/// Either retrieve an existing part instance with the specified sharing id, or
/// create and share a new part instance using <paramref name="creator"/> within
/// <paramref name="operation"/>.
/// </summary>
/// <param name="sharingId">Sharing id for the part in question.</param>
/// <param name="operation">Operation in which to activate a new part instance if necessary.</param>
/// <param name="creator">Activator that can activate a new part instance if necessary.</param>
/// <returns>The part instance corresponding to <paramref name="sharingId"/> within this lifetime context.</returns>
/// <remarks>This method is lock-free if the part instance already exists. If the part instance must be created,
/// a lock will be taken that will serialize other writes via this method (concurrent reads will continue to
/// be safe and lock-free). It is important that the composition, and thus lock acquisition, is strictly
/// leaf-to-root in the lifetime tree.</remarks>
public object GetOrCreate(int sharingId, CompositionOperation operation, CompositeActivator creator)
{
object result;
if (_sharedPartInstances != null && _sharedPartInstances.TryGetValue(sharingId, out result))
return result;
// Remains locked for the rest of the operation.
operation.EnterSharingLock(_sharingLock);
if (_sharedPartInstances == null)
{
_sharedPartInstances = new SmallSparseInitonlyArray();
_instancesUndergoingInitialization = new SmallSparseInitonlyArray();
}
else if (_sharedPartInstances.TryGetValue(sharingId, out result))
{
return result;
}
// Already being initialized _on the same thread_.
if (_instancesUndergoingInitialization.TryGetValue(sharingId, out result))
return result;
result = creator(this, operation);
_instancesUndergoingInitialization.Add(sharingId, result);
operation.AddPostCompositionAction(() =>
{
_sharedPartInstances.Add(sharingId, result);
});
return result;
}
public CompositeActivatorParameters( LifetimeContext context, CompositionOperation operation )
{
Context = context;
Operation = operation;
}