Question

我只是想知道在编译时是否使用？：运算符的简单静态函数。这是使用代码的任意示例。

    public static int Max(int value, int max)
    {
        return value > max ? max : value;
    }

其中给出了以下IL：

Max:
IL_0000:  nop         
IL_0001:  ldarg.0     
IL_0002:  ldarg.1     
IL_0003:  bgt.s       IL_0008
IL_0005:  ldarg.0     
IL_0006:  br.s        IL_0009
IL_0008:  ldarg.1     
IL_0009:  stloc.0     
IL_000A:  br.s        IL_000C
IL_000C:  ldloc.0     
IL_000D:  ret

或者更简单的替代方案是内联的吗？

        public static int Max(int value, int max)
        {
            if (value > max)
            {
                return max;
            }
            else
            {
                return value;
            }
        }

以下是IL：

Max:
IL_0000:  nop         
IL_0001:  ldarg.0     
IL_0002:  ldarg.1     
IL_0003:  cgt         
IL_0005:  stloc.0     
IL_0006:  ldloc.0     
IL_0007:  brfalse.s   IL_000E
IL_0009:  nop         
IL_000A:  ldarg.1     
IL_000B:  stloc.1     
IL_000C:  br.s        IL_0013
IL_000E:  nop         
IL_000F:  ldarg.0     
IL_0010:  stloc.1     
IL_0011:  br.s        IL_0013
IL_0013:  ldloc.1     
IL_0014:  ret

？：运算符显然比if选项生成更简洁的MSIL，但有人知道在JIT编译期间会发生什么吗？这两个都是内联的吗？它们中的任何一个都是内联的吗？

Answer 1

我们怎么能找到？我们来看看生成的代码。

这是一个测试程序：

internal static class Program
{
    public static int MaxA(int value, int max)
    {
        return value > max ? max : value;
    }

    public static int MaxB(int value, int max)
    {
        if (value > max)
            return max;
        else
            return value;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    private static int TestA(int a, int b)
    {
        return MaxA(a, b);
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    private static int TestB(int a, int b)
    {
        return MaxB(a, b);
    }

    private static void Main()
    {
        var rand = new Random();
        var a = rand.Next();
        var b = rand.Next();

        var result = TestA(a, b);
        Console.WriteLine(result);

        result = TestB(a, b);
        Console.WriteLine(result);
    }
}

首先，让我们直截了当。在 Release 版本中，MaxA的IL是（在Roslyn上）：

.method public hidebysig static 
    int32 MaxA (
        int32 'value',
        int32 max
    ) cil managed 
{
    // Method begins at RVA 0x2050
    // Code size 8 (0x8)
    .maxstack 8

    IL_0000: ldarg.0
    IL_0001: ldarg.1
    IL_0002: bgt.s IL_0006

    IL_0004: ldarg.0
    IL_0005: ret

    IL_0006: ldarg.1
    IL_0007: ret
} // end of method Program::MaxA

对于MaxB，它是：

.method public hidebysig static 
    int32 MaxB (
        int32 'value',
        int32 max
    ) cil managed 
{
    // Method begins at RVA 0x2059
    // Code size 8 (0x8)
    .maxstack 8

    IL_0000: ldarg.0
    IL_0001: ldarg.1
    IL_0002: ble.s IL_0006

    IL_0004: ldarg.1
    IL_0005: ret

    IL_0006: ldarg.0
    IL_0007: ret
} // end of method Program::MaxB

因此IL对于两个函数都是对称的（它是相同的代码，除了分支的排序以及分支指令被反转）。

现在，我们来看看TestA和TestB的x64代码是什么样的。

TestA，x64，RyuJIT：

            return MaxA(a, b);
00007FFED5F94530  cmp         ecx,edx  
00007FFED5F94532  jg          00007FFED5F94538  
00007FFED5F94534  mov         eax,ecx  
00007FFED5F94536  jmp         00007FFED5F9453A  
00007FFED5F94538  mov         eax,edx  
00007FFED5F9453A  ret

您可以看到MaxA函数已内联（没有call指令，如果更大的“分支指令，您可以清楚地看到jg ”跳转）。

TestB，x64：

return MaxB(a, b); 00007FFED5F94550 cmp ecx,edx 00007FFED5F94552 jle 00007FFED5F94558 00007FFED5F94554 mov eax,edx 00007FFED5F94556 jmp 00007FFED5F9455A 00007FFED5F94558 mov eax,ecx 00007FFED5F9455A ret

不出所料，我们得到了相同的结果。

为了强制，这里是x86上的MaxA：

return MaxA(a, b); 00A32E22 in al,dx 00A32E23 cmp ecx,edx 00A32E25 jg 00A32E2B 00A32E27 mov eax,ecx 00A32E29 jmp 00A32E2D 00A32E2B mov eax,edx 00A32E2D pop ebp 00A32E2E ret

也可以内联。

作为参考，您可以在断点时使用反汇编窗口（Debug - ＆gt; Windows - ＆gt; Disassembly）检查生成的汇编代码，但首先请确保取消选中抑制模块加载选项的JIT优化：

Answer 2

可以内联使用三元运算符的方法。一个<script .../>的方法。当然这一切都取决于方法中的其他操作。

检查它的一种简单方法是在方法中抛出异常并检查堆栈跟踪。如果方法是内联的，它将不会出现在堆栈跟踪中。

以下代码

if/else

.NET 4.6中的

64位（发布版本）抛出以下异常：

System.DivideByZeroException：尝试除以零。

在Test.Program.Main（String [] args）

堆栈跟踪中没有class Program { static void Main(string[] args) { try { int i = ThrowInTernaryOperator(1, 0); } catch (DivideByZeroException ex) { Console.WriteLine(ex.ToString()); } } public static int ThrowInTernaryOperator(int value, int max) { return value > max ? value / 0 : 0; } }，因此它是内联的。

在不同版本的.NET和32/64位体系结构中，行为可能会有所不同。

在JIT编译期间是否使用？：运算符内联的方法？

2 个答案: