2. 程式人生 > >ASP.NET Core 執行原理解剖[1]:Hosting

ASP.NET Core 執行原理解剖[1]:Hosting

阿新 • • 發佈：2019-01-08
原文: ASP.NET Core 執行原理解剖[1]:Hosting

ASP.NET Core 是新一代的 ASP.NET，第一次出現時代號為 ASP.NET vNext，後來命名為ASP.NET 5，隨著它的完善與成熟，最終命名為 ASP.NET Core，表明它不是 ASP.NET 的升級，而是一個重新設計的Web開發框架。而它一個非常重要的變化就是它不再依賴於IIS，而是一個獨立的自寄宿的控制檯應用程式，這也是它可以跨平臺的基石，而本文就來詳細探討一下 ASP.NET Core 的啟動過程。

目錄

本系列文章從原始碼分析的角度來探索 ASP.NET Core 的執行原理，分為以下幾個章節：

ASP.NET Core 執行原理解剖[1]:Hosting(Current)

ASP.NET Core 執行原理解剖[2]:Hosting補充之配置介紹

ASP.NET Core 執行原理解剖[3]:Middleware-請求管道的構成

ASP.NET Core 執行原理解剖[4]:進入HttpContext的世界

ASP.NET Core 執行原理解剖[5]:Authentication

前言

我們先回顧一下以前的 ASP.NET 是怎麼來執行的：

IISClassicAspNet

ASP.NET 是嚴重依賴於IIS的，System.Web 中有很多方法都是直接呼叫的 IIS API，並且它還是駐留在IIS程序中的。而 ASP.NET Core 的執行則是一個完全獨立的控制檯程式，它有自己的 Kestrel

Server，可以直接對外部提供服務。

不過 Kestrel 的功能相對較於簡單，所以我們還是需要一個反向代理伺服器將 Kestrel 伺服器保護起來。而微軟也為我們提供了 UseIISIntegration 方法，方便與IIS進行整合。因此，在 Windows 下，通常還是使用IIS來部署，那麼，此時與 ASP.NET 的執行方式又有什麼區別呢？

IISHosting

通過上圖，可以很清楚的明白它們的區別。在 ASP.NET Core 中，IIS 是通過 HTTP 的方式來呼叫我們的 ASP.NET Core 程式。而部署在IIS中時，並不需要我們手動來啟動 ASP.NET Core 的控制檯程式，這是因為IIS新增了一個 AspNetCoreModule

模組，它負責 ASP.NET Core 程式的啟動與停止，並能監聽 ASP.NET Core 程式的狀態，在我們的應用程式意外崩潰時重新啟動。

下面開始進入正題，進入到 ASP.NET Core 的程式碼中去。

WebHost的建立

對於一個程式控制臺程式來說，它的入口點便是 Program 中的 Main 方法，ASP.NET Core 程式自然也不例外：

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 是在 2.0 中新增的，在 MetaPackages 程式集中，程式碼如下：

public static IWebHostBuilder CreateDefaultBuilder(string[] args)
{
    var builder = new WebHostBuilder()
        .UseKestrel()
        .UseContentRoot(Directory.GetCurrentDirectory())
        .ConfigureAppConfiguration((hostingContext, 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;
}

它只是用來簡化我們的程式碼，做了一些基本的配置：

  1. 註冊 Kestrel 中介軟體，指定 WebHost 要使用的 Server（HTTP伺服器）。
  2. 設定 Content 根目錄，將當前專案的根目錄作為 ContentRoot 的目錄。
  3. 讀取 appsettinggs.json 配置檔案，開發環境下的 UserSecrets 以及環境變數和命令列引數。
  4. 讀取配置檔案中的 Logging 節點，對日誌系統進行配置。
  5. 新增 IISIntegration 中介軟體。
  6. 設定開發環境下， ServiceProvider 的 ValidateScopes 為 true，避免直接在 Configure 方法中獲取 Scope 例項。

然後指定 Startup 類，最後通過 Build 方法建立 WebHost 物件，而WebHostBuilder 的程式碼較多，感興趣的可以去看完整程式碼： WebHostBuilder，而在這裡我只展示部分程式碼片段來幫助理解：

public IWebHost Build()
{
    var hostingServices = BuildCommonServices(out var hostingStartupErrors);
    var applicationServices = hostingServices.Clone();
    var hostingServiceProvider = hostingServices.BuildServiceProvider();

    AddApplicationServices(applicationServices, hostingServiceProvider);
}

Build 中的 BuildCommonServices 方法主要有兩個功能：

首先在程式集中查詢 HostingStartupAttribute:

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

    // Execute the hosting startup assemblies
    foreach (var assemblyName in _options.HostingStartupAssemblies)
    {
        var assembly = Assembly.Load(new AssemblyName(assemblyName));

        foreach (var attribute in assembly.GetCustomAttributes<HostingStartupAttribute>())
        {
            var hostingStartup = (IHostingStartup)Activator.CreateInstance(attribute.HostingStartupType);
            hostingStartup.Configure(this);
        }
    }
}

HostingStartupAttribute 給我們一個在其它程式集中做一些啟動配置的機會，在我們進行多層開發及模組化的時候非常有用，下一站會詳細解釋。

然後便是查詢我們的 Startup 類：

if (!string.IsNullOrEmpty(_options.StartupAssembly))
{
    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);
        });
    }
}

