理解ASP.NET Core - 主机(Host)

注：本文隶属于《理解ASP.NET Core》系列文章，请查看置顶博客或点击此处查看全文目录

本文会涉及部分 Host 相关的源码，并会附上 github 源码地址，不过为了降低篇幅，我会删除一些不涉及的代码。

为了方便，还是建议你将源码（.net5）runtime 和 aspnetcore 下载下来，通过VS等工具阅读

请耐心阅读！

Generic Host & WebHost

在.NET Core 2.x时，ASP.NET Core 默认使用的是WebHost：

public class Program
{
    public static void Main(string[] args)
    {
        CreateWebHostBuilder(args).Build().Run();
    }

    public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
            .UseStartup();
}

而到了.NET Core 3.x，ASP.NET Core 默认选择使用Generic Host：

public class Program
{
    public static void Main(string[] args)
    {
        CreateHostBuilder(args).Build().Run();
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.UseStartup();
            });
}

那么，为什么.NET团队要将Web主机（Web Host）替换为通用主机（Generic Host）呢？

参考 What is the difference between Host and WebHost class in asp.net core

Generic Host在.NET Core 2.1就已经存在了，并且它就是按照.NET Core未来版本的通用标准来实现的。不过由于当时的Generic Host只能用于非HTTP工作负载，所以.NET Core 2.x仍然使用的是 Web Host。不过到了.NET Core 3.x，Generic Host已经可以同时支持HTTP和非HTTP工作负载了。

为什么要使用Generic Host呢？那是因为Web Host与HTTP请求紧密关联，且用于Web应用。然而，随着微服务和Docker的出现，.NET团队认为需要一个更加通用的主机，不仅能够服务于Web应用，还能服务于控制台等其他类型的应用。所以就实现了Generic Host。

在我们的ASP.NET Core应用中，需要创建一个Generic Host，并通过ConfigureWebHostDefaults等扩展方法针对Web Host进行配置。

所以，我们应该在所有类型的应用中始终使用通用主机。

因此，接下来咱们就聊一下通用主机。

Generic Host——通用主机

先上两张Host的启动流程图：

请大家就着上面这张两图食用以下内容。

ConfigureXXX

在深入之前，大家要先了解一下ConfigureHostConfiguration、ConfigureAppConfiguration、ConfigureServices等方法到底做了什么。其实，很简单，就是将委托暂存到了一个临时变量里。

public class HostBuilder : IHostBuilder
{
    private List> _configureHostConfigActions = new List>();
    private List> _configureAppConfigActions = new List>();
    private List> _configureServicesActions = new List>();

    public IHostBuilder ConfigureHostConfiguration(Action configureDelegate)
    {
        _configureHostConfigActions.Add(configureDelegate ?? throw new ArgumentNullException(nameof(configureDelegate)));
        return this;
    }
    
    public IHostBuilder ConfigureAppConfiguration(Action configureDelegate)
    {
        _configureAppConfigActions.Add(configureDelegate ?? throw new ArgumentNullException(nameof(configureDelegate)));
        return this;
    }
        
    public IHostBuilder ConfigureServices(Action configureDelegate)
    {
        _configureServicesActions.Add(configureDelegate ?? throw new ArgumentNullException(nameof(configureDelegate)));
        return this;
    }
}

Host.CreateDefaultBuilder(args)

• 源码请戳CreateDefaultBuilder

