/// <summary>
/// Continue building the object graph by instantiating <paramref name="registration"/> in the
/// current <paramref name="currentOperationScope"/>.
/// </summary>
/// <param name="currentOperationScope">The current scope of the operation.</param>
/// <param name="registration">The component to activate.</param>
/// <param name="parameters">The parameters for the component.</param>
/// <returns>The resolved instance.</returns>
/// <exception cref="ArgumentNullException"/>
public object GetOrCreateInstance(ISharingLifetimeScope currentOperationScope, IComponentRegistration registration, IEnumerable <Parameter> parameters)
{
if (_ended)
{
throw new ObjectDisposedException(ResolveOperationResources.TemporaryContextDisposed, innerException: null);
}
CircularDependencyDetector.CheckForCircularDependency(registration, _activationStack, ++_callDepth);
var activation = new InstanceLookup(registration, this, currentOperationScope, parameters);
_activationStack.Push(activation);
var handler = InstanceLookupBeginning;
handler?.Invoke(this, new InstanceLookupBeginningEventArgs(activation));
var instance = activation.Execute();
_successfulActivations.Add(activation);
_activationStack.Pop();
if (_activationStack.Count == 0)
{
CompleteActivations();
}
--_callDepth;
return(instance);
}
/// <summary>
/// Continue building the object graph by instantiating <paramref name="registration"/> in the
/// current <paramref name="currentOperationScope"/>.
/// </summary>
/// <param name="currentOperationScope">The current scope of the operation.</param>
/// <param name="registration">The component to activate.</param>
/// <param name="parameters">The parameters for the component.</param>
/// <returns>The resolved instance.</returns>
/// <exception cref="ArgumentNullException"/>
public object GetOrCreateInstance(ISharingLifetimeScope currentOperationScope, IComponentRegistration registration, IEnumerable <Parameter> parameters)
{
if (_ended)
{
throw new ObjectDisposedException(ResolveOperationResources.TemporaryContextDisposed, innerException: null);
}
CircularDependencyDetector.CheckForCircularDependency(registration, _activationStack, ++_callDepth);
var activation = new InstanceLookup(registration, this, currentOperationScope, parameters);
// Do not add to the circular dependency resolution stack unless the activator is a reflection activator (ie: generates the actual instance)
bool isRealActivation = (activation.ComponentRegistration.Activator is ReflectionActivator);
if (isRealActivation)
{
_activationStack.Push(activation);
}
// Count the number of activations so we know when the last one is completed. We need to keep track of all activations, not
// just reflection activations here
_activationCount++;
var handler = InstanceLookupBeginning;
if (handler != null)
{
handler(this, new InstanceLookupBeginningEventArgs(activation));
}
var instance = activation.Execute();
_successfulActivations.Add(activation);
// Do not pop unless we pushed it above
if (isRealActivation)
{
_activationStack.Pop();
}
// Decrement the activation count
_activationCount--;
// Inject properties AFTER the item is removed from the circular dependency stack, so property-property circular dependencies always work
activation.InjectProperties();
// Complete activations if this is the last recursive item in the activation list
if (_activationCount == 0)
{
CompleteActivations();
}
--_callDepth;
return(instance);
}
/// <summary>
/// Continue building the object graph by instantiating <paramref name="registration"/> in the
/// current <paramref name="currentOperationScope"/>.
/// </summary>
/// <param name="currentOperationScope">The current scope of the operation.</param>
/// <param name="registration">The component to activate.</param>
/// <param name="parameters">The parameters for the component.</param>
/// <returns>The resolved instance.</returns>
/// <exception cref="ArgumentNullException"/>
public object GetOrCreateInstance(ISharingLifetimeScope currentOperationScope, IComponentRegistration registration, IEnumerable <Parameter> parameters)
{
if (_ended)
{
throw new ObjectDisposedException(ResolveOperationResources.TemporaryContextDisposed, innerException: null);
}
++_callDepth;
if (_activationStack.Count > 0)
{
CircularDependencyDetector.CheckForCircularDependency(registration, _activationStack, _callDepth);
}
var activation = new InstanceLookup(registration, this, currentOperationScope, parameters);
_activationStack.Push(activation);
var handler = InstanceLookupBeginning;
handler?.Invoke(this, new InstanceLookupBeginningEventArgs(activation));
try
{
var instance = activation.Execute();
_successfulActivations.Add(activation);
return(instance);
}
finally
{
// Issue #929: Allow the activation stack to be popped even if the activation failed.
// This allows try/catch to happen in lambda registrations without corrupting the stack.
_activationStack.Pop();
if (_activationStack.Count == 0)
{
CompleteActivations();
}
--_callDepth;
}
}
public object GetOrCreateInstance(ISharingLifetimeScope currentOperationScope, IComponentRegistration registration, IEnumerable <Parameter> parameters)
{
if (currentOperationScope == null)
{
throw new ArgumentNullException("currentOperationScope");
}
if (registration == null)
{
throw new ArgumentNullException("registration");
}
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
if (this._ended)
{
Exception innerException = null;
throw new ObjectDisposedException(ResolveOperationResources.TemporaryContextDisposed, innerException);
}
this._circularDependencyDetector.CheckForCircularDependency(registration, this._activationStack, ++this._callDepth);
InstanceLookup item = new InstanceLookup(registration, this, currentOperationScope, parameters);
this._activationStack.Push(item);
EventHandler <InstanceLookupBeginningEventArgs> instanceLookupBeginning = this.InstanceLookupBeginning;
if (instanceLookupBeginning != null)
{
instanceLookupBeginning(this, new InstanceLookupBeginningEventArgs(item));
}
object obj2 = item.Execute();
this._successfulActivations.Add(item);
this._activationStack.Pop();
if (this._activationStack.Count == 0)
{
this.CompleteActivations();
}
this._callDepth--;
return(obj2);
}
/// <summary>
/// Continue building the object graph by instantiating <paramref name="registration"/> in the
/// current <paramref name="currentOperationScope"/>.
/// </summary>
/// <param name="currentOperationScope">The current scope of the operation.</param>
/// <param name="registration">The component to activate.</param>
/// <param name="parameters">The parameters for the component.</param>
/// <returns>The resolved instance.</returns>
/// <exception cref="ArgumentNullException"/>
public object GetOrCreateInstance(ISharingLifetimeScope currentOperationScope, IComponentRegistration registration, IEnumerable<Parameter> parameters)
{
if (currentOperationScope == null) throw new ArgumentNullException("currentOperationScope");
if (registration == null) throw new ArgumentNullException("registration");
if (parameters == null) throw new ArgumentNullException("parameters");
if (_ended) throw new ObjectDisposedException(ResolveOperationResources.TemporaryContextDisposed, innerException: null);
_circularDependencyDetector.CheckForCircularDependency(registration, _activationStack, ++_callDepth);
var activation = new InstanceLookup(registration, this, currentOperationScope, parameters);
_activationStack.Push(activation);
var handler = InstanceLookupBeginning;
if (handler != null)
handler(this, new InstanceLookupBeginningEventArgs(activation));
var instance = activation.Execute();
_successfulActivations.Add(activation);
_activationStack.Pop();
if (_activationStack.Count == 0)
CompleteActivations();
--_callDepth;
return instance;
}