1. title: Asp.Net Core底层源码剖析（二）过滤器
  2. date: 2022-09-18 10:41:57
  3. categories: 后端
  4. tags:
  5. - .NET

正文

Asp.Net Core中的过滤器有好几种，包括AuthorizationFilter、ActionFilter，ResourceFilter，ExceptionFilter，ResultFilter，平时一般用的多的就是AuthorizationFilter、ActionFilter、ExceptionFilter三个，下面我们写个自定义的ActionFilter，然后debug看一下源码

自定义ActionFilter

我们自定义的ActionFilter可以继承自ActionFilterAttribute，也可以直接实现接口IActionFilter，两者的作用是差不多的，因为ActionFilterAttribute也实现了这个接口，我们看下源码：

  1. [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true, Inherited = true)]
  2. public abstract class ActionFilterAttribute :
  3. Attribute, IActionFilter, IAsyncActionFilter, IResultFilter, IAsyncResultFilter, IOrderedFilter
  4. {
  5.     // 实现...
  6. }

可以看出，ActionFilterAttribute继承了好几个接口，下面是这几个接口的简单说明

所以我们直接继承ActionFilterAttribute，其实同时实现了好几个方法：

  1. public class MyActionFilterAttribute:ActionFilterAttribute
  2. {
  3.     public override void OnActionExecuting(ActionExecutingContext actionExecutingContext)
  4.     {
  5.         Console.WriteLine("OnActionExecuting");
  6.     }
  8.     public override void OnActionExecuted(ActionExecutedContext context)
  9.     {
  10.         base.OnActionExecuted(context);
  11.         Console.WriteLine("OnActionExecuted");
  13.     }
  15.     public override Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
  16.     {
  17.         return base.OnActionExecutionAsync(context, next);
  18.         Console.WriteLine("OnActionExecutionAsync");
  20.     }
  22.     public override void OnResultExecuting(ResultExecutingContext context)
  23.     {
  24.         base.OnResultExecuting(context);
  25.         Console.WriteLine("OnResultExecuting");
  27.     }
  29.     public override void OnResultExecuted(ResultExecutedContext context)
  30.     {
  31.         base.OnResultExecuted(context);
  32.         Console.WriteLine("OnResultExecuted");
  34.     }
  36.     public override Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next)
  37.     {
  38.         return base.OnResultExecutionAsync(context, next);
  39.         Console.WriteLine("OnResultExecuted");
  40.     }
  41. }

下面我们把自己写的过滤器添加到全局的过滤器中，而不是直接用在controller或者方法上

  1. builder.Services.AddMvc(it => it.Filters.Add(typeof(MyActionFilterAttribute)));

然后我们开始debug，给OnActionExecuting函数打个断点，然后查看运行的堆栈，我们可以看到是在EndpointMiddleware中间件内部来调用过滤器的