public static class Host
{
    public static IHostBuilder CreateDefaultBuilder(string[] args)
    {
        var builder = new HostBuilder();
    
        // 将 Content Root（项目根目录）设置为 Directory.GetCurrentDirectory (当前工作目录)
        builder.UseContentRoot(Directory.GetCurrentDirectory());
        builder.ConfigureHostConfiguration(config =>
        {
            // 添加以 DOTNET_ 为前缀的环境变量（会将前缀删除作为环境变量的Key）
            config.AddEnvironmentVariables(prefix: "DOTNET_");
            if (args != null)
            {
                // 添加命令行参数 args
                config.AddCommandLine(args);
            }
        });
    
        builder.ConfigureAppConfiguration((hostingContext, config) =>
        {
            IHostEnvironment env = hostingContext.HostingEnvironment;
    
            // 默认当配置发生更改时，重载配置
            bool reloadOnChange = hostingContext.Configuration.GetValue("hostBuilder:reloadConfigOnChange", defaultValue: true);
    
            // appsettings.json、appsettings.{Environment}.json
            config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: reloadOnChange)
                  .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: reloadOnChange);
    
            // 启用 User Secrets（仅当运行在 Development 环境时）
            if (env.IsDevelopment() && !string.IsNullOrEmpty(env.ApplicationName))
            {
                var appAssembly = Assembly.Load(new AssemblyName(env.ApplicationName));
                if (appAssembly != null)
                {
                    config.AddUserSecrets(appAssembly, optional: true);
                }
            }
    
            // 添加环境变量（未限定前缀）
            // 目的是当应用（App）配置加载完毕后（注意是加载完毕后），允许读取所有环境变量，且优先级更高
            // 即若存在多个同名的环境变量，不带前缀的比带前缀的优先级更高
            config.AddEnvironmentVariables();
    
            if (args != null)
            {
                // 添加命令行参数 args
                config.AddCommandLine(args);
            }
        })
        .ConfigureLogging((hostingContext, logging) =>
        {
            bool isWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
    
            if (isWindows)
            {
                logging.AddFilter(level => level >= LogLevel.Warning);
            }
    
            // 添加 Logging 配置
            logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
            
            logging.AddConsole();
            logging.AddDebug();
            logging.AddEventSourceLogger();
    
            if (isWindows)
            {
                // 在Windows平台上，添加 EventLogLoggerProvider
                logging.AddEventLog();
            }
    
            logging.Configure(options =>
            {
                options.ActivityTrackingOptions = ActivityTrackingOptions.SpanId
                                                    | ActivityTrackingOptions.TraceId
                                                    | ActivityTrackingOptions.ParentId;
            });
    
        })
        .UseDefaultServiceProvider((context, options) =>
        {
            // 启用范围验证 scope validation 和依赖关系验证 dependency validation（仅当运行在 Development 环境时）
            bool isDevelopment = context.HostingEnvironment.IsDevelopment();
            options.ValidateScopes = isDevelopment;
            options.ValidateOnBuild = isDevelopment;
        });
    
        return builder;
    }
}

ConfigureWebHostDefaults

• 源码请戳ConfigureWebHostDefaults、ConfigureWebHost、GenericWebHostBuilder、WebHost.ConfigureWebDefaults、UseStartup、GenericWebHostBuilder.UseStartup、GenericWebHostService

public static class GenericHostBuilderExtensions
{
    public static IHostBuilder ConfigureWebHostDefaults(this IHostBuilder builder, Action configure)
    {
        return builder.ConfigureWebHost(webHostBuilder =>
        {
            WebHost.ConfigureWebDefaults(webHostBuilder);
    
            // 执行 UseStartup 等
            configure(webHostBuilder);
        });
    }
}

public static class GenericHostWebHostBuilderExtensions
{
    public static IHostBuilder ConfigureWebHost(this IHostBuilder builder, Action configure)
    {
        return builder.ConfigureWebHost(configure, _ => { });
    }
    
    public static IHostBuilder ConfigureWebHost(this IHostBuilder builder, Action configure, Action configureWebHostBuilder)
    {
        var webHostBuilderOptions = new WebHostBuilderOptions();
        configureWebHostBuilder(webHostBuilderOptions);
        
        // 重点1： GenericWebHostBuilder
        var webhostBuilder = new GenericWebHostBuilder(builder, webHostBuilderOptions);
        configure(webhostBuilder);
        
        // 重点2：GenericWebHostService
        builder.ConfigureServices((context, services) => services.AddHostedService());
        return builder;
    }
}

