ASP.NET Core 中间件(Middleware)的使用及其源码解析(三)- 对中间件管道进行分支

  • ASP.NET Core 中间件(Middleware)的使用及其源码解析(三)- 对中间件管道进行分支已关闭评论
  • 42 次浏览
  • A+
所属分类:.NET技术
摘要

如果业务逻辑比较简单的话,一条主管道就够了,确实用不到分支管道。不过当业务逻辑比较复杂的时候,有时候我们可能希望根据情况的不同使用特殊的一组中间件来处理 HttpContext。这种情况下如果只用一条管道,处理起来会非常麻烦和混乱。此时就可以使用 Map/MapWhen/UseWhen 建立一个分支管道,当条件符合我们的设定时,由这个分支管道来处理 HttpContext。使用 Map/MapWhen/UseWhen 添加分支管道是很容易的,只要提供合适跳转到分支管道的判断逻辑,以及分支管道的构建方法就可以了。

如果业务逻辑比较简单的话,一条主管道就够了,确实用不到分支管道。不过当业务逻辑比较复杂的时候,有时候我们可能希望根据情况的不同使用特殊的一组中间件来处理 HttpContext。这种情况下如果只用一条管道,处理起来会非常麻烦和混乱。此时就可以使用 Map/MapWhen/UseWhen 建立一个分支管道,当条件符合我们的设定时,由这个分支管道来处理 HttpContext。使用 Map/MapWhen/UseWhen 添加分支管道是很容易的,只要提供合适跳转到分支管道的判断逻辑,以及分支管道的构建方法就可以了。

ASP.NET Core 中间件(Middleware)的使用及其源码解析(三)- 对中间件管道进行分支

一、对中间件管道进行分支

废话不多说,我们直接通过一个Demo来看一下如何对中间件管道进行分支,如下:

