ASP.NET MVC - 漫谈ActionMethodDispatcher

跳过ASP.NET MVC中所有的路由映射和各种有的没的缓存机制，一个个请求从发送到处理，最终是由Action去执行的，而在ASP.NET MVC中，Action的最终执行者叫做ActionMethodDispacher。

在这篇文章中，我想从无到有地建立一个Dispatcher，顺便窥探一下ASP.NET MVC中Action的执行机制。

在没有看源码之前，我觉得这个Dispatcher没有什么了不起，不就是个动态函数调用嘛，使用反射调用不就就行了，几行代码随便搞定：

    public class ReflectionDispatcher    {        public MethodInfo MethodInfo {get;set;}        public ReflectionDispatcher(MethodInfo methodInfo)        {            MethodInfo = methodInfo;        }        public object Execute(TestClass instance, object[] parameters)        {            return MethodInfo.Invoke(instance, parameters);        }    }

多么简单，简直就是一目了然，为了这么点功能，建一个类简直就是多余!

但是，如果ASP.NET MVC中的ActionMethodDispacher也是这样实现的话，那么...嘿嘿，估计会被人骂的很惨吧。

原因是这个ReflectDispacher的性能非常低下，不是因为代码写得太差，只是因为反射调用先天不足，本来就有性能的瓶颈。

关于如何高效动态调用函数，这里就不多说了，详见：http://www.codeproject.com/Articles/14593/A-General-Fast-Method-Invoker

下面我试着仿照ASP.NET MVC的ActionMethodDispacher来建一个性能高点的Dispacher，至于性能可以高多少，不妨等下做个小试验。

using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Reflection;using System.Linq.Expressions;namespace MvcConsole{    public class ActionMethodDispatcher    {        private delegate object ActionExecutor(TestClass instance, object[] parameters);        private delegate void VoidActionExecutor(TestClass instance, object[] parameters);        private ActionExecutor _executor;        private static ActionExecutor BuildActionExecutor(MethodInfo method)        {            ParameterExpression instanceParameter = Expression.Parameter(typeof(TestClass), "instance");            ParameterExpression parametersParameter = Expression.Parameter(typeof(object[]), "parameters");            List<Expression> parameters = new List<Expression>();            ParameterInfo[] parameterInfos = method.GetParameters();            for (int i = 0; i < parameterInfos.Length; i++)            {                ParameterInfo paramInfo = parameterInfos[i];                BinaryExpression valueObj = Expression.ArrayIndex(parametersParameter, Expression.Constant(i));                UnaryExpression valueCast = Expression.Convert(valueObj, paramInfo.ParameterType);                parameters.Add(valueCast);            }            MethodCallExpression methodCall = Expression.Call(instanceParameter, method, parameters);            return                methodCall.Type == typeof(void) ?                WrapVoidAction(Expression.Lambda<VoidActionExecutor>(methodCall, instanceParameter, parametersParameter).Compile()) :                Expression.Lambda<ActionExecutor>(methodCall, instanceParameter, parametersParameter).Compile();        }        public ActionMethodDispatcher(MethodInfo methodInfo)        {            _executor = BuildActionExecutor(methodInfo);        }        public object Execute(TestClass instance, object[] parameters)        {            return _executor(instance, parameters);        }        private static ActionExecutor WrapVoidAction(VoidActionExecutor executor)        {            return (instance, parameters) =>            {                executor(instance, parameters);                return null;            };        }    }}

从这个代码中，我们明显可以看到，这个Dispacher貌似要“胖”很多。

下面就来比较下两个Dispatcher的性能:

using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Reflection;using System.Linq.Expressions;using System.Diagnostics;namespace MvcConsole{    public class TestClass    {        public String State { get; set; }        public TestClass()        {            State = "Init";        }        public void PrintObjects(String para1, String para2)        {        }    }    class Program    {        static void Main(string[] args)        {            Stopwatch stopWatch = new Stopwatch();            int times = 10000000;            var dispatcher = new ActionMethodDispatcher(typeof(TestClass).GetMethod("PrintObjects"));            var testClass = new TestClass();            testClass.State = "Expression Call";            stopWatch.Start();            for (int i = 0; i < times; i++)            {                dispatcher.Execute(testClass, new object[] { "Hello", "World" });            }            stopWatch.Stop();            Console.WriteLine("Expression Call use: " + stopWatch.Elapsed);            var mydispatcher = new RelectionDispatcher(typeof(TestClass).GetMethod("PrintObjects"));            testClass.State = "Reflect Call";            stopWatch.Reset();            stopWatch.Start();            for (int i = 0; i < times; i++)            {                mydispatcher.Execute(testClass, new object[] { "Hello", "World" });            }            stopWatch.Stop();            Console.WriteLine("Reflect Call use: " + stopWatch.Elapsed);        }    }}

运行结果：

Expression Call use: 00:00:00.3916032
Reflect Call use: 00:00:09.4091986

ActionMethodDispatcher的性能要比ReflectDispatcher的性能高20多倍。好吧，这次Reflect的调用真是完败啊，为了这20多倍的性能，我们就是再多写20多倍的代码也在所不惜啊。