Add support for instantiating the startup class

davidfowl · davidfowl · commit 76846b04c992 · 2020-07-21T17:15:40.000-07:00
- Adds an overload of UseStartup that takes a factory so users can control the instance creation. The factory is given the WebHostBuilderContext to expose access to configuration and IWebHostEnvironment.
- Make sure only one startup delegate runs, the last one registered.
diff --git a/src/Hosting/Hosting/src/GenericHost/GenericWebHostBuilder.cs b/src/Hosting/Hosting/src/GenericHost/GenericWebHostBuilder.cs
@@ -21,6 +21,7 @@ internal class GenericWebHostBuilder : IWebHostBuilder, ISupportsStartup, ISuppo
     {
         private readonly IHostBuilder _builder;
         private readonly IConfiguration _config;
+        private object _startupObject;
         private readonly object _startupKey = new object();
 
         private AggregateException _hostingStartupErrors;
@@ -198,10 +199,12 @@ public IWebHostBuilder UseDefaultServiceProvider(Action<WebHostBuilderContext, S
         public IWebHostBuilder UseStartup(Type startupType)
         {
             // UseStartup can be called multiple times. Only run the last one.
-            _builder.Properties["UseStartup.StartupType"] = startupType;
+            _startupObject = startupType;
+
             _builder.ConfigureServices((context, services) =>
             {
-                if (_builder.Properties.TryGetValue("UseStartup.StartupType", out var cachedType) && (Type)cachedType == startupType)
+                // Run this delegate if the startup type matches
+                if (object.ReferenceEquals(_startupObject, startupType))
                 {
                     UseStartup(startupType, context, services);
                 }
@@ -210,13 +213,30 @@ public IWebHostBuilder UseStartup(Type startupType)
             return this;
         }
 
-        private void UseStartup(Type startupType, HostBuilderContext context, IServiceCollection services)
+        public IWebHostBuilder UseStartup(Func<WebHostBuilderContext, object> startupFactory)
+        {
+            // Clear the startup type
+            _startupObject = startupFactory;
+
+            _builder.ConfigureServices((context, services) =>
+            {
+                if (object.ReferenceEquals(_startupObject, startupFactory))
+                {
+                    var webHostBuilderContext = GetWebHostBuilderContext(context);
+                    var instance = startupFactory(webHostBuilderContext) ?? new InvalidOperationException("The specified factory returned null startup instance");
+                    UseStartup(instance.GetType(), context, services, instance);
+                }
+            });
+
+            return this;
+        }
+
+        private void UseStartup(Type startupType, HostBuilderContext context, IServiceCollection services, object instance = null)
         {
             var webHostBuilderContext = GetWebHostBuilderContext(context);
             var webHostOptions = (WebHostOptions)context.Properties[typeof(WebHostOptions)];
 
             ExceptionDispatchInfo startupError = null;
-            object instance = null;
             ConfigureBuilder configureBuilder = null;
 
             try
@@ -231,7 +251,7 @@ private void UseStartup(Type startupType, HostBuilderContext context, IServiceCo
                     throw new NotSupportedException($"ConfigureServices returning an {typeof(IServiceProvider)} isn't supported.");
                 }
 
-                instance = ActivatorUtilities.CreateInstance(new HostServiceProvider(webHostBuilderContext), startupType);
+                instance ??= ActivatorUtilities.CreateInstance(new HostServiceProvider(webHostBuilderContext), startupType);
                 context.Properties[_startupKey] = instance;
 
                 // Startup.ConfigureServices
@@ -296,13 +316,19 @@ private void ConfigureContainer<TContainer>(HostBuilderContext context, TContain
 
         public IWebHostBuilder Configure(Action<WebHostBuilderContext, IApplicationBuilder> configure)
         {
+            // Clear the startup type
+            _startupObject = configure;
+
             _builder.ConfigureServices((context, services) =>
             {
-                services.Configure<GenericWebHostServiceOptions>(options =>
+                if (object.ReferenceEquals(_startupObject, configure))
                 {
-                    var webhostBuilderContext = GetWebHostBuilderContext(context);
-                    options.ConfigureApplication = app => configure(webhostBuilderContext, app);
-                });
+                    services.Configure<GenericWebHostServiceOptions>(options =>
+                    {
+                        var webhostBuilderContext = GetWebHostBuilderContext(context);
+                        options.ConfigureApplication = app => configure(webhostBuilderContext, app);
+                    });
+                }
             });
 
             return this;
diff --git a/src/Hosting/Hosting/src/GenericHost/HostingStartupWebHostBuilder.cs b/src/Hosting/Hosting/src/GenericHost/HostingStartupWebHostBuilder.cs
@@ -75,5 +75,10 @@ public IWebHostBuilder UseStartup(Type startupType)
         {
             return _builder.UseStartup(startupType);
         }
+
+        public IWebHostBuilder UseStartup(Func<WebHostBuilderContext, object> startupFactory)
+        {
+            return _builder.UseStartup(startupFactory);
+        }
     }
 }
diff --git a/src/Hosting/Hosting/src/GenericHost/ISupportsStartup.cs b/src/Hosting/Hosting/src/GenericHost/ISupportsStartup.cs
@@ -10,5 +10,6 @@ internal interface ISupportsStartup
     {
         IWebHostBuilder Configure(Action<WebHostBuilderContext, IApplicationBuilder> configure);
         IWebHostBuilder UseStartup(Type startupType);
+        IWebHostBuilder UseStartup(Func<WebHostBuilderContext, object> startupFactory);
     }
 }
diff --git a/src/Hosting/Hosting/src/Internal/StartupLoader.cs b/src/Hosting/Hosting/src/Internal/StartupLoader.cs
@@ -37,15 +37,14 @@ internal class StartupLoader
         // 
         // If the Startup class ConfigureServices returns an <see cref="IServiceProvider"/> and there is at least an <see cref="IStartupConfigureServicesFilter"/> registered we
         // throw as the filters can't be applied.
-        public static StartupMethods LoadMethods(IServiceProvider hostingServiceProvider, Type startupType, string environmentName)
+        public static StartupMethods LoadMethods(IServiceProvider hostingServiceProvider, Type startupType, string environmentName, object instance = null)
         {
             var configureMethod = FindConfigureDelegate(startupType, environmentName);
 
             var servicesMethod = FindConfigureServicesDelegate(startupType, environmentName);
             var configureContainerMethod = FindConfigureContainerDelegate(startupType, environmentName);
 
-            object instance = null;
-            if (!configureMethod.MethodInfo.IsStatic || (servicesMethod != null && !servicesMethod.MethodInfo.IsStatic))
+            if (instance == null && (!configureMethod.MethodInfo.IsStatic || (servicesMethod != null && !servicesMethod.MethodInfo.IsStatic)))
             {
                 instance = ActivatorUtilities.GetServiceOrCreateInstance(hostingServiceProvider, startupType);
             }
@@ -54,7 +53,7 @@ public static StartupMethods LoadMethods(IServiceProvider hostingServiceProvider
             // going to be used for anything.
             var type = configureContainerMethod.MethodInfo != null ? configureContainerMethod.GetContainerType() : typeof(object);
 
-            var builder = (ConfigureServicesDelegateBuilder) Activator.CreateInstance(
+            var builder = (ConfigureServicesDelegateBuilder)Activator.CreateInstance(
                 typeof(ConfigureServicesDelegateBuilder<>).MakeGenericType(type),
                 hostingServiceProvider,
                 servicesMethod,
@@ -104,13 +103,13 @@ Action<object> ConfigureContainerPipeline(Action<object> action)
 
                     // The ConfigureContainer pipeline needs an Action<TContainerBuilder> as source, so we just adapt the
                     // signature with this function.
-                    void Source(TContainerBuilder containerBuilder) => 
+                    void Source(TContainerBuilder containerBuilder) =>
                         action(containerBuilder);
 
                     // The ConfigureContainerBuilder.ConfigureContainerFilters expects an Action<object> as value, but our pipeline
                     // produces an Action<TContainerBuilder> given a source, so we wrap it on an Action<object> that internally casts
                     // the object containerBuilder to TContainerBuilder to match the expected signature of our ConfigureContainer pipeline.
-                    void Target(object containerBuilder) => 
+                    void Target(object containerBuilder) =>
                         BuildStartupConfigureContainerFiltersPipeline(Source)((TContainerBuilder)containerBuilder);
                 }
             }
diff --git a/src/Hosting/Hosting/src/WebHostBuilderExtensions.cs b/src/Hosting/Hosting/src/WebHostBuilderExtensions.cs
@@ -61,6 +61,37 @@ private static IWebHostBuilder Configure(this IWebHostBuilder hostBuilder, Actio
             });
         }
 
+        /// <summary>
+        /// Specify a factory that creates the startup instance to be used by the web host.
+        /// </summary>
+        /// <param name="hostBuilder">The <see cref="IWebHostBuilder"/> to configure.</param>
+        /// <param name="startupFactory">A delegate that specifies a factory for the startup class.</param>
+        /// <returns>The <see cref="IWebHostBuilder"/>.</returns>
+        public static IWebHostBuilder UseStartup(this IWebHostBuilder hostBuilder, Func<WebHostBuilderContext, object> startupFactory)
+        {
+            var startupAssemblyName = startupFactory.GetMethodInfo().DeclaringType.GetTypeInfo().Assembly.GetName().Name;
+
+            hostBuilder.UseSetting(WebHostDefaults.ApplicationKey, startupAssemblyName);
+
+            // Light up the GenericWebHostBuilder implementation
+            if (hostBuilder is ISupportsStartup supportsStartup)
+            {
+                return supportsStartup.UseStartup(startupFactory);
+            }
+
+            return hostBuilder
+                .ConfigureServices((context, services) =>
+                {
+                    services.AddSingleton(typeof(IStartup), sp =>
+                    {
+                        var instance = startupFactory(context) ?? new InvalidOperationException("The specified factory returned null startup instance");
+
+                        var hostingEnvironment = sp.GetRequiredService<IHostEnvironment>();
+
+                        return new ConventionBasedStartup(StartupLoader.LoadMethods(sp, instance.GetType(), hostingEnvironment.EnvironmentName, instance));
+                    });
+                });
+        }
 
         /// <summary>
         /// Specify the startup type to be used by the web host.
diff --git a/src/Hosting/Hosting/test/Fakes/GenericWebHostBuilderWrapper.cs b/src/Hosting/Hosting/test/Fakes/GenericWebHostBuilderWrapper.cs
@@ -73,5 +73,11 @@ public IWebHostBuilder UseStartup(Type startupType)
             _builder.UseStartup(startupType);
             return this;
         }
+
+        public IWebHostBuilder UseStartup(Func<WebHostBuilderContext, object> startupFactory)
+        {
+            _builder.UseStartup(startupFactory);
+            return this;
+        }
     }
 }