using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Hosting; using Microsoft.Extensions.Configuration; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Hosting; using System; using System.Collections.Generic; using System.Linq; using System.Threading.Tasks;  using NETCoreMiddleware.Middlewares;  namespace NETCoreMiddleware {     public class Startup     {         public Startup(IConfiguration configuration)         {             Configuration = configuration;         }          public IConfiguration Configuration { get; }          //服务注册(往容器中添加服务)         // This method gets called by the runtime. Use this method to add services to the container.         public void ConfigureServices(IServiceCollection services)         {             services.AddControllersWithViews();         }          /// <summary>         /// 配置Http请求处理管道         /// Http请求管道模型---就是Http请求被处理的步骤         /// 所谓管道,就是拿着HttpContext,经过多个步骤的加工,生成Response,这就是管道         /// </summary>         /// <param name="app"></param>         /// <param name="env"></param>         // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.         public void Configure(IApplicationBuilder app, IWebHostEnvironment env)         {             #region 环境参数              if (env.IsDevelopment())             {                 app.UseDeveloperExceptionPage();             }             else             {                 app.UseExceptionHandler("/Home/Error");             }              #endregion 环境参数              //静态文件中间件             app.UseStaticFiles();              #region 创建管道分支              //Map管道分支             app.Map("/map1", HandleMapTest1);             app.Map("/map2", HandleMapTest2);              //MapWhen管道分支             app.MapWhen(context => context.Request.Query.ContainsKey("mapwhen"), HandleBranch);              //UseWhen管道分支             //UseWhen 与 MapWhen 不同的是,如果这个分支不发生短路或包含终端中间件,则会重新加入主管道             app.UseWhen(context => context.Request.Query.ContainsKey("usewhen"), HandleBranchAndRejoin);              #endregion 创建管道分支              #region Use中间件              //中间件1             app.Use(next =>             {                 Console.WriteLine("middleware 1");                 return async context =>                 {                     await Task.Run(() =>                     {                         Console.WriteLine("");                         Console.WriteLine("===================================Middleware===================================");                         Console.WriteLine($"This is middleware 1 Start");                     });                     await next.Invoke(context);                     await Task.Run(() =>                     {                         Console.WriteLine($"This is middleware 1 End");                         Console.WriteLine("===================================Middleware===================================");                     });                 };             });              //中间件2             app.Use(next =>             {                 Console.WriteLine("middleware 2");                 return async context =>                 {                     await Task.Run(() => Console.WriteLine($"This is middleware 2 Start"));                     await next.Invoke(context); //可通过不调用 next 参数使请求管道短路                     await Task.Run(() => Console.WriteLine($"This is middleware 2 End"));                 };             });              //中间件3             app.Use(next =>             {                 Console.WriteLine("middleware 3");                 return async context =>                 {                     await Task.Run(() => Console.WriteLine($"This is middleware 3 Start"));                     await next.Invoke(context);                     await Task.Run(() => Console.WriteLine($"This is middleware 3 End"));                 };             });              //中间件4             //Use方法的另外一个重载             app.Use(async (context, next) =>             {                 await Task.Run(() => Console.WriteLine($"This is middleware 4 Start"));                 await next();                 await Task.Run(() => Console.WriteLine($"This is middleware 4 End"));             });              #endregion Use中间件              #region UseMiddleware中间件              app.UseMiddleware<CustomMiddleware>();              #endregion UseMiddleware中间件              #region 终端中间件              //app.Use(_ => handler);             app.Run(async context =>             {                 await Task.Run(() => Console.WriteLine($"This is Run"));             });              #endregion 终端中间件              #region 最终把请求交给MVC              app.UseRouting();             app.UseAuthorization();             app.UseEndpoints(endpoints =>             {                 endpoints.MapControllerRoute(                     name: "areas",                     pattern: "{area:exists}/{controller=Home}/{action=Index}/{id?}");                  endpoints.MapControllerRoute(                     name: "default",                     pattern: "{controller=Home}/{action=Index}/{id?}");             });              #endregion 最终把请求交给MVC         }          #region 创建管道分支          /// <summary>         /// Map管道分支1         /// </summary>         /// <param name="app"></param>         static void HandleMapTest1(IApplicationBuilder app)         {             //中间件             app.Use(next =>             {                 Console.WriteLine("HandleMapTest1");                 return async context =>                 {                     await Task.Run(() =>                     {                         Console.WriteLine("");                         Console.WriteLine($"This is HandleMapTest1 Start");                     });                     await next.Invoke(context); //可通过不调用 next 参数使请求管道短路                     await Task.Run(() => Console.WriteLine($"This is HandleMapTest1 End"));                 };             });         }          /// <summary>         /// Map管道分支2         /// </summary>         /// <param name="app"></param>         static void HandleMapTest2(IApplicationBuilder app)         {             //中间件             app.Use(next =>             {                 Console.WriteLine("HandleMapTest2");                 return async context =>                 {                     await Task.Run(() =>                     {                         Console.WriteLine("");                         Console.WriteLine($"This is HandleMapTest2 Start");                     });                     await next.Invoke(context); //可通过不调用 next 参数使请求管道短路                     await Task.Run(() => Console.WriteLine($"This is HandleMapTest2 End"));                 };             });         }          /// <summary>         /// MapWhen管道分支         /// </summary>         /// <param name="app"></param>         static void HandleBranch(IApplicationBuilder app)         {             //中间件             app.Use(next =>             {                 Console.WriteLine("HandleBranch");                 return async context =>                 {                     await Task.Run(() =>                     {                         Console.WriteLine("");                         Console.WriteLine($"This is HandleBranch Start");                     });                     await next.Invoke(context); //可通过不调用 next 参数使请求管道短路                     await Task.Run(() => Console.WriteLine($"This is HandleBranch End"));                 };             });         }          /// <summary>         /// UseWhen管道分支         /// </summary>         /// <param name="app"></param>         static void HandleBranchAndRejoin(IApplicationBuilder app)         {             //中间件             app.Use(next =>             {                 Console.WriteLine("HandleBranchAndRejoin");                 return async context =>                 {                     await Task.Run(() =>                     {                         Console.WriteLine("");                         Console.WriteLine($"This is HandleBranchAndRejoin Start");                     });                     await next.Invoke(context); //可通过不调用 next 参数使请求管道短路                     await Task.Run(() => Console.WriteLine($"This is HandleBranchAndRejoin End"));                 };             });         }          #endregion 创建管道分支     } }

下面我们使用命令行(CLI)方式启动我们的网站,如下所示:

ASP.NET Core 中间件(Middleware)的使用及其源码解析(三)- 对中间件管道进行分支

启动成功后,我们来访问一下 “http://localhost:5000/map1/” ,控制台输出结果如下所示:

ASP.NET Core 中间件(Middleware)的使用及其源码解析(三)- 对中间件管道进行分支

访问 “http://localhost:5000/map2/” ,控制台输出结果如下所示:

ASP.NET Core 中间件(Middleware)的使用及其源码解析(三)- 对中间件管道进行分支

访问 “http://localhost:5000/home/?mapwhen=1” ,控制台输出结果如下所示:

ASP.NET Core 中间件(Middleware)的使用及其源码解析(三)- 对中间件管道进行分支

访问 “http://localhost:5000/home/?usewhen=1” ,控制台输出结果如下所示: 

ASP.NET Core 中间件(Middleware)的使用及其源码解析(三)- 对中间件管道进行分支

Map 扩展用作约定来创建管道分支。 Map 基于给定请求路径的匹配项来创建请求管道分支。 如果请求路径以给定路径开头,则执行分支。

MapWhen 基于给定谓词的结果创建请求管道分支。 Func<HttpContext, bool> 类型的任何谓词均可用于将请求映射到管道的新分支。 

UseWhen 也基于给定谓词的结果创建请求管道分支。 与 MapWhen 不同的是,如果这个分支不发生短路或包含终端中间件,则会重新加入主管道。

二、中间件管道分支源码解析

下面我们结合ASP.NET Core源码来分析下其实现原理: 

1、Map扩展原理

我们将光标移动到 Map 处按 F12 转到定义,如下所示:

ASP.NET Core 中间件(Middleware)的使用及其源码解析(三)- 对中间件管道进行分支

ASP.NET Core 中间件(Middleware)的使用及其源码解析(三)- 对中间件管道进行分支

可以发现它是位于 MapExtensions 扩展类中的,我们找到 MapExtensions 类的源码,如下所示:

// Copyright (c) .NET Foundation. All rights reserved. // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.  using System; using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Builder.Extensions;  namespace Microsoft.AspNetCore.Builder {     /// <summary>     /// Extension methods for the <see cref="MapMiddleware"/>.     /// </summary>     public static class MapExtensions     {         /// <summary>         /// Branches the request pipeline based on matches of the given request path. If the request path starts with         /// the given path, the branch is executed.         /// </summary>         /// <param name="app">The <see cref="IApplicationBuilder"/> instance.</param>         /// <param name="pathMatch">The request path to match.</param>         /// <param name="configuration">The branch to take for positive path matches.</param>         /// <returns>The <see cref="IApplicationBuilder"/> instance.</returns>         public static IApplicationBuilder Map(this IApplicationBuilder app, PathString pathMatch, Action<IApplicationBuilder> configuration)         {             if (app == null)             {                 throw new ArgumentNullException(nameof(app));             }              if (configuration == null)             {                 throw new ArgumentNullException(nameof(configuration));             }              if (pathMatch.HasValue && pathMatch.Value.EndsWith("/", StringComparison.Ordinal))             {                 throw new ArgumentException("The path must not end with a '/'", nameof(pathMatch));             }              // create branch             var branchBuilder = app.New();             configuration(branchBuilder);             var branch = branchBuilder.Build();              var options = new MapOptions             {                 Branch = branch,                 PathMatch = pathMatch,             };             return app.Use(next => new MapMiddleware(next, options).Invoke);         }     } }

其中 ApplicationBuilder 类的源码,如下所示: 

ASP.NET Core 中间件(Middleware)的使用及其源码解析(三)- 对中间件管道进行分支ASP.NET Core 中间件(Middleware)的使用及其源码解析(三)- 对中间件管道进行分支

// Copyright (c) .NET Foundation. All rights reserved. // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.  using System; using System.Collections.Generic; using System.Linq; using System.Threading.Tasks; using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http.Features; using Microsoft.Extensions.Internal;  namespace Microsoft.AspNetCore.Builder {     public class ApplicationBuilder : IApplicationBuilder     {         private const string ServerFeaturesKey = "server.Features";         private const string ApplicationServicesKey = "application.Services";          private readonly IList<Func<RequestDelegate, RequestDelegate>> _components = new List<Func<RequestDelegate, RequestDelegate>>();          public ApplicationBuilder(IServiceProvider serviceProvider)         {             Properties = new Dictionary<string, object>(StringComparer.Ordinal);             ApplicationServices = serviceProvider;         }          public ApplicationBuilder(IServiceProvider serviceProvider, object server)             : this(serviceProvider)         {             SetProperty(ServerFeaturesKey, server);         }          private ApplicationBuilder(ApplicationBuilder builder)         {             Properties = new CopyOnWriteDictionary<string, object>(builder.Properties, StringComparer.Ordinal);         }          public IServiceProvider ApplicationServices         {             get             {                 return GetProperty<IServiceProvider>(ApplicationServicesKey);             }             set             {                 SetProperty<IServiceProvider>(ApplicationServicesKey, value);             }         }          public IFeatureCollection ServerFeatures         {             get             {                 return GetProperty<IFeatureCollection>(ServerFeaturesKey);             }         }          public IDictionary<string, object> Properties { get; }          private T GetProperty<T>(string key)         {             object value;             return Properties.TryGetValue(key, out value) ? (T)value : default(T);         }          private void SetProperty<T>(string key, T value)         {             Properties[key] = value;         }          public IApplicationBuilder Use(Func<RequestDelegate, RequestDelegate> middleware)         {             _components.Add(middleware);             return this;         }          public IApplicationBuilder New()         {             return new ApplicationBuilder(this);         }          public RequestDelegate Build()         {             RequestDelegate app = context =>             {                 // If we reach the end of the pipeline, but we have an endpoint, then something unexpected has happened.                 // This could happen if user code sets an endpoint, but they forgot to add the UseEndpoint middleware.                 var endpoint = context.GetEndpoint();                 var endpointRequestDelegate = endpoint?.RequestDelegate;                 if (endpointRequestDelegate != null)                 {                     var message =                         $"The request reached the end of the pipeline without executing the endpoint: '{endpoint.DisplayName}'. " +                         $"Please register the EndpointMiddleware using '{nameof(IApplicationBuilder)}.UseEndpoints(...)' if using " +                         $"routing.";                     throw new InvalidOperationException(message);                 }                  context.Response.StatusCode = 404;                 return Task.CompletedTask;             };              foreach (var component in _components.Reverse())             {                 app = component(app);             }              return app;         }     } }

Microsoft.AspNetCore.Builder.ApplicationBuilder类源码

其中 MapMiddleware 类的源码,如下所示: 

// Copyright (c) .NET Foundation. All rights reserved. // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.  using System; using System.Threading.Tasks; using Microsoft.AspNetCore.Http;  namespace Microsoft.AspNetCore.Builder.Extensions {     /// <summary>     /// Represents a middleware that maps a request path to a sub-request pipeline.     /// </summary>     public class MapMiddleware     {         private readonly RequestDelegate _next;         private readonly MapOptions _options;          /// <summary>         /// Creates a new instance of <see cref="MapMiddleware"/>.         /// </summary>         /// <param name="next">The delegate representing the next middleware in the request pipeline.</param>         /// <param name="options">The middleware options.</param>         public MapMiddleware(RequestDelegate next, MapOptions options)         {             if (next == null)             {                 throw new ArgumentNullException(nameof(next));             }              if (options == null)             {                 throw new ArgumentNullException(nameof(options));             }              _next = next;             _options = options;         }          /// <summary>         /// Executes the middleware.         /// </summary>         /// <param name="context">The <see cref="HttpContext"/> for the current request.</param>         /// <returns>A task that represents the execution of this middleware.</returns>         public async Task Invoke(HttpContext context)         {             if (context == null)             {                 throw new ArgumentNullException(nameof(context));             }              PathString matchedPath;             PathString remainingPath;              if (context.Request.Path.StartsWithSegments(_options.PathMatch, out matchedPath, out remainingPath))             {                 // Update the path                 var path = context.Request.Path;                 var pathBase = context.Request.PathBase;                 context.Request.PathBase = pathBase.Add(matchedPath);                 context.Request.Path = remainingPath;                  try                 {                     await _options.Branch(context);                 }                 finally                 {                     context.Request.PathBase = pathBase;                     context.Request.Path = path;                 }             }             else             {                 await _next(context);             }         }     } }

在前两篇文章中我们已经介绍过,中间件的注册和管道的构建都是通过 ApplicationBuilder 进行的。因此要构建一个分支管道,需要一个新的 ApplicationBuilder ,并用它来注册中间件,构建管道。为了在分支管道中也能够共享我们在当前 ApplicationBuilder 中注册的服务(或者说共享依赖注入容器,当然共享的并不止这些),在创建新的 ApplicationBuilder 时并不是直接 new 一个全新的,而是调用当前 ApplicationBuilder 的 New 方法在当前的基础上创建新的,共享了当前 ApplicationBuilder 的 Properties(其中包含了依赖注入容器)。 

在使用 Map 注册中间件时我们会传入一个 Action<IApplicationBuilder> 参数,它的作用就是当我们创建了新的 ApplicationBuilder 后,使用这个方法对其进行各种设置,最重要的就是在新的 ApplicationBuilder 上注册分支管道的中间件。配置完成后调用分支 ApplicationBuilder 的 Build 方法构建管道,并把第一个中间件保存下来作为分支管道的入口。

在使用 Map 注册中间件时传入了一个 PathString 参数,PathString 对象我们可以简单地认为是 string 。它用于记录 HttpContext.HttpRequest.Path 中要匹配的区段(Segment)。这个字符串参数结尾不能是“/”。如果匹配成功则进入分支管道,匹配失则败继续当前管道。

新构建的管道和用于匹配的字符串保存为 MapOptions 对象,保存了 Map 规则和分支管道的入口。之后构建 MapMiddleware 对象,并把它的 Invoke 方法包装为 RequestDelegate ,使用当前 ApplicationBuilder 的 Use 方法注册中间件。

2、MapWhen扩展原理

我们将光标移动到 MapWhen 处按 F12 转到定义,如下所示:

ASP.NET Core 中间件(Middleware)的使用及其源码解析(三)- 对中间件管道进行分支

ASP.NET Core 中间件(Middleware)的使用及其源码解析(三)- 对中间件管道进行分支

可以发现它是位于 MapWhenExtensions 扩展类中的,我们找到 MapWhenExtensions 类的源码,如下所示: 

// Copyright (c) .NET Foundation. All rights reserved. // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.  using System; using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Builder.Extensions;   namespace Microsoft.AspNetCore.Builder {     using Predicate = Func<HttpContext, bool>;      /// <summary>     /// Extension methods for the <see cref="MapWhenMiddleware"/>.     /// </summary>     public static class MapWhenExtensions     {         /// <summary>         /// Branches the request pipeline based on the result of the given predicate.         /// </summary>         /// <param name="app"></param>         /// <param name="predicate">Invoked with the request environment to determine if the branch should be taken</param>         /// <param name="configuration">Configures a branch to take</param>         /// <returns></returns>         public static IApplicationBuilder MapWhen(this IApplicationBuilder app, Predicate predicate, Action<IApplicationBuilder> configuration)         {             if (app == null)             {                 throw new ArgumentNullException(nameof(app));             }              if (predicate == null)             {                 throw new ArgumentNullException(nameof(predicate));             }              if (configuration == null)             {                 throw new ArgumentNullException(nameof(configuration));             }              // create branch             var branchBuilder = app.New();             configuration(branchBuilder);             var branch = branchBuilder.Build();              // put middleware in pipeline             var options = new MapWhenOptions             {                 Predicate = predicate,                 Branch = branch,             };             return app.Use(next => new MapWhenMiddleware(next, options).Invoke);         }     } }

其中 MapWhenMiddleware 类的源码,如下所示: 

// Copyright (c) .NET Foundation. All rights reserved. // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.  using System; using System.Threading.Tasks; using Microsoft.AspNetCore.Http;  namespace Microsoft.AspNetCore.Builder.Extensions {     /// <summary>     /// Represents a middleware that runs a sub-request pipeline when a given predicate is matched.     /// </summary>     public class MapWhenMiddleware     {         private readonly RequestDelegate _next;         private readonly MapWhenOptions _options;          /// <summary>         /// Creates a new instance of <see cref="MapWhenMiddleware"/>.         /// </summary>         /// <param name="next">The delegate representing the next middleware in the request pipeline.</param>         /// <param name="options">The middleware options.</param>         public MapWhenMiddleware(RequestDelegate next, MapWhenOptions options)         {             if (next == null)             {                 throw new ArgumentNullException(nameof(next));             }              if (options == null)             {                 throw new ArgumentNullException(nameof(options));             }              _next = next;             _options = options;         }          /// <summary>         /// Executes the middleware.         /// </summary>         /// <param name="context">The <see cref="HttpContext"/> for the current request.</param>         /// <returns>A task that represents the execution of this middleware.</returns>         public async Task Invoke(HttpContext context)         {             if (context == null)             {                 throw new ArgumentNullException(nameof(context));             }              if (_options.Predicate(context))             {                 await _options.Branch(context);             }             else             {                 await _next(context);             }         }     } }

Map 主要通过 URL 中的 Path 来判断是否需要进入分支管道,但有时候我们很可能会有别的需求,例如我想对所有 Method 为 DELETE 的请求用特殊管道处理,这时候就需要用 MapWhen 了。MapWhen 是一种通用的 Map,可以由使用者来决定什么时候进入分支管道什么时候不进入。可以说 Map 是 MapWhen 的一种情况,因为这种情况太常见了,所以官方实现了一个。这样看来 MapWhen 就很简单了,在 Map 中我们传入参数 PathString 来进行 HttpRequest.Path 的匹配,而在 MapWhen 中我们传入 Func<HttpContext, bool> 参数,由我们自行指定,当返回 true 时进入分支管道,返回 false 则继续当前管道。

3、UseWhen扩展原理

我们将光标移动到 UseWhen 处按 F12 转到定义,如下所示: 

ASP.NET Core 中间件(Middleware)的使用及其源码解析(三)- 对中间件管道进行分支

ASP.NET Core 中间件(Middleware)的使用及其源码解析(三)- 对中间件管道进行分支

可以发现它是位于 UseWhenExtensions 扩展类中的,我们找到 UseWhenExtensions 类的源码,如下所示: 

// Copyright (c) .NET Foundation. All rights reserved. // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.  using System; using Microsoft.AspNetCore.Http;  namespace Microsoft.AspNetCore.Builder {     using Predicate = Func<HttpContext, bool>;      /// <summary>     /// Extension methods for <see cref="IApplicationBuilder"/>.     /// </summary>     public static class UseWhenExtensions     {         /// <summary>         /// Conditionally creates a branch in the request pipeline that is rejoined to the main pipeline.         /// </summary>         /// <param name="app"></param>         /// <param name="predicate">Invoked with the request environment to determine if the branch should be taken</param>         /// <param name="configuration">Configures a branch to take</param>         /// <returns></returns>         public static IApplicationBuilder UseWhen(this IApplicationBuilder app, Predicate predicate, Action<IApplicationBuilder> configuration)         {             if (app == null)             {                 throw new ArgumentNullException(nameof(app));             }              if (predicate == null)             {                 throw new ArgumentNullException(nameof(predicate));             }              if (configuration == null)             {                 throw new ArgumentNullException(nameof(configuration));             }              // Create and configure the branch builder right away; otherwise,             // we would end up running our branch after all the components             // that were subsequently added to the main builder.             var branchBuilder = app.New();             configuration(branchBuilder);              return app.Use(main =>             {                 // This is called only when the main application builder                  // is built, not per request.                 branchBuilder.Run(main);                 var branch = branchBuilder.Build();                  return context =>                 {                     if (predicate(context))                     {                         return branch(context);                     }                     else                     {                         return main(context);                     }                 };             });         }     } }

UseWhen 也基于给定谓词的结果创建请求管道分支。 与 MapWhen 不同的是,如果这个分支不发生短路或包含终端中间件,则会重新加入主管道。

 

本文部分内容参考博文:https://www.cnblogs.com/durow/p/5752055.html

更多关于ASP.NET Core 中间件的相关知识可参考微软官方文档: https://docs.microsoft.com/zh-cn/aspnet/core/fundamentals/middleware/?view=aspnetcore-6.0

至此本文就全部介绍完了,如果觉得对您有所启发请记得点个赞哦!!!

 

Demo源码:

链接:https://pan.baidu.com/s/18I66dBmKZUpfPCNn85HI2g  提取码:2xcj

此文由博主精心撰写转载请保留此原文链接:https://www.cnblogs.com/xyh9039/p/16492284.html

版权声明:如有雷同纯属巧合,如有侵权请及时联系本人修改,谢谢!!!