【转】替代反射调用的几种方式及性能测试

lsekfe

园子里和这个话题的相关文章比较多，本文是旧话重提，外加个小的总结。主要因为近期看到很多同事、朋友都已经使用 VS2012 进行 .NET 4.5 开发了，却还在大量使用反射，不知道用新的方式。或有所了解，但又害怕性能不好不敢大胆去用。

本文以如下类为例：

1. public class MyMath
   
2. {
   
3.     public int Add(int a, int b)
   
4.     {
   
5.         return a + b;
   
6.     }
   
7. }

复制代码

替代反射的几种方式

倒序说吧，从最先进最简单的开始。

1. dynamic 调用

.NET 4 引入了 dynamic 类型，可以使用如下方式来完成对 MyMath.Add 方法的动态调用：

1. dynamic math = new MyMath();
   
2. int result = math.Add(1, 2);

复制代码

非常简单，效率也不错，可以看后面的性能对比测试结果。

但有一点要注意， dynamic 遵守 .NET 的访问级别限定，会对成员进行可见性检查。也就是说，只能 dynamic 调用 public 成员；当然，如果是同一程序集内部，internal 成员也是可以访问的。

2. Expression Tree 编译调用

Expression Tree 是 .NET 3.5 引入的。简单地，我们可以使用 lambda 构建一颗 Expression Tree：

1. var math = new MyMath();
   
2. Expression<Func<int, int, int>> add = (a, b) => math.Add(a, b);

复制代码

这种方法适合手工编码构建，还有另外一种方式可以动态构建：

1. var add = typeof(MyMath).GetMethod("Add");
   
2. var math = Expression.Parameter(typeof(MyMath));
   
3. var a = Expression.Parameter(typeof(int), "a");
   
4. var b = Expression.Parameter(typeof(int), "b");
   
5. var body = Expression.Call(myMath, add, a, b);
   
6. var lambda = Expression.Lambda<Func<MyMath, int, int, int>>(body, math, a, b);

复制代码

两种方式构建出的 Tree 是相同的。

话归正题，构建出表达式树后，调用其 Compile 方法便可编译成一个委托，如下代码第 3 行：

1. var math = new MyMath();
   
2. Expression<Func<int, int, int>> addExpTree = (a, b) => math.Add(a, b);  // ExressionTree
   
3. Func<int, int, int> add = addExpTree.Compile();                         //  编译成委托
   
4. var result = add(1, 2);                                                 // 相加，结果为3

复制代码

与 dynamic 调用方法同，Expression Tree 编译出的委托方法也遵守 .NET 的访问级别限定，会对成员进行可见性检查，不能访问私有成员。

3. 反射发出调用

这里只介绍反射发出的一项技术 DynamicMethod，.NET 2.0 新增此类。

使用 DynamicMethod 类在运行时定义轻量全局方法，然后使用委托执行这些方法。

针对 MyMath.Add 方法，调用比前面两种方式复杂些：

1. var addMethod = typeof(MyMath).GetMethod("Add");
   
2. var dynamicMethod = new DynamicMethod("", typeof(int), new[] { typeof(MyMath), typeof(int), typeof(int) });
   
3. //
   
4. var il = dynamicMethod.GetILGenerator();
   
5. il.Emit(OpCodes.Ldarg_0);
   
6. il.Emit(OpCodes.Ldarg_1);
   
7. il.Emit(OpCodes.Ldarg_2);
   
8. il.Emit(OpCodes.Callvirt, addMethod);
   
9. il.Emit(OpCodes.Ret);
   
10. //
    
11. var add = (Func<MyMath, int, int, int>)dynamicMethod.CreateDelegate(typeof(Func<MyMath, int, int, int>));
    
12. //
    
13. var math = new MyMath();
    
14. var result = add(math, 1, 2);

复制代码

从第 5 行起，使用几个 IL 汇编指令，简单一说：

• 第 5 行，OpCodes.Ldarg_0 是将索引为 0 的参数值推送到堆栈上，Ldarg_1、Ldarg_2 以此类推；
• 第 6 行，OpCodes.Callvirt 是调用对象的（后期绑定）方法，并且将返回值推送到计算堆栈上；
• 第 9 行，OpCodes.Ret 表达从当前方法返回，并将返回值（如果存在）从调用方的计算堆栈推送到被调用方的计算堆栈上。
  

反射发出是在汇编级别的，很底层，也就意味着效率更高、威力更强大。反射发出能绕过跳过 JIT 可见性检查，访问 private 成员（对于 DynamicMethod 类，请查看：DynamicMethod 构造函数 (String, Type, Type[], Boolean)）。

下面是几种方法的性能测试。

性能对比测试

这里对直接、反射发出、dynamic 、表达式树编译、反射五种调用方式进行性能对比测试。

测试结果

先给出测试的结果：

从上图中可以看出：

• 直接调用性能最佳；
• 反射发出和表达式树两种方式性能相当，速度接近直接调用；
• dynamic 性能居中，也不错；
• 反射方式性能最差。
  
  

另外说明两点：

