.NET Core 3.1.1--HostBuilder 类源码

// Assembly location: C:Program FilesdotnetsharedMicrosoft.AspNetCore.App3.1.1Microsoft.Extensions.Hosting.dll

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.FileProviders;
using Microsoft.Extensions.Hosting.Internal;
using System;
using System.Collections.Generic;
using System.IO;
using System.Reflection;

namespace Microsoft.Extensions.Hosting
{
  public class HostBuilder : IHostBuilder
  {
    private List<Action<IConfigurationBuilder>> _configureHostConfigActions = new List<Action<IConfigurationBuilder>>();
    private List<Action<HostBuilderContext, IConfigurationBuilder>> _configureAppConfigActions = new List<Action<HostBuilderContext, IConfigurationBuilder>>();
    private List<Action<HostBuilderContext, IServiceCollection>> _configureServicesActions = new List<Action<HostBuilderContext, IServiceCollection>>();
    private List<IConfigureContainerAdapter> _configureContainerActions = new List<IConfigureContainerAdapter>();
    private IServiceFactoryAdapter _serviceProviderFactory = (IServiceFactoryAdapter) new ServiceFactoryAdapter<IServiceCollection>((IServiceProviderFactory<IServiceCollection>) new DefaultServiceProviderFactory());
    private bool _hostBuilt;
    private IConfiguration _hostConfiguration;
    private IConfiguration _appConfiguration;
    private HostBuilderContext _hostBuilderContext;
    private HostingEnvironment _hostingEnvironment;
    private IServiceProvider _appServices;

    public IDictionary<object, object> Properties { get; } = (IDictionary<object, object>) new Dictionary<object, object>();

    public IHostBuilder ConfigureHostConfiguration(
      Action<IConfigurationBuilder> configureDelegate)
    {
      List<Action<IConfigurationBuilder>> hostConfigActions = this._configureHostConfigActions;
      Action<IConfigurationBuilder> action = configureDelegate;
      if (action == null)
        throw new ArgumentNullException(nameof (configureDelegate));
      hostConfigActions.Add(action);
      return (IHostBuilder) this;
    }

    public IHostBuilder ConfigureAppConfiguration(
      Action<HostBuilderContext, IConfigurationBuilder> configureDelegate)
    {
      List<Action<HostBuilderContext, IConfigurationBuilder>> appConfigActions = this._configureAppConfigActions;
      Action<HostBuilderContext, IConfigurationBuilder> action = configureDelegate;
      if (action == null)
        throw new ArgumentNullException(nameof (configureDelegate));
      appConfigActions.Add(action);
      return (IHostBuilder) this;
    }

    public IHostBuilder ConfigureServices(
      Action<HostBuilderContext, IServiceCollection> configureDelegate)
    {
      List<Action<HostBuilderContext, IServiceCollection>> configureServicesActions = this._configureServicesActions;
      Action<HostBuilderContext, IServiceCollection> action = configureDelegate;
      if (action == null)
        throw new ArgumentNullException(nameof (configureDelegate));
      configureServicesActions.Add(action);
      return (IHostBuilder) this;
    }

    public IHostBuilder UseServiceProviderFactory<TContainerBuilder>(
      IServiceProviderFactory<TContainerBuilder> factory)
    {
      IServiceProviderFactory<TContainerBuilder> serviceProviderFactory = factory;
      if (serviceProviderFactory == null)
        throw new ArgumentNullException(nameof (factory));
      this._serviceProviderFactory = (IServiceFactoryAdapter) new ServiceFactoryAdapter<TContainerBuilder>(serviceProviderFactory);
      return (IHostBuilder) this;
    }

    public IHostBuilder UseServiceProviderFactory<TContainerBuilder>(
      Func<HostBuilderContext, IServiceProviderFactory<TContainerBuilder>> factory)
    {
      Func<HostBuilderContext> contextResolver = (Func<HostBuilderContext>) (() => this._hostBuilderContext);
      Func<HostBuilderContext, IServiceProviderFactory<TContainerBuilder>> factoryResolver = factory;
      if (factoryResolver == null)
        throw new ArgumentNullException(nameof (factory));
      this._serviceProviderFactory = (IServiceFactoryAdapter) new ServiceFactoryAdapter<TContainerBuilder>(contextResolver, factoryResolver);
      return (IHostBuilder) this;
    }

    public IHostBuilder ConfigureContainer<TContainerBuilder>(
      Action<HostBuilderContext, TContainerBuilder> configureDelegate)
    {
      List<IConfigureContainerAdapter> containerActions = this._configureContainerActions;
      Action<HostBuilderContext, TContainerBuilder> action = configureDelegate;
      if (action == null)
        throw new ArgumentNullException(nameof (configureDelegate));
      ConfigureContainerAdapter<TContainerBuilder> containerAdapter = new ConfigureContainerAdapter<TContainerBuilder>(action);
      containerActions.Add((IConfigureContainerAdapter) containerAdapter);
      return (IHostBuilder) this;
    }

