反射VS委托,到底谁更快？

       有时候我们需要动态调用一个方法，到底用什么方法呢？很多人想到了反射，有的人也想到了委托。大家都知道反射很慢，因为反射的类型不安全和以寻找字符串的方式来匹配相对应的成员，所以也有的人用委托，那到底谁更快呢？来看一个demo：

   

 public interface IGetData
    {
        int GetData(int data);
    }

    public class Test : IGetData
    {
        public int GetData(int data)
        {
            return data;
        }
    }

 假设正常情况下无法访问Test中的方法

  public class InvokeTestMember
    {
        private const BindingFlags flag = BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public;

        /// <summary>
        /// 使用反射
        /// </summary>
        public  void InvokeByReflect()
        {
            Test obj = (Test)Activator.CreateInstance(typeof(Test));
            MethodInfo mi = typeof(Test).GetMethod("GetData", flag);

            object result = mi.Invoke(obj, new object[] { 10 });
        }

        /// <summary>
        /// 使用委托
        /// </summary>
        public void InvokeByCreateDelegate()
        {
            Test obj = (Test)Activator.CreateInstance(typeof(Test));
            MethodInfo mi = typeof(Test).GetMethod("GetData", flag);

            Func<int, int> del = (Func<int, int>)Delegate.CreateDelegate(typeof(Func<int, int>), obj, mi);
            object result = del(10);
        }
    }

现在来测试一下谁更快：

class Program
    {
        static void Main(string[] args)
        {
            Go();
        }

        static void Go()
        {
            InvokeTestMember itm = new InvokeTestMember();

            Stopwatch sw = Stopwatch.StartNew();
            for (int i = 0; i < 1000 * 1000; i++)
            {
                itm.InvokeByCreateDelegate();
            }
            Console.WriteLine("invokebydelegate: " + sw.Elapsed);

             sw = Stopwatch.StartNew();
            for (int i = 0; i < 1000 * 1000; i++)
            {
                itm.InvokeByReflect();
            }
            Console.WriteLine("invokebyreflect: " + sw.Elapsed);
        }
    }

下面是输出结果：

有点意外啊，反射更快，至于是什么原因，大家去讨论一下吧，我现在也不是很清楚，有点复杂啊。。。。。。

当然了，还有更好的方法，速度更快，就是使用Dynamic关键字，此关键字在运行时跟object有点类似，它创建的对象只能在运行时去匹配相关的类型成员，所以有点类型不安全哦，下面是用dynamic关键字调用的方法，很简单：

  public void InvokeByDynamicKeyword()
        {
            dynamic obj = (Test)Activator.CreateInstance(typeof(Test));
            object result = obj.GetData(10);
        }

同样执行1000*1000次，它需要的时间如下：

当然了，我前面用到了接口，对于反射速度慢的最佳解决方案是，实现一个接口或一个抽象类，用他们的引用指向实现该接口的成员实例或继承该抽象类的成员实例，这是典型的插件编程模式，来看一下代码，很简单：

 public void InvokeByInterface()
        {
            IGetData obj = (IGetData)Activator.CreateInstance(typeof(Test));
            object result = obj.GetData(10);
        }

同样执行1000*1000次，它需要的时间如下：

呵呵，心血来潮，跟大家分享一下，太忙了，可能写的不好，大家见谅了。