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

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

/// <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(tory)));
    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;
}

/// <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.");
    }
}

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

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