上面这段代码重点有两个：

• 一个是GenericWebHostBuilder这个类，记住它，ConfigureWebHostDefaults委托中的webBuilder参数就是它！
• 另一个是GenericWebHostService。

下面，我们先看一下GenericWebHostBuilder的构造函数:

internal class GenericWebHostBuilder : IWebHostBuilder, ISupportsStartup, ISupportsUseDefaultServiceProvider
{
    public GenericWebHostBuilder(IHostBuilder builder, WebHostBuilderOptions options)
    {
        _builder = builder;
        var configBuilder = new ConfigurationBuilder()
            .AddInMemoryCollection();
    
        if (!options.SuppressEnvironmentConfiguration)
        {
            // 添加以 ASPNETCORE_ 为前缀的环境变量（会将前缀删除作为环境变量的Key）
            configBuilder.AddEnvironmentVariables(prefix: "ASPNETCORE_");
        }
    
        _config = configBuilder.Build();
    
        _builder.ConfigureHostConfiguration(config =>
        {
            // 添加到主机（Host）配置
            config.AddConfiguration(_config);
            
            // 执行 HostingStartups，详见下方的 ExecuteHostingStartups 方法
            ExecuteHostingStartups();
        });
    
        _builder.ConfigureAppConfiguration((context, configurationBuilder) =>
        {
            // 在 ExecuteHostingStartups 方法中，该字段通常会被初始化
            if (_hostingStartupWebHostBuilder != null)
            {
                var webhostContext = GetWebHostBuilderContext(context);
                // 加载 HostingStartups 中添加的应用（App）配置
                _hostingStartupWebHostBuilder.ConfigureAppConfiguration(webhostContext, configurationBuilder);
            }
        });
    
        _builder.ConfigureServices((context, services) =>
        {
            var webhostContext = GetWebHostBuilderContext(context);
            var webHostOptions = (WebHostOptions)context.Properties[typeof(WebHostOptions)];
    
            // 注册 IWebHostEnvironment
            services.AddSingleton(webhostContext.HostingEnvironment);
            services.AddSingleton((AspNetCore.Hosting.IHostingEnvironment)webhostContext.HostingEnvironment);
            services.AddSingleton();
    
            services.Configure(options =>
            {
                options.WebHostOptions = webHostOptions;
                options.HostingStartupExceptions = _hostingStartupErrors;
            });
    
            var listener = new DiagnosticListener("Microsoft.AspNetCore");
            services.TryAddSingleton(listener);
            services.TryAddSingleton(listener);
    
            services.TryAddSingleton();
            services.TryAddScoped();
            services.TryAddSingleton();
    
            // 注册 IHostingStartup 中配置的服务
            _hostingStartupWebHostBuilder?.ConfigureServices(webhostContext, services);
    
            if (!string.IsNullOrEmpty(webHostOptions.StartupAssembly))
            {
                try
                {
                    var startupType = StartupLoader.FindStartupType(webHostOptions.StartupAssembly, webhostContext.HostingEnvironment.EnvironmentName);
                    UseStartup(startupType, context, services);
                }
                catch (Exception ex) when (webHostOptions.CaptureStartupErrors)
                {
                    var capture = ExceptionDispatchInfo.Capture(ex);
    
                    services.Configure(options =>
                    {
                        options.ConfigureApplication = app =>
                        {
                            capture.Throw();
                        };
                    });
                }
            }
        });
    }
    
