【aspnetcore】模拟中间件处理请求的管道

几个核心对象：

1. ApplicationBuilder 就是startup->Configure方法的第一个参数，请求（HttpContext） 就是由这个类来处理的
2. HttpContext 这个就不解释了
3. RequestDelegate 一个异步委托，委托的参数就是HttpContext，定义了一些对HttpContext的操作；可以看做是一个Action<HttpContext>()，只不过方法体内必须有异步的代码（await ）

下面解释下ApplicationBuilder，这个类内部维护了一个中间件的列表，还有几个核心的方法：

1. Use(Func<RequestDelegate, RequestDelegate> middleware)，没错，就是我们常用的那个app.User(...)方法。作用是把中间件加到中间件列表
2. Build()，构建此应用程序用于处理HTTP请求的委托。就是把HttpContext传递给中间件，由中间件处理完成后将结果返回给用户

再看看网上经典的管道图：

请求过来后，

1. 执行中间件1的逻辑
2. 调用Next()把处理后的HttpContext传递给中间件2
3. 执行中间件2内的逻辑
4. 调用Next()把HttpContext传递给中间件3
5. 执行中间件3的逻辑
6. 因为中间件3内没有next()，所以请求流转回中间件2
7. 执行中间件2中next()方法后面定义的逻辑，请求流转回中间件1
8. 执行中间件1中next()方法后的逻辑，返回结果Response。

下面是模拟的代码，因为使用了很多委托，比较烧脑，所以加了N多注释，不知道能不能说的清楚

using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace RequestPipe
{
    class Program
    {
        static void Main(string[] args)
        {
            // 实例化一个处理程序
            var builder = new ApplicationBuilder();

            // 把中间件加入处理程序，给HttpContext的Name加点内容
            // 中间件一定要调用Next()，不然不会向后传递
            // await 不解释了，当代码执行到这句后，程序会进入next()的执行流程而不会继续执行后面的语句
            // 也就是说会显示 第一个开始执行，但 第一个执行结束 这句会等到 next() 运行完成后才执行
            builder.Use((next) => 
                async (context) =>
                {
                    Console.WriteLine("**********第一个开始执行**********");
                    context.Name += "First；";
                    await next(context);
                    Console.WriteLine("**********第一个结束执行**********");
                }
            );

            builder.Use((next) =>
                async (context) =>
                {
                    Console.WriteLine("**********第二个开始执行**********");
                    context.Name += "Second；";

                    // 执行委托的方法的标准写法，也可以直接next(context)
                    await next.Invoke(context); 
                    Console.WriteLine("**********第二个结束执行**********");
                }
            );

            // 特地用匿名函数来写一个，希望看起来稍微清晰一点
            builder.Use(
                new Func<RequestDelegate, RequestDelegate>(
                    delegate (RequestDelegate next)
                    {
                        return new RequestDelegate(async delegate (HttpContext context)
                        {
                            Console.WriteLine("**********第三个开始执行**********");
                            context.Name += "Third；";
                            await next(context);
                            Console.WriteLine("**********第三个开始执行**********");
                        });
                    }
                )
            );

            // 执行处理
            builder.Build();

            Console.ReadLine();
        }
    }

    public class ApplicationBuilder
    {
        // 中间件列表
        private List<Func<RequestDelegate, RequestDelegate>> middlewares = new List<Func<RequestDelegate, RequestDelegate>>();

        public void New()
        { }

        public void Build()
        {
            // 先构建一个基础的HttpContext
            var baseContext = new HttpContext();

            // 构建一个默认的委托（HttpContext的处理方法），就叫中间件0吧
            // 如果没有经过中间件处理，就直接输出404
            // 如果中间件处理成功，这里应该是输出 First;Second;Third;
            var baseDelegate = new RequestDelegate(async (context) => 
            {
                context.Name = string.IsNullOrWhiteSpace(context.Name) ? "404" : context.Name;
                await context.Show();
            });

            // 把中间件列表的顺序反转一下
            middlewares.Reverse();

            // 遍历中间件列表
            foreach (var middleware in middlewares)
            {
                // 还记得moddleware的类型吧，传入一个RequestDelegate，返回一个RequestDelegate 93                 // 经过上面的反转，现在第一个元素应该是中间件3
                // baseDelegate也就是中间件0现在作为参数传递给中间件3
                // 中间件3内部通过 await next(context); 保存了对默认委托的调用
                // 然后将中间件3返回
                // 现在 baseDelegate = 中间件3
                // 接下来进入列表的第二个元素，也就是中间件2
                // 和上面的逻辑一样，中间件2保存了对中间件3的引用，然后将中间件2返回出来
                // ...
                // 列表遍历完成后，baseDelegate = 中间件1
                baseDelegate = middleware.Invoke(baseDelegate);
            }

            // 执行中间件1
            // 中间件1中保存了对中间件2的引用，所以运行到await next()的时候，就会进入到中间件2
            // 同理中间件2会进入到中间件3，中间件3进入默认委托，也就是中间件0
            // 中间件0执行完成（此程序中就是打印HttpContext的Name属性）返回中间件3
            // 然后依次返回到中间件1,最终结束执行
            baseDelegate.Invoke(baseContext);
        }

        public void Use(Func<RequestDelegate, RequestDelegate> middleware)
        {
            middlewares.Add(middleware);
        }
    }

    public class HttpContext
    {
        public string Name { get; set; }

        public async Task Show()
        {
            Console.WriteLine(Name);
            await Task.CompletedTask;
        }
    }

    public delegate Task RequestDelegate(HttpContext context);133 }

执行结果

**********第一个开始执行**********
**********第二个开始执行**********
**********第三个开始执行**********
First；Second；Third；
**********第三个开始执行**********
**********第二个结束执行**********
**********第一个结束执行**********

OK，这里的难点就是委托套委托，讲真的委托这东西确实强大，但代码读起来真的很难受，后面还是要整理下关于委托使用的文档，加深理解才行。