本系列将分析ASP.NET Core运行原理

本节将分析WebHost.StartAsync();代码,确定是如何一步一步到我们注册的中间件,并介绍几种Configure的方式。

源代码参考.NET Core 2.0.0

目录

  • Server.StartAsync

    • Server
    • IHttpApplication
    • HttpContextFactory
    • HttpContext
  • Configure
    • IApplicationBuilder
    • Use
    • Run
    • UseMiddleware
    • UseWhen
    • MapWhen
    • Map

Server.StartAsync

在上节我们知道WebHost.StartAsync内部是调用Server.StartAsync的。

public async Task StartAsync<TContext>(IHttpApplication<TContext> application, CancellationToken cancellationToken)
{
async Task OnBind(ListenOptions endpoint)
{
var connectionHandler = new ConnectionHandler<TContext>(endpoint, ServiceContext, application);
var transport = _transportFactory.Create(endpoint, connectionHandler);
_transports.Add(transport); await transport.BindAsync().ConfigureAwait(false);
} await AddressBinder.BindAsync(_serverAddresses, Options.ListenOptions, Trace, OnBind).ConfigureAwait(false);
}

参数application即为之前的new HostingApplication。在这里说下大概的流程:

KestrelServer.StartAsync -> new ConnectionHandler<TContext>().OnConnection -> new FrameConnection().StartRequestProcessing() ->
new Frame<TContext>().ProcessRequestsAsync() -> _application.CreateContext(this) && _application.ProcessRequestAsync(context)

如果你需要更细节的流程,可参考如下:

LibuvTransportFactory -> LibuvTransport.BindAsync() -> ListenerPrimary.StartAsync() ->
listener.ListenSocket.Listen(LibuvConstants.ListenBacklog, ConnectionCallback, listener) -> listener.OnConnection(stream, status) -> ConnectionCallback() ->
new LibuvConnection(this, socket).Start() -> ConnectionHandler.OnConnection() -> connection.StartRequestProcessing() ->
ProcessRequestsAsync -> CreateFrame -> await _frame.ProcessRequestsAsync()
  1. _application 为上面的HostingApplication;
  2. 每个WebHost.StartAsync 将创建唯一的一个HostingApplication实例并在每次请求时使用。
  3. 由Frame类调用HostingApplication的方法。

下面展示Frame以及HostingApplication:

Frame

public class Frame<TContext> : Frame
{
public override async Task ProcessRequestsAsync()
{
while (!_requestProcessingStopping)
{
Reset(); EnsureHostHeaderExists(); var messageBody = MessageBody.For(_httpVersion, FrameRequestHeaders, this);
InitializeStreams(messageBody); var context = _application.CreateContext(this);
try
{
await _application.ProcessRequestAsync(context);
}
finally
{
_application.DisposeContext(context, _applicationException);
}
}
}
}

HostingApplication

public class HostingApplication : IHttpApplication<HostingApplication.Context>
{
private readonly RequestDelegate _application;
private readonly IHttpContextFactory _httpContextFactory; public HostingApplication(
RequestDelegate application,
IHttpContextFactory httpContextFactory)
{
_application = application;
_httpContextFactory = httpContextFactory;
} // Set up the request
public Context CreateContext(IFeatureCollection contextFeatures)
{
var context = new Context();
var httpContext = _httpContextFactory.Create(contextFeatures);
context.HttpContext = httpContext;
return context;
} // Execute the request
public Task ProcessRequestAsync(Context context)
{
return _application(context.HttpContext);
} // Clean up the request
public void DisposeContext(Context context, Exception exception)
{
var httpContext = context.HttpContext;
_httpContextFactory.Dispose(httpContext);
} public struct Context
{
public HttpContext HttpContext { get; set; }
}
}

由此我们发现HttpContext是由HttpContextFactory创建的,其中_httpContextFactory则是上节在WebHostBuilder的BuildCommon注入的

同时在HostingApplication的ProcessRequestAsync方法中,我们看到我们的_application(Startup注册的中间件)被调用了。

IHttpContextFactory

HttpContextFactory

public HttpContext Create(IFeatureCollection featureCollection)
{
var httpContext = new DefaultHttpContext(featureCollection);
if (_httpContextAccessor != null)
_httpContextAccessor.HttpContext = httpContext;
return httpContext;
}

而创建的HttpContext则是DefaultHttpContext类型:

public class DefaultHttpContext : HttpContext
{
public virtual void Initialize(IFeatureCollection features)
{
_features = new FeatureReferences<FeatureInterfaces>(features);
_request = InitializeHttpRequest();
_response = InitializeHttpResponse();
} public override HttpRequest Request => _request; public override HttpResponse Response => _response;
}

Configure

IApplicationBuilder

我们知道在Startup的Configure方法中,通过IApplicationBuilder可以注册中间件。

public interface IApplicationBuilder
{
IServiceProvider ApplicationServices { get; set; }
RequestDelegate Build();
IApplicationBuilder Use(Func<RequestDelegate, RequestDelegate> middleware);
}

默认实现类为:

