Fixes #3. Added AddAspNetCore overload that allows controlling behavior of accessing IServiceScopes for cross wiring.

Author: dotnetjunkie

src/SimpleInjector.Integration.AspNetCore.Mvc.Core/SimpleInjector.Integration.AspNetCore.Mvc.Core.csproj

@@ -29,7 +29,7 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.AspNetCore.Mvc.Core" Version="2.0.0" />
     <PackageReference Include="SimpleInjector" Version="5.0.0" />
-    <PackageReference Include="SimpleInjector.Integration.ServiceCollection" Version="5.0.0" />
+    <PackageReference Include="SimpleInjector.Integration.AspNetCore" Version="5.0.0" />
   </ItemGroup>
 
   <ItemGroup Condition=" '$(TargetFramework)' == 'net451' ">

src/SimpleInjector.Integration.AspNetCore/OnePerNestedScopeServiceProviderAccessor.cs

@@ -0,0 +1,32 @@
+// Copyright (c) Simple Injector Contributors. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license information.
+
+namespace SimpleInjector.Integration.AspNetCore
+{
+    using System;
+    using Microsoft.AspNetCore.Http;
+    using SimpleInjector;
+    using SimpleInjector.Integration.ServiceCollection;
+
+    internal sealed class OnePerNestedScopeServiceProviderAccessor : IServiceProviderAccessor
+    {
+        private readonly Container container;
+        private readonly IServiceProviderAccessor decoratee;
+
+        internal OnePerNestedScopeServiceProviderAccessor(Container container, IServiceProviderAccessor decoratee)
+        {
+            this.decoratee = decoratee;
+            this.container = container;
+        }
+
+        public IServiceProvider Current =>
+            this.RootScopeHttpContext?.RequestServices ?? this.decoratee.Current;
+
+        // Only the scope wrapping the request (the root scope) contains the HttpContext in its Items dictionary.
+        // With nested scopes, this property returns null.
+        private HttpContext? RootScopeHttpContext =>
+            this.CurrentScope?.GetItem(RequestScopingStartupFilter.HttpContextKey) as HttpContext;
+
+        private Scope? CurrentScope => Lifestyle.Scoped.GetCurrentScope(this.container);
+    }
+}

…ore/AspNetCoreServiceProviderAccessor.cs …/OnePerRequestServiceProviderAccessor.cssrc/SimpleInjector.Integration.AspNetCore/AspNetCoreServiceProviderAccessor.cs renamed to src/SimpleInjector.Integration.AspNetCore/OnePerRequestServiceProviderAccessor.cs src/SimpleInjector.Integration.AspNetCore/AspNetCoreServiceProviderAccessor.cs renamed to src/SimpleInjector.Integration.AspNetCore/OnePerRequestServiceProviderAccessor.cs

@@ -7,12 +7,12 @@ namespace SimpleInjector.Integration.AspNetCore
     using Microsoft.AspNetCore.Http;
     using SimpleInjector.Integration.ServiceCollection;
 
