为什么反编译的代码包含一个 foreach 循环？

Question

我已经实现了一个 foreach 循环和一个 while 循环，它们应该创建几乎相同的 IL 代码。

IL 代码（使用 C#5 的编译器版本 12.0.40629 生成）确实几乎相同（某些数字等自然例外），但反编译器能够重现初始代码。

允许反编译器判断前一个代码块是 foreach 循环而后一个代码块代表一个 while 循环的关键区别是什么？

我在下面提供的反编译代码是使用 ILSpy (2.3.1.1855) 的最新版本（截至今天）生成的，但我也使用了 JustDecompile、.NET Reflector 和 dotPeek — 没有区别。我没有配置任何东西，我只是安装了工具。

原码：

using System;
using System.Collections.Generic;

namespace ForeachVersusWhile
{
    public class Program
    {
        public static void Main(string[] args)
        {
            var x = new List<int> {1, 2};
            foreach (var item in x)
            {
                Console.WriteLine(item);
            }

            using (var enumerator = x.GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    Console.WriteLine(enumerator.Current);
                }
            }
        }
    }
}

反编译代码：

List<int> x = new List<int>
{
    1,
    2
};
foreach (int item in x)
{
    Console.WriteLine(item);
}
using (List<int>.Enumerator enumerator = x.GetEnumerator())
{
    while (enumerator.MoveNext())
    {
        Console.WriteLine(enumerator.Current);
    }
}

IL 代码（仅限循环）：

[...]
IL_0016: ldloc.0
IL_0017: callvirt instance valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<!0> class [mscorlib]System.Collections.Generic.List`1<int32>::GetEnumerator()
IL_001c: stloc.s CS$5$0000
.try
{
    IL_001e: br.s IL_002e
    // loop start (head: IL_002e)
        IL_0020: ldloca.s CS$5$0000
        IL_0022: call instance !0 valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32>::get_Current()
        IL_0027: stloc.1
        IL_0028: ldloc.1
        IL_0029: call void [mscorlib]System.Console::WriteLine(int32)

        IL_002e: ldloca.s CS$5$0000
        IL_0030: call instance bool valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32>::MoveNext()
        IL_0035: brtrue.s IL_0020
    // end loop

    IL_0037: leave.s IL_0047
} // end .try
finally
{
    IL_0039: ldloca.s CS$5$0000
    IL_003b: constrained. valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32>
    IL_0041: callvirt instance void [mscorlib]System.IDisposable::Dispose()
    IL_0046: endfinally
} // end handler

IL_0047: ldloc.0
IL_0048: callvirt instance valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<!0> class [mscorlib]System.Collections.Generic.List`1<int32>::GetEnumerator()
IL_004d: stloc.2
.try
{
    IL_004e: br.s IL_005c
    // loop start (head: IL_005c)
        IL_0050: ldloca.s enumerator
        IL_0052: call instance !0 valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32>::get_Current()
        IL_0057: call void [mscorlib]System.Console::WriteLine(int32)

        IL_005c: ldloca.s enumerator
        IL_005e: call instance bool valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32>::MoveNext()
        IL_0063: brtrue.s IL_0050
    // end loop

    IL_0065: leave.s IL_0075
} // end .try
finally
{
    IL_0067: ldloca.s enumerator
    IL_0069: constrained. valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32>
    IL_006f: callvirt instance void [mscorlib]System.IDisposable::Dispose()
    IL_0074: endfinally
} // end handler

---

问题的背景：

我读过一篇文章，他们查看了 C# 代码被编译成的内容。在第一步中，他们查看了一个简单的示例：foreach 循环。

在MSDN 的支持下，foreach 循环应该“隐藏枚举器的复杂性”。 IL 代码对 foreach 循环一无所知。所以，我的理解是，在底层，foreach 循环的 IL 代码等于使用 IEnumerator.MoveNext 的 while 循环。

因为 IL 代码不代表 foreach 循环，所以反编译器很难判断使用了 foreach 循环。这引发了几个问题，人们想知道为什么在反编译自己的代码时会看到一个while循环。这是example。

我自己想看看，写了一个带有foreach循环的小程序并编译了它。然后我使用反编译器查看代码的样子。我没想到会有一个 foreach 循环，但当我真正得到一个时，我感到很惊讶。

