.NET Core 3.0之深入源碼理解Host(二)

 

寫在前面

停了近一個月的技術博客，隨着正式脫離996的魔窟，接下來也正式恢復了。本文從源碼角度進一步討論.NET Core 3.0 中關於Host擴展的一些技術點，主要討論Long Run Program的創建與守護。

關於Host，我們最容易想到的就是程序的啟動與停止，而其中隱藏着非常關鍵的功能，就是Host的初始化，我們所需要的所有資源都必須而且應該在程序啟動過程中初始化完成，本文的主要內容並不是Host初始化，前文已經累述。為了更好的守護與管理已經啟動的Host，.NET Core 3.0將程序的生命周期事件的訂閱開放給開發者，也包括自定義的Host Service對象。

注：本文代碼基於.NET Core 3.0 Preview9

.NET Core 3.0中創建Long Run Program

IHost與IHostBuilder

當我們創建Long Run Program時，會首先關注程序的啟動與停止，.NET Core 3.0為此提供了一個接口IHost，該接口位於Microsoft.Extensions.Hosting類庫中，其源碼如下：

/// <summary>
/// A program abstraction.
/// </summary>
public interface IHost : IDisposable
{
    /// <summary>
    /// The programs configured services.
    /// </summary>
    IServiceProvider Services { get; }

    /// <summary>
    /// Start the program.
    /// </summary>
    /// <param name="cancellationToken">Used to abort program start.</param>
    /// <returns>A <see cref="Task"/> that will be completed when the <see cref="IHost"/> starts.</returns>
    Task StartAsync(CancellationToken cancellationToken = default);

    /// <summary>
    /// Attempts to gracefully stop the program.
    /// </summary>
    /// <param name="cancellationToken">Used to indicate when stop should no longer be graceful.</param>
    /// <returns>A <see cref="Task"/> that will be completed when the <see cref="IHost"/> stops.</returns>
    Task StopAsync(CancellationToken cancellationToken = default);
}

該接口含有一個只讀屬性：IServiceProvider Services { get; }，通過該屬性，我們可以拿到所有Host初始化時所注入的對象信息。

IHostBuilder接口所承擔的核心功能就是程序的初始化，通過：IHost Build()來完成，當然只需要運行一次即可。其初始化內容一般包括以下幾個功能：

另外需要說明的是，以上功能的初始化，是通過IHostBuilder提供的接口獲取用戶輸入的信息后，通過調用Build()方法來完成初始化。以下為IHostBuilder的部分源代碼：

/// <summary>
/// Set up the configuration for the builder itself. This will be used to initialize the <see cref="IHostEnvironment"/>
/// for use later in the build process. This can be called multiple times and the results will be additive.
/// </summary>
/// <param name="configureDelegate">The delegate for configuring the <see cref="IConfigurationBuilder"/> that will be used
/// to construct the <see cref="IConfiguration"/> for the host.</param>
/// <returns>The same instance of the <see cref="IHostBuilder"/> for chaining.</returns>
public IHostBuilder ConfigureHostConfiguration(Action<IConfigurationBuilder> configureDelegate)
{
    _configureHostConfigActions.Add(configureDelegate ?? throw new ArgumentNullException(nameof(configureDelegate)));
    return this;
}

/// <summary>
/// Adds services to the container. This can be called multiple times and the results will be additive.
/// </summary>
/// <param name="configureDelegate">The delegate for configuring the <see cref="IConfigurationBuilder"/> that will be used
/// to construct the <see cref="IConfiguration"/> for the host.</param>
/// <returns>The same instance of the <see cref="IHostBuilder"/> for chaining.</returns>
public IHostBuilder ConfigureServices(Action<HostBuilderContext, IServiceCollection> configureDelegate)
{
    _configureServicesActions.Add(configureDelegate ?? throw new ArgumentNullException(nameof(configureDelegate)));
    return this;
}

/// <summary>
/// Overrides the factory used to create the service provider.
/// </summary>
/// <typeparam name="TContainerBuilder">The type of the builder to create.</typeparam>
/// <param name="factory">A factory used for creating service providers.</param>
/// <returns>The same instance of the <see cref="IHostBuilder"/> for chaining.</returns>
public IHostBuilder UseServiceProviderFactory<TContainerBuilder>(IServiceProviderFactory<TContainerBuilder> factory)
{
    _serviceProviderFactory = new ServiceFactoryAdapter<TContainerBuilder>(factory ?? throw new ArgumentNullException(nameof(factory)));
    return this;
}

/// <summary>
/// Enables configuring the instantiated dependency container. This can be called multiple times and
/// the results will be additive.
/// </summary>
/// <typeparam name="TContainerBuilder">The type of the builder to create.</typeparam>
/// <param name="configureDelegate">The delegate for configuring the <see cref="IConfigurationBuilder"/> that will be used
/// to construct the <see cref="IConfiguration"/> for the host.</param>
/// <returns>The same instance of the <see cref="IHostBuilder"/> for chaining.</returns>
public IHostBuilder ConfigureContainer<TContainerBuilder>(Action<HostBuilderContext, TContainerBuilder> configureDelegate)
{
    _configureContainerActions.Add(new ConfigureContainerAdapter<TContainerBuilder>(configureDelegate
        ?? throw new ArgumentNullException(nameof(configureDelegate))));
    return this;
}

IHostService

文章開頭有說過自定義Host Service對象，那么我們如何自定義呢，其實很簡單只需要實現IHostService，並在ConfigureServices中調用services.AddHostedService<MyServiceA>()即可，以下是IHostService的源碼：

