.net 温故知新【17】：Asp.Net Core WebAPI 中间件

带刺的蜗牛

一、前言

到这篇文章为止，关于.NET "温故知新"系列的基础知识就完结了，从这一系列的系统回顾和再学习，对于.NET core、ASP.NET CORE又有了一个新的认识。
不光是从使用，还包括这些知识点的原理，虽然深入原理谈不上，但对于日常使用也够了，我想的是知其然，知其所以然。
在实际开发过程中可能是知道怎么使用就行，但系统学习了这些基本的框架、组件、或者说原理后，对于我们软件设计、开发、扩展和解决问题还是有帮助的。
刚好到2023新年前赶着写完，也算对自己这个系列的一个交代，实际上我平时基本不使用ASP.NET CORE，目前我主要开发桌面程序，还是用的winform。
写这个系列的初衷是想紧跟.NET的发展进程，同时储备基础知识，平时还搞一些微服务(Java)、NLP、OCR、知识图谱、前端(Vue3)，只要需要反正啥都搞，没必要固执，技术只是手段，不是目的。
那么接下来就继续简单的梳理一下中间件，欢迎对这个系列拍砖！
二、中间件

中间件是一种装配到应用管道以处理请求和响应的软件。 每个组件：

• 选择是否将请求传递到管道中的下一个组件。
  
• 可在管道中的下一个组件前后执行工作。
  

这个是关于中间件概念的概括，官方的概括是相当精准，那么我们就围绕管道、传递、组件来看看中间件。
请求委托用于生成请求管道。 请求委托处理每个 HTTP 请求。使用 Run、Map 和 Use 扩展方法来配置请求委托。
我们照例新建一个ASP.NET CORE Web API 项目：WebAPI_Middleware

1. namespace WebAPI_Middleware
2. {
3.     public class Program
4.     {
5.         public static void Main(string[] args)
6.         {
7.             var builder = WebApplication.CreateBuilder(args);
9.             // Add services to the container.
11.             builder.Services.AddControllers();
12.             // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
13.             builder.Services.AddEndpointsApiExplorer();
14.             builder.Services.AddSwaggerGen();
16.             var app = builder.Build();
18.             // Configure the HTTP request pipeline.
19.             if (app.Environment.IsDevelopment())
20.             {
21.                 app.UseSwagger();
22.                 app.UseSwaggerUI();
23.             }
25.             app.UseHttpsRedirection();
27.             app.UseAuthorization();
30.             app.MapControllers();
32.             app.Run();
33.         }
34.     }
35. }

复制代码

在Program.cs 中我们看到前面部分builder是配置依赖注入的东西，这部分可以参看.net 温故知新【13】：Asp.Net Core WebAPI 使用依赖注入DI 。
app 使用Use扩展用于中间件添加到管道中
Map 基于给定请求路径的匹配项来创建请求管道分支
Run 委托始终为终端，用于终止管道。
中间件的执行顺序过程如下：

三、Map

我们将上面自动创建的东西全都删除，用Map来匹配路由，然后通过不同的代理处理请求。

1.     public class Program
2.     {
3.         public static void Main(string[] args)
4.         {
5.             var builder = WebApplication.CreateBuilder(args);
7.             var app = builder.Build();
8.            
9.             //匹配map1 请求
10.             app.Map("/map1", new Action<IApplicationBuilder>((app) =>
11.             {
12.                 app.Run(async context =>
13.                 {
14.                     await context.Response.WriteAsync("map1 run");
15.                 });
16.             }));
17.             //匹配map2 请求
18.             app.Map("/map2", new Action<IApplicationBuilder>((app) =>
19.             {
20.                 app.Run(async context =>
21.                 {
22.                     await context.Response.WriteAsync("map2 run");
23.                 });
24.             }));
26.             app.Run();
27.         }
28.     }

复制代码

• 请求map1 我们输出：map1 run
  

• 请求map2 我们输出：map2 run
  

Asp.Net Core MapControllers 的扩展方法也是类似道理，用来匹配路由调用处理程序。
四、Run

在上面的 Map 后面我们使用的处理方法中 Run 用于终止管道。也就是说在该管道中如果调用了 Run 那么就直接返回了，即使你后面还添加了 Use 也不会执行。

1. app.Run(async context =>
2. {
3.     await context.Response.WriteAsync("map1 run");
4. });

复制代码

Map 相当于是迎客进门，Map 上了就用指定的管道进行处理，如果没有 Map 上就调用主管道，也就是主管道上的其他中间件也会执行处理。比如我们再加一个 Run 用于没匹配上路由也输出点信息。

加了context.Response.ContentType = "text/plain; charset=utf-8"; 不然中文会乱码。

因为 Run 是终结点，那这个管道中我还想加其他处理怎么办呢，这个时候就该轮到　Use 出场了。
五、Use

用 Use 将多个请求委托链接在一起。 next 参数表示管道中的下一个委托。 可通过不调用 next 参数使管道短路。
首先我们在外面添加两个 Use，不放到 Map 中，这样的话就只有未匹配到的路由会调用