接着我们继续往下，能找到下面这个函数

  1. private Task Next(ref State next, ref Scope scope, ref object? state, ref bool isCompleted)
  2. {
  3.     switch (next)
  4.     {
  5.         case State.InvokeBegin:
  6.             {
  7.                 goto case State.AuthorizationBegin;
  8.             }
  10.         case State.AuthorizationBegin:
  11.             {
  12.                 _cursor.Reset();
  13.                 goto case State.AuthorizationNext;
  14.             }
  16.         case State.AuthorizationNext:
  17.             {
  18.                 var current = _cursor.GetNextFilter<IAuthorizationFilter, IAsyncAuthorizationFilter>();
  19.                 if (current.FilterAsync != null)
  20.                 {
  21.                     if (_authorizationContext == null)
  22.                     {
  23.                         _authorizationContext = new AuthorizationFilterContextSealed(_actionContext, _filters);
  24.                     }
  26.                     state = current.FilterAsync;
  27.                     goto case State.AuthorizationAsyncBegin;
  28.                 }
  29.                 else if (current.Filter != null)
  30.                 {
  31.                     if (_authorizationContext == null)
  32.                     {
  33.                         _authorizationContext = new AuthorizationFilterContextSealed(_actionContext, _filters);
  34.                     }
  36.                     state = current.Filter;
  37.                     goto case State.AuthorizationSync;
  38.                 }
  39.                 else
  40.                 {
  41.                     goto case State.AuthorizationEnd;
  42.                 }
  43.             }
  45.         case State.AuthorizationAsyncBegin:
  46.             {
  47.                 Debug.Assert(state != null);
  48.                 Debug.Assert(_authorizationContext != null);
  50.                 var filter = (IAsyncAuthorizationFilter)state;
  51.                 var authorizationContext = _authorizationContext;
  53.                 _diagnosticListener.BeforeOnAuthorizationAsync(authorizationContext, filter);
  54.                 _logger.BeforeExecutingMethodOnFilter(
  55.                     FilterTypeConstants.AuthorizationFilter,
  56.                     nameof(IAsyncAuthorizationFilter.OnAuthorizationAsync),
  57.                     filter);
  59.                 var task = filter.OnAuthorizationAsync(authorizationContext);
  60.                 if (!task.IsCompletedSuccessfully)
  61.                 {
  62.                     next = State.AuthorizationAsyncEnd;
  63.                     return task;
  64.                 }
  66.                 goto case State.AuthorizationAsyncEnd;
  67.             }
  69.         case State.AuthorizationAsyncEnd:
  70.             {
  71.                 Debug.Assert(state != null);
  72.                 Debug.Assert(_authorizationContext != null);
  74.                 var filter = (IAsyncAuthorizationFilter)state;
  75.                 var authorizationContext = _authorizationContext;
  77.                 _diagnosticListener.AfterOnAuthorizationAsync(authorizationContext, filter);
  78.                 _logger.AfterExecutingMethodOnFilter(
  79.                     FilterTypeConstants.AuthorizationFilter,
  80.                     nameof(IAsyncAuthorizationFilter.OnAuthorizationAsync),
  81.                     filter);
  83.                 if (authorizationContext.Result != null)
  84.                 {
  85.                     goto case State.AuthorizationShortCircuit;
  86.                 }
  88.                 goto case State.AuthorizationNext;
  89.             }
  91.         case State.AuthorizationSync:
  92.             {
  93.                 Debug.Assert(state != null);
  94.                 Debug.Assert(_authorizationContext != null);
  96.                 var filter = (IAuthorizationFilter)state;
  97.                 var authorizationContext = _authorizationContext;
  99.                 _diagnosticListener.BeforeOnAuthorization(authorizationContext, filter);
  100.                 _logger.BeforeExecutingMethodOnFilter(
  101.                     FilterTypeConstants.AuthorizationFilter,
  102.                     nameof(IAuthorizationFilter.OnAuthorization),
  103.                     filter);
  105.                 filter.OnAuthorization(authorizationContext);
  107.                 _diagnosticListener.AfterOnAuthorization(authorizationContext, filter);
  108.                 _logger.AfterExecutingMethodOnFilter(
  109.                     FilterTypeConstants.AuthorizationFilter,
  110.                     nameof(IAuthorizationFilter.OnAuthorization),
  111.                     filter);
  113.                 if (authorizationContext.Result != null)
  114.                 {
  115.                     goto case State.AuthorizationShortCircuit;
  116.                 }
  118.                 goto case State.AuthorizationNext;
  119.             }
  121.         case State.AuthorizationShortCircuit:
  122.             {
  123.                 Debug.Assert(state != null);
  124.                 Debug.Assert(_authorizationContext != null);
  125.                 Debug.Assert(_authorizationContext.Result != null);
  127.                 _logger.AuthorizationFailure((IFilterMetadata)state);
  129.                 // This is a short-circuit - execute relevant result filters + result and complete this invocation.
  130.                 isCompleted = true;
  131.                 _result = _authorizationContext.Result;
  132.                 return InvokeAlwaysRunResultFilters();
  133.             }
  135.         case State.AuthorizationEnd:
  136.             {
  137.                 goto case State.ResourceBegin;
  138.             }
  140.         case State.ResourceBegin:
  141.             {
  142.                 _cursor.Reset();
  143.                 goto case State.ResourceNext;
  144.             }
  146.         case State.ResourceNext:
  147.             {
  148.                 var current = _cursor.GetNextFilter<IResourceFilter, IAsyncResourceFilter>();
  149.                 if (current.FilterAsync != null)
  150.                 {
  151.                     if (_resourceExecutingContext == null)
  152.                     {
  153.                         _resourceExecutingContext = new ResourceExecutingContextSealed(
  154.                             _actionContext,
  155.                             _filters,
  156.                             _valueProviderFactories);
  157.                     }
  159.                     state = current.FilterAsync;
  160.                     goto case State.ResourceAsyncBegin;
  161.                 }
  162.                 else if (current.Filter != null)
  163.                 {
  164.                     if (_resourceExecutingContext == null)
  165.                     {
  166.                         _resourceExecutingContext = new ResourceExecutingContextSealed(
  167.                             _actionContext,
  168.                             _filters,
  169.                             _valueProviderFactories);
  170.                     }
  172.                     state = current.Filter;
  173.                     goto case State.ResourceSyncBegin;
  174.                 }
  175.                 else
  176.                 {
  177.                     // All resource filters are currently on the stack - now execute the 'inside'.
  178.                     goto case State.ResourceInside;
  179.                 }
  180.             }
  182.         case State.ResourceAsyncBegin:
  183.             {
  184.                 Debug.Assert(state != null);
  185.                 Debug.Assert(_resourceExecutingContext != null);
  187.                 var filter = (IAsyncResourceFilter)state;
  188.                 var resourceExecutingContext = _resourceExecutingContext;
  190.                 _diagnosticListener.BeforeOnResourceExecution(resourceExecutingContext, filter);
  191.                 _logger.BeforeExecutingMethodOnFilter(
  192.                     FilterTypeConstants.ResourceFilter,
  193.                     nameof(IAsyncResourceFilter.OnResourceExecutionAsync),
  194.                     filter);
  196.                 var task = filter.OnResourceExecutionAsync(resourceExecutingContext, InvokeNextResourceFilterAwaitedAsync);
  197.                 if (!task.IsCompletedSuccessfully)
  198.                 {
  199.                     next = State.ResourceAsyncEnd;
  200.                     return task;
  201.                 }
  203.                 goto case State.ResourceAsyncEnd;
  204.             }
  206.         case State.ResourceAsyncEnd:
  207.             {
  208.                 Debug.Assert(state != null);
  209.                 Debug.Assert(_resourceExecutingContext != null);
  211.                 var filter = (IAsyncResourceFilter)state;
  212.                 if (_resourceExecutedContext == null)
  213.                 {
  214.                     // If we get here then the filter didn't call 'next' indicating a short circuit.
  215.                     _resourceExecutedContext = new ResourceExecutedContextSealed(_resourceExecutingContext, _filters)
  216.                     {
  217.                         Canceled = true,
  218.                         Result = _resourceExecutingContext.Result,
  219.                     };
  221.                     _diagnosticListener.AfterOnResourceExecution(_resourceExecutedContext, filter);
  222.                     _logger.AfterExecutingMethodOnFilter(
  223.                         FilterTypeConstants.ResourceFilter,
  224.                         nameof(IAsyncResourceFilter.OnResourceExecutionAsync),
  225.                         filter);
  227.                     // A filter could complete a Task without setting a result
  228.                     if (_resourceExecutingContext.Result != null)
  229.                     {
  230.                         goto case State.ResourceShortCircuit;
  231.                     }
  232.                 }
  234.                 goto case State.ResourceEnd;
  235.             }
  237.         case State.ResourceSyncBegin:
  238.             {
  239.                 Debug.Assert(state != null);
  240.                 Debug.Assert(_resourceExecutingContext != null);
  242.                 var filter = (IResourceFilter)state;
  243.                 var resourceExecutingContext = _resourceExecutingContext;
  245.                 _diagnosticListener.BeforeOnResourceExecuting(resourceExecutingContext, filter);
  246.                 _logger.BeforeExecutingMethodOnFilter(
  247.                     FilterTypeConstants.ResourceFilter,
  248.                     nameof(IResourceFilter.OnResourceExecuting),
  249.                     filter);
  251.                 filter.OnResourceExecuting(resourceExecutingContext);
  253.                 _diagnosticListener.AfterOnResourceExecuting(resourceExecutingContext, filter);
  254.                 _logger.AfterExecutingMethodOnFilter(
  255.                     FilterTypeConstants.ResourceFilter,
  256.                     nameof(IResourceFilter.OnResourceExecuting),
  257.                     filter);
  259.                 if (resourceExecutingContext.Result != null)
  260.                 {
  261.                     _resourceExecutedContext = new ResourceExecutedContextSealed(resourceExecutingContext, _filters)
  262.                     {
  263.                         Canceled = true,
  264.                         Result = _resourceExecutingContext.Result,
  265.                     };
  267.                     goto case State.ResourceShortCircuit;
  268.                 }
  270.                 var task = InvokeNextResourceFilter();
  271.                 if (!task.IsCompletedSuccessfully)
  272.                 {
  273.                     next = State.ResourceSyncEnd;
  274.                     return task;
  275.                 }
  277.                 goto case State.ResourceSyncEnd;
  278.             }
  280.         case State.ResourceSyncEnd:
  281.             {
  282.                 Debug.Assert(state != null);
  283.                 Debug.Assert(_resourceExecutingContext != null);
  284.                 Debug.Assert(_resourceExecutedContext != null);
  286.                 var filter = (IResourceFilter)state;
  287.                 var resourceExecutedContext = _resourceExecutedContext;
  289.                 _diagnosticListener.BeforeOnResourceExecuted(resourceExecutedContext, filter);
  290.                 _logger.BeforeExecutingMethodOnFilter(
  291.                     FilterTypeConstants.ResourceFilter,
  292.                     nameof(IResourceFilter.OnResourceExecuted),
  293.                     filter);
  295.                 filter.OnResourceExecuted(resourceExecutedContext);
  297.                 _diagnosticListener.AfterOnResourceExecuted(resourceExecutedContext, filter);
  298.                 _logger.AfterExecutingMethodOnFilter(
  299.                     FilterTypeConstants.ResourceFilter,
  300.                     nameof(IResourceFilter.OnResourceExecuted),
  301.                     filter);
  303.                 goto case State.ResourceEnd;
  304.             }
  306.         case State.ResourceShortCircuit:
  307.             {
  308.                 Debug.Assert(state != null);
  309.                 Debug.Assert(_resourceExecutingContext != null);
  310.                 Debug.Assert(_resourceExecutedContext != null);
  312.                 _logger.ResourceFilterShortCircuited((IFilterMetadata)state);
  314.                 _result = _resourceExecutingContext.Result;
  315.                 var task = InvokeAlwaysRunResultFilters();
  316.                 if (!task.IsCompletedSuccessfully)
  317.                 {
  318.                     next = State.ResourceEnd;
  319.                     return task;
  320.                 }
  322.                 goto case State.ResourceEnd;
  323.             }
  325.         case State.ResourceInside:
  326.             {
  327.                 goto case State.ExceptionBegin;
  328.             }
  330.         case State.ExceptionBegin:
  331.             {
  332.                 _cursor.Reset();
  333.                 goto case State.ExceptionNext;
  334.             }
  336.         case State.ExceptionNext:
  337.             {
  338.                 var current = _cursor.GetNextFilter<IExceptionFilter, IAsyncExceptionFilter>();
  339.                 if (current.FilterAsync != null)
  340.                 {
  341.                     state = current.FilterAsync;
  342.                     goto case State.ExceptionAsyncBegin;
  343.                 }
  344.                 else if (current.Filter != null)
  345.                 {
  346.                     state = current.Filter;
  347.                     goto case State.ExceptionSyncBegin;
  348.                 }
  349.                 else if (scope == Scope.Exception)
  350.                 {
  351.                     // All exception filters are on the stack already - so execute the 'inside'.
  352.                     goto case State.ExceptionInside;
  353.                 }
  354.                 else
  355.                 {
  356.                     // There are no exception filters - so jump right to the action.
  357.                     Debug.Assert(scope == Scope.Invoker || scope == Scope.Resource);
  358.                     goto case State.ActionBegin;
  359.                 }
  360.             }
  362.         case State.ExceptionAsyncBegin:
  363.             {
  364.                 var task = InvokeNextExceptionFilterAsync();
  365.                 if (!task.IsCompletedSuccessfully)
  366.                 {
  367.                     next = State.ExceptionAsyncResume;
  368.                     return task;
  369.                 }
  371.                 goto case State.ExceptionAsyncResume;
  372.             }
  374.         case State.ExceptionAsyncResume:
  375.             {
  376.                 Debug.Assert(state != null);
  378.                 var filter = (IAsyncExceptionFilter)state;
  379.                 var exceptionContext = _exceptionContext;
  381.                 // When we get here we're 'unwinding' the stack of exception filters. If we have an unhandled exception,
  382.                 // we'll call the filter. Otherwise there's nothing to do.
  383.                 if (exceptionContext?.Exception != null && !exceptionContext.ExceptionHandled)
  384.                 {
  385.                     _diagnosticListener.BeforeOnExceptionAsync(exceptionContext, filter);
  386.                     _logger.BeforeExecutingMethodOnFilter(
  387.                         FilterTypeConstants.ExceptionFilter,
  388.                         nameof(IAsyncExceptionFilter.OnExceptionAsync),
  389.                         filter);
  391.                     var task = filter.OnExceptionAsync(exceptionContext);
  392.                     if (!task.IsCompletedSuccessfully)
  393.                     {
  394.                         next = State.ExceptionAsyncEnd;
  395.                         return task;
  396.                     }
  398.                     goto case State.ExceptionAsyncEnd;
  399.                 }
  401.                 goto case State.ExceptionEnd;
  402.             }
  404.         case State.ExceptionAsyncEnd:
  405.             {
  406.                 Debug.Assert(state != null);
  407.                 Debug.Assert(_exceptionContext != null);
  409.                 var filter = (IAsyncExceptionFilter)state;
  410.                 var exceptionContext = _exceptionContext;
  412.                 _diagnosticListener.AfterOnExceptionAsync(exceptionContext, filter);
  413.                 _logger.AfterExecutingMethodOnFilter(
  414.                     FilterTypeConstants.ExceptionFilter,
  415.                     nameof(IAsyncExceptionFilter.OnExceptionAsync),
  416.                     filter);
  418.                 if (exceptionContext.Exception == null || exceptionContext.ExceptionHandled)
  419.                 {
  420.                     // We don't need to do anything to trigger a short circuit. If there's another
  421.                     // exception filter on the stack it will check the same set of conditions
  422.                     // and then just skip itself.
  423.                     _logger.ExceptionFilterShortCircuited(filter);
  424.                 }
  426.                 goto case State.ExceptionEnd;
  427.             }
  429.         case State.ExceptionSyncBegin:
  430.             {
  431.                 var task = InvokeNextExceptionFilterAsync();
  432.                 if (!task.IsCompletedSuccessfully)
  433.                 {
  434.                     next = State.ExceptionSyncEnd;
  435.                     return task;
  436.                 }
  438.                 goto case State.ExceptionSyncEnd;
  439.             }
  441.         case State.ExceptionSyncEnd:
  442.             {
  443.                 Debug.Assert(state != null);
  445.                 var filter = (IExceptionFilter)state;
  446.                 var exceptionContext = _exceptionContext;
  448.                 // When we get here we're 'unwinding' the stack of exception filters. If we have an unhandled exception,
  449.                 // we'll call the filter. Otherwise there's nothing to do.
  450.                 if (exceptionContext?.Exception != null && !exceptionContext.ExceptionHandled)
  451.                 {
  452.                     _diagnosticListener.BeforeOnException(exceptionContext, filter);
  453.                     _logger.BeforeExecutingMethodOnFilter(
  454.                         FilterTypeConstants.ExceptionFilter,
  455.                         nameof(IExceptionFilter.OnException),
  456.                         filter);
  458.                     filter.OnException(exceptionContext);
  460.                     _diagnosticListener.AfterOnException(exceptionContext, filter);
  461.                     _logger.AfterExecutingMethodOnFilter(
  462.                         FilterTypeConstants.ExceptionFilter,
  463.                         nameof(IExceptionFilter.OnException),
  464.                         filter);
  466.                     if (exceptionContext.Exception == null || exceptionContext.ExceptionHandled)
  467.                     {
  468.                         // We don't need to do anything to trigger a short circuit. If there's another
  469.                         // exception filter on the stack it will check the same set of conditions
  470.                         // and then just skip itself.
  471.                         _logger.ExceptionFilterShortCircuited(filter);
  472.                     }
  473.                 }
  475.                 goto case State.ExceptionEnd;
  476.             }
  478.         case State.ExceptionInside:
  479.             {
  480.                 goto case State.ActionBegin;
  481.             }
  483.         case State.ExceptionHandled:
  484.             {
  485.                 // We arrive in this state when an exception happened, but was handled by exception filters
  486.                 // either by setting ExceptionHandled, or nulling out the Exception or setting a result
  487.                 // on the ExceptionContext.
  488.                 //
  489.                 // We need to execute the result (if any) and then exit gracefully which unwinding Resource
  490.                 // filters.
  492.                 Debug.Assert(state != null);
  493.                 Debug.Assert(_exceptionContext != null);
  495.                 if (_exceptionContext.Result == null)
  496.                 {
  497.                     _exceptionContext.Result = new EmptyResult();
  498.                 }
  500.                 _result = _exceptionContext.Result;
  502.                 var task = InvokeAlwaysRunResultFilters();
  503.                 if (!task.IsCompletedSuccessfully)
  504.                 {
  505.                     next = State.ResourceInsideEnd;
  506.                     return task;
  507.                 }
  509.                 goto case State.ResourceInsideEnd;
  510.             }
  512.         case State.ExceptionEnd:
  513.             {
  514.                 var exceptionContext = _exceptionContext;
  516.                 if (scope == Scope.Exception)
  517.                 {
  518.                     isCompleted = true;
  519.                     return Task.CompletedTask;
  520.                 }
  522.                 if (exceptionContext != null)
  523.                 {
  524.                     if (exceptionContext.Result != null ||
  525.                         exceptionContext.Exception == null ||
  526.                         exceptionContext.ExceptionHandled)
  527.                     {
  528.                         goto case State.ExceptionHandled;
  529.                     }
  531.                     Rethrow(exceptionContext);
  532.                     Debug.Fail("unreachable");
  533.                 }
  535.                 var task = InvokeResultFilters();
  536.                 if (!task.IsCompletedSuccessfully)
  537.                 {
  538.                     next = State.ResourceInsideEnd;
  539.                     return task;
  540.                 }
  541.                 goto case State.ResourceInsideEnd;
  542.             }
  544.         case State.ActionBegin:
  545.             {
  546.                 var task = InvokeInnerFilterAsync();
  547.                 if (!task.IsCompletedSuccessfully)
  548.                 {
  549.                     next = State.ActionEnd;
  550.                     return task;
  551.                 }
  553.                 goto case State.ActionEnd;
  554.             }
  556.         case State.ActionEnd:
  557.             {
  558.                 if (scope == Scope.Exception)
  559.                 {
  560.                     // If we're inside an exception filter, let's allow those filters to 'unwind' before
  561.                     // the result.
  562.                     isCompleted = true;
  563.                     return Task.CompletedTask;
  564.                 }
  566.                 Debug.Assert(scope == Scope.Invoker || scope == Scope.Resource);
  567.                 var task = InvokeResultFilters();
  568.                 if (!task.IsCompletedSuccessfully)
  569.                 {
  570.                     next = State.ResourceInsideEnd;
  571.                     return task;
  572.                 }
  573.                 goto case State.ResourceInsideEnd;
  574.             }
  576.         case State.ResourceInsideEnd:
  577.             {
  578.                 if (scope == Scope.Resource)
  579.                 {
  580.                     _resourceExecutedContext = new ResourceExecutedContextSealed(_actionContext, _filters)
  581.                     {
  582.                         Result = _result,
  583.                     };
  585.                     goto case State.ResourceEnd;
  586.                 }
  588.                 goto case State.InvokeEnd;
  589.             }
  591.         case State.ResourceEnd:
  592.             {
  593.                 if (scope == Scope.Resource)
  594.                 {
  595.                     isCompleted = true;
  596.                     return Task.CompletedTask;
  597.                 }
  599.                 Debug.Assert(scope == Scope.Invoker);
  600.                 Rethrow(_resourceExecutedContext!);
  602.                 goto case State.InvokeEnd;
  603.             }
  605.         case State.InvokeEnd:
  606.             {
  607.                 isCompleted = true;
  608.                 return Task.CompletedTask;
  609.             }
  611.         default:
  612.             throw new InvalidOperationException();
  613.     }
  614. }