diff --git a/src/Hosting/Hosting/test/WebHostBuilderTests.cs b/src/Hosting/Hosting/test/WebHostBuilderTests.cs
@@ -6,15 +6,19 @@
 using System.IO;
 using System.Linq;
 using System.Reflection;
+using System.Runtime.ExceptionServices;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Web;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Hosting.Fakes;
 using Microsoft.AspNetCore.Hosting.Server;
 using Microsoft.AspNetCore.Hosting.Tests.Fakes;
 using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http.Extensions;
 using Microsoft.AspNetCore.Http.Features;
+using Microsoft.AspNetCore.WebUtilities;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
@@ -68,6 +72,54 @@ public async Task StartupStaticCtorThrows_Fallback(IWebHostBuilder builder)
             }
         }
 
+        [Theory]
+        [MemberData(nameof(DefaultWebHostBuildersWithConfig))]
+        public async Task MultipleUseStartupCallsLastWins(IWebHostBuilder builder)
+        {
+            var server = new TestServer();
+            var host = builder.UseServer(server)
+                              .UseStartup<StartupCtorThrows>()
+                              .UseStartup(context => throw new InvalidOperationException("This doesn't run"))
+                              .Configure(app =>
+                              {
+                                  throw new InvalidOperationException("This doesn't run");
+                              })
+                              .Configure(app =>
+                              {
+                                  app.Run(context =>
+                                  {
+                                      return context.Response.WriteAsync("This wins");
+                                  });
+                              })
+                              .Build();
+            using (host)
+            {
+                await host.StartAsync();
+                await AssertResponseContains(server.RequestDelegate, "This wins");
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(DefaultWebHostBuildersWithConfig))]
+        public async Task UseStartupFactoryWorks(IWebHostBuilder builder)
+        {
+            void ConfigureServices(IServiceCollection services) { }
+            void Configure(IApplicationBuilder app)
+            {
+                app.Run(context => context.Response.WriteAsync("UseStartupFactoryWorks"));
+            }
+
+            var server = new TestServer();
+            var host = builder.UseServer(server)
+                              .UseStartup(context => new DelegatingStartup(ConfigureServices, Configure))
+                              .Build();
+            using (host)
+            {
+                await host.StartAsync();
+                await AssertResponseContains(server.RequestDelegate, "UseStartupFactoryWorks");
+            }
+        }
+
         [Theory]
         [MemberData(nameof(DefaultWebHostBuildersWithConfig))]
         public async Task StartupCtorThrows_Fallback(IWebHostBuilder builder)
