关于Expression Tree和IL Emit的所谓的"性能差别"

昨天写了《三种属性操作性能比较》,有个网友写信问我一个问题:从性能上看,Expression Tree和IL Emit孰优孰劣?虽然我在回信中作了简单的回答,但不知道这个网友是否懂我的意思。反正今天呆在家里也没事儿,干脆再就这个话题再写一篇文章。

目录: 一、Expression Tree和IL Emit并不存在所谓的性能差异 二、属性赋值操作的两种写法 三、属性取值操作的两种写法 四、两种写法对应的IL

一、Expression Tree和IL Emit并不存在所谓的性能差异

Expression Tree和IL Emit的性能孰优孰劣,这本是个“不是问题的问题”。因为两者之间并不存在本质的区别,所以也谈不上性能的优劣问题。举个例子来说,我们知道.NET Framework 2.0,3.0和3.5使用的是相同的CLR。但是C# 3.0、3.5在2.0的基础上推出了很多语言层面的特性,比如自动实现属性:

   1: public class Foo
   2: {
   3:     public Bar Bar{get;set;}
   4:     public Foo()
   5:     {
   6:         this.Bar = new Bar();
   7:     }
   8: }

我们也可以按照下面“传统”的方式来写上面这段代码,谁都知道这两种写法在本质上是完全一样的。就上面的程序来说,在编译的时候C#编译器会将其转化成下一种形式,什么自动实现属性、匿名属性、扩展方法,都是浮云——语法糖而已。

   1: public class Foo
   2: {
   3:     private Bar _bar;
   4:     public Bar Bar
   5:     {
   6:         get{return _bar;}
   7:         set{_bar = value;}
   8:     }
   9:     public Foo()
  10:     {
  11:         _bar = new Bar();
  12:     }
  13: }

Expression Tree和IL Emit之间的关系与这些“语法糖”类似。编译后的Expression Tree就是IL代码;而IL Emit让我们可以用高级语言的编程方式来控制中间语言(IL)程序。由于最终的东西都是一样的,谈不上谁比谁好的问题。编译Expression Tree实现了向IL的转换,如果你通过IL Emit写的IL能够比Expression Tree自动转换的好,那么你的程序性能就好,否则性能就差。但是我们不能说Expression Tree和IL Emit在性能上孰优孰劣。

二、属性赋值操作的两种写法

我们说明Expression Tree和IL Emit之间不存在性能的差异,我们不妨写个例子。简单起见,我们还是采用前面谈到过的属性赋值和取值的操作为例。假设有如下一个接口IFoo,包含一个类型和名称均为Bar的可读写的属性。

   1: public interface IFoo
   2: {
   3:     Bar{get;set;}
   4: }
   5: public class Bar{}

现在我们通过Expression Tree和IL Emit两种方式编写一个静态方法对IFoo对象的Bar属性进行赋值。简单起见,我们甚至将静态方法的参数类型直接指定为IFoo和Bar,从而省去了类型转换操作。下面是通过Expression Tree进行属性赋值的方法:SetPropertyValueViaExpression。

   1: public static void SetPropertyValueViaExpression(IFoo foo, Bar bar)
   2: {
   3:     var property = typeof(IFoo).GetProperty("Bar");
   4:     var target = Expression.Parameter(typeof(IFoo));
   5:     var propertyValue = Expression.Parameter(typeof(Bar));
   6:     var setPropertyValue = Expression.Call(target, property.GetSetMethod(), propertyValue);
   7:     var setAction= Expression.Lambda<Action<IFoo, Bar>>(setPropertyValue, target, propertyValue).Compile();
   8:     setAction(foo, bar);
   9: }

而下面的SetPropertyValueViaEmit则通过IL Emit的方式完成了一样的工作:

   1: public static void SetPropertyValueViaEmit(IFoo foo, Bar bar)
   2: {
   3:     var property = typeof(IFoo).GetProperty("Bar");
   4:     DynamicMethod method = new DynamicMethod("SetValue", null, new Type[] { typeof(IFoo), typeof(Bar) });
   5:     ILGenerator ilGenerator = method.GetILGenerator();
   6:     ilGenerator.Emit(OpCodes.Ldarg_0);
   7:     ilGenerator.Emit(OpCodes.Ldarg_1);
   8:     ilGenerator.EmitCall(OpCodes.Callvirt, property.GetSetMethod(), null);
   9:     ilGenerator.Emit(OpCodes.Ret);
  10:  
  11:     method.DefineParameter(1, ParameterAttributes.In, "obj");
  12:     method.DefineParameter(2, ParameterAttributes.In, "value");
  13:     var setAction = (Action<IFoo, Bar>)method.CreateDelegate(typeof(Action<IFoo, Bar>));
  14:     setAction(foo, bar);
  15: }