    public IHost Build()
    {
      if (this._hostBuilt)
        throw new InvalidOperationException("Build can only be called once.");
      this._hostBuilt = true;
      this.BuildHostConfiguration();
      this.CreateHostingEnvironment();
      this.CreateHostBuilderContext();
      this.BuildAppConfiguration();
      this.CreateServiceProvider();
      return this._appServices.GetRequiredService<IHost>();
    }

    private void BuildHostConfiguration()
    {
      IConfigurationBuilder configurationBuilder = new ConfigurationBuilder().AddInMemoryCollection();
      foreach (Action<IConfigurationBuilder> hostConfigAction in this._configureHostConfigActions)
        hostConfigAction(configurationBuilder);
      this._hostConfiguration = (IConfiguration) configurationBuilder.Build();
    }

    private void CreateHostingEnvironment()
    {
      this._hostingEnvironment = new HostingEnvironment()
      {
        ApplicationName = this._hostConfiguration[HostDefaults.ApplicationKey],
        EnvironmentName = this._hostConfiguration[HostDefaults.EnvironmentKey] ?? Environments.Production,
        ContentRootPath = this.ResolveContentRootPath(this._hostConfiguration[HostDefaults.ContentRootKey], AppContext.BaseDirectory)
      };
      if (string.IsNullOrEmpty(this._hostingEnvironment.ApplicationName))
      {
        HostingEnvironment hostingEnvironment = this._hostingEnvironment;
        Assembly entryAssembly = Assembly.GetEntryAssembly();
        string str = (object) entryAssembly != null ? entryAssembly.GetName().Name : (string) null;
        hostingEnvironment.ApplicationName = str;
      }
      this._hostingEnvironment.ContentRootFileProvider = (IFileProvider) new PhysicalFileProvider(this._hostingEnvironment.ContentRootPath);
    }

    private string ResolveContentRootPath(string contentRootPath, string basePath)
    {
      if (string.IsNullOrEmpty(contentRootPath))
        return basePath;
      return Path.IsPathRooted(contentRootPath) ? contentRootPath : Path.Combine(Path.GetFullPath(basePath), contentRootPath);
    }

    private void CreateHostBuilderContext()
    {
      this._hostBuilderContext = new HostBuilderContext(this.Properties)
      {
        HostingEnvironment = (IHostEnvironment) this._hostingEnvironment,
        Configuration = this._hostConfiguration
      };
    }

    private void BuildAppConfiguration()
    {
      IConfigurationBuilder configurationBuilder = new ConfigurationBuilder().SetBasePath(this._hostingEnvironment.ContentRootPath).AddConfiguration(this._hostConfiguration, true);
      foreach (Action<HostBuilderContext, IConfigurationBuilder> configureAppConfigAction in this._configureAppConfigActions)
        configureAppConfigAction(this._hostBuilderContext, configurationBuilder);
      this._appConfiguration = (IConfiguration) configurationBuilder.Build();
      this._hostBuilderContext.Configuration = this._appConfiguration;
    }

    private void CreateServiceProvider()
    {
      ServiceCollection services = new ServiceCollection();
      services.AddSingleton<IHostingEnvironment>((IHostingEnvironment) this._hostingEnvironment);
      services.AddSingleton<IHostEnvironment>((IHostEnvironment) this._hostingEnvironment);
      services.AddSingleton<HostBuilderContext>(this._hostBuilderContext);
      services.AddSingleton<IConfiguration>((Func<IServiceProvider, IConfiguration>) (_ => this._appConfiguration));
      services.AddSingleton<IApplicationLifetime>((Func<IServiceProvider, IApplicationLifetime>) (s => (IApplicationLifetime) s.GetService<IHostApplicationLifetime>()));
      services.AddSingleton<IHostApplicationLifetime, ApplicationLifetime>();
      services.AddSingleton<IHostLifetime, ConsoleLifetime>();
      services.AddSingleton<IHost, Microsoft.Extensions.Hosting.Internal.Host>();
      services.AddOptions();
      services.AddLogging();
      foreach (Action<HostBuilderContext, IServiceCollection> configureServicesAction in this._configureServicesActions)
        configureServicesAction(this._hostBuilderContext, (IServiceCollection) services);
      object builder = this._serviceProviderFactory.CreateBuilder((IServiceCollection) services);
      foreach (IConfigureContainerAdapter configureContainerAction in this._configureContainerActions)
        configureContainerAction.ConfigureContainer(this._hostBuilderContext, builder);
      this._appServices = this._serviceProviderFactory.CreateServiceProvider(builder);
      if (this._appServices == null)
        throw new InvalidOperationException("The IServiceProviderFactory returned a null IServiceProvider.");
      this._appServices.GetService<IConfiguration>();
    }
  }
}