@@ -199,7 +251,7 @@ public void ConfigureDefaultServiceProviderWithContext(IWebHostBuilder builder)
                     options.ValidateScopes = true;
                 });
 
-            using  var host = hostBuilder.Build();
+            using var host = hostBuilder.Build();
             Assert.Throws<InvalidOperationException>(() => host.Start());
             Assert.True(configurationCallbackCalled);
         }
@@ -728,6 +780,22 @@ public void DefaultApplicationNameWithConfigure(IWebHostBuilder builder)
             }
         }
 
+        [Theory]
+        [MemberData(nameof(DefaultWebHostBuilders))]
+        public void DefaultApplicationNameWithUseStartupFactory(IWebHostBuilder builder)
+        {
+            using (var host = builder
+                .UseServer(new TestServer())
+                .UseStartup(context => new DelegatingStartup(s => { }, app => { }))
+                .Build())
+            {
+                var hostingEnv = host.Services.GetService<IHostEnvironment>();
+
+                // Should be the assembly containing this test, because that's where the delegate comes from
+                Assert.Equal(typeof(WebHostBuilderTests).Assembly.GetName().Name, hostingEnv.ApplicationName);
+            }
+        }
+
         [Theory]
         [MemberData(nameof(DefaultWebHostBuilders))]
         public void Configure_SupportsNonStaticMethodDelegate(IWebHostBuilder builder)
