探究ASP.NET Core Middleware實現方法

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();

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;
}