• 本次测试仅针对 MyMath.Add 方法，其参数和返回值都是值类型，反射调用时存在大量装箱、拆箱。如果测试方法的参数和返回值都是引用类型，反射方式与其它方式间的差距会小些。
• 从上图可以看出这几次方式性能差别较大，但此结果是重复 100 万次的情况下得出的。考虑单次调用，反射只比直接调用慢 381 纳秒。如果你的代码不是位于循环的中心或是系统的瓶颈，调用次数不多，性能差异可以完全忽略。
  
  

测试代码

以下是测试用代码，仅参考：

1. using System;
   
2. using System.Linq.Expressions;
   
3. using System.Reflection.Emit;
   
4. 
   
5. public class MyMath {
   
6.     public int Add(int a, int b) { return a + b; }
   
7. }
   
8. 
   
9. class Program {
   
10.     static void Main(string[] args) {
    
11.         int result;
    
12.         var math = new MyMath();
    
13.         var count = 1000000;
    
14. 
    
15.         Console.WriteLine("数据量：" + count);
    
16.         Console.WriteLine("-----------------------------r\n");
    
17. 
    
18.         using (Profiler.Step("循环：{0} ms")) {
    
19.             for (int i = 0; i < count; i++)
    
20.                 result = 1;
    
21.         }
    
22.         using (Profiler.Step("直接调用 ：{0} ms")) {
    
23.             for (int i = 0; i < count; i++)
    
24.                 result = math.Add(i, i);
    
25.         }
    
26.         using (Profiler.Step("反射发出：{0} ms")) {
    
27.             var emitAdd = BuildEmitAddFunc();
    
28.             for (int i = 0; i < count; i++)
    
29.                 result = emitAdd(math, i, i);
    
30.         }
    
31.         using (Profiler.Step("表达式树：{0} ms")) {
    
32.             var expressionAdd = BuildExpressionAddFunc();
    
33.             for (int i = 0; i < count; i++)
    
34.                 result = expressionAdd(math, i, i);
    
35.         }
    
36.         using (Profiler.Step("dynamic 调用：{0} ms")) {
    
37.             dynamic d = math;
    
38.             for (int i = 0; i < count; i++)
    
39.                 result = d.Add(i, i);
    
40.         }
    
41.         using (Profiler.Step("反射调用：{0} ms")) {
    
42.             var add = typeof(MyMath).GetMethod("Add");
    
43.             for (int i = 0; i < count; i++)
    
44.                 result = (int)add.Invoke(math, new object[] { i, i });
    
45.         }
    
46. 
    
47.         Console.WriteLine("\r\n\r\n测试完成，任意键退出...");
    
48.         Console.ReadKey();
    
49.     }
    
50.     static Func<MyMath, int, int, int> BuildExpressionAddFunc() {
    
51.         var add = typeof(MyMath).GetMethod("Add");
    
52.         var math = Expression.Parameter(typeof(MyMath));
    
53.         var a = Expression.Parameter(typeof(int), "a");
    
54.         var b = Expression.Parameter(typeof(int), "b");
    
55.         var body = Expression.Call(math, add, a, b);
    
56.         var lambda = Expression.Lambda<Func<MyMath, int, int, int>>(body, math, a, b);
    
57.         return lambda.Compile();
    
58.     }
    
59.     static Func<MyMath, int, int, int> BuildEmitAddFunc() {
    
60.         var add = typeof(MyMath).GetMethod("Add");
    
61.         var dynamicMethod = new DynamicMethod("", typeof(int), new[] { typeof(MyMath), typeof(int), typeof(int) });
    
62.         var il = dynamicMethod.GetILGenerator();
    
63.         il.Emit(OpCodes.Ldarg_0);
    
64.         il.Emit(OpCodes.Ldarg_1);
    
65.         il.Emit(OpCodes.Ldarg_2);
    
66.         il.Emit(OpCodes.Callvirt, add);
    
67.         il.Emit(OpCodes.Ret);
    
68.         return (Func<MyMath, int, int, int>)dynamicMethod.CreateDelegate(typeof(Func<MyMath, int, int, int>));
    
69.     }
    
70. }

复制代码

Profiler 是我写的一个类，用于简化测试：

1. using System;
   
2. using System.Diagnostics;
   
3. 
   
4. public class Profiler : IDisposable {
   
5.     private Stopwatch watch;
   
6.     private string message;
   
7. 
   
8.     private Profiler(string message) {
   
9.         this.watch = new Stopwatch();
   
10.         this.watch.Start();
    
11.         this.message = message;
    
12.     }
    
13. 
    
14.     public void Dispose() {
    
15.         watch.Stop();
    
16.         Console.WriteLine(message, watch.ElapsedMilliseconds);
    
17.         Console.WriteLine();
    
18.     }
    
19. 
    
20.     public static IDisposable Step(string message) {
    
21.         return new Profiler(message);
    
22.     }
    
23. 
    
24.     public static T Inline<T>(string message, Func<T> func) {
    
25.         using (new Profiler(message))
    
26.             return func();
    
27.     }
    
28. }

复制代码

总结

综上所述，我们可以使用 .NET 2.0 的 DynamicMethod，.NET 3.5 引入的 Expression Tree、.NET 4 新增的 dynamic 来替换反射调用，带来更好的性能。

希望本文对大家有所帮助，也希望整天忙于项目、疲于工作的朋友抽点时间学习下 .NET Framework 的一些“新”特性。