上面这段就是过滤器的核心代码了，其实很简单，就是在一个switch里面不停地根据条件跳转，下面是官网上不同过滤器的执行顺序图

那么过滤器和管道之间的执行顺序又是什么样的呢？直接看官方文档内的图：

其实从刚开始的单步调试我们就已经知道了，是在EndpointMiddleware管道内执行的，也就是说先执行了一些我们自己添加的中间件，到最后和Action交互的时候才会执行相关的过滤器

过滤器和管道的重要区别

  1. 中间件可以处理所有的请求，而过滤器只能针对到达EndpointMiddleware Api的请求进行处理

  2. 过滤器处理的是ActionExecutingContext、ResultExecutedContext等，而中间件处理的是HttpContext，相较于HttpContext，ActionExecutingContext拥有了更多的信息，比如执行的方法，对应的参数等

以异常处理来举例，我们可以在中间件的级别来处理异常，也可以在过滤器的级别来处理异常，那一般情况下我们应该怎么选择呢？

  1. 如果我们需要处理Asp.Net Core框架内部的错误，比如管道中处理出现了一些异常，我们需要使用中间件处理异常，并且位于管道的开始位置
  2. 如果我们只关心自己的业务代码是否出现异常，比如controller中的action抛出了异常，我们可以使用过滤器，这样有个好处就是我们更方便获取对应抛出异常方法的信息
  3. 如果我们又想处理Asp.Net Core框架内部的异常，又想处理业务逻辑的异常，那么我们可以两者都同时使用