    private void ExecuteHostingStartups()
    {
        var webHostOptions = new WebHostOptions(_config, Assembly.GetEntryAssembly()?.GetName().Name);
    
        if (webHostOptions.PreventHostingStartup)
        {
            return;
        }
    
        var exceptions = new List();
        // 注意这里对 _hostingStartupWebHostBuilder 进行了初始化
        _hostingStartupWebHostBuilder = new HostingStartupWebHostBuilder(this);
    
        // 从当前程序集和环境变量`ASPNETCORE_HOSTINGSTARTUPASSEMBLIES`配置的程序集列表（排除`ASPNETCORE_HOSTINGSTARTUPEXCLUDEASSEMBLIES`中配置的程序集列表）中寻找特性`HostingStartupAttribute`，
        // 并通过反射的方式创建特性所标识的`IHostingStartup`实现的实例，并调用其`Configure`方法。
        foreach (var assemblyName in webHostOptions.GetFinalHostingStartupAssemblies().Distinct(StringComparer.OrdinalIgnoreCase))
        {
            try
            {
                var assembly = Assembly.Load(new AssemblyName(assemblyName));
    
                foreach (var attribute in assembly.GetCustomAttributes())
                {
                    var hostingStartup = (IHostingStartup)Activator.CreateInstance(attribute.HostingStartupType);
                    hostingStartup.Configure(_hostingStartupWebHostBuilder);
                }
            }
            catch (Exception ex)
            {
                exceptions.Add(new InvalidOperationException($"Startup assembly {assemblyName} failed to execute. See the inner exception for more details.", ex));
            }
        }
    
        if (exceptions.Count > 0)
        {
            _hostingStartupErrors = new AggregateException(exceptions);
        }
    }
}

接着来看WebHost.ConfigureWebDefaults：

public static class WebHost
{
    internal static void ConfigureWebDefaults(IWebHostBuilder builder)
    {
        builder.ConfigureAppConfiguration((ctx, cb) =>
        {
            if (ctx.HostingEnvironment.IsDevelopment())
            {
                StaticWebAssetsLoader.UseStaticWebAssets(ctx.HostingEnvironment, ctx.Configuration);
            }
        });
        // 将 Kestrel 服务器设置为 Web 服务器，并添加配置
        builder.UseKestrel((builderContext, options) =>
        {
            options.Configure(builderContext.Configuration.GetSection("Kestrel"), reloadOnChange: true);
        })
        .ConfigureServices((hostingContext, services) =>
        {
            // 配置主机过滤中间件（Host Filtering）
            services.PostConfigure(options =>
            {
                if (options.AllowedHosts == null || options.AllowedHosts.Count == 0)
                {
                    var hosts = hostingContext.Configuration["AllowedHosts"]?.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
                    options.AllowedHosts = (hosts?.Length > 0 ? hosts : new[] { "*" });
                }
            });
    
            services.AddSingleton>(
                        new ConfigurationChangeTokenSource(hostingContext.Configuration));
    
            services.AddTransient();
    
            // 当环境变量 ASPNETCORE_FORWARDEDHEADERS_ENABLED 为 true 时，添加转接头中间件（Forwarded Headers）
            if (string.Equals("true", hostingContext.Configuration["ForwardedHeaders_Enabled"], StringComparison.OrdinalIgnoreCase))
            {
                services.Configure(options =>
                {
                    options.ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto;
                    options.KnownNetworks.Clear();
                    options.KnownProxies.Clear();
                });
    
                services.AddTransient();
            }
    
            services.AddRouting();
        })
        // 启用IIS集成
        .UseIIS()
        .UseIISIntegration();
    }
}

我们通常会在ConfigureWebHostDefaults扩展方法的委托中调用UseStartup来指定Startup类，下面我们就来看一下UseStartup到底做了什么：将Startup.ConfigureServices中要注册的服务添加到ConfigureServices的委托中

public static class WebHostBuilderExtensions
{
    public static IWebHostBuilder UseStartup<[DynamicallyAccessedMembers(StartupLinkerOptions.Accessibility)]TStartup>(this IWebHostBuilder hostBuilder) where TStartup : class
    {
        return hostBuilder.UseStartup(typeof(TStartup));
    }
    
