ASP.NET Core 中間件（Middleware)（一）

• 2021 年 2 月 14 日
• 筆記
• .netcore

本文主要目標：記錄Middleware的運行原理流程，並繪製流程圖。

目錄結構：

1、運行環境
2、Demo實踐
3、源碼追蹤
4、AspnetCore內置middleware

一、運行環境

Visual Studio Community 2019 版本 16.8.5

.Net Sdk Version: 5.0.103

二、Demo實踐

講解或學習一個東西的時候，最方便的方式是先寫一個Demo。基於此，我寫以一個中間件的記錄請求輸出的實踐Demo來理解Middleware。

實體：

    public class RequestResponseLog
    {
        public string Id { get; set; }
        public DateTime CreateTime { get; set; }
        public string RequestJson { get; set; }
        public string ResponseJson { get; set; }
    }    
    
    public class Student
    {
        public string Id { get; set; }
        public string Name { get; set; }
        /// <summary>
        /// 學校
        /// </summary>
        public string School { get; set; }
        /// <summary>
        /// 班級
        /// </summary>
        public string Class { get; set; }
        /// <summary>
        /// 年級
        /// </summary>
        public string Grade { get; set; }
    }

Controller:用於接收請求

    [Route("api/[controller]")]
    [ApiController]
    public class StudentController : Controller
    {
        [HttpGet("GetStudent")]
        public IActionResult GetStudent()
        {
            var student = new Student()
            {
                Id = Guid.NewGuid().ToString(),
                Class = "321",
                Grade = "23",
                Name = "Name001",
                School = "School002"
            };
            return Ok(student);
        }
    }

Middleware 中間件（記錄Request和Response）:

public class RequestResponseLoggingMiddleware
    {
        private RequestDelegate _next;
        public RequestResponseLoggingMiddleware(RequestDelegate next)
        {
            this._next = next;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="httpContext"></param>
        /// <returns></returns>
        public async Task Invoke(HttpContext context)
        {

            //First, get the incoming request
            var request = await FormatRequest(context.Request);

            var body = context.Response.Body;

            //Copy a pointer to the original response body stream
            var originalBodyStream = context.Response.Body;

            //Create a new memory stream...
            using (var responseBody = new MemoryStream())
            {
                //...and use that for the temporary response body
                context.Response.Body = responseBody;

                //Continue down the Middleware pipeline, eventually returning to this class
                await _next(context);

                //Format the response from the server
                var response = await FormatResponse(context.Response);

                //TODO: Save log to chosen datastore,臨時使用
                DemoQueueBlock<RequestResponseLog>.Add(new RequestResponseLog()
                {
                    Id=Guid.NewGuid().ToString(),
                    CreateTime = DateTime.Now,
                    ResponseJson = response,
                    RequestJson = request
                });

                //Copy the contents of the new memory stream (which contains the response) to the original stream, which is then returned to the client.
                await responseBody.CopyToAsync(originalBodyStream);
            }
        }

為了防止實時存儲資料庫壓力過大，倉儲部分用了BlockingCollection實現的簡易隊列。

blockingcollection-1.getconsumingenumerable

//docs.microsoft.com/zh-cn/dotnet/api/system.collections.concurrent.blockingcollection-1.getconsumingenumerable?view=net-5.0

 public static void Consume(Action<T> func)
{
            Task.Factory.StartNew(() =>
            {
                foreach (var item in Colls.GetConsumingEnumerable())
                {
                    func(item);
                    Console.WriteLine(string.Format("---------------: {0}", item));
                }
            });
}

消費隊列時入庫：

public class DemoConsume
    {
        private readonly MysqlDbContext _dbContext;
        public DemoConsume(MysqlDbContext dbContext)
        {
            _dbContext = dbContext;
        }
        public bool Consume()
        {
            DemoQueueBlock<RequestResponseLog>.Consume(async (log)=> {
               await _dbContext.AddAsync(log);
               await _dbContext.SaveChangesAsync();
            });
            return true;
        }
    }

StartUp文件AddConsume和

app.UseMiddleware();

   public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();
            var connection = Configuration.GetConnectionString("MysqlConnection");
            services.AddDbContext<MysqlDbContext>(options => options.UseMySQL(connection),ServiceLifetime.Scoped);
            services.AddConsume();
        }
        
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
           app.UseHttpsRedirection();
            app.UseRouting();
            app.UseAuthorization();
            app.UseMiddleware<RequestResponseLoggingMiddleware>();
            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
            });
        }

Sql語句：

