Asp.net Core 启动流程分析

新建的.net core 程序启动本质上是一个控制台应用程序，所以它的入口在Main方法中，所以启动的开始时从Main方法开始。

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

         public static IWebHost BuildWebHost(string[] args)=>
             WebHost.CreateDefaultBuilder(args).UseStartup<Startup>().Build();

     }

WebHost的CreateDefaultBuilder方法负责创建WebHostBuilder，最后调用WebHostBuilder的build方法创建一个WebHost，这个流程是现在Core里面流行的创建方式，类似读取Config的流程。

IConfiguration configuration = new ConfigurationBuilder().Add(new MemoryConfigurationSource { InitialData = source }).Build(); configuration.GetSection("Format")；//调用Config的获得数据的方法。

我们看到的第一个方法：WebHost.CreateDefaultBuilder(args)。

  public static IWebHostBuilder CreateDefaultBuilder(string[] args)
         {
             var builder = new WebHostBuilder()
                 .UseKestrel()//用Kestreal作为服务器
                 .UseContentRoot(Directory.GetCurrentDirectory())//设置程序的根目录
                 .ConfigureAppConfiguration((hostingContext, config) =>
                 {
                     //根据环境把对应的appsetting配置文件加入到config容器中
                     var env = hostingContext.HostingEnvironment;

                     config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
                           .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);

                     if (env.IsDevelopment())
                     {
                         var appAssembly = Assembly.Load(new AssemblyName(env.ApplicationName));
                         if (appAssembly != null)
                         {
                             //添加用户机密数据
                             config.AddUserSecrets(appAssembly, optional: true);
                         }
                     }
                     //添加环境变量
                     config.AddEnvironmentVariables();
                     //这句加参数不知道有什么用
                     if (args != null)
                     {
                         config.AddCommandLine(args);
                     }
                 })
                 .ConfigureLogging((hostingContext, logging) =>
                 {
                     logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
                     logging.AddConsole();
                     logging.AddDebug();
                 })
                 .UseIISIntegration()
                 .UseDefaultServiceProvider((context, options) =>
                 {
                     options.ValidateScopes = context.HostingEnvironment.IsDevelopment();
                 });

             return builder;
         }

添加用户机密是干什么的可以详细看ASP.NET Core 优雅的在开发环境保存机密（User Secrets），具体就是用来保存一些机密数据。

WebHostBuilder类

         //环境变量的参数
         private readonly IHostingEnvironment _hostingEnvironment;
         //存储添加的Service委托的一个集合
         private readonly List<Action<WebHostBuilderContext, IServiceCollection>> _configureServicesDelegates;
         //访问配置文件
         private IConfiguration _config;
         //WebHost的一些配置选项，它里面其实都是存在config里面的
         private WebHostOptions _options;
         //webHostBuilder上下文，里面两个属性，一个是IHostingEnvironment，一个是IConfiguration
         private WebHostBuilderContext _context;
         //判断是否调用了Build方法，调用以后为true，再次调用Build方法时会报错
         private bool _webHostBuilt;
         //存储添加配置的一个委托集合
         private List<Action<WebHostBuilderContext, IConfigurationBuilder>> _configureAppConfigurationBuilderDelegates;

         /// <summary>
         /// Initializes a new instance of the <see cref="WebHostBuilder"/> class.
         /// </summary>
         public WebHostBuilder()
         {
             _hostingEnvironment = new HostingEnvironment();
             _configureServicesDelegates = new List<Action<WebHostBuilderContext, IServiceCollection>>();
             _configureAppConfigurationBuilderDelegates = new List<Action<WebHostBuilderContext, IConfigurationBuilder>>();

             _config = new ConfigurationBuilder()
                 .AddEnvironmentVariables(prefix: "ASPNETCORE_")
                 .Build();

             if (string.IsNullOrEmpty(GetSetting(WebHostDefaults.EnvironmentKey)))
             {
                 // Try adding legacy environment keys, never remove these.
                 UseSetting(WebHostDefaults.EnvironmentKey, Environment.GetEnvironmentVariable("Hosting:Environment")
                     ?? Environment.GetEnvironmentVariable("ASPNET_ENV"));
             }

             if (string.IsNullOrEmpty(GetSetting(WebHostDefaults.ServerUrlsKey)))
             {
                 // Try adding legacy url key, never remove this.
                 UseSetting(WebHostDefaults.ServerUrlsKey, Environment.GetEnvironmentVariable("ASPNETCORE_SERVER.URLS"));
             }

             _context = new WebHostBuilderContext
             {
                 Configuration = _config
             };
         }

