探究ASP.NET Core Middleware实现方法-6ren

探究ASP.NET Core Middleware实现方法

转载作者：qq735679552 更新时间：2022-09-29 22:32:09

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章探究ASP.NET Core Middleware实现方法由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

概念。

ASP.NET Core Middleware是在应用程序处理管道pipeline中用于处理请求和操作响应的组件.

每个组件:

在pipeline中判断是否将请求传递给下一个组件
在处理管道的下个组件执行之前和之后执行一些工作， HttpContxt对象能跨域请求、响应的执行周期

特性和行为。

ASP.NET Core处理管道由一系列请求委托组成，一环接一环的被调用，下面给出自己绘制的Middleware pipeline流程图:

探究ASP.NET Core Middleware实现方法

从上图可以看出，请求自进入处理管道，经历了四个中间件，每个中间件都包含后续紧邻中间件执行委托（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方法完成前后中间件的链式传值关系

探究ASP.NET Core Middleware实现方法

分析源码：回答上面的问题:

使用反射构造中间件的时候，第一个参数Array[0] 是下一个中间件的执行委托
当前中间件执行委托函数名称被限制为： Invoke/InvokeAsync，函数支持传入除HttpContext之外的参数
按照代码顺序添加进入 _components容器，通过后一个中间件的执行委托 -----（指向）----> 前一个中间件的输入执行委托建立链式关系。

附：非标准中间件的用法。

短路中间件、分叉中间件、条件中间件。

整个处理管道的形成，存在一些管道分叉或者临时插入中间件的行为，一些重要方法可供使用。

Use方法是一个注册中间件的简便写法
Run方法是一个约定，一些中间件使用Run方法来完成管道的结尾
Map扩展方法：请求满足指定路径，将会执行分叉管道，强调满足 path
MapWhen方法：HttpContext满足条件，将会执行分叉管道：
UseWhen方法：HttpContext满足条件则插入中间件

探究ASP.NET Core Middleware实现方法

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我.

原文链接：http://www.cnblogs.com/mi12205599/p/10334472.html 。

最后此篇关于探究ASP.NET Core Middleware实现方法的文章就讲到这里了,如果你想了解更多关于探究ASP.NET Core Middleware实现方法的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！。

文章推荐： SQLserver2008使用表达式递归查询

文章推荐： numpy中索引和切片详解

文章推荐： String类下compareTo()与compare()方法比较

文章推荐： .NET Core开发日志之OData（Open Data Protocol）

Ruby 方法() 方法
我想了解 Ruby 方法 methods() 是如何工作的。我尝试使用“ruby 方法”在 Google 上搜索，但这不是我需要的。我也看过 ruby-doc.org，但我没有找到这种方法。
VBS教程：方法-Test 方法
Test 方法对指定的字符串执行一个正则表达式搜索，并返回一个 Boolean 值指示是否找到匹配的模式。 object.Test(string) 参数 object 必选项。总是一个
VBS教程：方法-Replace 方法
Replace 方法替换在正则表达式查找中找到的文本。 object.Replace(string1, string2) 参数 object 必选项。总是一个 RegExp 对象的名称。
VBS教程：方法-Raise 方法
Raise 方法生成运行时错误 object.Raise(number, source, description, helpfile, helpcontext) 参数 object 应为
VBS教程：方法-Execute 方法
Execute 方法对指定的字符串执行正则表达式搜索。 object.Execute(string) 参数 object 必选项。总是一个 RegExp 对象的名称。 string
VBS教程：方法-Clear 方法
Clear 方法清除 Err 对象的所有属性设置。 object.Clear object 应为 Err 对象的名称。说明在错误处理后，使用 Clear 显式地清除 Err 对象。此
VBS教程：方法-CopyFile 方法
CopyFile 方法将一个或多个文件从某位置复制到另一位置。 object.CopyFile source, destination[, overwrite] 参数 object 必选
VBS教程：方法-Copy 方法
Copy 方法将指定的文件或文件夹从某位置复制到另一位置。 object.Copy destination[, overwrite] 参数 object 必选项。应为 File 或 F
VBS教程：方法-Close 方法
Close 方法关闭打开的 TextStream 文件。 object.Close object 应为 TextStream 对象的名称。说明下面例子举例说明如何使用 Close 方
VBS教程：方法-BuildPath 方法
BuildPath 方法向现有路径后添加名称。 object.BuildPath(path, name) 参数 object 必选项。应为 FileSystemObject 对象的名称
VBS教程：方法-GetFolder 方法
GetFolder 方法返回与指定的路径中某文件夹相应的 Folder 对象。 object.GetFolder(folderspec) 参数 object 必选项。应为 FileSy
VBS教程：方法-GetFileName 方法
GetFileName 方法返回指定路径（不是指定驱动器路径部分）的最后一个文件或文件夹。 object.GetFileName(pathspec) 参数 object 必选项。应为
VBS教程：方法-GetFile 方法
GetFile 方法返回与指定路径中某文件相应的 File 对象。 object.GetFile(filespec) 参数 object 必选项。应为 FileSystemObject
VBS教程：方法-GetExtensionName 方法
GetExtensionName 方法返回字符串，该字符串包含路径最后一个组成部分的扩展名。 object.GetExtensionName(path) 参数 object 必选项。应
VBS教程：方法-GetDriveName 方法
GetDriveName 方法返回包含指定路径中驱动器名的字符串。 object.GetDriveName(path) 参数 object 必选项。应为 FileSystemObjec
VBS教程：方法-GetDrive 方法
GetDrive 方法返回与指定的路径中驱动器相对应的 Drive 对象。 object.GetDrive drivespec 参数 object 必选项。应为 FileSystemO
VBS教程：方法-GetBaseName 方法
GetBaseName 方法返回字符串，其中包含文件的基本名 (不带扩展名), 或者提供的路径说明中的文件夹。 object.GetBaseName(path) 参数 object 必
VBS教程：方法-GetAbsolutePathName 方法
GetAbsolutePathName 方法从提供的指定路径中返回完整且含义明确的路径。 object.GetAbsolutePathName(pathspec) 参数 object
VBS教程：方法-FolderExists 方法
FolderExists 方法如果指定的文件夹存在，则返回 True；否则返回 False。 object.FolderExists(folderspec) 参数 object 必选项
VBS教程：方法-FileExists 方法
FileExists 方法如果指定的文件存在返回 True；否则返回 False。 object.FileExists(filespec) 参数 object 必选项。应为 FileS

qq735679552

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

探究ASP.NET Core Middleware实现方法