//伪代码
var middlewares=new []{FooMiddleware,BarMiddleware,BazMiddleware};
middlewares.Reverse();
var  next=完成的处理器;
foreach(var middleware in middlewares)
{
    next=  middleware(next);
}
//最后的next，就是最终要传入IServer 中的处理器

模拟运行时的伪代码：

 //传入完成处理器，返回处理器C
 处理器 BazMiddleware(完成处理器)
 { 
     return 处理器C
            {    
               //处理器C的处理代码
               完成处理器
            };
 }
 //传入处理器C，返回处理器B
  处理器  BarMiddleware(处理器C)
 { 
     return 处理器B
            {    
               //处理器B的处理代码
               执行处理器C
            };
 }
  //传入处理器B，返回处理器A
  处理器  FooMiddleware(处理器B)
 { 
     return 处理器A
            {    
               //处理器A的处理代码
               执行处理器B
            };
 }

 

这样当处理器A执行的时候，会先执行自身的代码，然后执行处理器B,处理器B执行的时候，先执行自身的代码，然后执行处理器C,依次类推。

所以，中间件的方法应该是下面这样的：

RequestDelegate DoMiddleware(RequestDelegate next);

中间件的管理

要管理中间件，就要提供注册中间件的方法和最终构建出RequestDelegate的方法。
定义注册中间件和构建处理器的接口： IApplicationBuilder

    public interface IApplicationBuilder
    {
        IApplicationBuilder Use(Func<RequestDelegate, RequestDelegate> middleware);

        RequestDelegate Build();
    }

实现：

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

定义中间件测试

在Program 类里定义三个中间件：

        static RequestDelegate FooMiddleware(RequestDelegate next)
        {
            return async context =>
            {
                await context.Response.WriteAsync("foo=>");
                await next(context);
            };
        }
        static RequestDelegate BarMiddleware(RequestDelegate next)
        {
            return async context =>
            {
                await context.Response.WriteAsync("bar=>");
                await next(context);
            };
        }
        static RequestDelegate BazMiddleware(RequestDelegate next)
        {
            return async context =>
            {
                await context.Response.WriteAsync("baz=>");
                await next(context);
            };
        }

修改Main方法测试运行

        static async Task Main(string[] args)
        {
            IServer server = new HttpListenerServer();

            var handler = new ApplicationBuilder()
                .Use(FooMiddleware)
                .Use(BarMiddleware)
                .Use(BazMiddleware)
                .Build();
            await server.StartAsync(handler); 
        }

运行结果如下：

六 管理服务器和处理器

为了管理服务器和处理器之间的关系 抽象出web宿主
如下：

 public interface IWebHost
    {
        Task StartAsync();
    }

    public class WebHost : IWebHost
    {
        private readonly IServer _server;

        private readonly RequestDelegate _handler;

        public WebHost(IServer server,RequestDelegate handler)
        {
            _server = server;
            _handler = handler;

        }
        public Task StartAsync()
        {
            return _server.StartAsync(_handler);
        }
    }

Main方法可以改一下测试

        static async Task Main(string[] args)
        {
            IServer server = new HttpListenerServer();

            var handler = new ApplicationBuilder()
                .Use(FooMiddleware)
                .Use(BarMiddleware)
                .Use(BazMiddleware)
                .Build();

            IWebHost webHost = new WebHost(server, handler);
            await webHost.StartAsync();
        }

要构建WebHost，需要知道用哪个服务器，和配置了哪些中间件，最后可以构建出WebHost
代码如下：