三、属性取值操作的两种写法

接下来,我们来编写用于进行属性取值操作的方法。下面的SetPropertyValueViaExpression方法是基于Expression Tree的。

   1: public static Bar GetPropertyValueViaExpression(IFoo foo)
   2: {
   3:     var property = typeof(IFoo).GetProperty("Bar");
   4:     var target = Expression.Parameter(typeof(IFoo));
   5:     var getPropertyValue = Expression.Property(target, property);
   6:     var getFunc = Expression.Lambda<Func<IFoo, Bar>>(getPropertyValue, target).Compile();
   7:     return getFunc(foo);
   8: }

下面则是基于IL Emit的版本:

   1: public static Bar GetPropertyValueViaEmit(IFoo foo)
   2: {
   3:     var property = typeof(IFoo).GetProperty("Bar");
   4:     DynamicMethod method = new DynamicMethod("GetValue", typeof(Bar), new Type[] { typeof(IFoo) });
   5:  
   6:     ILGenerator ilGenerator = method.GetILGenerator();
   7:     ilGenerator.Emit(OpCodes.Ldarg_0);
   8:     ilGenerator.EmitCall(OpCodes.Callvirt, property.GetGetMethod(), null);
   9:     ilGenerator.Emit(OpCodes.Ret);
  10:  
  11:     method.DefineParameter(1, ParameterAttributes.In, "target");
  12:     var getFunc = (Func<IFoo, Bar>)method.CreateDelegate(typeof(Func<IFoo, Bar>));
  13:     return getFunc(foo);
  14: }

四、看看两种写法对应的IL

我们说过,经过编译的Expression Tree就是一段IL代码,而IL Emit则直接反映了IL的执行流程。要判断两者在性能方面孰优孰劣,我们只需要看看Expression Tree最终被转换成怎样的IL。我们现在的做法是动态生成一个程序集,将Expression Tree部分定义到一个方法之中。虽然IL Emit已经是真实底反映了底层的IL代码,但是为了我们的比较更加直观,我们也将IL Emit的部分也写入相应的方法。