1.     public class Program
2.     {
3.         public static void Main(string[] args)
4.         {
5.             var builder = WebApplication.CreateBuilder(args);
7.             var app = builder.Build();
9.             
11.             app.Map("/map1", new Action<IApplicationBuilder>((app) =>
12.             {
13.                 app.Run(async context =>
14.                 {
15.                     await context.Response.WriteAsync("map1 run");
16.                 });
17.             }));
19.             app.Map("/map2", new Action<IApplicationBuilder>((app) =>
20.             {
21.                 app.Run(async context =>
22.                 {
23.                     await context.Response.WriteAsync("map2 run");
24.                 });
25.             }));
26.             //Use1
27.             app.Use(async (context, next) =>
28.             {
29.                 context.Response.ContentType = "text/plain; charset=utf-8";
31.                 await context.Response.WriteAsync("第 1 个Use   开始!\r\n", Encoding.UTF8);
33.                 await next();
35.                 await context.Response.WriteAsync("第 1 个Use   结束!\r\n", Encoding.UTF8);
37.             });
38.             
39.             //Use2
40.             app.Use(async (context, next) =>
41.             {
42.                 await context.Response.WriteAsync("第 2 个Use   开始!\r\n", Encoding.UTF8);
44.                 await next();
46.                 await context.Response.WriteAsync("第 2 个Use   结束!\r\n", Encoding.UTF8);
48.             });
49.             //结束管道处理
50.             app.Run(async context =>
51.             {
52.                 await context.Response.WriteAsync("未匹配处理!\r\n", Encoding.UTF8);
53.             });
55.             app.Run();
56.         }
57.     }

复制代码

最后执行的路径和最开始的图是一致的。

为什么将context.Response.ContentType = "text/plain; charset=utf-8"; 放到第一个 Use 呢，因为如果放到 Run 里面会报错，改变了 Header 标头。所以理论上也不要在 Use 里面发送响应WriteAsync，此处为了演示所以这么写。

六、中间件类

上面的代理方法可以移动到类中，这个类就是中间件类。中间件类需要如下要求：

• 具有类型为 RequestDelegate 的参数的公共构造函数。
  
• 名为 Invoke 或 InvokeAsync 的公共方法。 此方法必须：
  返回 Task。
  接受类型 HttpContext 的第一个参数。
  

构造函数和 Invoke/InvokeAsync 的其他参数由依赖关系注入 (DI) 填充。
将上面的未匹配路由处理逻辑移动到中间件类中：

• TestMiddleware1：
  

1.     public class TestMiddleware1
2.     {
3.         private readonly RequestDelegate _next;
5.         public TestMiddleware1(RequestDelegate next)
6.         {
7.             _next = next;
8.         }
10.         public async Task InvokeAsync(HttpContext context)
11.         {
13.             context.Response.ContentType = "text/plain; charset=utf-8";
15.             await context.Response.WriteAsync("第 1 个Use   开始!\r\n", Encoding.UTF8);
17.             await _next(context);
19.             await context.Response.WriteAsync("第 1 个Use   结束!\r\n", Encoding.UTF8);
20.         }
21.     }

复制代码

• TestMiddleware2
  

1.     public class TestMiddleware2
2.     {
3.         private readonly RequestDelegate _next;
5.         public TestMiddleware2(RequestDelegate next)
6.         {
7.             _next = next;
8.         }
10.         public async Task InvokeAsync(HttpContext context)
11.         {
14.             await context.Response.WriteAsync("第 2 个Use   开始!\r\n", Encoding.UTF8);
16.             await _next(context);
18.             await context.Response.WriteAsync("第 2 个Use   结束!\r\n", Encoding.UTF8);
19.         }
20.     }

复制代码

• Program
  
  
  
• 运行
  
  
  

此处的中间件使用有顺序问题，如果我先app.UseMiddleware() 因为 TestMiddleware1 修改了标头，根据约定是不允许的，所以程序是有报错。

因此中间件组件的顺序定义了针对请求调用这些组件的顺序，以及响应的相反顺序。 此顺序对于安全性、性能和功能至关重要。
七、中间件顺序

以上是内置中间件的默认顺序规则，具体如何使用内置中间件，可参阅官方资料。
八、写在最后

以上就是关于中间件的部分知识，结合我自己的理解做了前后衔接的梳理逻辑。
官方网站更多的是讲解每个知识点的细节，前后需要结合起来理解，当然我还是强烈建议跟着官方文档学习，而且是最权威最可信的：ASP.NET Core 中间件
这个系列历时2年，工作生活都比较忙，也有放纵啥事不相干的时候，中间断断续续的，总算是坚持完了。很多东西就是这样，累了就休息一下贵在坚持，即使再慢，积累的成果也有收获。

来源:https://www.cnblogs.com/SunSpring/Undeclared/17969336
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！