Add support for instantiating the startup class

- 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.

Author: davidfowl

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;

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);
+        }
     }
 }

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);
     }
 }

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);
                 }
             }

src/Hosting/Hosting/src/WebHostBuilderExtensions.cs

@@ -61,6 +61,33 @@ 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)
+        {
+            // 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.

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;
+        }
     }
 }