    public static IWebHostBuilder UseStartup(this IWebHostBuilder hostBuilder, [DynamicallyAccessedMembers(StartupLinkerOptions.Accessibility)] Type startupType)
    {
        // ...删除了一些代码
    
        // 会进入该条件分支
        // 不知道为什么进入该分支？上面让你牢记的 GenericWebHostBuilder 还记得吗？快去看看它实现了哪些接口
        if (hostBuilder is ISupportsStartup supportsStartup)
        {
            return supportsStartup.UseStartup(startupType);
        }
    
        // ...删除了一些代码
    }
}

internal class GenericWebHostBuilder : IWebHostBuilder, ISupportsStartup, ISupportsUseDefaultServiceProvider
{
    public IWebHostBuilder UseStartup([DynamicallyAccessedMembers(StartupLinkerOptions.Accessibility)] Type startupType)
    {
        // 可以看到，虽然 UseStartup 可以调用多次，但是只有最后一次才有效
        _startupObject = startupType;
    
        // 将 Startup.ConfigureServices 中要注册的服务添加进来
        // 好了，暂时看到这里就ok了
        _builder.ConfigureServices((context, services) =>
        {
            if (object.ReferenceEquals(_startupObject, startupType))
            {
                UseStartup(startupType, context, services);
            }
        });
    
        return this;
    }
}

最后，看一下上面提到的第二个重点GenericWebHostService：用于后续Run方法时执行Configure（包括StartupFilters.Configure、Startup.Configure等）

internal class GenericWebHostService : IHostedService
{
    // 构造函数注入
    public GenericWebHostServiceOptions Options { get; }
    // 构造函数注入
    public IEnumerable StartupFilters { get; }

    public async Task StartAsync(CancellationToken cancellationToken)
    {
        // ...删除了一些代码

        RequestDelegate application = null;

        try
        {
            // 这里取到了 Startup.Configure
            // 可能你不知道为什么这里可以取到，别着急，文章后面会为你解释的
            Action configure = Options.ConfigureApplication;

            // 要求 Startup 必须包含 Configure 方法，或必须调用 IWebHostBuilder.Configure
            if (configure == null)
            {
                throw new InvalidOperationException($"No application configured. Please specify an application via IWebHostBuilder.UseStartup, IWebHostBuilder.Configure, or specifying the startup assembly via {nameof(WebHostDefaults.StartupAssemblyKey)} in the web host configuration.");
            }

            var builder = ApplicationBuilderFactory.CreateBuilder(Server.Features);
            
            // 注意：这里来执行 StartupFilters.Configure 与 Startup.Configure 
            // 将 Startup.Configure 与 StartupFilters.Configure 连接成中间件管道
            // 为什么 Reverse？因为要先执行 StartupFilters.Configure，最后才执行 Startup.Configure，
            // 所以用类似链条的方式，从尾巴开始向头部牵手，这样，最终得到的 configure 指向的就是头部
            // 当执行 configure 时，就可以从头部流转到尾巴
            foreach (var filter in StartupFilters.Reverse())
            {
                configure = filter.Configure(configure);
            }

            // 执行 Configure 方法
            configure(builder);

            // Build HTTP 请求管道
            application = builder.Build();
        }
        catch (Exception ex)
        {
            Logger.ApplicationError(ex);

            if (!Options.WebHostOptions.CaptureStartupErrors)
            {
                throw;
            }

            application = BuildErrorPageApplication(ex);
        }

        var httpApplication = new HostingApplication(application, Logger, DiagnosticListener, HttpContextFactory);

        await Server.StartAsync(httpApplication, cancellationToken);

        // ...删除了一些代码
    }
}

Build

• 源码请戳Build

public class HostBuilder : IHostBuilder
{
    public IHost Build()
    {
        // 加载主机（Host）配置
        BuildHostConfiguration();
        // 实例化 HostingEnvironment
        CreateHostingEnvironment();
        // 实例化 HostBuilderContext
        CreateHostBuilderContext();
        // 加载应用（App）配置
        BuildAppConfiguration();
        // 注册服务并创建 Service Provider
        CreateServiceProvider();
    
        // 生成 IHost 实例并返回
        return _appServices.GetRequiredService();
    }
}