/// <summary>
/// Defines methods for objects that are managed by the host.
/// </summary>
public interface IHostedService
{
    /// <summary>
    /// Triggered when the application host is ready to start the service.
    /// </summary>
    /// <param name="cancellationToken">Indicates that the start process has been aborted.</param>
    Task StartAsync(CancellationToken cancellationToken);

    /// <summary>
    /// Triggered when the application host is performing a graceful shutdown.
    /// </summary>
    /// <param name="cancellationToken">Indicates that the shutdown process should no longer be graceful.</param>
    Task StopAsync(CancellationToken cancellationToken);
}

根據源碼我們可以知道，該接口只有兩個方法，即代碼程序開始與停止的方法。具體的實現可以參考如下：

public class MyServiceA : IHostedService, IDisposable
{
    private bool _stopping;
    private Task _backgroundTask;

    public MyServiceA(ILoggerFactory loggerFactory)
    {
        Logger = loggerFactory.CreateLogger<MyServiceB>();
    }

    public ILogger Logger { get; }

    public Task StartAsync(CancellationToken cancellationToken)
    {
        Logger.LogInformation("MyServiceB is starting.");
        _backgroundTask = BackgroundTask();
        return Task.CompletedTask;
    }

    private async Task BackgroundTask()
    {
        while (!_stopping)
        {
            await Task.Delay(TimeSpan.FromSeconds(7));
            Logger.LogInformation("MyServiceB is doing background work.");
        }

        Logger.LogInformation("MyServiceB background task is stopping.");
    }

    public async Task StopAsync(CancellationToken cancellationToken)
    {
        Logger.LogInformation("MyServiceB is stopping.");
        _stopping = true;
        if (_backgroundTask != null)
        {
            // TODO: cancellation
            await _backgroundTask;
        }
    }

    public void Dispose()
    {
        Logger.LogInformation("MyServiceB is disposing.");
    }
}

IHostService是我們自定義Host管理對象的入口，所有需要壓入到Host托管的對象都必須要實現此接口。

Host生命周期的管理

該接口提供了一種我們可以在程序運行期間進行管理的功能，如程序的啟動與停止事件的訂閱，關於Host生命周期的管理，主要由IHostApplicationLifetime和IHostLifetime這兩個接口來完成。

以下是IHostApplicationLifetime的源碼​

public interface IHostApplicationLifetime
{
    /// <summary>
    /// Triggered when the application host has fully started.
    /// </summary>
    CancellationToken ApplicationStarted { get; }

    /// <summary>
    /// Triggered when the application host is performing a graceful shutdown.
    /// Shutdown will block until this event completes.
    /// </summary>
    CancellationToken ApplicationStopping { get; }

    /// <summary>
    /// Triggered when the application host is performing a graceful shutdown.
    /// Shutdown will block until this event completes.
    /// </summary>
    CancellationToken ApplicationStopped { get; }

    /// <summary>
    /// Requests termination of the current application.
    /// </summary>
    void StopApplication();
}

IHostLifetime源碼如下：

public interface IHostLifetime
{
    /// <summary>
    /// Called at the start of <see cref="IHost.StartAsync(CancellationToken)"/> which will wait until it's complete before
    /// continuing. This can be used to delay startup until signaled by an external event.
    /// </summary>
    /// <param name="cancellationToken">Used to indicate when stop should no longer be graceful.</param>
    /// <returns>A <see cref="Task"/>.</returns>
    Task WaitForStartAsync(CancellationToken cancellationToken);

    /// <summary>
    /// Called from <see cref="IHost.StopAsync(CancellationToken)"/> to indicate that the host is stopping and it's time to shut down.
    /// </summary>
    /// <param name="cancellationToken">Used to indicate when stop should no longer be graceful.</param>
    /// <returns>A <see cref="Task"/>.</returns>
    Task StopAsync(CancellationToken cancellationToken);
}

具體的使用可以參考如下代碼：

public class MyLifetime : IHostLifetime, IDisposable
{
    .........

    private IHostApplicationLifetime ApplicationLifetime { get; }

    public ConsoleLifetime(IHostApplicationLifetime applicationLifetime)
    {
        ApplicationLifetime = applicationLifetime ?? throw new ArgumentNullException(nameof(applicationLifetime));
    }

    public Task WaitForStartAsync(CancellationToken cancellationToken)
    {
        _applicationStartedRegistration = ApplicationLifetime.ApplicationStarted.Register(state =>
        {
            ((ConsoleLifetime)state).OnApplicationStarted();
        },
        this);
        _applicationStoppingRegistration = ApplicationLifetime.ApplicationStopping.Register(state =>
        {
            ((ConsoleLifetime)state).OnApplicationStopping();
        },
        this);

        .......

        return Task.CompletedTask;
    }

    private void OnApplicationStarted()
    {
        Logger.LogInformation("Application started. Press Ctrl+C to shut down.");
        Logger.LogInformation("Hosting environment: {envName}", Environment.EnvironmentName);
        Logger.LogInformation("Content root path: {contentRoot}", Environment.ContentRootPath);
    }

    private void OnApplicationStopping()
    {
        Logger.LogInformation("Application is shutting down...");
    }

    ........
}

總結

至此，我們知道了創建Long Run Program所需要關注的幾個點，分別是繼承IHostService、訂閱程序的生命周期時間以及Host的初始化過程。相對來說這段內容還是比較簡單的，但是開發過程中，依然會遇到很多的問題，比如任務的定時機制、消息的接入、以及程序的性能優化等等，這些都需要我們在實踐中進一步總結完善。