ConfigureAppConfiguration方法就是把委托加到_configureAppConfigurationBuilderDelegates的集合当中去。

AddLogging就是把Service添加到_configureServicesDelegates中去。

UseStartUp方法

        public static IWebHostBuilder UseStartup(this IWebHostBuilder hostBuilder, Type startupType)
        {
            var startupAssemblyName = startupType.GetTypeInfo().Assembly.GetName().Name;

            return hostBuilder
                .UseSetting(WebHostDefaults.ApplicationKey, startupAssemblyName)
                .ConfigureServices(services =>
                {
                    if (typeof(IStartup).GetTypeInfo().IsAssignableFrom(startupType.GetTypeInfo()))
                    {
                        services.AddSingleton(typeof(IStartup), startupType);
                    }
                    else
                    {
                        services.AddSingleton(typeof(IStartup), sp =>
                        {
                            var hostingEnvironment = sp.GetRequiredService<IHostingEnvironment>();
                            return new ConventionBasedStartup(StartupLoader.LoadMethods(sp, startupType, hostingEnvironment.EnvironmentName));
                        });
                    }
                });
        }

设置一下webhostBuilder的程序集名称，把StartUp注册到DI容器中去。目前还没有注入到di容器中去，只是跟之前一样，把这个委托加到了_configureServicesDelegates中去了，在循环执行委托的时候，才真正的注入到di容器中去，这个委托的用处就是把StartUp注入到DI去。

此时有两个判断，如果泛型传进来的StartUp类是继承了IStartup的话就直接注入到DI去的，如果不是的话，就装载默认的StartUp类，也就是我们Core项目的新建时候的那个StartUp类。

看一下StartupLoader.LoadMethods(sp, startupType, hostingEnvironment.EnvironmentName)方法的代码：

         public static StartupMethods LoadMethods(IServiceProvider hostingServiceProvider, Type startupType, string environmentName)
         {
             //获取StartUp类的Config方法(注：这个是可以根据环境来获取不同的配置方法：方法名带有环境变量类似于：Configure{0}，占位符就是环境变量的值test，stage等)
             var configureMethod = FindConfigureDelegate(startupType, environmentName);
             //获取StartUp类的ConfigService方法（跟Config获取一样可以分环境获取方法,Configure{0}Service）
             var servicesMethod = FindConfigureServicesDelegate(startupType, environmentName);

             //获取StartUp类的ConfigContainer方法（跟Config获取一样可以分环境获取方法,Configure{0}Container）
             var configureContainerMethod = FindConfigureContainerDelegate(startupType, environmentName);

             object instance = null;
             if (!configureMethod.MethodInfo.IsStatic || (servicesMethod != null && !servicesMethod.MethodInfo.IsStatic))
             {
                 instance = ActivatorUtilities.GetServiceOrCreateInstance(hostingServiceProvider, startupType);
             }
             //构建一个执行ConfigService的委托
             var configureServicesCallback = servicesMethod.Build(instance);
             var configureContainerCallback = configureContainerMethod.Build(instance);

             Func<IServiceCollection, IServiceProvider> configureServices = services =>
             {
                 // Call ConfigureServices, if that returned an IServiceProvider, we're done，执行ConfigService，如果执行ConfigService方法返回的是一个IServiceProvider，则就直接返回，不执行下面的替换ConfigContainer的方法
                 IServiceProvider applicationServiceProvider = configureServicesCallback.Invoke(services);

                 if (applicationServiceProvider != null)
                 {
                     return applicationServiceProvider;
                 }

                 // If there's a ConfigureContainer method
                 if (configureContainerMethod.MethodInfo != null)
                 {
                     // We have a ConfigureContainer method, get the IServiceProviderFactory<TContainerBuilder>
                     var serviceProviderFactoryType = typeof(IServiceProviderFactory<>).MakeGenericType(configureContainerMethod.GetContainerType());
                     var serviceProviderFactory = hostingServiceProvider.GetRequiredService(serviceProviderFactoryType);
                     // var builder = serviceProviderFactory.CreateBuilder(services);
                     var builder = serviceProviderFactoryType.GetMethod(nameof(DefaultServiceProviderFactory.CreateBuilder)).Invoke(serviceProviderFactory, new object[] { services });
                     configureContainerCallback.Invoke(builder);
                     // applicationServiceProvider = serviceProviderFactory.CreateServiceProvider(builder);
                     applicationServiceProvider = (IServiceProvider)serviceProviderFactoryType.GetMethod(nameof(DefaultServiceProviderFactory.CreateServiceProvider)).Invoke(serviceProviderFactory, new object[] { builder });
                 }
                 else
                 {
                     // Get the default factory
                     var serviceProviderFactory = hostingServiceProvider.GetRequiredService<IServiceProviderFactory<IServiceCollection>>();

                     // Don't bother calling CreateBuilder since it just returns the default service collection
                     applicationServiceProvider = serviceProviderFactory.CreateServiceProvider(services);
                 }

                 return applicationServiceProvider ?? services.BuildServiceProvider();
             };

             return new StartupMethods(instance, configureMethod.Build(instance), configureServices);
         }