纯 IL 代码自然包含对 IEnumerator.MoveNext 等的调用。

我想我做错了什么，因此使工具能够访问更多信息，从而正确地告诉我正在使用 foreach 循环。那么，为什么我看到的是 foreach 循环而不是使用 IEnumerator.MoveNext 的 while 循环？

Answer 1

这是我编译的代码，这使得查看差异稍微容易一些：

using System;
using System.Collections.Generic;

class Test
{
    static void Main() {} // Just to make it simpler to compile

    public static void ForEach(List<int> x)
    {        
        foreach (var item in x)
        {
            Console.WriteLine(item);
        }
    }

    public static void While(List<int> x)
    {
        using (var enumerator = x.GetEnumerator())
        {
            while (enumerator.MoveNext())
            {
                Console.WriteLine(enumerator.Current);
            }
        }
    }
}

我正在使用 Roslyn，通过 VS2015 更新 1 - 版本 1.1.0.51109。

用 csc /o- /debug- Test.cs 编译

在这种情况下，Reflector 9.0.1.318 可以区分...我也可以。foreach 循环的本地变量是：

.locals init (valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32> V_0,
       int32 V_1)

但 while 循环的本地变量是：

.locals init (valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32> V_0,
       bool V_1)

在while 循环中，有一个stloc.1/ldloc.1 对，其结果为MoveNext()，但不是，结果为Current... 而在foreach 正好相反。

使用 csc /o+ /debug-Test.cs 编译

在这种情况下，Reflector 在这两种情况下都显示了while 循环，并且 IL 确实是相同的。在任一循环中都没有 stloc.1/ldloc.1 对。

你的 IL

查看 您的 编译产生的 IL - 再次，foreach 循环中的 Current 属性有 stloc.1/ldloc.1 对。

手工制作的 IL

我从“无法区分版本”中取出 IL，只是更改了 .locals 部分并添加了 stloc.1/ldloc.1 混合，宾果 - 反射器还以为是foreach 循环。

所以基本上，虽然我不了解其他反编译器，但似乎 Reflector 使用您对 Current 调用所做的操作作为信号。

验证

我将While 方法更改为：

public static void While(List<int> x)
{        
    using (var enumerator = x.GetEnumerator())
    {
        while (enumerator.MoveNext())
        {
            int item = enumerator.Current;
            Console.WriteLine(item);
        }
    }
}

现在即使使用csc /o- /debug+，Reflector 仍认为while 循环实际上是foreach 循环。

Answer 2

Jon Skeet 帮助我理解了其中的区别。他提到了关键点，但以“更详细的方式”，所以对于潜在的未来读者，我想用不同的词来表达。

未优化时，foreach 循环内部包含（最多）三个变量。

• 迭代所必需的枚举器，
• 一个布尔变量，用于判断 MoveNext 的调用是否返回 true 或 false，
• 和一个存储当前值的 int 变量。

.locals 初始化 (
    [0] int32,
    [1] 值类型 [mscorlib]System.Collections.Generic.List`1/Enumerator,
    [2] 布尔
)

_{请注意，bool 变量并非由所有编译器版本生成。代码可能只包含枚举器和 int 变量。}

相比之下，while 循环没有那个 int 变量。

.locals 初始化 (
    [0] 值类型 [mscorlib]System.Collections.Generic.List`1/Enumerator,
    [1] 布尔
)

反编译器使用这个额外的 int 变量来表示带有 foreach 循环的代码。这可以通过在 while 循环中添加该变量来验证，如 Jon Skeet 所示。

int item = enumerator.Current;

在反编译相应的 IL 代码时，反编译器会显示一个 foreach 循环，其中实际使用了一个 while 循环。

但是，int 和 bool 变量都不是必需的。在 IL 代码中，您可以看到两个值都从堆栈中拉出到变量中，然后立即再次压入堆栈。

stloc.1
ldloc.1

优化代码时，它们都可以被删除。因此，当两个变量都被删除并且 int 变量不存在时，反编译器会使用 while 循环来表示 IL。

话虽如此，并非所有编译器版本都会删除 int 变量。旧版本只删除了 bool 变量，因此，反编译器可以在两个循环之间产生差异。