我刚刚构建了动态方法 - 见下文(感谢其他 SO 用户)。看起来 Func 创建为动态方法，IL 注入(inject)比 lambda 慢 2 倍。

有人知道为什么吗？

(编辑:这是在 VS2010 中作为版本 x64 构建的。请从控制台而不是从 Visual Studio F5 内部运行它。)

class Program
{
    static void Main(string[] args)
    {
        var mul1 = IL_EmbedConst(5);
        var res = mul1(4);

        Console.WriteLine(res);

        var mul2 = EmbedConstFunc(5);
        res = mul2(4);

        Console.WriteLine(res);

        double d, acc = 0;

        Stopwatch sw = new Stopwatch();

        for (int k = 0; k < 10; k++)
        {
            long time1;

            sw.Restart();

            for (int i = 0; i < 10000000; i++)
            {
                d = mul2(i);
                acc += d;
            }

            sw.Stop();

            time1 = sw.ElapsedMilliseconds;

            sw.Restart();

            for (int i = 0; i < 10000000; i++)
            {
                d = mul1(i);
                acc += d;
            }

            sw.Stop();

            Console.WriteLine("{0,6} {1,6}", time1, sw.ElapsedMilliseconds);
        }

        Console.WriteLine("\n{0}...\n", acc);
        Console.ReadLine();
    }

    static Func<int, int> IL_EmbedConst(int b)
    {
        var method = new DynamicMethod("EmbedConst", typeof(int), new[] { typeof(int) } );

        var il = method.GetILGenerator();

        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Ldc_I4, b);
        il.Emit(OpCodes.Mul);
        il.Emit(OpCodes.Ret);

        return (Func<int, int>)method.CreateDelegate(typeof(Func<int, int>));
    }

    static Func<int, int> EmbedConstFunc(int b)
    {
        return a => a * b;
    }
}

这是输出(对于 i7 920)

20
20

25     51
25     51
24     51
24     51
24     51
25     51
25     51
25     51
24     51
24     51

4.9999995E+15...

============================================= =============================

编辑编辑编辑编辑

这里证明了 dhtorpe 是正确的——更复杂的 lambda 将失去其优势。 证明它的代码(这表明 Lambda 与 IL 注入(inject)具有完全相同的性能):

class Program
{
    static void Main(string[] args)
    {
        var mul1 = IL_EmbedConst(5);
        double res = mul1(4,6);

        Console.WriteLine(res);

        var mul2 = EmbedConstFunc(5);
        res = mul2(4,6);

        Console.WriteLine(res);

        double d, acc = 0;

        Stopwatch sw = new Stopwatch();

        for (int k = 0; k < 10; k++)
        {
            long time1;

            sw.Restart();

            for (int i = 0; i < 10000000; i++)
            {
                d = mul2(i, i+1);
                acc += d;
            }

            sw.Stop();

            time1 = sw.ElapsedMilliseconds;

            sw.Restart();

            for (int i = 0; i < 10000000; i++)
            {
                d = mul1(i, i + 1);
                acc += d;
            }

            sw.Stop();

            Console.WriteLine("{0,6} {1,6}", time1, sw.ElapsedMilliseconds);
        }

        Console.WriteLine("\n{0}...\n", acc);
        Console.ReadLine();
    }

    static Func<int, int, double> IL_EmbedConst(int b)
    {
        var method = new DynamicMethod("EmbedConstIL", typeof(double), new[] { typeof(int), typeof(int) });

        var log = typeof(Math).GetMethod("Log", new Type[] { typeof(double) });

        var il = method.GetILGenerator();

        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Ldc_I4, b);
        il.Emit(OpCodes.Mul);
        il.Emit(OpCodes.Conv_R8);

        il.Emit(OpCodes.Ldarg_1);
        il.Emit(OpCodes.Ldc_I4, b);
        il.Emit(OpCodes.Mul);
        il.Emit(OpCodes.Conv_R8);

        il.Emit(OpCodes.Call, log);

        il.Emit(OpCodes.Sub);

        il.Emit(OpCodes.Ret);

        return (Func<int, int, double>)method.CreateDelegate(typeof(Func<int, int, double>));
    }

    static Func<int, int, double> EmbedConstFunc(int b)
    {
        return (a, z) => a * b - Math.Log(z * b);
    }
} 

最佳答案

常数 5 是原因。 到底为什么会这样？原因:当 JIT 知道常量为 5 时，它不会发出 imul 指令，而是发出 lea [rax, rax * 4]。这是众所周知的汇编级优化。但是由于某种原因，这段代码执行得比较慢。优化是一种悲观。

C# 编译器发出一个闭包阻止 JIT 以这种特定方式优化代码。

证明:将常数更改为 56878567 并且性能发生变化。检查 JITed 代码时，您可以看到现在使用了 imul。

我通过像这样将常量 5 硬编码到 lambda 中来设法捕捉到这一点:

    static Func<int, int> EmbedConstFunc2(int b)
    {
        return a => a * 5;
    }

这让我可以检查 JITed x86。

旁注:.NET JIT 不会以任何方式内联委托(delegate)调用。之所以提及这一点，是因为评论中错误地推测情况就是如此。

Sidenode 2:为了获得完整的 JIT 优化级别，您需要在 Release模式下编译并在没有附加调试器的情况下启动。调试器会阻止执行优化，即使在 Release模式下也是如此。

旁注 3:尽管 EmbedConstFunc 包含一个闭包并且通常比动态生成的方法慢，但这种“lea”优化的效果造成更大的损害并最终变慢。

关于c# - 为什么 lambda 比 IL 注入(inject)动态方法快？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/11023993/