.Net Core 管道底层源码实现

在 .NET Core 中，请求处理管道是一个中间件（Middleware）链，用于处理 HTTP 请求并天生响应。管道的底层实现基于 Microsoft.AspNetCore.Http 定名空间中的一些核心类和接口

1. 核心组件

1.1 HttpContext

• • HttpContext 是 HTTP 请求和响应的核心抽象，封装了请求信息（如请求头、请求体、查询参数等）和响应信息（如状态码、响应头、响应体等）。
  
• • 每个请求都会创建一个 HttpContext 实例，并在整个管道中传递。
  

1.2 HttpRequest 和 HttpResponse

• • HttpRequest 和 HttpResponse 分别表现 HTTP 请求和响应，是 HttpContext 的一部分。
  
• • HttpRequest 包罗请求的具体信息，如路径、方法、头、体等。
  
• • HttpResponse 用于设置响应的状态码、头、体等。
  

1.3 RequestDelegate

• • RequestDelegate 是一个委托，表现处理 HTTP 请求的方法：
  

1. public delegate Task RequestDelegate(HttpContext context);

复制代码

• • 管道中的每个中间件都是一个 RequestDelegate。
  

1.4 Middleware

• • 中间件是一个类或方法，用于处理请求并调用管道中的下一个中间件。
  
• • 中间件通常通过 Use 或 Run 方法注册到管道中。
  

2. 定义 ApplicationBuilder 接口

首先，我们定义 IApplicationBuilder 接口：

1. public interface IApplicationBuilder
2. {
3.     // 添加中间件到管道中
4.     IApplicationBuilder Use(Func<RequestDelegate, RequestDelegate> middleware);
6.     // 构建最终的请求处理管道
7.     RequestDelegate Build();
9.     // 获取或设置应用程序服务提供者
10.     IServiceProvider ApplicationServices { get; set; }
12.     // 获取属性字典，用于存储共享数据
13.     IDictionary<string, object> Properties { get; }
14. }

复制代码

3. 定义 RequestDelegate 委托

管道的核心是基于委托（Delegate）和上下文（Context）的机制。
**RequestDelegate**：是一个表现处理 HTTP 请求的委托。

1. public delegate Task RequestDelegate(HttpContext context);

复制代码

• • **HttpContext**：封装了 HTTP 请求和响应的所有信息，包括请求头、请求体、响应头、响应体等。
  

每个中间件本质上是一个 RequestDelegate，它接收 HttpContext 并处理请求，同时可以选择调用下一个中间件。
4. 实现 ApplicationBuilder 类

接下来，我们实现 ApplicationBuilder 类：

1. public class ApplicationBuilder : IApplicationBuilder
2. {
3.     // 存储中间件组件的列表
4.     private readonly IList<Func<RequestDelegate, RequestDelegate>> _components = new List<Func<RequestDelegate, RequestDelegate>>();
6.     // 获取或设置应用程序服务提供者
7.     public IServiceProvider ApplicationServices { get; set; }
9.     // 获取属性字典，用于存储共享数据
10.     public IDictionary<string, object> Properties { get; } = new Dictionary<string, object>();
12.     // 添加中间件到管道中
13.     public IApplicationBuilder Use(Func<RequestDelegate, RequestDelegate> middleware)
14.     {
15.         _components.Add(middleware);
16.         return this;
17.     }
19.     // 构建最终的请求处理管道
20.     public RequestDelegate Build()
21.     {
22.         // 默认的请求处理程序，返回 404 状态码
23.         RequestDelegate app = context =>
24.         {
25.             context.Response.StatusCode = 404;
26.             return Task.CompletedTask;
27.         };
29.         // 反向遍历中间件组件列表，构建嵌套的请求处理管道
30.         foreach (var component in _components.Reverse())
31.         {
32.             app = component(app);
33.         }
35.         return app;
36.     }
37. }

复制代码

5. 创建中间件

我们创建一个简单的日志网络中间件来展示如何使用 **ApplicationBuilder** ：

1. public class CustomizeMiddleware
2. {
3.     private readonly RequestDelegate _next;
5.     // 构造函数，接受下一个中间件的委托
6.     public CustomizeMiddleware(RequestDelegate next)
7.     {
8.         _next = next;
9.     }
11.     // 中间件的请求处理方法
12.     public async Task Invoke(HttpContext context)
13.     {
14.         Console.WriteLine("自定义中间件: Before");
15.         await _next(context); // 调用下一个中间件
16.         Console.WriteLine("自定义中间件: After");
17.     }
18. }

复制代码

6. 使用 ApplicationBuilder 构建管道

1. public class Program
2. {
3.     public static void Main(string[] args)
4.     {
5.         // 创建 ApplicationBuilder 实例
6.         var builder = new ApplicationBuilder();
8.         // 添加 CustomizeMiddleware 到管道中
9.         builder.Use(next => new CustomizeMiddleware(next).Invoke);
11.         // 添加内联中间件到管道中
12.         builder.Use(next => async context =>
13.         {
14.             Console.WriteLine("内联中间件: Before");
15.             await next(context); // 调用下一个中间件
16.             Console.WriteLine("内联中间件: After");
17.         });
19.         // 构建最终的请求处理管道
20.         var app = builder.Build();
22.         // 创建一个 HttpContext 实例
23.         var context = new DefaultHttpContext();
25.         // 执行管道
26.         app(context).Wait();
27.     }
28. }

复制代码

输入效果为：

7.总结

.NET Core 管道的底层实现是基于委托链的机制，每个中间件都是一个 RequestDelegate，通过链式调用来处理 HTTP 请求和响应。管道的构建过程通过 IApplicationBuilder 接口完成，中间件的添加次序决定了管道的执行次序。通过明白管道的底层实现，可以更好地掌握 .NET Core 的请求处理机制，并能够机动地配置和扩展管道。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。