为什么是 Func<>从 Expression<Func<>> 创建比 Func 慢直接声明? [英] Why is Func<> created from Expression<Func<>> slower than Func<> declared directly?

问题描述

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

Why is a Func<> created from an Expression<Func<>> via .Compile() considerably slower than just using a Func<> declared directly ?

我刚刚从使用直接声明的 Func 更改为在应用程序 i 中从 Expression> 创建的我正在努力，我注意到性能下降了.

I just changed from using a Func<IInterface, object> declared directly to one created from an Expression<Func<IInterface, object>> in an app i am working on and i noticed that the performance went down.

我刚刚做了一个小测试，从表达式创建的 Func<> 花费几乎"两倍于直接声明的 Func<> 时间.

I have just done a little test, and the Func<> created from an Expression takes "almost" double the time of an Func<> declared directly.

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

On my machine the Direct Func<> takes about 7.5 seconds and the Expression<Func<>> takes about 12.6 seconds.

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

Here is the test code I used (running 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; }
}

我怎样才能恢复性能?

我可以做些什么来让 Expression 创建的 Func<> 像直接声明的那样执行?p>

How can i get the performance back ?

Is there anything i can do to get the Func<> created from the Expression<Func<>> to perform like one declared directly ?

推荐答案

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

As others have mentioned, the overhead of calling a dynamic delegate is causing your slowdown. On my computer that overhead is about 12ns with my CPU at 3GHz. The way to get around that is to load the method from a compiled assembly, like this:

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.

When I add the above code, result3 is always just a fraction of a second higher than result1, for about a 1ns overhead.

既然可以拥有更快的委托 (test3)，为什么还要费心使用已编译的 lambda (test2)?因为通常创建动态程序集的开销要大得多，并且每次调用只为您节省 10-20ns.

So why even bother with a compiled lambda (test2) when you can have a faster delegate (test3)? Because creating the dynamic assembly is much more overhead in general, and only saves you 10-20ns on each invocation.

这篇关于为什么是 Func<>从 Expression<Func<>> 创建比 Func 慢直接声明?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！