为此我们在一个Console应用中的Main方法编写了如下的代码:动态创建了名称为Artech.EmitVsExpression的程序集,其中定义了同名的模块。一个唯一的类型Program定义其中,其中定义了四个静态方法:GetPropertyValueViaExpression、SetPropertyValueViaExpression、GetPropertyValueViaEmit和GetPropertyValueViaEmit。而方法体部分则是上面Expression Tree和IL Emit定义的内容。最后这个程序集被保存为一个同名的.dll文件。

   1: static void Main()
   2: {
   3:     var property        = typeof(IFoo).GetProperty("Bar");
   4:     var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName("Artech.EmitVsExpression"), AssemblyBuilderAccess.RunAndSave);
   5:     var moduleBuilder   = assemblyBuilder.DefineDynamicModule("Artech.EmitVsExpression", "Artech.EmitVsExpression.dll");
   6:     var typeBuilder     = moduleBuilder.DefineType("Program");
   7:  
   8:     //GetPropertyValueViaExpression
   9:     var methodBuilder       = typeBuilder.DefineMethod("GetPropertyValueViaExpression", MethodAttributes.Static | MethodAttributes.Public, typeof(Bar), new Type[] { typeof(IFoo) });
  10:     var target              = Expression.Parameter(typeof(IFoo));
  11:     var getPropertyValue    = Expression.Property(target, property);
  12:     Expression.Lambda<Func<IFoo, Bar>>(getPropertyValue, target).CompileToMethod(methodBuilder);
  13:  
  14:     //SetPropertyValueViaExpression
  15:     methodBuilder           = typeBuilder.DefineMethod("SetPropertyValueViaExpression", MethodAttributes.Static | MethodAttributes.Public, typeof(void), new Type[] { typeof(IFoo), typeof(Bar) });
  16:     target                  = Expression.Parameter(typeof(IFoo));
  17:     var propertyValue       = Expression.Parameter(typeof(Bar));
  18:     var setPropertyValue    = Expression.Call(target, property.GetSetMethod(), propertyValue);
  19:     Expression.Lambda<Action<IFoo, Bar>>(setPropertyValue, target, propertyValue).CompileToMethod(methodBuilder);
  20:  
  21:     //GetPropertyValueViaEmit
  22:     methodBuilder           = typeBuilder.DefineMethod("GetPropertyValueViaEmit", MethodAttributes.Static| MethodAttributes.Public, typeof(Bar), new Type[] { typeof(IFoo) });
  23:     ILGenerator ilGenerator = methodBuilder.GetILGenerator();
  24:     ilGenerator.Emit(OpCodes.Ldarg_0);
  25:     ilGenerator.EmitCall(OpCodes.Callvirt, property.GetGetMethod(), null);
  26:     ilGenerator.Emit(OpCodes.Ret);
  27:  
  28:     //SetPropertyValueViaEmit
  29:     methodBuilder   = typeBuilder.DefineMethod("SetPropertyValueViaEmit", MethodAttributes.Static | MethodAttributes.Public, typeof(void), new Type[] { typeof(IFoo), typeof(Bar) });
  30:     ilGenerator     = methodBuilder.GetILGenerator();
  31:     ilGenerator.Emit(OpCodes.Ldarg_0);
  32:     ilGenerator.Emit(OpCodes.Ldarg_1);
  33:     ilGenerator.EmitCall(OpCodes.Callvirt, property.GetSetMethod(), null);
  34:     ilGenerator.Emit(OpCodes.Ret);
  35:  
  36:     typeBuilder.CreateType();
  37:     assemblyBuilder.Save("Artech.EmitVsExpression.dll");
  38: }

现在我们通过IL Disassembler打开这个.dll文件,看看四个静态方法的IL代码。下面是用于用于获取属性值的GetPropertyValueViaExpression和GetPropertyValueViaEmit方法,我们可以看出它们具有完全一致的方式体。

   1: .method public static class [EmitVsExpressionTree]Bar 
   2:         GetPropertyValueViaExpression(class [EmitVsExpressionTree]IFoo A_0) cil managed
   3: {
   4:   // Code size       7 (0x7)
   5:   .maxstack  1
   6:   IL_0000:  ldarg.0
   7:   IL_0001:  callvirt   instance class [EmitVsExpressionTree]Bar [EmitVsExpressionTree]IFoo::get_Bar()
   8:   IL_0006:  ret
   9: } // end of method Program::GetPropertyValueViaExpression
  10:  
  11: .method public static class [EmitVsExpressionTree]Bar 
  12:         GetPropertyValueViaEmit(class [EmitVsExpressionTree]IFoo A_0) cil managed
  13: {
  14:   // Code size       7 (0x7)
  15:   .maxstack  1
  16:   IL_0000:  ldarg.0
  17:   IL_0001:  callvirt   instance class [EmitVsExpressionTree]Bar [EmitVsExpressionTree]IFoo::get_Bar()
  18:   IL_0006:  ret
  19: } // end of method Program::GetPropertyValueViaEmit

下面是用于对属性进行赋值的两个静态方法:SetPropertyValueViaExpression和SetPropertyValueViaEmit,毫无疑问它们之间也没有差异。到现在,你还在怀疑两种之间在性能上孰优孰劣吗?

   1: .method public static void  SetPropertyValueViaExpression(class [EmitVsExpressionTree]IFoo A_0,
   2:                                                           class [EmitVsExpressionTree]Bar A_1) cil managed
   3: {
   4:   // Code size       8 (0x8)
   5:   .maxstack  2
   6:   IL_0000:  ldarg.0
   7:   IL_0001:  ldarg.1
   8:   IL_0002:  callvirt   instance void [EmitVsExpressionTree]IFoo::set_Bar(class [EmitVsExpressionTree]Bar)
   9:   IL_0007:  ret
  10: } // end of method Program::SetPropertyValueViaExpression
  11:  
  12: .method public static void  SetPropertyValueViaEmit(class [EmitVsExpressionTree]IFoo A_0,
  13:                                                     class [EmitVsExpressionTree]Bar A_1) cil managed
  14: {
  15:   // Code size       8 (0x8)
  16:   .maxstack  2
  17:   IL_0000:  ldarg.0
  18:   IL_0001:  ldarg.1
  19:   IL_0002:  callvirt   instance void [EmitVsExpressionTree]IFoo::set_Bar(class [EmitVsExpressionTree]Bar)
  20:   IL_0007:  ret
  21: } // end of method Program::SetPropertyValueViaEmit

