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; }