CREATE TABLE `request_response_log`  (
  `id` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `create_time` datetime(0) NULL DEFAULT NULL,
  `request_json` text CHARACTER SET utf8 COLLATE utf8_general_ci NULL,
  `response_json` text CHARACTER SET utf8 COLLATE utf8_general_ci NULL
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

運行程式效果：

可以看到該Demo提供了一個記錄Http請求和輸出日誌的功能。

這裡面和Middleware有關的功能為：

1、定義了RequestResponseLoggingMiddleware類

RequestDelegate向下轉發請求，

Invoke方法

2、StartUp的app.UseMiddleware()。

這些方法具體怎麼流轉運行的呢？我們來搜一下源碼可以確認下。

三、源碼跟蹤

所以我們可以看下UseMiddlewareExtensions

 public static class UseMiddlewareExtensions
    {
        internal const string InvokeMethodName = "Invoke";
        internal const string InvokeAsyncMethodName = "InvokeAsync";
 /// <summary>
        /// Adds a middleware type to the application's request pipeline.
        /// </summary>
        /// <param name="app">The <see cref="IApplicationBuilder"/> instance.</param>
        /// <param name="middleware">The middleware type.</param>
        /// <param name="args">The arguments to pass to the middleware type instance's constructor.</param>
        /// <returns>The <see cref="IApplicationBuilder"/> instance.</returns>
        public static IApplicationBuilder UseMiddleware(this IApplicationBuilder app, [DynamicallyAccessedMembers(MiddlewareAccessibility)] Type middleware, params object?[] args)
        {
            if (typeof(IMiddleware).IsAssignableFrom(middleware))
            {
                // IMiddleware doesn't support passing args directly since it's
                // activated from the container
                if (args.Length > 0)
                {
                    throw new NotSupportedException(Resources.FormatException_UseMiddlewareExplicitArgumentsNotSupported(typeof(IMiddleware)));
                }

                return UseMiddlewareInterface(app, middleware);
            }

            var applicationServices = app.ApplicationServices;
            return app.Use(next =>
            {
                var methods = middleware.GetMethods(BindingFlags.Instance | BindingFlags.Public);
                var invokeMethods = methods.Where(m =>
                    string.Equals(m.Name, InvokeMethodName, StringComparison.Ordinal)
                    || string.Equals(m.Name, InvokeAsyncMethodName, StringComparison.Ordinal)
                    ).ToArray();

                if (invokeMethods.Length > 1)
                {
                    throw new InvalidOperationException(Resources.FormatException_UseMiddleMutlipleInvokes(InvokeMethodName, InvokeAsyncMethodName));
                }

                if (invokeMethods.Length == 0)
                {
                    throw new InvalidOperationException(Resources.FormatException_UseMiddlewareNoInvokeMethod(InvokeMethodName, InvokeAsyncMethodName, middleware));
                }

                var methodInfo = invokeMethods[0];
                if (!typeof(Task).IsAssignableFrom(methodInfo.ReturnType))
                {
                    throw new InvalidOperationException(Resources.FormatException_UseMiddlewareNonTaskReturnType(InvokeMethodName, InvokeAsyncMethodName, nameof(Task)));
                }

                var parameters = methodInfo.GetParameters();
                if (parameters.Length == 0 || parameters[0].ParameterType != typeof(HttpContext))
                {
                    throw new InvalidOperationException(Resources.FormatException_UseMiddlewareNoParameters(InvokeMethodName, InvokeAsyncMethodName, nameof(HttpContext)));
                }

                var ctorArgs = new object[args.Length + 1];
                ctorArgs[0] = next;
                Array.Copy(args, 0, ctorArgs, 1, args.Length);
                var instance = ActivatorUtilities.CreateInstance(app.ApplicationServices, middleware, ctorArgs);
                if (parameters.Length == 1)
                {
                    return (RequestDelegate)methodInfo.CreateDelegate(typeof(RequestDelegate), instance);
                }

                var factory = Compile<object>(methodInfo, parameters);

                return context =>
                {
                    var serviceProvider = context.RequestServices ?? applicationServices;
                    if (serviceProvider == null)
                    {
                        throw new InvalidOperationException(Resources.FormatException_UseMiddlewareIServiceProviderNotAvailable(nameof(IServiceProvider)));
                    }

                    return factory(instance, context, serviceProvider);
                };
            });
        }

這裡面用了

UseMiddleware(),進而調用

UseMiddleware（type TMiddleware）

進行了如下判斷：

1、如果TMiddleware是繼承了IMiddleware,則執行UseMiddlewareInterface方法。利用IMiddlewareFactory提供中間件的工廠創建方式，Microsoft.AspNetCore.Http提供了IMiddlewareFactory的默認實現MiddlewareFactory。

return app.Use(next =>
            {
                return async context =>
                {
                    var middlewareFactory = (IMiddlewareFactory?)context.RequestServices.GetService(typeof(IMiddlewareFactory));
                    if (middlewareFactory == null)
                    {
                        // No middleware factory
                        throw new InvalidOperationException(Resources.FormatException_UseMiddlewareNoMiddlewareFactory(typeof(IMiddlewareFactory)));
                    }

                    var middleware = middlewareFactory.Create(middlewareType);
                    if (middleware == null)
                    {
                        // The factory returned null, it's a broken implementation
                        throw new InvalidOperationException(Resources.FormatException_UseMiddlewareUnableToCreateMiddleware(middlewareFactory.GetType(), middlewareType));
                    }

                    try
                    {
                        await middleware.InvokeAsync(context, next);
                    }
                    finally
                    {
                        middlewareFactory.Release(middleware);
                    }
                };
            });

2、如果沒有繼承Middleware,則執行以下操作：

1、根據Invoke或InvokeAsync查找方法

2、驗證只存在一個方法

3、驗證返回類型為Task

4、驗證第一個參數必須是HttpContext

5、ActivatorUtilities.CreateInstance 創建實例

6、如果只有一個參數，返回一個RequestDelegate類型的方法委託？

7、多個參數繼續執行如下操作。Compile方法和參數。

var factory = Compile