ConventionBasedStartup这个类就是一个类似于StartUp的类，New得到时候，就是把StartupMethods传进去，里面的话，就是有两个方法Config指向StartUp的Config方法，ConfigService方法执行StartUp的ConfigService方法。

最后就是WebHostBuilder.Build()方法

 public IWebHost Build()
         {
             if (_webHostBuilt)
             {
                 throw new InvalidOperationException(Resources.WebHostBuilder_SingleInstance);
             }
             _webHostBuilt = true;

             // Warn about deprecated environment variables
             if (Environment.GetEnvironmentVariable("Hosting:Environment") != null)
             {
                 Console.WriteLine("The environment variable 'Hosting:Environment' is obsolete and has been replaced with 'ASPNETCORE_ENVIRONMENT'");
             }

             if (Environment.GetEnvironmentVariable("ASPNET_ENV") != null)
             {
                 Console.WriteLine("The environment variable 'ASPNET_ENV' is obsolete and has been replaced with 'ASPNETCORE_ENVIRONMENT'");
             }

             if (Environment.GetEnvironmentVariable("ASPNETCORE_SERVER.URLS") != null)
             {
                 Console.WriteLine("The environment variable 'ASPNETCORE_SERVER.URLS' is obsolete and has been replaced with 'ASPNETCORE_URLS'");
             }

             var hostingServices = BuildCommonServices(out var hostingStartupErrors);
             var applicationServices = hostingServices.Clone();
             var hostingServiceProvider = hostingServices.BuildServiceProvider();

             AddApplicationServices(applicationServices, hostingServiceProvider);

             var host = new WebHost(
                 applicationServices,
                 hostingServiceProvider,
                 _options,
                 _config,
                 hostingStartupErrors);

             host.Initialize();

             return host;
         }