过滤器执行顺序

过滤器的执行是有顺序的，官方文档提供了一个表格我们可以参考一下：

Sequence Filter scope Filter method
1 Global OnActionExecuting
2 Controller OnActionExecuting
3 Action OnActionExecuting
4 Action OnActionExecuted
5 Controller OnActionExecuted
6 Global OnActionExecuted

看得出来顺序是这样的：

  1. 全局级别
  2. Controller级别
  3. Action级别

返回时执行顺序相反，这个顺序也不是写死的，我们可以通过配置一个字段来设置顺序：

  1.  [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true, Inherited = true)]
  2.     public abstract class ActionFilterAttribute :
  3.         Attribute, IActionFilter, IAsyncActionFilter, IResultFilter, IAsyncResultFilter, IOrderedFilter
  4.     {
  5.         /// <inheritdoc />
  6.         public int Order { get; set; }
  7.     }

实现了IOrderedFilter接口的过滤器都可以通过Order字段设置执行顺序，这个Order的默认值都是0，我们可以在自定义的过滤器上添加下面的代码来测试是否是这样的：

  1. public int Level { get; set; } = 0;
  2. public override void OnActionExecuting(ActionExecutingContext actionExecutingContext)
  3. {
  4.     Console.WriteLine($"OnActionExecuting {Order} {Level}");
  5. }

