internal LifetimeScope(IComponentRegistry registry, ISharingLifetimeScope parentLifetimeScope) : this(registry) { RootLifetimeScope = parentLifetimeScope.RootLifetimeScope; ParentLifetimeScope = parentLifetimeScope; }
/// <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> /// Create a root lifetime scope for the provided components. /// </summary> /// <param name="tag">The tag applied to the <see cref="ILifetimeScope"/>.</param> /// <param name="componentRegistry">Components used in the scope.</param> public LifetimeScope(IComponentRegistry componentRegistry, object tag) : this() { _componentRegistry = Enforce.ArgumentNotNull(componentRegistry, "componentRegistry"); _root = this; _tag = Enforce.ArgumentNotNull(tag, "tag"); }
/// <summary> /// Initializes a new instance of the <see cref="ResolveOperation" /> class. /// </summary> /// <param name="mostNestedLifetimeScope"> The most nested scope in which to begin the operation. The operation /// can move upward to less nested scopes as components with wider sharing scopes are activated. /// </param> /// <param name="diagnosticSource"> /// The <see cref="System.Diagnostics.DiagnosticListener" /> to which trace events should be written. /// </param> public ResolveOperation( ISharingLifetimeScope mostNestedLifetimeScope, DiagnosticListener diagnosticSource) { CurrentScope = mostNestedLifetimeScope ?? throw new ArgumentNullException(nameof(mostNestedLifetimeScope)); DiagnosticSource = diagnosticSource ?? throw new ArgumentNullException(nameof(diagnosticSource)); }
public InstanceLookup( IResolveOperation context, ISharingLifetimeScope mostNestedVisibleScope, ResolveRequest request) { _context = context; _service = request.Service; _decoratorTargetComponent = request.DecoratorTarget; ComponentRegistration = request.Registration; Parameters = request.Parameters; try { _activationScope = ComponentRegistration.Lifetime.FindScope(mostNestedVisibleScope); } catch (DependencyResolutionException ex) { var services = new StringBuilder(); foreach (var s in ComponentRegistration.Services) { services.Append("- "); services.AppendLine(s.Description); } var message = string.Format(CultureInfo.CurrentCulture, ComponentActivationResources.UnableToLocateLifetimeScope, ComponentRegistration.Activator.LimitType, services); throw new DependencyResolutionException(message, ex); } }
public InstanceLookup(IComponentRegistration registration, IResolveOperation context, ISharingLifetimeScope mostNestedVisibleScope, IEnumerable <Parameter> parameters) { this._parameters = parameters; this._componentRegistration = registration; this._context = context; this._activationScope = this._componentRegistration.Lifetime.FindScope(mostNestedVisibleScope); }
internal override void DoBuildInstance(ISharingLifetimeScope scope, ParameterSet parameters, out T instance) { var context = new NonViralSharedInjectionContext <T>(scope, _description, parameters); _process.Execute(context); instance = context.Instance; }
public InstanceLookup( IComponentRegistration registration, IResolveOperation context, ISharingLifetimeScope mostNestedVisibleScope, IEnumerable <Parameter> parameters) { Parameters = parameters; ComponentRegistration = registration; _context = context; try { _activationScope = ComponentRegistration.Lifetime.FindScope(mostNestedVisibleScope); } catch (DependencyResolutionException ex) { var services = new StringBuilder(); foreach (var s in registration.Services) { services.Append("- "); services.AppendLine(s.Description); } var message = String.Format(CultureInfo.CurrentCulture, ComponentActivationResources.UnableToLocateLifetimeScope, registration.Activator.LimitType, services); throw new DependencyResolutionException(message, ex); } }
// A lock is only needed when the first time an instance is built internal override void DoBuildInstance(ISharingLifetimeScope scope, ParameterSet parameters, out T instance) { var injectionOperator = _builder.InjectionOperator; if (!ReferenceEquals(injectionOperator, this)) { _builder.BuildInstance(scope, parameters, out instance); return; } Monitor.Enter(_builder.ObjectRelation.SyncRoot); injectionOperator = _builder.InjectionOperator; if (!ReferenceEquals(injectionOperator, this)) { Monitor.Exit(_builder.ObjectRelation.SyncRoot); _builder.BuildInstance(scope, parameters, out instance); return; } try { var process = _configurationSet.CreateInjectionProcess <T>(scope.Kernel); var oneoff = new OneOffInjectionOperator <T>(_builder, _description, _lifetime, process); InjectionOperatorHelper.UpgradeToOneOffObjectBuilder(_builder, oneoff); oneoff.BuildInstance(scope, parameters, out instance); } finally { Monitor.Exit(_builder.ObjectRelation.SyncRoot); } }
/// <summary> /// Initializes a new instance of the <see cref="ResolveOperation"/> class. /// </summary> /// <param name="mostNestedLifetimeScope">The most nested scope in which to begin the operation. The operation /// can move upward to less nested scopes as components with wider sharing scopes are activated.</param> public ResolveOperation(ISharingLifetimeScope mostNestedLifetimeScope) { _mostNestedLifetimeScope = mostNestedLifetimeScope; // Initialise _successfulActivations. ResetSuccessfulActivations(); }
/// <summary> /// Create a root lifetime scope for the provided components. /// </summary> /// <param name="tag">The tag applied to the <see cref="ILifetimeScope"/>.</param> /// <param name="componentRegistry">Components used in the scope.</param> public LifetimeScope(IComponentRegistry componentRegistry, object tag) : this() { _componentRegistry = Enforce.ArgumentNotNull(componentRegistry, "componentRegistry"); _root = this; _tag = Enforce.ArgumentNotNull(tag, "tag"); }
protected T DoBuildInstance(ISharingLifetimeScope scope, InjectionOperator <T> injectionOperator, ParameterSet parameters) { T instance; injectionOperator.DoBuildInstance(scope, parameters, out instance); return(instance); }
public InstanceLookup( IComponentRegistration registration, IResolveOperation context, ISharingLifetimeScope mostNestedVisibleScope, IEnumerable<Parameter> parameters) { Parameters = parameters; ComponentRegistration = registration; _context = context; try { _activationScope = ComponentRegistration.Lifetime.FindScope(mostNestedVisibleScope); } catch (DependencyResolutionException ex) { var services = new StringBuilder(); foreach (var s in registration.Services) { services.Append("- "); services.AppendLine(s.Description); } var message = String.Format(CultureInfo.CurrentCulture, ComponentActivationResources.UnableToLocateLifetimeScope, registration.Activator.LimitType, services); throw new DependencyResolutionException(message, ex); } }
/// <summary> /// Given the most nested scope visible within the resolve operation, find /// the scope for the component. /// </summary> /// <param name="mostNestedVisibleScope">The most nested visible scope.</param> /// <returns>The scope for the component.</returns> public ISharingLifetimeScope FindScope(ISharingLifetimeScope mostNestedVisibleScope) { if (mostNestedVisibleScope == null) { throw new ArgumentNullException("mostNestedVisibleScope"); } return(mostNestedVisibleScope.RootLifetimeScope); }
public ISharingLifetimeScope FindScope(ISharingLifetimeScope mostNestedVisibleScope) { if (_threadScope.Value == null) { _threadScope.Value = new LifetimeScope(mostNestedVisibleScope.ComponentRegistry); } return((ISharingLifetimeScope)_threadScope.Value); }
public InProcessPipline(ILifetimeScope lifetimeScope, Func <T, ILifetimeScope, Task> eventHandler) { this.Pipline = Channel.CreateUnbounded <T>(); this.EventHandler = eventHandler; Container = ((LifetimeScope)lifetimeScope).RootLifetimeScope; logger = lifetimeScope.Resolve <ILogger>(); _ = SubscribeHandleInvoke(); }
internal InjectionContext(InjectionContext context, ObjectDescription description, ParameterSet parameters) { _parentContext = context; _scope = context.LifetimeScope; _description = description; _parameters = parameters; }
/// <summary> /// Create a lifetime scope for the provided components and nested beneath a parent. /// </summary> /// <param name="tag">The tag applied to the <see cref="ILifetimeScope"/>.</param> /// <param name="componentRegistry">Components used in the scope.</param> /// <param name="parent">Parent scope.</param> protected LifetimeScope(IComponentRegistry componentRegistry, LifetimeScope parent, object tag) : this(componentRegistry, tag) { if (parent == null) throw new ArgumentNullException(nameof(parent)); _parent = parent; RootLifetimeScope = _parent.RootLifetimeScope; }
public override T BuildInstance(ISharingLifetimeScope scope, InjectionOperator <T> injectionOperator, ParameterSet parameters) { if (injectionOperator.Resolved) { return(_instance); } _instance = BuildSingletonInstance(scope, injectionOperator, parameters); 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); }
protected override T BuildSingletonInstance(ISharingLifetimeScope scope, InjectionOperator <T> injectionOperator, ParameterSet parameters) { var instance = DoBuildInstance(scope, injectionOperator, parameters); var disposable = instance as IDisposable; var matchingScope = scope.ContainerScope; lock (matchingScope.SyncRoot) matchingScope.RegisterForDisposal(disposable); return(instance); }
internal override void DoBuildInstance(ISharingLifetimeScope scope, ParameterSet parameters, out T instance) { var context = new ViralSharedInjectionContext <T>(scope, _description, parameters); _process.Execute(context); instance = context.Instance; // replace the ObjectBuilder InjectionOperatorHelper.UpgradeToNonSharedObjectBuilder (_builder, new NonSharedInjectionOperator <T>(_builder, _description, _lifetime, _process)); }
public InstanceLookup( IComponentRegistration registration, IResolveOperation context, ISharingLifetimeScope mostNestedVisibleScope, IEnumerable<Parameter> parameters) { Parameters = parameters; ComponentRegistration = registration; _context = context; _activationScope = ComponentRegistration.Lifetime.FindScope(mostNestedVisibleScope); }
/// <summary> /// Initializes a new instance of the <see cref="LifetimeScope"/> class. /// </summary> /// <param name="tag">The tag applied to the <see cref="ILifetimeScope"/>.</param> /// <param name="componentRegistry">Components used in the scope.</param> /// <param name="parent">Parent scope.</param> protected LifetimeScope(IComponentRegistry componentRegistry, LifetimeScope parent, object tag) : this(componentRegistry, tag) { if (parent == null) { throw new ArgumentNullException(nameof(parent)); } _parent = parent; RootLifetimeScope = _parent.RootLifetimeScope; }
public override T BuildInstance(ISharingLifetimeScope scope, InjectionOperator <T> injectionOperator, ParameterSet parameters) { var matchingScope = scope.SharingScope; Lifetime.ThrowWhenMatchingScopeIsNull(matchingScope, _error); var instance = DoBuildInstance(scope, injectionOperator, parameters); var disposable = instance as IDisposable; lock (matchingScope.SyncRoot) matchingScope.RegisterForDisposal(disposable); return(instance); }
/// <summary> /// Initializes a new instance of the <see cref="DefaultResolveRequestContext" /> class. /// </summary> /// <param name="owningOperation">The owning resolve operation.</param> /// <param name="request">The initiating resolve request.</param> /// <param name="scope">The lifetime scope.</param> /// <param name="diagnosticSource"> /// The <see cref="System.Diagnostics.DiagnosticListener" /> to which trace events should be written. /// </param> internal DefaultResolveRequestContext( IResolveOperation owningOperation, ResolveRequest request, ISharingLifetimeScope scope, DiagnosticListener diagnosticSource) { Operation = owningOperation; ActivationScope = scope; Parameters = request.Parameters; _resolveRequest = request ?? throw new ArgumentNullException(nameof(request)); PhaseReached = PipelinePhase.ResolveRequestStart; DiagnosticSource = diagnosticSource; }
/// <summary> /// Releases unmanaged and - optionally - managed resources /// </summary> /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param> protected override void Dispose(bool disposing) { _currentResolutionScope = _parent; if (disposing) { _disposer.Dispose(); _serviceCache.Clear(); lock (_synchRoot) _sharedInstances.Clear(); } base.Dispose(disposing); }
//internal readonly int ThreadID; public InstanceLookup( Service service, IComponentRegistration registration, IComponentContext scope, ISharingLifetimeScope mostNestedVisibleScope, IEnumerable<Parameter> parameters) { _service = service; _parameters = parameters; _componentRegistration = registration; _scope = scope; _activationScope = _componentRegistration.Lifetime.FindScope(mostNestedVisibleScope); //ThreadID = Thread.CurrentThread.ManagedThreadId; }
//internal readonly int ThreadID; public InstanceLookup( Service service, IComponentRegistration registration, IComponentContext scope, ISharingLifetimeScope mostNestedVisibleScope, IEnumerable <Parameter> parameters) { _service = service; _parameters = parameters; _componentRegistration = registration; _scope = scope; _activationScope = _componentRegistration.Lifetime.FindScope(mostNestedVisibleScope); //ThreadID = Thread.CurrentThread.ManagedThreadId; }
public ISharingLifetimeScope FindScope(ISharingLifetimeScope mostNestedVisibleScope) { if (mostNestedVisibleScope == null) { throw new ArgumentNullException("mostNestedVisibleScope"); } for (ISharingLifetimeScope scope = mostNestedVisibleScope; scope != null; scope = scope.ParentLifetimeScope) { if (this._matcher(scope)) { return(scope); } } throw new DependencyResolutionException(string.Format(CultureInfo.CurrentCulture, MatchingScopeLifetimeResources.MatchingScopeNotFound, new object[] { this._matchExpressionCode })); }
private void CheckTagIsUnique(object tag) { ISharingLifetimeScope parentScope = this; while (parentScope != RootLifetimeScope) { if (parentScope.Tag.Equals(tag)) { throw new InvalidOperationException( string.Format(CultureInfo.CurrentCulture, LifetimeScopeResources.DuplicateTagDetected, tag)); } parentScope = parentScope.ParentLifetimeScope; } }
/// <summary> /// Given the most nested scope visible within the resolve operation, find /// the scope for the component. /// </summary> /// <param name="mostNestedVisibleScope">The most nested visible scope.</param> /// <returns>The scope for the component.</returns> public ISharingLifetimeScope FindScope(ISharingLifetimeScope mostNestedVisibleScope) { if (mostNestedVisibleScope == null) throw new ArgumentNullException("mostNestedVisibleScope"); var next = mostNestedVisibleScope; while (next != null) { if (_matcher(next)) return next; next = next.ParentLifetimeScope; } throw new DependencyResolutionException(string.Format( CultureInfo.CurrentCulture, MatchingScopeLifetimeResources.MatchingScopeNotFound, _matchExpressionCode)); }
/// <summary> /// Given the most nested scope visible within the resolve operation, find /// the scope for the component. /// </summary> /// <param name="mostNestedVisibleScope">The most nested visible scope.</param> /// <returns>The scope for the component.</returns> public ISharingLifetimeScope FindScope(ISharingLifetimeScope mostNestedVisibleScope) { if (mostNestedVisibleScope == null) throw new ArgumentNullException("mostNestedVisibleScope"); var next = mostNestedVisibleScope; while (next != null) { if (_tagsToMatch.Contains(next.Tag)) return next; next = next.ParentLifetimeScope; } throw new DependencyResolutionException(string.Format( CultureInfo.CurrentCulture, MatchingScopeLifetimeResources.MatchingScopeNotFound, string.Join(", ", _tagsToMatch))); }
public ISharingLifetimeScope FindScope(ISharingLifetimeScope mostNestedVisibleScope) { if (mostNestedVisibleScope == null) { throw new ArgumentNullException("mostNestedVisibleScope"); } var next = mostNestedVisibleScope; while (next != null) { if (_tagsToMatch.Contains(next.Tag)) { return(next); } next = next.ParentLifetimeScope; } return(mostNestedVisibleScope.RootLifetimeScope); }
public override T BuildInstance(ISharingLifetimeScope scope, InjectionOperator <T> injectionOperator, ParameterSet parameters) { var matchingScope = scope.SharingScope; Lifetime.ThrowWhenMatchingScopeIsNull(matchingScope, _error); lock (matchingScope.SyncRoot) { var cachedInstance = matchingScope.GetInstance(injectionOperator.ObjectDescription); if (cachedInstance != null) { return((T)cachedInstance); } var instance = DoBuildInstance(scope, injectionOperator, parameters); matchingScope.SetInstance(injectionOperator.ObjectDescription, instance); 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 ISharingLifetimeScope FindScope(ISharingLifetimeScope mostNestedVisibleScope) { #if NetCore var context = _container.GetInstance <IHttpContextAccessor>()?.HttpContext; if (context == null) { return(null); } if (!context.Items.ContainsKey(typeof(IComponentLifetime))) { lock (context) { if (!context.Items.ContainsKey(typeof(IComponentLifetime))) { var scope = (ISharingLifetimeScope)mostNestedVisibleScope.BeginLifetimeScope(mostNestedVisibleScope.ComponentRegistry); context.Items[typeof(IComponentLifetime)] = scope; return(scope); } } } return((ISharingLifetimeScope)context.Items[typeof(IComponentLifetime)]); #else var context = System.Web.HttpContext.Current; if (context == null) { return(null); } if (!context.Items.Contains(typeof(IComponentLifetime))) { lock (context.Items.SyncRoot) { if (!context.Items.Contains(typeof(IComponentLifetime))) { var scope = (ISharingLifetimeScope)mostNestedVisibleScope.BeginLifetimeScope(mostNestedVisibleScope.ComponentRegistry); context.Items[typeof(IComponentLifetime)] = scope; context.DisposeOnPipelineCompleted(scope); return(scope); } } } return((ISharingLifetimeScope)context.Items[typeof(IComponentLifetime)]); #endif }
/// <summary> /// Releases unmanaged and - optionally - managed resources /// </summary> /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param> protected override void Dispose(bool disposing) { _currentResolutionScope = _parent; if (disposing) { _disposer.Dispose(); _serviceCache.Clear(); lock (_synchRoot) _sharedInstances.Clear(); } base.Dispose(disposing); }
/// <summary> /// Create a lifetime scope for the provided components and nested beneath a parent. /// </summary> /// <param name="tag">The tag applied to the <see cref="ILifetimeScope"/>.</param> /// <param name="componentRegistry">Components used in the scope.</param> /// <param name="parent">Parent scope.</param> protected LifetimeScope(IComponentRegistry componentRegistry, LifetimeScope parent, object tag) : this(componentRegistry, tag) { _parent = Enforce.ArgumentNotNull(parent, "parent"); _root = _parent.RootLifetimeScope; }
/// <summary> /// Create an instance of <see cref="ResolveOperation"/> in the provided scope. /// </summary> /// <param name="mostNestedLifetimeScope">The most nested scope in which to begin the operation. The operation /// can move upward to less nested scopes as components with wider sharing scopes are activated</param> public ResolveOperation(ISharingLifetimeScope mostNestedLifetimeScope) { _mostNestedLifetimeScope = mostNestedLifetimeScope; ResetSuccessfulActivations(); }
/// <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; }
private LifetimeScope() { _sharedInstances.Add(SelfRegistrationId, this); _currentResolutionScope = this; }
/// <summary> /// Given the most nested scope visible within the resolve operation, find /// the scope for the component. /// </summary> /// <param name="mostNestedVisibleScope">The most nested visible scope.</param> /// <returns>The scope for the component.</returns> public ISharingLifetimeScope FindScope(ISharingLifetimeScope mostNestedVisibleScope) { if (mostNestedVisibleScope == null) throw new ArgumentNullException("mostNestedVisibleScope"); var next = mostNestedVisibleScope; while (next != null) { if (_matcher(next)) return next; next = next.ParentLifetimeScope; } throw new DependencyResolutionException(string.Format( CultureInfo.CurrentCulture, "No scope with a Tag matching '{0}' is visible from the scope in which the instance was requested. This generally indicates that a component registered as per-HTTP request is being reqested by a SingleInstance() component (or a similar scenario.) Under the web integration always request dependencies from the DependencyResolver.Current or ILifetimeScopeProvider.RequestLifetime, never from the container itself.", _matchExpressionCode)); }
/// <summary> /// Given the most nested scope visible within the resolve operation, find /// the scope for the component. /// </summary> /// <param name="mostNestedVisibleScope">The most nested visible scope.</param> /// <returns>The scope for the component.</returns> public ISharingLifetimeScope FindScope(ISharingLifetimeScope mostNestedVisibleScope) { if (mostNestedVisibleScope == null) throw new ArgumentNullException("mostNestedVisibleScope"); return mostNestedVisibleScope.RootLifetimeScope; }