-    internal class AspNetCoreServiceProviderAccessor : IServiceProviderAccessor
+    internal sealed class OnePerRequestServiceProviderAccessor : IServiceProviderAccessor
     {
         private readonly IHttpContextAccessor accessor;
         private readonly IServiceProviderAccessor decoratee;
 
-        internal AspNetCoreServiceProviderAccessor(
+        internal OnePerRequestServiceProviderAccessor(
             IHttpContextAccessor accessor,
             IServiceProviderAccessor decoratee)
         {

src/SimpleInjector.Integration.AspNetCore/RequestScopingStartupFilter.cs

@@ -11,6 +11,8 @@ namespace SimpleInjector.Integration.AspNetCore
 
     internal sealed class RequestScopingStartupFilter : IStartupFilter
     {
+        internal static readonly object HttpContextKey = new object();
+
         private readonly Container container;
 
         public RequestScopingStartupFilter(Container container)
@@ -30,13 +32,13 @@ public Action<IApplicationBuilder> Configure(Action<IApplicationBuilder> next)
 
         private void ConfigureRequestScoping(IApplicationBuilder builder)
         {
-            builder.Use(async (_, next) =>
+            builder.Use(async (httpContext, next) =>
             {
-                using (var scope = AsyncScopedLifestyle.BeginScope(this.container))
+                await using (var scope = AsyncScopedLifestyle.BeginScope(this.container))
                 {
-                    await next();
+                    scope.SetItem(HttpContextKey, httpContext);
 
-                    await scope.DisposeAsync();
+                    await next();
                 }
             });
         }

src/SimpleInjector.Integration.AspNetCore/ServiceScopeReuseBehavior.enum.cs

@@ -0,0 +1,44 @@
+// Copyright (c) Simple Injector Contributors. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license information.
+
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.DependencyInjection;
+using SimpleInjector.Integration.ServiceCollection;
+
+namespace SimpleInjector
+{
+    /// <summary>
+    /// Specifies the behavior of how ASP.NET Core <see cref="IServiceScope"/> instances are reused.
+    /// </summary>
+    public enum ServiceScopeReuseBehavior
+    {
+        /// <summary>
+        /// Within the context of a web request (or SignalR connection), Simple Injector will reuse the same
+        /// <see cref="IServiceScope"/> instance, irregardless of how many Simple Injector <see cref="Scope"/>
+        /// instances are created. Outside the context of a (web) request (i.e.
+        /// <see cref="IHttpContextAccessor.HttpContext"/> returns <c>null</c>), this behavior falls back to
+        /// <see cref="Unchanged" />.
+        /// </summary>
+        OnePerRequest = 0,
+
+        /// <summary>
+        /// Within the context of a web request (or SignalR connection), Simple Injector will use the request's
+        /// <see cref="IServiceScope"/> within its root scope. Within a nested scope or outside the context of a (web)
+        /// request, this behavior falls back to <see cref="Unchanged" />.
+        /// </summary>
+        OnePerNestedScope = 1,
+
+        /// <summary>
+        /// This leaves the original configured <see cref="SimpleInjectorAddOptions.ServiceProviderAccessor"/> as-is.
+        /// If <see cref="SimpleInjectorAddOptions.ServiceProviderAccessor">ServiceProviderAccessor</see> is not
+        /// replaced, the default value, as returned by
+        /// <see cref="SimpleInjectorServiceCollectionExtensions.AddSimpleInjector"/>, ensures the creation of a new
+        /// .NET Core <see cref="IServiceScope"/> instance, for every Simple Injector <see cref="Scope"/>. The
+        /// <see cref="IServiceScope"/> is <i>scoped</i> to that <see cref="Scope"/>. The ASP.NET Core's request
+        /// <see cref="IServiceScope"/> will <b>NEVER</b> be used. Instead Simple Injector creates a new one for the
+        /// request (and one for each nested scope). This disallows accessing ASP.NET Core services that depend on or
+        /// return request-specific data.
+        /// </summary>
+        Unchanged = 2,
+    }
+}

src/SimpleInjector.Integration.AspNetCore/SimpleInjector.Integration.AspNetCore.csproj

@@ -3,8 +3,8 @@
     <Description>Integration library for ASP.NET Core for Simple Injector.</Description>
     <AssemblyTitle>Simple Injector ASP.NET Core Integration</AssemblyTitle>
     <NeutralLanguage>en-US</NeutralLanguage>
-    <VersionPrefix>5.0.0</VersionPrefix>
-    <PackageReleaseNotes>https://github.com/simpleinjector/SimpleInjector.Integration.AspNetCore/releases/tag/5.0.0</PackageReleaseNotes>
+    <VersionPrefix>5.1.0</VersionPrefix>
+    <PackageReleaseNotes>https://github.com/simpleinjector/SimpleInjector.Integration.AspNetCore/releases/tag/5.1.0</PackageReleaseNotes>
     <AssemblyVersion>5.0.0.0</AssemblyVersion>
     <Authors>Simple Injector Contributors</Authors>
     <TargetFrameworks>netstandard2.0</TargetFrameworks>

src/SimpleInjector.Integration.AspNetCore/SimpleInjectorAddOptionsAspNetCoreExtensions.cs

@@ -22,15 +22,42 @@ public static class SimpleInjectorAddOptionsAspNetCoreExtensions
         /// additional integration options to be applied. These basic integrations includes wrapping each web
         /// request in an <see cref="AsyncScopedLifestyle"/> scope and making the nessesary changes that make
         /// it possible for enabling the injection of framework components in Simple Injector-constructed
-        /// components when 
+        /// components when
         /// <see cref="SimpleInjectorServiceCollectionExtensions.UseSimpleInjector(IServiceProvider, Container)"/>
-        /// is called.
+        /// is called. This method uses the default <see cref="ServiceScopeReuseBehavior"/>, which is
+        /// <see cref="ServiceScopeReuseBehavior.OnePerRequest"/>. This means that within a single web request, the same
+        /// <see cref="IServiceScope"/> instance will be used, irregardless of the number of Simple Injector
+        /// <see cref="Scope"/> instances you create. Outside the context of a web request, the ASP.NET Core
+        /// integration falls back to the default behavior specified by the
+        /// <see cref="SimpleInjectorAddOptions.ServiceProviderAccessor"/>. By default, a new
+        /// <see cref="IServiceScope"/> instance will be created per Simple Injector <see cref="Scope"/>.
         /// </summary>
         /// <param name="options">The options to which the integration should be applied.</param>
         /// <returns>A new <see cref="SimpleInjectorAspNetCoreBuilder"/> instance that allows additional
         /// configurations to be made.</returns>
         /// <exception cref="ArgumentNullException">Thrown when <paramref name="options"/> is null.</exception>
         public static SimpleInjectorAspNetCoreBuilder AddAspNetCore(this SimpleInjectorAddOptions options)
+        {
+            return AddAspNetCore(options, ServiceScopeReuseBehavior.OnePerRequest);
+        }
+
+        /// <summary>
+        /// Adds basic Simple Injector integration for ASP.NET Core and returns a builder object that allow
+        /// additional integration options to be applied. These basic integrations includes wrapping each web
+        /// request in an <see cref="AsyncScopedLifestyle"/> scope and making the nessesary changes that make
+        /// it possible for enabling the injection of framework components in Simple Injector-constructed
+        /// components when
+        /// <see cref="SimpleInjectorServiceCollectionExtensions.UseSimpleInjector(IServiceProvider, Container)"/>
+        /// is called.
+        /// </summary>
+        /// <param name="options">The options to which the integration should be applied.</param>
+        /// <param name="serviceScopeBehavior">Defines in which way Simple Injector should use and reuse the ASP.NET
+        /// Core <see cref="IServiceScope"/>, which is used to resolve cross-wired dependencies from.</param>
+        /// <returns>A new <see cref="SimpleInjectorAspNetCoreBuilder"/> instance that allows additional
+        /// configurations to be made.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="options"/> is null.</exception>
+        public static SimpleInjectorAspNetCoreBuilder AddAspNetCore(
+            this SimpleInjectorAddOptions options, ServiceScopeReuseBehavior serviceScopeBehavior)
         {
             if (options is null)
             {
@@ -44,15 +71,41 @@ public static SimpleInjectorAspNetCoreBuilder AddAspNetCore(this SimpleInjectorA
             // Add the IHttpContextAccessor to allow Simple Injector cross wiring to work in ASP.NET Core.
             services.TryAddSingleton<IHttpContextAccessor, HttpContextAccessor>();
 
-            // Replace the default IServiceProviderAccessor with on that can use IHttpContextAccessor to
-            // resolve instances that are scoped inside the current request.
-            options.ServiceProviderAccessor = new AspNetCoreServiceProviderAccessor(
-                new HttpContextAccessor(),
-                options.ServiceProviderAccessor);
+            options.ServiceProviderAccessor = CreateServiceProviderAccessor(options, serviceScopeBehavior);
 
             services.UseSimpleInjectorAspNetRequestScoping(container);
 
             return new SimpleInjectorAspNetCoreBuilder(options);
         }
+
+        private static IServiceProviderAccessor CreateServiceProviderAccessor(
+            SimpleInjectorAddOptions options, ServiceScopeReuseBehavior serviceScopeBehavior)
+        {
+            if (serviceScopeBehavior < ServiceScopeReuseBehavior.OnePerRequest
+                || serviceScopeBehavior > ServiceScopeReuseBehavior.Unchanged)
+            {
+                throw new ArgumentOutOfRangeException(nameof(serviceScopeBehavior));
+            }
+
+            if (serviceScopeBehavior == ServiceScopeReuseBehavior.OnePerRequest)
+            {
+                // This IServiceProviderAccessor uses IHttpContextAccessor to resolve instances that are scoped inside
+                // the current request.
+                return new OnePerRequestServiceProviderAccessor(
+                    new HttpContextAccessor(),
+                    options.ServiceProviderAccessor);
+            }
+            else if (serviceScopeBehavior == ServiceScopeReuseBehavior.OnePerNestedScope)
+            {
+                // This IServiceProviderAccessor resolves cross-wired services from the request's IServiceScope, but
+                // uses a new IServiceScope within a nested scope.
+                return new OnePerNestedScopeServiceProviderAccessor(options.Container, options.ServiceProviderAccessor);
+            }
+            else
+            {
+                // This uses the default behavior.
+                return options.ServiceProviderAccessor;
+            }
+        }
     }
 }

src/SimpleInjector.Integration.AspNetCore/SimpleInjectorAspNetCoreBuilder.cs

@@ -7,7 +7,8 @@ namespace SimpleInjector.Integration.AspNetCore
     using SimpleInjector.Integration.ServiceCollection;
 
     /// <summary>
-    /// Builder object returned by <see cref="SimpleInjectorAddOptionsAspNetCoreExtensions.AddAspNetCore"/>
+    /// Builder object returned by
+    /// <see cref="SimpleInjectorAddOptionsAspNetCoreExtensions.AddAspNetCore(SimpleInjectorAddOptions)"/>
     /// that allows additional integration options to be applied.
     /// </summary>
     public sealed class SimpleInjectorAspNetCoreBuilder