在全局、Controller和Action级别都添加一个：

  1. [MyActionFilter(Level = 100)]
  2. [Route("api/[controller]")]
  3. [ApiController]
  4. public class ValuesController : ControllerBase
  5. {
  7.     public ValuesController()
  8.     {
  9.     }
  10.     [MyActionFilter(Level = 99)]
  11.     [HttpGet("test")]
  12.     public string Test()
  13.     {
  14.         return "123";
  15.     }
  16. }

最后调用这个接口，输出的结果为：

  1. OnActionExecuting 0 0
  2. OnActionExecuting 0 100
  3. OnActionExecuting 0 99

可以看出，默认的Order都是0，如果我们想要将某个过滤器在其它过滤器前执行，则可以手动设置Order的顺序，Order越小优先级越高

这里有个问题，如果我们设置某一个过滤器的执行顺序在全局和Controller之间，那我们也必须设置Controller级别的过滤器的Order属性，比如Action级别的过滤器Order为1，那么Controller级别的过滤器Orde必须大于1，如果涉及到很多个过滤器的话这里会比较复杂，而且不直观，所以一般情况下都不会对这个字段进行修改

参考

  1. https://stackoverflow.com/questions/42582758/asp-net-core-middleware-vs-filters

  2. https://learn.microsoft.com/en-us/aspnet/core/mvc/controllers/filters?view=aspnetcore-6.0

  3. https://www.yogihosting.com/advanced-filters-topics-aspnet-core/#execution-order

  4. https://www.dotnettricks.com/learn/aspnetcore/mvc-core-filters-real-world-exmaple

  5. https://stackoverflow.com/questions/50887540/exceptionhandling-middleware-vs-filter-aspnetcore-webapi-2-1?noredirect=1&lq=1

  6. https://www.cnblogs.com/Bo-H/p/16584380.html

