c# - 为什么从 Expression> 创建的 Func<> 比直接声明的 Func<> 慢？

Question

为什么是Func<>从 Expression<Func<>> 创建通过 .Compile() 比仅使用 Func<> 慢得多直接声明？

我刚从使用 Func<IInterface, object> 更改为直接声明为从 Expression<Func<IInterface, object>> 创建的一个在我正在开发的应用程序中，我注意到性能下降了。

我刚刚做了一个小测试，Func<>从表达式创建的时间“几乎”是 Func<> 的两倍直接声明。

在我的机器上直接 Func<>大约需要 7.5 秒，Expression<Func<>>大约需要 12.6 秒。

这里是我使用的测试代码(运行Net 4.0)

// Direct
Func<int, Foo> test1 = x => new Foo(x * 2);

int counter1 = 0;

Stopwatch s1 = new Stopwatch();
s1.Start();
for (int i = 0; i < 300000000; i++)
{
 counter1 += test1(i).Value;
}
s1.Stop();
var result1 = s1.Elapsed;



// Expression . Compile()
Expression<Func<int, Foo>> expression = x => new Foo(x * 2);
Func<int, Foo> test2 = expression.Compile();

int counter2 = 0;

Stopwatch s2 = new Stopwatch();
s2.Start();
for (int i = 0; i < 300000000; i++)
{
 counter2 += test2(i).Value;
}
s2.Stop();
var result2 = s2.Elapsed;



public class Foo
{
 public Foo(int i)
 {
  Value = i;
 }
 public int Value { get; set; }
}

我怎样才能恢复性能？

我能做些什么来获得 Func<>从 Expression<Func<>> 创建像直接声明的那样执行？

Answer 1

正如其他人所提到的，调用动态委托(delegate)的开销导致您的速度变慢。在我的计算机上，当我的 CPU 频率为 3GHz 时，开销约为 12ns。解决这个问题的方法是从已编译的程序集中加载方法，如下所示:

var ab = AppDomain.CurrentDomain.DefineDynamicAssembly(
             new AssemblyName("assembly"), AssemblyBuilderAccess.Run);
var mod = ab.DefineDynamicModule("module");
var tb = mod.DefineType("type", TypeAttributes.Public);
var mb = tb.DefineMethod(
             "test3", MethodAttributes.Public | MethodAttributes.Static);
expression.CompileToMethod(mb);
var t = tb.CreateType();
var test3 = (Func<int, Foo>)Delegate.CreateDelegate(
                typeof(Func<int, Foo>), t.GetMethod("test3"));

int counter3 = 0;
Stopwatch s3 = new Stopwatch();
s3.Start();
for (int i = 0; i < 300000000; i++)
{
    counter3 += test3(i).Value;
}
s3.Stop();
var result3 = s3.Elapsed;

当我添加上面的代码时，result3 总是比 result1 高几分之一秒，开销大约为 1ns。

那么，当您可以拥有更快的委托(delegate)(test3)时，为什么还要费心使用已编译的 lambda(test2)呢？因为通常创建动态程序集的开销要大得多，而且每次调用只会节省 10-20 纳秒。