既然在IL上它们没有差别,那么它们就是两对等效的方法。如果你通过Reflector来打开我们生成的.dll,你会清晰地看到这真的是两对完全一致的方法。

   1: internal class Program
   2: {
   3:     // Methods
   4:     public static Bar GetPropertyValueViaEmit(IFoo foo1)
   5:     {
   6:         return foo1.Bar;
   7:     }
   8:  
   9:     public static Bar GetPropertyValueViaExpression(IFoo foo1)
  10:     {
  11:         return foo1.Bar;
  12:     }
  13:  
  14:     public static void SetPropertyValueViaEmit(IFoo foo1, Bar bar1)
  15:     {
  16:         foo1.Bar = bar1;
  17:     }
  18:  
  19:     public static void SetPropertyValueViaExpression(IFoo foo1, Bar bar1)
  20:     {
  21:         foo1.Bar = bar1;
  22:     }
  23: } 

晚绑定场景下对象属性赋值和取值可以不需要PropertyInfo 三种属性操作性能比较:PropertyInfo + Expression Tree + Delegate.CreateDelegate 关于Expression Tree和IL Emit的所谓的"性能差别"

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏一个会写诗的程序员的博客

《Kotlin极简教程》第五章 Kotlin面向对象编程(OOP)一个OOP版本的HelloWorld构造函数传参Data Class定义接口&实现之写pojo bean定一个Rectangle对象封

We frequently create a class to do nothing but hold data. In such a class some s...

2014
来自专栏数据之美

Python Tips, Tricks, and Hacks

一、快速技巧 1.1、4 种引号 '  '''  "  """  print """I wish that I'd never heard him say...

2705
来自专栏IT可乐

Java 枚举类 详解

1、枚举是什么?   Java中的枚举其实是一种语法糖,在 JDK 1.5之后出现,用来表示固定且有限个的对象。比如一个季节类有春、夏、秋、冬四个对象;一个星期...

2359
来自专栏小樱的经验随笔

洛谷 P1598 垂直柱状图【字符串+模拟】

P1598 垂直柱状图 题目描述 写一个程序从输入文件中去读取四行大写字母(全都是大写的,每行不超过72个字符),然后用柱状图输出每个字符在输入文件中出现的次数...

3105
来自专栏mySoul

设计模式 里氏替换原则

在场景中,三毛需要什么枪支,就直接new 出一个枪支即可,然后其内通过抽象类获取到对象,然后对齐进行修饰

1216
来自专栏wym

2013年多校赛 hdu4607

   那么就考虑树上最长距离,树的直径, 如果访问的点大于树的直径就要走回头路,答案即多的数乘2加上原来树的直径

1225
来自专栏强仔仔

Java基础系列之正则表达式

Java在处理一些复杂的字符串操作时,往往不是通过String中函数实现的,而是通过Java中正则表达式实现的。 下面通过一个具体的例子简单的介绍一下Java中...

1816
来自专栏数据结构与算法

3027 线段覆盖 2

3027 线段覆盖 2  时间限制: 1 s  空间限制: 128000 KB  题目等级 : 黄金 Gold 题解  查看运行结果 题目描述 Descript...

2896
来自专栏進无尽的文章

编码篇 - 正则表达式及其相关

有时我们需要在一大段长文本中过滤出我们需要的字段,或者检验该文本是否符合要求(该文本是否是邮箱,链接,电话号码或身份证),这时候就需要用到正则表达式了,当然我们...

1102
来自专栏小樱的经验随笔

Codeforces 842A Kirill And The Game【暴力,水】

A. Kirill And The Game time limit per test:2 seconds memory limit per test:256 m...

2877

扫码关注云+社区

领取腾讯云代金券