Asp-Net-Core-管道VS过滤器的更多相关文章

  1. ASP.NET CORE 管道模型及中间件使用解读

    说到ASP.NET CORE 管道模型不得不先来看看之前的ASP.NET 的管道模型,两者差异很大,.NET CORE 3.1 后完全重新设计了框架的底层,.net core 3.1 的管道模型更加灵 ...

  2. 通过重建Hosting系统理解HTTP请求在ASP.NET Core管道中的处理流程[下]：管道是如何构建起来的？

    在<中篇>中,我们对管道的构成以及它对请求的处理流程进行了详细介绍,接下来我们需要了解的是这样一个管道是如何被构建起来的.总的来说,管道由一个服务器和一个HttpApplication构成 ...

  3. ASP.NET Core管道深度剖析（4）：管道是如何建立起来的？

    在<管道是如何处理HTTP请求的?>中,我们对ASP.NET Core的请求处理管道的构成以及它对请求的处理流程进行了详细介绍,接下来我们需要了解的是这样一个管道是如何被构建起来的.这样一 ...

  4. ASP.NET Core管道深度剖析（2）：创建一个“迷你版”的管道来模拟真实管道请求处理流程

    从<ASP.NET Core管道深度剖析(1):采用管道处理HTTP请求>我们知道ASP.NET Core请求处理管道由一个服务器和一组有序的中间件组成,所以从总体设计来讲是非常简单的,但 ...

  5. ASP.Net 管道模型 VS Asp.Net Core 管道 总结

    1 管道模型  1 Asp.Net Web Form管道 请求进入Asp.Net工作进程后,由进程创建HttpWorkRequest对象,封装此次请求有关的所有信息,然后进入HttpRuntime类进 ...

  6. ASP.NET Core管道深度剖析[共4篇]

    之所以称ASP.NET Core是一个Web开发平台,源于它具有一个极具扩展性的请求处理管道,我们可以通过这个管道的定制来满足各种场景下的HTTP处理需求.ASP. NET Core应用的很多特性,比 ...

  7. ASP.NET Core管道深度剖析（3）：管道是如何处理HTTP请求的？

    我们知道ASP.NET Core请求处理管道由一个服务器和一组有序的中间件组成,所以从总体设计来讲是非常简单的,但是就具体的实现来说,由于其中涉及很多对象的交互,我想很少人能够地把它弄清楚.为了让读者 ...

  8. ASP.NET Core管道深度剖析（1）：采用管道处理HTTP请求

    之所以称ASP.NET Core是一个Web开发平台,源于它具有一个极具扩展性的请求处理管道,我们可以通过这个管道的定制来满足各种场景下的HTTP处理需求.ASP. NET Core应用的很多特性,比 ...

  9. 【WPF】【UWP】借鉴 asp.net core 管道处理模型打造图片缓存控件 ImageEx

    在 Web 开发中,img 标签用来呈现图片,而且一般来说,浏览器是会对这些图片进行缓存的. 比如访问百度,我们可以发现,图片.脚本这种都是从缓存(内存缓存/磁盘缓存)中加载的,而不是再去访问一次百度 ...

  10. ASP.NET Core管道深度剖析

    ASP.NET管道 以IIS 6.0为例,在工作进程w3wp.exe中,利用Aspnet_ispai.dll加载.NET运行时(如果.NET运行时尚未加载).IIS 6引入了应用程序池的概念,一个工作 ...

