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