public class ApplicationBuilder : IApplicationBuilder
{
private readonly IList<Func<RequestDelegate, RequestDelegate>> _components = new List<Func<RequestDelegate, RequestDelegate>>();
public IApplicationBuilder Use(Func<RequestDelegate, RequestDelegate> middleware)
{
_components.Add(middleware);
return this;
} public RequestDelegate Build()
{
RequestDelegate app = context =>
{
context.Response.StatusCode = 404;
return Task.CompletedTask;
}; foreach (var component in _components.Reverse())
app = component(app); return app;
}
}

其中Use方法为注册中间件。中间件的本质就是一个Func<RequestDelegate, RequestDelegate>对象。

该对象的传入参数为下一个中间件,返回对象为本中间件。

而Build方法为生成一个RequestDelegate,在HostingApplication构造函数中的参数即为该对象。

在Build方法中,我们看到最后一个中间件为404中间件。其他的中间件都是通过Use方法注册到内部维护的_components对象上。

Use

我们通过一个Use示例,来看下中间件的流程:

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
app.Use(next => async context =>
{
Console.WriteLine("A begin");
await next(context);
Console.WriteLine("A end");
}); app.Use(next => async context =>
{
Console.WriteLine("B begin");
await next(context);
Console.WriteLine("B end");
});
}

访问结果:

A begin

B begin

B end

A end

流程图:

Run

当我们不使用next 下一个中间件的时候,我们可以使用Run方法来实现

Run方法接受一个RequestDelegate对象,本身是IApplicationBuilder的扩展方法。

public static void Run(this IApplicationBuilder app, RequestDelegate handler);
{
app.Use(_ => handler);
}

Run示例

app.Run(context=>context.Response.WriteAsync("Run Core"));

该示例相当于:

app.Use(next => context => context.Response.WriteAsync("Run Core"));

UseMiddleware

而通常我们添加中间件的方式是通过UseMiddleware来更加方便的操作。

先看下IMiddleware:

public interface IMiddleware
{
Task InvokeAsync(HttpContext context, RequestDelegate next);
}

参数next即为下一个中间件。

有2种实现UseMiddleware的方式:

  1. 实现IMiddleware接口。
  2. 基于接口约定的方法。

IMiddleware接口

public class DemoMiddle : IMiddleware
{
public Task InvokeAsync(HttpContext context, RequestDelegate next)
{
return context.Response.WriteAsync("hello middleware");
}
}

在使用IMiddleware接口的时候,还需要注册该类到DI系统中。

约定

public class DemoMiddle
{
private RequestDelegate _next;
public DemoMiddle(RequestDelegate next)
{
_next = next;
}
public Task InvokeAsync(HttpContext context)
{
return context.Response.WriteAsync("hello middleware");
}
}

这种方式,不用再注册到DI中,如果需要对该类构造函数传入参数,直接在app.UseMiddleware<DemoMiddle>("hi1");传入参数即可。

UseWhen

app.Use(next => async context => { await context.Response.WriteAsync("Begin"); await next(context); });

app.UseWhen(context => context.Request.Path.Value == "/hello", branch => branch.Use(
next => async context => { await context.Response.WriteAsync("hello"); await next(context); })); app.Run(context => context.Response.WriteAsync("End"));

当我们访问/hello时,结果为:BeginhelloEnd

分析源码得知在构建管道的时候,克隆一个另外的IApplicationBuilder。

public static IApplicationBuilder UseWhen(this IApplicationBuilder app, Predicate predicate, Action<IApplicationBuilder> configuration)
{
var branchBuilder = app.New();
configuration(branchBuilder); return app.Use(main =>
{
// This is called only when the main application builder
// is built, not per request.
branchBuilder.Run(main);// 添加(调用)原来的中间件
var branch = branchBuilder.Build(); return context => predicate(context) ? branch(context): main(context);
});
}

MapWhen

app.Use(next => async context => { await context.Response.WriteAsync("Begin"); await next(context); });

app.MapWhen(context => context.Request.Path.Value == "/hello", app2 => app2.Run(context => context.Response.WriteAsync("hello")));

app.Run(context => context.Response.WriteAsync("End"));

当我们访问/hello时,结果为:Beginhello

分析源码得知在构建管道的时候,新分支并没有再调用原来的中间件。

public static IApplicationBuilder MapWhen(this IApplicationBuilder app, Predicate predicate, Action<IApplicationBuilder> configuration)
{
var branchBuilder = app.New();
configuration(branchBuilder);
var branch = branchBuilder.Build();
return app.Use(next => context => predicate(context) ? branch(context): next(context));
}

Map

app.Map("/hello", app2 => app2.Run(context => context.Response.WriteAsync("hello")));

当我们访问/hello时,结果为:Beginhello。与MapWhen效果一样。

如果我们只是判断URLPath的话,通常我们会使用Map方法。

以上是常用的注册中间件的方式。

本文链接:http://neverc.cnblogs.com/p/8029419.html