首先是判斷是否有 _options.StartupAssembly，對應配置檔案中的 "startupAssembly" ，如果我們沒有設定，那便是空的，並不會執行上面程式碼。通常我們會使用 UseStartup<Startup> 的方法來註冊 Startup 類，而他們的作用是一樣的，都是將我們的 Startup 類做為一個單例註冊到了 DI 系統。

而最終 BuildCommonServices 返回一個 IServiceCollection，用於構建 hostingServiceProvider：

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

接下來建立 WebHost :

public IWebHost Build()
{
    var host = new WebHost(
        applicationServices,
        hostingServiceProvider,
        _options,
        _config,
        hostingStartupErrors);
    }
    
    host.Initialize();

    return host;
}

這裡需要說明的，hostingServiceProvider 是 ASP.NET Core 中的第一個 ServiceProvider，也是根 ServiceProvider，但它是在我們的 Starpup 類執行之前建立的，也就是說並不會包含我們在 ConfigureServices 中註冊的服務（但包含使用 HostingStartupAttribute 註冊的服務）。

WebHost啟動流程

在上一步，建立完 WebHost 之後，便呼叫它的 Run 方法，而 Run 方法再去呼叫 WebHost 的 StartAsync 方法，開始 ASP.NET Core 的啟動工作，主要包含以下幾個步驟：

1. 初始化，構建 RequestDelegate

RequestDelegate 是我們的應用程式處理請求，輸出響應的整個過程，也就是我們的 ASP.NET Core 請求管道。

而它有如下定義：

public delegate Task RequestDelegate(HttpContext context);

這裡不再對 RequestDelegate 進行過多的介紹，以後會詳細解釋。

1.1. 呼叫 Startup 中的 ConfigureServices 方法

在前面介紹過，我們的 Startup 類已經註冊到了 ASP.NET Coer 的 DI 系統中，因此可以直接從 DI 中獲取：

private IStartup _startup;
private IServiceProvider _applicationServices;

_startup = _hostingServiceProvider.GetRequiredService<IStartup>();
 _applicationServices = _startup.ConfigureServices(_applicationServiceCollection);

這裡使用的 _hostingServiceProvider 是我們在 WebHost 中建立的根 ServieProvider。

1.2. 初始化 Http Server

Server 是一個HTTP伺服器，負責HTTP的監聽，接收一組 FeatureCollection 型別的原始請求，並將其包裝成 HttpContext 以供我們的應用程式完成響應的處理。

public interface IServer : IDisposable
{
    IFeatureCollection Features { get; }

    Task StartAsync<TContext>(IHttpApplication<TContext> application, CancellationToken cancellationToken);

    Task StopAsync(CancellationToken cancellationToken);
}

而上面註冊的 Kestrel 便是預設的 Server ：

public static IWebHostBuilder UseKestrel(this IWebHostBuilder hostBuilder)
{
    hostBuilder.UseLibuv();

    return hostBuilder.ConfigureServices(services =>
    {
        services.AddTransient<IConfigureOptions<KestrelServerOptions>, KestrelServerOptionsSetup>();
        services.AddSingleton<IServer, KestrelServer>();
    });
}

Server的初始化主要是配置要監聽的地址：