里面的重点是在BuildCommonServices中，里面默认添加了一系列的Service。如下面的代码：

         private IServiceCollection BuildCommonServices(out AggregateException hostingStartupErrors)
         {
             hostingStartupErrors = null;

             _options = new WebHostOptions(_config);

             if (!_options.PreventHostingStartup)
             {
                 var exceptions = new List<Exception>();

                 // Execute the hosting startup assemblies
                 // HostingStartupAssemblies = $"{ApplicationName};{configuration[WebHostDefaults.HostingStartupAssembliesKey]}".Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries) ?? new string[0];这就是HostingStartupAssembly查找，当我们有类继承与IHostingStartup是，他必须得在build的config里面添加一个key为WebHostDefaults.HostingStartupAssembliesKey的程序集名称，多个以分号隔开。
                 foreach (var assemblyName in _options.HostingStartupAssemblies)
                 {
                     try
                     {
                         var assembly = Assembly.Load(new AssemblyName(assemblyName));

                         //程序集上必须打上HostingStartupAttribute标签
                         foreach (var attribute in assembly.GetCustomAttributes<HostingStartupAttribute>())
                         {
                             var hostingStartup = (IHostingStartup)Activator.CreateInstance(attribute.HostingStartupType);
                             //执行hostingStartup的config方法。
                             hostingStartup.Configure(this);
                         }
                     }
                     catch (Exception ex)
                     {
                         // Capture any errors that happen during startup
                         exceptions.Add(new InvalidOperationException($"Startup assembly {assemblyName} failed to execute. See the inner exception for more details.", ex));
                     }
                 }

                 if (exceptions.Count > )
                 {
                     hostingStartupErrors = new AggregateException(exceptions);
                 }
             }

             var contentRootPath = ResolveContentRootPath(_options.ContentRootPath, AppContext.BaseDirectory);
             var applicationName = _options.ApplicationName;

             // Initialize the hosting environment
             _hostingEnvironment.Initialize(applicationName, contentRootPath, _options);
             _context.HostingEnvironment = _hostingEnvironment;

             var services = new ServiceCollection();
             services.AddSingleton(_hostingEnvironment);
             services.AddSingleton(_context);

             var builder = new ConfigurationBuilder()
                 .SetBasePath(_hostingEnvironment.ContentRootPath)
                 .AddInMemoryCollection(_config.AsEnumerable());

             //执行之前添加的配置文件的委托
             foreach (var configureAppConfiguration in _configureAppConfigurationBuilderDelegates)
             {
                 configureAppConfiguration(_context, builder);
             }

             var configuration = builder.Build();
             services.AddSingleton<IConfiguration>(configuration);
             _context.Configuration = configuration;

             var listener = new DiagnosticListener("Microsoft.AspNetCore");
             services.AddSingleton<DiagnosticListener>(listener);
             services.AddSingleton<DiagnosticSource>(listener);

             services.AddTransient<IApplicationBuilderFactory, ApplicationBuilderFactory>();
             services.AddTransient<IHttpContextFactory, HttpContextFactory>();
             services.AddScoped<IMiddlewareFactory, MiddlewareFactory>();
             services.AddOptions();
             services.AddLogging();

             // Conjure up a RequestServices
             services.AddTransient<IStartupFilter, AutoRequestServicesStartupFilter>();
             services.AddTransient<IServiceProviderFactory<IServiceCollection>, DefaultServiceProviderFactory>();

             // Ensure object pooling is available everywhere.
             services.AddSingleton<ObjectPoolProvider, DefaultObjectPoolProvider>();
             //之前再UseStartUp(string assemblyName)设置的startup类的程序集,在这之前也执行了 一段这个代码，在UseStartUp里面
             //UseStartUp<T>(),这个重载的方法里面是没有加入这个程序集名称的，只是设置一下UseSetting(WebHostDefaults.ApplicationKey, startupAssemblyName)
             if (!string.IsNullOrEmpty(_options.StartupAssembly))
             {
                 try
                 {
                     var startupType = StartupLoader.FindStartupType(_options.StartupAssembly, _hostingEnvironment.EnvironmentName);

                     if (typeof(IStartup).GetTypeInfo().IsAssignableFrom(startupType.GetTypeInfo()))
                     {
                         services.AddSingleton(typeof(IStartup), startupType);
                     }
                     else
                     {
                         services.AddSingleton(typeof(IStartup), sp =>
                         {
                             var hostingEnvironment = sp.GetRequiredService<IHostingEnvironment>();
                             var methods = StartupLoader.LoadMethods(sp, startupType, hostingEnvironment.EnvironmentName);
                             return new ConventionBasedStartup(methods);
                         });
                     }
                 }
                 catch (Exception ex)
                 {
                     var capture = ExceptionDispatchInfo.Capture(ex);
                     services.AddSingleton<IStartup>(_ =>
                     {
                         capture.Throw();
                         return null;
                     });
                 }
             }
             //到这里就已经把说有的Service加到ServiceCollection
             foreach (var configureServices in _configureServicesDelegates)
             {
                 configureServices(_context, services);
             }

             return services;
         }

