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 > 0)
                {
                    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的思想！