Create a scoped service provider for the call to Configure (#1106)

* Create a scoped service provider for the call to Configure
- This allows scoped dependencies to be injected into the Configure method.
It means you can resolve the DbContext or any other scoped service without
the hassle of the CreateScope boiler plate. As a side effect, it also makes
Startup.Configure a bit more testable.

src/Microsoft.AspNetCore.Hosting/Internal/ConfigureBuilder.cs

@@ -21,34 +21,39 @@ public ConfigureBuilder(MethodInfo configure)
 
         private void Invoke(object instance, IApplicationBuilder builder)
         {
-            var serviceProvider = builder.ApplicationServices;
-            var parameterInfos = MethodInfo.GetParameters();
-            var parameters = new object[parameterInfos.Length];
-            for (var index = 0; index < parameterInfos.Length; index++)
+            // Create a scope for Configure, this allows creating scoped dependencies
+            // without the hassle of manually creating a scope.
+            using (var scope = builder.ApplicationServices.CreateScope())
             {
-                var parameterInfo = parameterInfos[index];
-                if (parameterInfo.ParameterType == typeof(IApplicationBuilder))
+                var serviceProvider = scope.ServiceProvider;
+                var parameterInfos = MethodInfo.GetParameters();
+                var parameters = new object[parameterInfos.Length];
+                for (var index = 0; index < parameterInfos.Length; index++)
                 {
-                    parameters[index] = builder;
-                }
-                else
-                {
-                    try
+                    var parameterInfo = parameterInfos[index];
+                    if (parameterInfo.ParameterType == typeof(IApplicationBuilder))
                     {
-                        parameters[index] = serviceProvider.GetRequiredService(parameterInfo.ParameterType);
+                        parameters[index] = builder;
                     }
-                    catch (Exception ex)
+                    else
                     {
-                        throw new Exception(string.Format(
-                            "Could not resolve a service of type '{0}' for the parameter '{1}' of method '{2}' on type '{3}'.",
-                            parameterInfo.ParameterType.FullName,
-                            parameterInfo.Name,
-                            MethodInfo.Name,
-                            MethodInfo.DeclaringType.FullName), ex);
+                        try
+                        {
+                            parameters[index] = serviceProvider.GetRequiredService(parameterInfo.ParameterType);
+                        }
+                        catch (Exception ex)
+                        {
+                            throw new Exception(string.Format(
+                                "Could not resolve a service of type '{0}' for the parameter '{1}' of method '{2}' on type '{3}'.",
+                                parameterInfo.ParameterType.FullName,
+                                parameterInfo.Name,
+                                MethodInfo.Name,
+                                MethodInfo.DeclaringType.FullName), ex);
+                        }
                     }
                 }
+                MethodInfo.Invoke(instance, parameters);
             }
-            MethodInfo.Invoke(instance, parameters);
         }
     }
 }

src/Microsoft.AspNetCore.Hosting/Internal/StartupLoader.cs

@@ -60,7 +60,7 @@ public static StartupMethods LoadMethods(IServiceProvider hostingServiceProvider
                 return applicationServiceProvider ?? services.BuildServiceProvider();
             };
 
-            return new StartupMethods(configureMethod.Build(instance), configureServices);
+            return new StartupMethods(instance, configureMethod.Build(instance), configureServices);
         }
 
         public static Type FindStartupType(string startupAssemblyName, string environmentName)

src/Microsoft.AspNetCore.Hosting/Internal/StartupMethods.cs

@@ -10,15 +10,17 @@ namespace Microsoft.AspNetCore.Hosting.Internal
 {
     public class StartupMethods
     {
-        public StartupMethods(Action<IApplicationBuilder> configure, Func<IServiceCollection, IServiceProvider> configureServices)
+        public StartupMethods(object instance, Action<IApplicationBuilder> configure, Func<IServiceCollection, IServiceProvider> configureServices)
         {
             Debug.Assert(configure != null);
             Debug.Assert(configureServices != null);
 
+            StartupInstance = instance;
             ConfigureDelegate = configure;
             ConfigureServicesDelegate = configureServices;
         }
 
+        public object StartupInstance { get; }
         public Func<IServiceCollection, IServiceProvider> ConfigureServicesDelegate { get; }
         public Action<IApplicationBuilder> ConfigureDelegate { get; }
 

test/Microsoft.AspNetCore.Hosting.Tests/Fakes/StartupWithScopedServices.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Microsoft.AspNetCore.Builder;
+using static Microsoft.AspNetCore.Hosting.Tests.StartupManagerTests;
+
+namespace Microsoft.AspNetCore.Hosting.Fakes
+{
+    public class StartupWithScopedServices
+    {
+        public DisposableService DisposableService { get; set; }
+
+        public void Configure(IApplicationBuilder builder, DisposableService disposable)
+        {
+            DisposableService = disposable;
+        }
+    }
+}

test/Microsoft.AspNetCore.Hosting.Tests/StartupManagerTests.cs

@@ -36,6 +36,31 @@ public void StartupClassMayHaveHostingServicesInjected()
             Assert.Equal(2, callbackStartup.MethodsCalled);
         }
 
+        [Fact]
+        public void StartupClassMayHaveScopedServicesInjected()
+        {
+            var serviceCollection = new ServiceCollection();
+            serviceCollection.AddSingleton<IServiceProviderFactory<IServiceCollection>>(new DefaultServiceProviderFactory(new ServiceProviderOptions
+            {
+                ValidateScopes = true
+            }));
+
+            serviceCollection.AddScoped<DisposableService>();
+            var services = serviceCollection.BuildServiceProvider();
+
+            var type = StartupLoader.FindStartupType("Microsoft.AspNetCore.Hosting.Tests", "WithScopedServices");
+            var startup = StartupLoader.LoadMethods(services, type, "WithScopedServices");
+            Assert.NotNull(startup.StartupInstance);
+
+            var app = new ApplicationBuilder(services);
+            app.ApplicationServices = startup.ConfigureServicesDelegate(serviceCollection);
+            startup.ConfigureDelegate(app);
+
+            var instance = (StartupWithScopedServices)startup.StartupInstance;
+            Assert.NotNull(instance.DisposableService);
+            Assert.True(instance.DisposableService.Disposed);
+        }
+
         [Theory]
         [InlineData(null)]
         [InlineData("Dev")]
@@ -405,5 +430,15 @@ public void ConfigurationMethodCalled(object instance)
                 _configurationMethodCalledList.Add(instance);
             }
         }
+
+        public class DisposableService : IDisposable
+        {
+            public bool Disposed { get; set; }
+
+            public void Dispose()
+            {
+                Disposed = true;
+            }
+        }
     }
 }