var applicationServices = hostingServices.Clone();
var hostingServiceProvider = hostingServices.BuildServiceProvider();

AddApplicationServices(applicationServices, hostingServiceProvider)

这里就是新建一个IServiceCollection，把hostingServices里面的service复制一份到applicationService里面去，同时里面有一个

            var listener = new DiagnosticListener("Microsoft.AspNetCore");
            services.AddSingleton<DiagnosticListener>(listener);
            services.AddSingleton<DiagnosticSource>(listener);

这个listener，要保证在两个container里面都是同一个。

         private void AddApplicationServices(IServiceCollection services, IServiceProvider hostingServiceProvider)
         {
             // We are forwarding services from hosting contrainer so hosting container
             // can still manage their lifetime (disposal) shared instances with application services.
             // NOTE: This code overrides original services lifetime. Instances would always be singleton in
             // application container.
             var listener = hostingServiceProvider.GetService<DiagnosticListener>();
             services.Replace(ServiceDescriptor.Singleton(typeof(DiagnosticListener), listener));
             services.Replace(ServiceDescriptor.Singleton(typeof(DiagnosticSource), listener));
         }

最后是新建一个WebHost，然后是调用Initialize方法进行初始化的一些工作，我们最重要的就是看里面的初始化干了什么东西？

 

                //确保是否_applicationService是不是空的,空的话就调用IStartUp的ConfigServices方法获得
                EnsureApplicationServices();
                //调用了UseUrls，则这里面把Server.Feature.Address的值赋值上去
                EnsureServer();

                var builderFactory = _applicationServices.GetRequiredService<IApplicationBuilderFactory>();
                var builder = builderFactory.CreateBuilder(Server.Features);
                builder.ApplicationServices = _applicationServices;

                var startupFilters = _applicationServices.GetService<IEnumerable<IStartupFilter>>();
                Action<IApplicationBuilder> configure = _startup.Configure;
                //查找是否 注册了StartUpFilter，如果注册了，则先调用过滤器
                foreach (var filter in startupFilters.Reverse())
                {
                    configure = filter.Configure(configure);
                }
                //调用第一个注册的config的方法然后接连调用链条
                configure(builder);

                return builder.Build();

EnsureApplicationServices（）的方法是最终调用StartUp类里面的ConfigService方法，把Service注入进去。

private void EnsureApplicationServices()
        {
            if (_applicationServices == null)
            {
                EnsureStartup();
                //调用ConfigureServices方法把服务注册进去（实际调用的是ConventionBasedStartup这个类的ConfigService方法。）
                _applicationServices = _startup.ConfigureServices(_applicationServiceCollection); 
            } 
        }

至此，build方法弄完了。

最后是Run方法：

                //这里时开始的方法。
                await host.StartAsync(token);

                var hostingEnvironment = host.Services.GetService<IHostingEnvironment>();
                var applicationLifetime = host.Services.GetService<IApplicationLifetime>();

                Console.WriteLine($"Hosting environment: {hostingEnvironment.EnvironmentName}");
                Console.WriteLine($"Content root path: {hostingEnvironment.ContentRootPath}");

                //UseUrls时，传入的url，这里回监听这些地址。
                var serverAddresses = host.ServerFeatures.Get<IServerAddressesFeature>()?.Addresses;
                if (serverAddresses != null)
                {
                    foreach (var address in serverAddresses)
                    {
                        Console.WriteLine($"Now listening on: {address}");
                    }
                }

                if (!string.IsNullOrEmpty(shutdownMessage))
                {
                    Console.WriteLine(shutdownMessage);
                }

                await host.WaitForTokenShutdownAsync(token);
            }

StartAsync里面最终调用的就是IServer的Start方法。

最终的启动流程就结束了！！！！。

最后感觉，这个启动流程为了配合DI容器写的好绕，里面很多的委托进行传进传出，看的人很晕！！

但是它带来的灵活性也是巨大的，可以自定义很多地方，真正体现了万物皆DI的思想！