MVC中IActionFilter过滤器俄罗斯套娃的实现方式

看mvc的源码我们知道，它是在 ControllerActionInvoker 类中执行 InvokeAction 方法来实现过滤器和action方法执行的。

通过查看源码我们知道，他是通过调用 InvokeActionMethodWithFilters 方法来实现IActionFilter过滤器和action方法执行的，如图

点进去这个方法我们可以看到

 protected virtual ActionExecutedContext InvokeActionMethodWithFilters(ControllerContext controllerContext, IList<IActionFilter> filters, ActionDescriptor actionDescriptor, IDictionary<string, object> parameters)

 {

     ActionExecutingContext preContext = new ActionExecutingContext(controllerContext, actionDescriptor, parameters);

     Func<ActionExecutedContext> seed = () => new ActionExecutedContext(controllerContext, actionDescriptor, false, null)

     {

         Result = this.InvokeActionMethod(controllerContext, actionDescriptor, parameters)

     };

     return filters.Reverse<IActionFilter>().Aggregate(seed, (Func<ActionExecutedContext> next, IActionFilter filter) => () => ControllerActionInvoker.InvokeActionMethodFilter(filter, preContext, next))();

 }

看到这里我直接懵逼了，由于它委托中嵌套了委托而且还简写，还调用了扩展方法Aggregate累加器，所以很难直接看懂，这到底是怎么执行代码的呐？我来把代码整理如下

    public class Class1

     {

         protected virtual ActionExecutedContext InvokeActionMethodWithFilters(ControllerContext controllerContext, IList<IActionFilter> filters, ActionDescriptor actionDescriptor, IDictionary<string, object> parameters)

         {

             ActionExecutingContext preContext = new ActionExecutingContext(controllerContext, actionDescriptor, parameters);

             Func<ActionExecutedContext> seed = () => new ActionExecutedContext(controllerContext, actionDescriptor, false, null)

             {

                 Result = this.InvokeActionMethod(controllerContext, actionDescriptor, parameters)

             };

             Func<Func<ActionExecutedContext>, IActionFilter, Func<ActionExecutedContext>> secondParam =

                 (Func<ActionExecutedContext> next, IActionFilter filter) =>

                 {

                     Func<ActionExecutedContext> returnFunc = () =>

                     {

                         return Class1.InvokeActionMethodFilter(filter, preContext, next);

                     };

                     return returnFunc;

                     //这个是简写

                     //return () => Class1.InvokeActionMethodFilter(filter, preContext, next);

                 };

             return filters.Reverse<IActionFilter>().Aggregate(seed,

                 //(Func<ActionExecutedContext> next, IActionFilter filter) => () => Class1.InvokeActionMethodFilter(filter, preContext, next)

                 secondParam

                 )

                 .Invoke();

         }

         internal static ActionExecutedContext InvokeActionMethodFilter(IActionFilter filter, ActionExecutingContext preContext, Func<ActionExecutedContext> continuation)

         {

             filter.OnActionExecuting(preContext);

             if (preContext.Result != null)

             {

                 return new ActionExecutedContext(preContext, preContext.ActionDescriptor, true, null)

                 {

                     Result = preContext.Result

                 };

             }

             bool flag = false;

             ActionExecutedContext actionExecutedContext = null;

             try

             {

                 actionExecutedContext = continuation();

             }

             catch (ThreadAbortException)

             {

                 actionExecutedContext = new ActionExecutedContext(preContext, preContext.ActionDescriptor, false, null);

                 filter.OnActionExecuted(actionExecutedContext);

                 throw;

             }

             catch (Exception exception)

             {

                 flag = true;

                 actionExecutedContext = new ActionExecutedContext(preContext, preContext.ActionDescriptor, false, exception);

                 filter.OnActionExecuted(actionExecutedContext);

                 if (!actionExecutedContext.ExceptionHandled)

                 {

                     throw;

                 }

             }

             if (!flag)

             {

                 filter.OnActionExecuted(actionExecutedContext);

             }

             return actionExecutedContext;

         }

         protected virtual ActionResult InvokeActionMethod(ControllerContext controllerContext, ActionDescriptor actionDescriptor, IDictionary<string, object> parameters)

         {

             object actionReturnValue = actionDescriptor.Execute(controllerContext, parameters);

             return this.CreateActionResult(controllerContext, actionDescriptor, actionReturnValue);

         }

         protected virtual ActionResult CreateActionResult(ControllerContext controllerContext, ActionDescriptor actionDescriptor, object actionReturnValue)

         {

             if (actionReturnValue == null)

             {

                 return new EmptyResult();

             }

             ActionResult arg_29_0;

             if ((arg_29_0 = (actionReturnValue as ActionResult)) == null)

             {

                 arg_29_0 = new ContentResult();

                 //(arg_29_0 = new ContentResult()).Content = Convert.ToString(actionReturnValue, CultureInfo.InvariantCulture);

                 (arg_29_0 as ContentResult).Content = Convert.ToString(actionReturnValue, CultureInfo.InvariantCulture);

             }

             return arg_29_0;

         }

     }

咋一看，还是不知所云，一步一步来，

首先，我们先要知道 Aggregate 这个扩展方法是怎么执行的，直接看源码如下

看了源码就很容易理解了，它就是遍历数据源来循环执行传递过来的委托，并把结果当成参数，执行下一次循环的委托。

所有我整理了一个容易理解的一串代码

     public class Class2

     {

         public void Test()

         {

             var preContext = new ActionExecutingContext();

             Func<ActionExecutedContext> seed = () =>

             {

                 Console.WriteLine("执行action");

                 return new ActionExecutedContext();

             };

             int[] arr = { , , , , , , , ,  };

             Func<Func<ActionExecutedContext>, int, Func<ActionExecutedContext>> secondParam =

             (Func<ActionExecutedContext> next, int filter) =>

             {

                 return () => this.getStr(next, filter, preContext);

             };

             var reFunc2 = arr.Reverse().Aggregate<int, Func<ActionExecutedContext>>(seed, secondParam);

             reFunc2.Invoke();

         }

         public ActionExecutedContext getStr(Func<ActionExecutedContext> func, int filter, ActionExecutingContext preContext)

         {

             Console.WriteLine("before action----" + filter + "----" + preContext.ToString());

             var res = func.Invoke();

             Console.WriteLine("before action----" + filter + "----" + res.ToString());

             return res;

         }

     }

我是用一个int数组来模拟IActionFilter集合，其它的写法都和mvc框架的写法一样。

运行结果为如图

看到这里，你是否明白了，它就是通过委托里嵌套委托来巧妙的实现了俄罗斯套娃的形式来实现IActionFilter过滤器和Action方法的执行。

巴特西

MVC中IActionFilter过滤器俄罗斯套娃的实现方式

最新文章

热门文章