@@ -1218,7 +1286,7 @@ public void UseConfigurationWithSectionAddsSubKeys(IWebHostBuilder builder)
 
             Assert.Equal("nestedvalue", builder.GetSetting("key"));
 
-            using  var host = builder.Build();
+            using var host = builder.Build();
             var appConfig = host.Services.GetRequiredService<IConfiguration>();
             Assert.Equal("nestedvalue", appConfig["key"]);
         }
@@ -1574,6 +1642,21 @@ public void Configure(IWebHostBuilder builder)
             }
         }
 
+        public class DelegatingStartup
+        {
+            private readonly Action<IServiceCollection> _configureServices;
+            private readonly Action<IApplicationBuilder> _configure;
+
+            public DelegatingStartup(Action<IServiceCollection> configureServices, Action<IApplicationBuilder> configure)
+            {
+                _configureServices = configureServices;
+                _configure = configure;
+            }
+
+            public void ConfigureServices(IServiceCollection services) => _configureServices(services);
+            public void Configure(IApplicationBuilder app) => _configure(app);
+        }
+
         public class StartupWithResolvedDisposableThatThrows
         {
             public StartupWithResolvedDisposableThatThrows(DisposableService service)

Original file line number	Diff line number	Diff line change
`@@ -75,5 +75,10 @@ public IWebHostBuilder UseStartup(Type startupType)`
`75`	`75`	`{`
`76`	`76`	`return _builder.UseStartup(startupType);`
`77`	`77`	`}`
	`78`	`+`
	`79`	`+ public IWebHostBuilder UseStartup(Func<WebHostBuilderContext, object> startupFactory)`
	`80`	`+ {`
	`81`	`+ return _builder.UseStartup(startupFactory);`
	`82`	`+ }`
`78`	`83`	`}`
`79`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,5 +10,6 @@ internal interface ISupportsStartup`
`10`	`10`	`{`
`11`	`11`	`IWebHostBuilder Configure(Action<WebHostBuilderContext, IApplicationBuilder> configure);`
`12`	`12`	`IWebHostBuilder UseStartup(Type startupType);`
	`13`	`+ IWebHostBuilder UseStartup(Func<WebHostBuilderContext, object> startupFactory);`
`13`	`14`	`}`
`14`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -73,5 +73,11 @@ public IWebHostBuilder UseStartup(Type startupType)`
`73`	`73`	`_builder.UseStartup(startupType);`
`74`	`74`	`return this;`
`75`	`75`	`}`
	`76`	`+`
	`77`	`+ public IWebHostBuilder UseStartup(Func<WebHostBuilderContext, object> startupFactory)`
	`78`	`+ {`
	`79`	`+ _builder.UseStartup(startupFactory);`
	`80`	`+ return this;`
	`81`	`+ }`
`76`	`82`	`}`
`77`	`83`	`}`