随机推荐

  1. webscraper 无代码爬虫

    官网:https://www.webscraper.io/web-scraper-first-time-install webscraper 简介 Web Scraper 是一款免费的,适用于普通用户 ...

  2. VBA---文件操作

    Text文件操作 Workbooks.OpenText() 载入一个文本文档,并将其作为包含单个工作表的新工作簿进行分列处理. 语法: 表达式.OpenText(Filename,StartRow, ...

  3. chrome工具调试

    项目调试的困境 程序开发总会遇到各种各样的问题,为什么实际结果和预期结果不一致? 这个时候如果能深入程序内部抽丝剥茧去一探究竟再好不过! 而chrome工具是前端开发的杀手锏,经常听到的一句话是: 出 ...

  4. 试试将.NET7编译为WASM并在Docker上运行

    之前有听到说Docker支持Wasmtime了,刚好.NET7也支持WASM,就带大家来了解一下这个东西,顺便试试它怎么样. 因为WASM(WebAssembly) 一开始是一个给浏览器的技术,比起J ...

  5. CH58X/CH57X/V208 Observer（观察者）例程讨论讲解

    使用的是沁恒的CH582M的Observer例程与官方的demo板. 本例程的功能是主机扫描到从机的MAC地址并打印出来. 先对宏定义进行理解讨论. 最大响应扫描数为8,在串口调试助手那里可以看到打印 ...

  6. Java安全之CC4,5,7

    前言 前边已经将CC链中的关键部分学习差不多,接下来就是一些扩展思路, CC4 ObjectInputStream.readObject() PriorityQueue.readObject() Pr ...

  7. JavaScrip基础学习笔记（一）

    一.三元表达式 1.1 什么是三元表达式 由三元运算符组成的式子我们称为三元表达式 1.2 语法结构 条件表达式 ? 表达式1 : 表达式2 1.3 执行思路 如果表达式为结果真 则返回表达式1的值, ...

  8. Dive into TensorFlow系列（2）- 解析TF核心抽象op算子

    本文作者:李杰 TF计算图从逻辑层来讲,由op与tensor构成.op是项点代表计算单元,tensor是边代表op之间流动的数据内容,两者配合以数据流图的形式来表达计算图.那么op对应的物理层实现是什 ...

  9. i春秋Fuzzing

    先查看源码...没东西,抓包 发现也没什么,但是右边有个提示hint: ip,Large internal network(最大内网ip) 可能需要我们伪造代码进行访问,这还不简单,直接在reques ...

  10. Zookeeper的服务器的log4j升级为log4j2的升级方案（忽略配置化兼容问题）

    参考在线markdown编辑器: http://marxi.co/ Zookeeper的服务器的log4j升级为log4j2的升级方案(忽略配置化兼容问题) 目前希望可以升级将Zookeeper中lo ...