private void EnsureServer()
{
    if (Server == null)
    {
        Server = _applicationServices.GetRequiredService<IServer>();

        var serverAddressesFeature = Server.Features?.Get<IServerAddressesFeature>();
        var addresses = serverAddressesFeature?.Addresses;
        if (addresses != null && !addresses.IsReadOnly && addresses.Count == 0)
        {
            var urls = _config[WebHostDefaults.ServerUrlsKey] ?? _config[DeprecatedServerUrlsKey];
            if (!string.IsNullOrEmpty(urls))
            {
                serverAddressesFeature.PreferHostingUrls = WebHostUtilities.ParseBool(_config, WebHostDefaults.PreferHostingUrlsKey);

                foreach (var value in urls.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
                {
                    addresses.Add(value);
                }
            }
        }
    }
}

Addresses 預設是通過在 launchSettings.json 中來查詢的。

1.3. 建立 IApplicationBuilder

IApplicationBuilder 用於構建應用程式的請求管道，也就是生成 RequestDelegate，有如下定義：

public interface IApplicationBuilder
{
    IServiceProvider ApplicationServices { get; set; }

    IFeatureCollection ServerFeatures { get; }

    IDictionary<string, object> Properties { get; }

    RequestDelegate Build();

    IApplicationBuilder New();

    IApplicationBuilder Use(Func<RequestDelegate, RequestDelegate> middleware);
}

而它的建立過程是通過 ApplicationBuilderFactory 來建立的：

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

IApplicationBuilderFactory 的預設實現 ApplicationBuilderFactory：

public IApplicationBuilder CreateBuilder(IFeatureCollection serverFeatures)
{
    return new ApplicationBuilder(_serviceProvider, serverFeatures);
}

ApplicationBuilder 的實現方式就不在這裡多說了，在講中介軟體的時候再來細說。

1.4. 配置 IApplicationBuilder

我們比較的熟悉的是在 Startup 類的 Configure 方法中對 IApplicationBuilder 進行配置，其實還有一個 IStartupFilter 也可以用來配置 IApplicationBuilder，並且在 Startup 類的Configure 方法之前執行：

var startupFilters = _applicationServices.GetService<IEnumerable<IStartupFilter>>();
Action<IApplicationBuilder> configure = _startup.Configure;
foreach (var filter in startupFilters.Reverse())
{
    configure = filter.Configure(configure);
}

configure(builder);

然後呼叫 IApplicationBuilder 的 Build 方法，便完成了 RequestDelegate 的建立：

 private RequestDelegate BuildApplication()
{
    ...

    return builder.Build();
}

2. 啟動 Server，監聽請求並響應

Server 本身是並不清楚 HttpContext 的細節的，因此它需要接收一個 IHttpApplication 型別的引數，來負責 HttpContext 的建立，由如下定義：

public interface IHttpApplication<TContext>
{
    TContext CreateContext(IFeatureCollection contextFeatures);

    Task ProcessRequestAsync(TContext context);

    void DisposeContext(TContext context, Exception exception);
}

它的預設實現是 HostingApplication 類，而 ProcessRequestAsync 方法則呼叫我們上面建立的 RequestDelegate 委託，來完成對 HttpContext 的處理：

public class HostingApplication : IHttpApplication<HostingApplication.Context>
{
    private readonly RequestDelegate _application;

    public Task ProcessRequestAsync(Context context)
    {
        return _application(context.HttpContext);
    }
}

最後啟動 Server：

var httpContextFactory = _applicationServices.GetRequiredService<IHttpContextFactory>();
var hostingApp = new HostingApplication(_application, _logger, diagnosticSource, httpContextFactory);

await Server.StartAsync(hostingApp, cancellationToken).ConfigureAwait(false);

Server 會繫結一個監聽埠，註冊HTTP連線事件，最終交給 Http2Stream<TContext> 來處理，通過上面的 hostingApp 來切入到我們的應用程式中，完成整個請求的處理：

public class Http2Stream<TContext> : Http2Stream
{
    private readonly IHttpApplication<TContext> _application;

    public override async Task ProcessRequestAsync()
    {
        ...

        var context = _application.CreateContext(this);

        try
        {
            await _application.ProcessRequestAsync(context);

            ...
        }
        finally
        {
            _application.DisposeContext(context, _applicationException);

            ...
        }
        ...
    }
}

3. 啟動 HostedService

HostedService 為我們提供一個註冊後臺執行服務的機會，它會在隨著我們的 ASP.NET Core 程式啟動而啟動，並在 ASP.NET Core 停止時進行優雅的關閉，有如下定義：

public interface IHostedService
{
    Task StartAsync(CancellationToken cancellationToken);

    Task StopAsync(CancellationToken cancellationToken);
}

而它是通過 HostedServiceExecutor 來執行的：

public class HostedServiceExecutor
{
    private readonly IEnumerable<IHostedService> _services;

    public async Task StartAsync(CancellationToken token)
    {
        await ExecuteAsync(service => service.StartAsync(token));
    }

    public async Task StopAsync(CancellationToken token)
    {
        await ExecuteAsync(service => service.StopAsync(token));
    }

    private async Task ExecuteAsync(Func<IHostedService, Task> callback)
    {
        foreach (var service in _services)
        {
            await callback(service);
        }
    }
}

WebHost 會呼叫 HostedServiceExecutor 的 StartAsync ，從而完成對 HostedService 的啟動：

_applicationLifetime = _applicationServices.GetRequiredService<IApplicationLifetime>() as ApplicationLifetime;
_hostedServiceExecutor = _applicationServices.GetRequiredService<HostedServiceExecutor>();

// Fire IApplicationLifetime.Started
_applicationLifetime?.NotifyStarted();

// Fire IHostedService.Start
await _hostedServiceExecutor.StartAsync(cancellationToken).ConfigureAwait(false);

這裡還有對 IApplicationLifetime 啟動事件的觸發，以後會介紹一下 IApplicationLifetime 的用途。

到此 WebHost 的整個啟動過程介紹完畢。

總結

本文粗略地介紹了一下 ASP.NET Core 中 WebHost 建立及啟動，它也是 ASP.NET Core 中的宿主，包含 HttpServer 的啟動與監聽，而其中也涉及到了很多關鍵點，對我們以後的開發非常有用，由於篇幅有限，下一章再來介紹一些本文沒有解釋清楚的概念。

參考文章：

Publishing-and-Running-ASPNET-Core-Applications-with-IIS

相關推薦

ASP.NET Core 執行原理解剖[1]:Hosting

原文: ASP.NET Core 執行原理解剖[1]:Hosting ASP.NET Core 是新一代的 ASP.NET，第一次出現時代號為 ASP.NET vNext，後來命名為ASP.NET 5，隨著它的完善與成熟，最終命名為 ASP.NET Core，表明它不是 ASP.NET 的升級，而是一個重新

ASP.NET Core 執行原理解剖[2]-Hosting補充之配置介紹

在上一章中，我們介紹了 ASP.NET Core 的啟動過程，主要是對 WebHost 原始碼的探索。而本文則是對上文的一個補充，更加偏向於實戰，詳細的介紹一下我們在實際開發中需要對 Hosting 做一些配置時經常用到的幾種方式。 目錄 本系列文章將會從原始碼分析來講解

ASP.NET Core 執行原理解剖[5]:Authentication

原文: ASP.NET Core 執行原理解剖[5]:Authentication 在現代應用程式中，認證已不再是簡單的將使用者憑證儲存在瀏覽器中，而要適應多種場景，如App，WebAPI，第三方登入等等。在 ASP.NET 4.x 時代的Windows認證和Forms認證已無法滿足現代化的需求，因此在AS

ASP.NET Core 執行原理解剖[3]:Middleware-請求管道的構成

原文: ASP.NET Core 執行原理解剖[3]:Middleware-請求管道的構成 在 ASP.NET 中，我們知道，它有一個面向切面的請求管道，有19個主要的事件構成，能夠讓我們進行靈活的擴充套件。通常是在 web.config 中通過註冊 HttpModule 來實現對請求管道事件監聽，並通過

ASP.NET Core 執行原理解剖[4]:進入HttpContext的世界

原文: ASP.NET Core 執行原理解剖[4]:進入HttpContext的世界 HttpContext是ASP.NET中的核心物件，每一個請求都會建立一個對應的HttpContext物件，我們的應用程式便是通過HttpContext物件來獲取請求資訊，最終生成響應，寫回到HttpContext中，完

ASP.NET Core 執行原理

1.1. 概述 在ASP.NET Core之前，ASP.NET Framework應用程式由IIS載入。Web應用程式的入口點由InetMgr.exe建立並呼叫託管。以初始化過程中觸發HttpApplication.Application_Start()事件。開發人員第一次執行程式碼的機會是處理

ASP.NET Core 執行原理剖析

1.1. 概述 在ASP.NET Core之前，ASP.NET Framework應用程式由IIS載入。Web應用程式的入口點由InetMgr.exe建立並呼叫託管。以初始化過程中觸發HttpApplication.Application_Start()事件。開發人員第一次執行程式碼的機會是處理

ASP.NET Core中的快取[1]：如何在一個ASP.NET Core應用中使用快取

.NET Core針對快取提供了很好的支援 ，我們不僅可以選擇將資料快取在應用程序自身的記憶體中，還可以採用分散式的形式將快取資料儲存在一個“中心資料庫”中。對於分散式快取，.NET Core提供了針對Redis和SQL Server的原生支援。除了這個獨立的快取系統之外，ASP.NET Core還藉助一箇中

Asp.net core 學習筆記 2.1 升級到 2.2

contex basepath nbsp odata art esp apps ack 一個 首先跟著官網 step by step https://docs.microsoft.com/en-us/aspnet/core/migration/21-to-22?view=

ASP.NET Core 微服務初探[1]：服務發現之Consul

原文: ASP.NET Core 微服務初探[1]：服務發現之Consul 在傳統單體架構中，由於應用動態性不強，不會頻繁的更新和釋出，也不會進行自動伸縮，我們通常將所有的服務地址都直接寫在專案的配置檔案中，發生變化時，手動改一下配置檔案，也不會覺得有什麼問題。但是在微服務模式下，服務會更細的拆分解耦，微服

ASP.NET Core 認證與授權[1]:初識認證

在ASP.NET 4.X 中，我們最常用的是Forms認證，它既可以用於區域網環境，也可用於網際網路環境，有著非常廣泛的使用。但是它很難進行擴充套件，更無法與第三方認證整合，因此，在 ASP.NET Core 中對認證與授權進行了全新的設計，並使用基於宣告的認證(claims-based authentica

《ASP.NET Core 高效能系列》ASP.NET Core的啟動過程(1)

一、一切從頭開始 簡述:知道事情的真相就應該從頭 開始,下面我們程式碼先行 public class Program { public static void Main(string[] args) { CreateHostBuilder(ar

ASP.NET Core路由中介軟體[1]: 終結點與URL的對映

藉助路由系統提供的請求URL模式與對應終結點（Endpoint）之間的對映關係，我們可以將具有相同URL模式的請求分發給應用的終結點進行處理。ASP.NET Core的路由是通過EndpointRoutingMiddleware和EndpointMiddleware這兩個中介軟體協作完成的，它們在ASP.NE

ASP.NET Core 運行原理剖析1:初始化WebApp模版並運行

正式版 功能 option urn server ack reference 修改 tin ASP.NET Core 運行原理剖析1:初始化WebApp模版並運行 核心框架 ASP.NET Core APP 創建與運行 總結 之前兩篇文章簡析.NET Core

asp.net core 2.1 DBfirst MySQL 執行命令出錯

Scaffold-DbContext "Data Source=localhost;Initial Catalog=FriendSourceDB;User ID=root;Password=;" Pomelo.EntityFrameworkCore.MySql -OutputDir EFModel

ASP.NET Core 2.1 使用Docker執行

1.新建一個 ASP.NET Core 2.1 專案 然後執行一下專案，確保我們剛剛建立的專案可以正常執行。 2.編寫 Dockerfile 新建一個文字檔案，命名為 Dockerfile FROM microsoft/dotnet:2.1-aspnetcore-runtime WORKDIR /app

ASP.NET Core 中文文件 第三章 原理（1）應用程式啟動

ASP.NET Core 為你的應用程式提供了處理每個請求的完整控制。Startup 類是應用程式的入口（entry point），這個類可以設定配置（configuration）並且將應用程式將要使用的服務連線起來。開發人員可以在 Startup 類中配置請求管道，該管道將用於處理應用程式的所有請求。 章

[ASP.NET Core 3框架揭祕] 服務承載系統[1]: 承載長時間執行的服務[上篇]

藉助.NET Core提供的承載（Hosting）系統，我們可以將任意一個或者多個長時間執行（Long-Running）的服務寄宿或者承載於託管程序中。ASP.NET Core應用僅僅是該承載系統的一種典型的服務型別而已，任何需要在後臺長時間執行的操作都可以定義成標準化的服務並利用該系統來承載。一、承載長時間

ABP官方文檔翻譯 6.2.1 ASP.NET Core集成

mic 模型 binder let 轉換 span optional document clas ASP.NET Core 介紹 遷移到ASP.NET Core？ 啟動模板 配置 啟動類 模塊配置 控制器 應用服務作為控制器

1.準備開發ASP.NET Core

tps 不同 sof asp.net 註意 .aspx 運行時 netcore detail 1.下載安裝dotnetcore sdk dotnet-sdk-2.0.3-win-x64.exe 搜索下載安裝即可 2.下載安裝VS2017 （當然可以使用其他:如 vs