BuildHostConfiguration

public class HostBuilder : IHostBuilder
{
    private void BuildHostConfiguration()
    {
        IConfigurationBuilder configBuilder = new ConfigurationBuilder()
            .AddInMemoryCollection(); 
    
        // 加载主机（Host）配置（同时会执行上面所说的 IHostingStartup.Configure）
        foreach (Action buildAction in _configureHostConfigActions)
        {
            buildAction(configBuilder);
        }
        _hostConfiguration = configBuilder.Build();
    }
}

CreateHostingEnvironment

public class HostBuilder : IHostBuilder
{
    private void CreateHostingEnvironment()
    {
        _hostingEnvironment = new HostingEnvironment()
        {
            ApplicationName = _hostConfiguration[HostDefaults.ApplicationKey],
            EnvironmentName = _hostConfiguration[HostDefaults.EnvironmentKey] ?? Environments.Production,
            ContentRootPath = ResolveContentRootPath(_hostConfiguration[HostDefaults.ContentRootKey], AppContext.BaseDirectory),
        };
    
        if (string.IsNullOrEmpty(_hostingEnvironment.ApplicationName))
        {
            _hostingEnvironment.ApplicationName = Assembly.GetEntryAssembly()?.GetName().Name;
        }
    
        _hostingEnvironment.ContentRootFileProvider = new PhysicalFileProvider(_hostingEnvironment.ContentRootPath);
    }
}

CreateHostBuilderContext

public class HostBuilder : IHostBuilder
{
    private void CreateHostBuilderContext()
    {
        _hostBuilderContext = new HostBuilderContext(Properties)
        {
            HostingEnvironment = _hostingEnvironment,
            Configuration = _hostConfiguration
        };
    }
}

BuildAppConfiguration

public class HostBuilder : IHostBuilder
{
    private void BuildAppConfiguration()
    {
        IConfigurationBuilder configBuilder = new ConfigurationBuilder()
            .SetBasePath(_hostingEnvironment.ContentRootPath)
            .AddConfiguration(_hostConfiguration, shouldDisposeConfiguration: true);
    
        foreach (Action buildAction in _configureAppConfigActions)
        {
            buildAction(_hostBuilderContext, configBuilder);
        }
        _appConfiguration = configBuilder.Build();
        _hostBuilderContext.Configuration = _appConfiguration;
    }
}

CreateServiceProvider

public class HostBuilder : IHostBuilder
{
    private void CreateServiceProvider()
    {
        var services = new ServiceCollection();
        services.AddSingleton(_hostingEnvironment);
        // 注册 IHostEnvironment
        services.AddSingleton(_hostingEnvironment);
        // 注册 HostBuilderContext
        services.AddSingleton(_hostBuilderContext);
        // 注册 IConfiguration，所以能在 Startup 中进行构造函数注入
        services.AddSingleton(_ => _appConfiguration);
        services.AddSingleton(s => (IApplicationLifetime)s.GetService());
        services.AddSingleton();
        // 注意这里注册了 IHostLifetime 服务的实例 ConsoleLifetime
        services.AddSingleton();
        // 注册 IHost 实例
        services.AddSingleton();
        services.AddOptions();
        services.AddLogging();
    
        // 执行 ConfigureServices 方法中的委托进行服务注册
        // 包括使用扩展方法 ConfigureServices、 Startup.ConfigureServices 等设置的委托
        foreach (Action configureServicesAction in _configureServicesActions)
        {
            configureServicesAction(_hostBuilderContext, services);
        }
    
        object containerBuilder = _serviceProviderFactory.CreateBuilder(services);
    
        // 加载容器配置
        foreach (IConfigureContainerAdapter containerAction in _configureContainerActions)
        {
            containerAction.ConfigureContainer(_hostBuilderContext, containerBuilder);
        }
    
        // 创建 Service Provider
        _appServices = _serviceProviderFactory.CreateServiceProvider(containerBuilder);
    
        if (_appServices == null)
        {
            throw new InvalidOperationException($"The IServiceProviderFactory returned a null IServiceProvider.");
        }
    
        _ = _appServices.GetService();
    }
}

