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 = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

            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方法的执行。