public static IHostBuilder CreateHostBuilder(string[] args) =>

    Host.CreateDefaultBuilder(args)

        .ConfigureWebHostDefaults(webBuilder =>

        {

            webBuilder.UseStartup<Startup>();

        });

public static IWebHostBuilder UseStartup<TStartup>(this IWebHostBuilder hostBuilder) where TStartup : class

{

    return hostBuilder.UseStartup(typeof(TStartup));

}

public static IWebHostBuilder UseStartup(this IWebHostBuilder hostBuilder, Type startupType)

{

    var startupAssemblyName = startupType.GetTypeInfo().Assembly.GetName().Name;

    hostBuilder.UseSetting(WebHostDefaults.ApplicationKey, startupAssemblyName);

    // 判断hostBuilder是否继承了ISupportsStartup接口

    if (hostBuilder is ISupportsStartup supportsStartup)

    {

        return supportsStartup.UseStartup(startupType);

    }

    ...

}

public static IHostBuilder ConfigureWebHostDefaults(this IHostBuilder builder, Action<IWebHostBuilder> configure)

{

    return builder.ConfigureWebHost(webHostBuilder =>

    {

        WebHost.ConfigureWebDefaults(webHostBuilder);

        // 执行委托，实际就是 webBuilder.UseStartup<Startup>();

        configure(webHostBuilder);

    });

}

public IWebHostBuilder UseStartup(Type startupType)

{

    // 保存启动类的类型

    _builder.Properties["UseStartup.StartupType"] = startupType;

    _builder.ConfigureServices((context, services) =>

    {

        // 判断待执行的类型是否与保存的类型一致

        // 如果调用了多次IWebHostBuilder.UseStartup，这里将只会执行最后一次添加的类型

        if (_builder.Properties.TryGetValue("UseStartup.StartupType", out var cachedType) && (Type)cachedType == startupType)

        {

            UseStartup(startupType, context, services);

        }

    });

    return this;

}

private void UseStartup(Type startupType, HostBuilderContext context, IServiceCollection services)

{

    var webHostBuilderContext = GetWebHostBuilderContext(context);

    var webHostOptions = (WebHostOptions)context.Properties[typeof(WebHostOptions)];

    ExceptionDispatchInfo startupError = null;

    object instance = null;

    ConfigureBuilder configureBuilder = null;

    try

    {

        if (typeof(IStartup).IsAssignableFrom(startupType))

        {

            throw new NotSupportedException($"{typeof(IStartup)} isn't supported");

        }

        if (StartupLoader.HasConfigureServicesIServiceProviderDelegate(startupType, context.HostingEnvironment.EnvironmentName))

        {

            throw new NotSupportedException($"ConfigureServices returning an {typeof(IServiceProvider)} isn't supported.");

        }

        // 创建Startup类的实例

        instance = ActivatorUtilities.CreateInstance(new HostServiceProvider(webHostBuilderContext), startupType);

        context.Properties[_startupKey] = instance;

        // 通过反射找到ConfigureServices方法，并包装成ConfigureServicesBuilder对象

        var configureServicesBuilder = StartupLoader.FindConfigureServicesDelegate(startupType, context.HostingEnvironment.EnvironmentName);

        var configureServices = configureServicesBuilder.Build(instance);

        // 执行ConfigureServices方法

        configureServices(services);

        // 通过反射找到ConfigureContainer方法，并包装成ConfigureContainerBuilder对象

        var configureContainerBuilder = StartupLoader.FindConfigureContainerDelegate(startupType, context.HostingEnvironment.EnvironmentName);

        if (configureContainerBuilder.MethodInfo != null)

        {

            var containerType = configureContainerBuilder.GetContainerType();

            _builder.Properties[typeof(ConfigureContainerBuilder)] = configureContainerBuilder;

            var actionType = typeof(Action<,>).MakeGenericType(typeof(HostBuilderContext), containerType);

            // 找到当前实例的私有ConfigureContainer方法，并创建该方法的委托

            var configureCallback = GetType().GetMethod(nameof(ConfigureContainer), BindingFlags.NonPublic | BindingFlags.Instance)

                                             .MakeGenericMethod(containerType)

                                             .CreateDelegate(actionType, this);

            // 执行ConfigureContainer方法的委托

            typeof(IHostBuilder).GetMethods().First(m => m.Name == nameof(IHostBuilder.ConfigureContainer))

                .MakeGenericMethod(containerType)

                .InvokeWithoutWrappingExceptions(_builder, new object[] { configureCallback });

        }

        // 通过反射找到Configure方法，并包装成ConfigureBuilder对象

        configureBuilder = StartupLoader.FindConfigureDelegate(startupType, context.HostingEnvironment.EnvironmentName);

    }

    catch (Exception ex) when (webHostOptions.CaptureStartupErrors)

    {

        startupError = ExceptionDispatchInfo.Capture(ex);

    }

    services.Configure<GenericWebHostServiceOptions>(options =>

    {

        options.ConfigureApplication = app =>

        {

            startupError?.Throw();

            if (instance != null && configureBuilder != null)

            {

                // 执行Configure方法

                configureBuilder.Build(instance)(app);

            }

        };

    });

}

private void ConfigureContainer<TContainer>(HostBuilderContext context, TContainer container)

{

    var instance = context.Properties[_startupKey];

    var builder = (ConfigureContainerBuilder)context.Properties[typeof(ConfigureContainerBuilder)];

    // 执行Startup实例的ConfigureContainer方法

    builder.Build(instance)(container);

}