【ASP.NET Core】运行原理(2):启动WebHost的更多相关文章

  1. 【ASP.NET Core】运行原理之启动WebHost

    ASP.NET Core运行原理之启动WebHost 本节将分析WebHost.CreateDefaultBuilder(args).UseStartup<Startup>().Build ...

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

    ASP.NET Core 是新一代的 ASP.NET,第一次出现时代号为 ASP.NET vNext,后来命名为ASP.NET 5,随着它的完善与成熟,最终命名为 ASP.NET Core,表明它不是 ...

  3. ASP.NET Core 运行原理解剖[2]:Hosting补充之配置介绍

    在上一章中,我们介绍了 ASP.NET Core 的启动过程,主要是对 WebHost 源码的探索.而本文则是对上文的一个补充,更加偏向于实战,详细的介绍一下我们在实际开发中需要对 Hosting 做 ...

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

    HttpContext是ASP.NET中的核心对象,每一个请求都会创建一个对应的HttpContext对象,我们的应用程序便是通过HttpContext对象来获取请求信息,最终生成响应,写回到Http ...

  5. ASP.NET Core 运行原理剖析1:初始化WebApp模版并运行

    ASP.NET Core 运行原理剖析1:初始化WebApp模版并运行 核心框架 ASP.NET Core APP 创建与运行 总结 之前两篇文章简析.NET Core 以及与 .NET Framew ...

  6. ASP.NET Core 运行原理解剖[3]:Middleware-请求管道的构成

    在 ASP.NET 中,我们知道,它有一个面向切面的请求管道,有19个主要的事件构成,能够让我们进行灵活的扩展.通常是在 web.config 中通过注册 HttpModule 来实现对请求管道事件监 ...

  7. ASP.NET Core 运行原理剖析

    1. ASP.NET Core 运行原理剖析 1.1. 概述 1.2. 文件配置 1.2.1. Starup文件配置 Configure ConfigureServices 1.2.2. appset ...

  8. ASP.NET Core 运行原理剖析2:Startup 和 Middleware(中间件)

    ASP.NET Core 运行原理剖析2:Startup 和 Middleware(中间件) Startup Class 1.Startup Constructor(构造函数) 2.Configure ...

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

    在现代应用程序中,认证已不再是简单的将用户凭证保存在浏览器中,而要适应多种场景,如App,WebAPI,第三方登录等等.在 ASP.NET 4.x 时代的Windows认证和Forms认证已无法满足现 ...

随机推荐

  1. [2018HN省队集训D6T2] girls

    [2018HN省队集训D6T2] girls 题意 给定一张 \(n\) 个点 \(m\) 条边的无向图, 求选三个不同结点并使它们两两不邻接的所有方案的权值和 \(\bmod 2^{64}\) 的值 ...

  2. DXperience 工具箱不显示/ Visual Studio 2012选择项打开崩溃

    1.移除NetFx40_LegacySecurityPolicy  节: 移除C:\Program Files (x86)\Microsoft Visual Studio 11.0\Common7\I ...

  3. [微信小程序直播平台开发]___(一)介绍与流程

    1.一个可以忽略的前言 最近在做的一个项目,客户要做一个直播平台,主播发起视频直播,然后其他人进入房间观看这样子,跟其他直播平台不同的是,主播可以打赏观众,噗. 因为客户要做的是一个民宿的微信小程序, ...

  4. 4514: [Sdoi2016]数字配对

    Description 有 n 种数字,第 i 种数字是 ai.有 bi 个,权值是 ci. 若两个数字 ai.aj 满足,ai 是 aj 的倍数,且 ai/aj 是一个质数, 那么这两个数字可以配对 ...

  5. [SCOI2007]组队

    嘟嘟嘟 这题有人说部分分O(n3)暴力,然而我暴力都没写过,调了半天也没用……还是看题解吧 首先,咱把A * ( h – minH ) + B * ( s – minS ) <= C 变个型,得 ...

  6. (十一)T检验-第二部分

    了解什么是有效大小,尝试一个单一样本t检验的完整示例. 效应量 调查研究的一个重要方面是效应量,在实验性研究中或存在处理变量的研究中,效应量是指处理效应的大小,意思很直观: 在非实验性研究中,效应量是 ...

  7. dede:channel二级导航currentstyle属性失效问题

    dede:channel默认只作用在一级导航中,在调用下级导航(type='son')时,发现不起作用. 修改方法:修改 include/taglib/channel.lib.php 第133行.if ...

  8. 微信授权获取用户openid前端实现

    近来,倒霉的后台跟我说让我拿个openid做微信支付使用,寻思很简单,开始干活.   首先引导用户打开如下链接,只需要将appid修改为自己的就可以,redirect_url写你的重定向url   h ...

  9. UCOS时钟节拍的讲究

    其实这个值取适中即可,100,200都行,看你的片子是什么,Cortex-M3的片子取200较合适这个值太小,系统调度周期较长,各个任务之间切换较慢,适时性降低,而太大了,中断周期与调试周期接近了,那 ...

  10. 【js】走近小程序(2) 常见问题总结

    一.API请求? 二.基础库兼容? 三.不同页面之间的传值   一.API请求? wx.request({ url: 'test.php', // 仅为示例,并非真实的接口地址 data: { x: ...