如何在ASP.NET Core 中實現Middleware

本篇文章為大家展示了如何在ASP.NET Core 中實現Middleware，內容簡明扼要并且容易理解，絕對能使你眼前一亮，通過這篇文章的詳細介紹希望你能有所收獲。

ASP.NET Core Middleware是在應用程序處理管道pipeline中用于處理請求和操作響應的組件。

每個組件：

• 在pipeline中判斷是否將請求傳遞給下一個組件

• 在處理管道的下個組件執行之前和之后執行一些工作， HttpContxt對象能跨域請求、響應的執行周期

特性和行為

ASP.NET Core處理管道由一系列請求委托組成，一環接一環的被調用， 下面給出自己繪制的Middleware pipeline流程圖：

從上圖可以看出，請求自進入處理管道，經歷了四個中間件，每個中間件都包含后續緊鄰中間件 執行委托（next）的引用，同時每個中間件在交棒之前和交棒之后可以自行決定參與一些Http請求和響應的邏輯處理。

每個中間件還可以決定不將請求轉發給下一個委托，這稱為請求管道的短路（短路是有必要的，某些專有中間件比如 StaticFileMiddleware 可以在完成功能之后，避免請求被轉發到其他動態處理過程）。

源碼實現

觀察一個標準的中間件代碼的寫法和用法：

using System.Threading.Tasks;
using Alyio.AspNetCore.ApiMessages;
using Gridsum.WebDissector.Common;
using Microsoft.AspNetCore.Http;
 
namespace Gridsum.WebDissector
{
  sealed class AuthorizationMiddleware
  {
    private readonly RequestDelegate _next;   // 下一個中間件執行委托的引用
 
    public AuthorizationMiddleware(RequestDelegate next)
    {
      _next = next;
    }
 
    public Task Invoke(HttpContext context)   // 貫穿始終的HttpContext對象
    {
      if (context.Request.Path.Value.StartsWith("/api/"))
      {
        return _next(context);
      }
      if (context.User.Identity.IsAuthenticated && context.User().DisallowBrowseWebsite)
      {
        throw new ForbiddenMessage("You are not allow to browse the website.");
      }
      return _next(context);
    }
  }
}
 
 public static IApplicationBuilder UserAuthorization(this IApplicationBuilder app)
 {
   return app.UseMiddleware<AuthorizationMiddleware>();
 }
 // 啟用該中間件，也就是注冊該中間件
 app.UserAuthorization();

標準的中間件使用方式是如此簡單明了，帶著幾個問題探究一下源碼實現

(1).中間件傳參是怎樣完成的： app.UseMiddleware<Authorization>(AuthOption); 我們傳參的時候，為什么能自動注入中間件構造函數非第1個參數

(2).編寫中間件的時候，為什么必須要定義特定的 Invoke/InvokeAsync 函數？

(3).設定中間件的順序很重要，中間件的嵌套順序是怎么確定的 ？

思考以上標準中間件的行為： 輸入下一個中間件的執行委托Next， 定義當前中間件的執行委托Invoke/InvokeAsync；

每個中間件完成了 Func<RequestDelegate，RequestDelegate>這樣的行為；

通過參數next與下一個中間件的執行委托Invoke/InvokeAsync 建立"鏈式"關系。

public delegate Task RequestDelegate(HttpContext context);

//-----------------節選自 Microsoft.AspNetCore.Builder.UseMiddlewareExtensions------------------
    /// <summary>
    /// Adds a middleware type to the application's request pipeline.
    /// </summary>
    /// <typeparam name="TMiddleware">The middleware type.</typeparam>
    /// <param name="app">The <see cref="IApplicationBuilder"/> instance.</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<TMiddleware>(this IApplicationBuilder app, params object[] args)
    {
      return app.UseMiddleware(typeof(TMiddleware), args);
    }
    /// <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, Type middleware, params object[] args)
    {
      if (typeof(IMiddleware).GetTypeInfo().IsAssignableFrom(middleware.GetTypeInfo()))
      {
        // 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);
        // 執行委托名稱被限制為Invoke/InvokeAsync
        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);
        }
        
        // 當前執行委托除了可指定HttpContext參數以外， 還可以注入更多的依賴參數  
        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);
        };
      });
    }
 
//-------------------節選自 Microsoft.AspNetCore.Builder.Internal.ApplicationBuilder-------------------
private readonly IList<Func<RequestDelegate, RequestDelegate>> _components = new List<Func<RequestDelegate, RequestDelegate>>();
 
publicIApplicationBuilder Use(Func<RequestDelegate,RequestDelegate> middleware)
{
  this._components.Add(middleware);
  return this;
}
 
public RequestDelegate Build()
{
   RequestDelegate app = context =>
   {
     context.Response.StatusCode = 404;
     return Task.CompletedTask;
   };
 
   foreach (var component in _components.Reverse())
  {
    app = component(app);
  }
 
  return app;
}

通過以上代碼我們可以看出：

• 注冊中間件的過程實際上，是給一個 Type= List<Func<RequestDelegate, RequestDelegate>> 的容器依次添加元素的過程；

• 容器中每個元素對應每個中間件的行為委托Func<RequestDelegate, RequestDelegate>， 這個行為委托包含2個關鍵行為：輸入下一個中間件的執行委托next：RequestDelegate， 完成當前中間件的Invoke函數： RequestDelegate;

• 通過build方法完成前后中間件的鏈式傳值關系

分析源碼：回答上面的問題：

1. 使用反射構造中間件的時候，第一個參數Array[0] 是下一個中間件的執行委托

2. 當前中間件執行委托 函數名稱被限制為： Invoke/InvokeAsync， 函數支持傳入除HttpContext之外的參數

3. 按照代碼順序添加進入 _components容器， 通過后一個中間件的執行委托 -----（指向）----> 前一個中間件的輸入執行委托建立鏈式關系。

附：非標準中間件的用法

短路中間件、 分叉中間件、條件中間件

整個處理管道的形成，存在一些管道分叉或者臨時插入中間件的行為，一些重要方法可供使用

• Use方法是一個注冊中間件的簡便寫法

• Run方法是一個約定，一些中間件使用Run方法來完成管道的結尾

• Map擴展方法：請求滿足指定路徑，將會執行分叉管道，強調滿足 path

• MapWhen方法：HttpContext滿足條件，將會執行分叉管道：

• UseWhen方法：HttpContext滿足條件 則插入中間件

上述內容就是如何在ASP.NET Core 中實現Middleware，你們學到知識或技能了嗎？如果還想學到更多技能或者豐富自己的知識儲備，歡迎關注億速云行業資訊頻道。