Run

• 源码请戳Run、StartAsync

public static class HostingAbstractionsHostExtensions
{
    public static void Run(this IHost host)
    {
        host.RunAsync().GetAwaiter().GetResult();
    }

    public static async Task RunAsync(this IHost host, CancellationToken token = default)
    {
        try
        {
            await host.StartAsync(token).ConfigureAwait(false);
    
            await host.WaitForShutdownAsync(token).ConfigureAwait(false);
        }
        finally
        {
            if (host is IAsyncDisposable asyncDisposable)
            {
                await asyncDisposable.DisposeAsync().ConfigureAwait(false);
            }
            else
            {
                host.Dispose();
            }
    
        }
    }
}

StartAsync

internal class Host : IHost, IAsyncDisposable
{
    public async Task StartAsync(CancellationToken cancellationToken = default)
    {
        _logger.Starting();
    
        using var combinedCancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _applicationLifetime.ApplicationStopping);
        CancellationToken combinedCancellationToken = combinedCancellationTokenSource.Token;
    
        // _hostLifetime 是在构造函数注入的
        // 还记得吗？在上面的 CreateServiceProvider 方法中，注入了该服务的默认实例 ConsoleLifetime，在下方你可以看到 ConsoleLifetime 的部分实现
        await _hostLifetime.WaitForStartAsync(combinedCancellationToken).ConfigureAwait(false);
    
        combinedCancellationToken.ThrowIfCancellationRequested();
        
        // 这里面就包含我们上面提到的重点 GenericWebHostService
        _hostedServices = Services.GetService>();
    
        foreach (IHostedService hostedService in _hostedServices)
        {
            // 激活 IHostedService.StartAsync
            await hostedService.StartAsync(combinedCancellationToken).ConfigureAwait(false);
        }
    
        // 激活 IHostApplicationLifetime.Started
        _applicationLifetime.NotifyStarted();
    
        _logger.Started();
    }
}

public class ConsoleLifetime : IHostLifetime, IDisposable
{
    public Task WaitForStartAsync(CancellationToken cancellationToken)
    {
        // ...删除了一些代码
    
        // 注册了程序退出回调
        AppDomain.CurrentDomain.ProcessExit += OnProcessExit;
        // 注册了 Ctrl + C 回调（这下你知道为啥执行了 Ctrl + C 程序就退出了吧？）
        Console.CancelKeyPress += OnCancelKeyPress;
    
        // 立即启动 Console applications
        return Task.CompletedTask;
    }
    
    private void OnProcessExit(object sender, EventArgs e)
    {
        ApplicationLifetime.StopApplication();
        if (!_shutdownBlock.WaitOne(HostOptions.ShutdownTimeout))
        {
            Logger.LogInformation("Waiting for the host to be disposed. Ensure all 'IHost' instances are wrapped in 'using' blocks.");
        }
        _shutdownBlock.WaitOne();

        System.Environment.ExitCode = 0;
    }
    
    private void OnCancelKeyPress(object sender, ConsoleCancelEventArgs e)
    {
        e.Cancel = true;
        ApplicationLifetime.StopApplication();
    }
}

WaitForShutdownAsync

public static async Task WaitForShutdownAsync(this IHost host, CancellationToken token = default)
{
    IHostApplicationLifetime applicationLifetime = host.Services.GetService();

    token.Register(state =>
    {
        ((IHostApplicationLifetime)state).StopApplication();
    },
    applicationLifetime);

    var waitForStop = new TaskCompletionSource