Question

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

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

允许反编译器告诉前一个代码块是一个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-loop。

由MSDN备份，foreach循环应该“隐藏枚举器的复杂性”。 IL代码不知道foreach循环的任何内容。所以，我的理解是，在引擎盖下，foreach循环的IL代码等于使用IEnumerator.MoveNext的while循环。

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

我想看到自己并用foreach循环编写了一个小程序并编译它。然后我使用Decompiler来查看代码的样子。我并没有期待一个foreach循环，但是当我真的有一个时，我感到很惊讶。

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

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

Answer 1

这是我编译的代码，这使得查看差异更容易：

client = pysvn.Client()
client.callback_get_login
with open("extracted_log_history",'wb') as log_file:
    wr = csv.writer(log_file)
    for commit in client.log("url"):
        rev = commit.revision.number
        auth = commit.author
        t = time.ctime(commit.date)
        mess = commit.message
        row = [rev, auth, t, mess]
        wr.writerow(row)

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

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

在这种情况下，Reflector 9.0.1.318可以区分......我也可以。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); } } } }循环的本地人是：

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，但不，结果为{ {1}} ...而在MoveNext()中却反过来了。

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

在这种情况下，Reflector在两种情况下都显示Current循环，并且IL 相同。在任何一个循环中都没有foreach / while对。

你的IL

查看编译的IL已经提出 - 再次，stloc.1 / ldloc.1对stloc.1属性ldloc.1 / Current对1}}循环。

手工制作IL

我从“无法区分版本”中获取了IL，只是更改了foreach部分，并将.locals / stloc.1添加到了mix和宾果游戏 - Reflector认为它再次成为ldloc.1循环。

所以基本上，虽然我不了解其他反编译器，但看起来Reflector使用你对foreach调用所做的信号作为信号。

<强>验证

我将Current方法更改为：

While

现在即使使用public static void While(List<int> x) { using (var enumerator = x.GetEnumerator()) { while (enumerator.MoveNext()) { int item = enumerator.Current; Console.WriteLine(item); } } }，Reflector也认为csc /o- /debug+循环实际上是while循环。

Answer 2

Jon Skeet帮助我理解了差异。他提到了关键点，但是采用了更为详尽的方式，所以对于潜在的未来读者，我想用不同的词语来表达。

当非优化时，foreach-loop内部由（最多）三个变量组成。

枚举器，是迭代所必需的，

一个bool变量，用于判断MoveNext的调用是返回true还是false，

和存储当前值的int变量。

.locals init ( [0] int32, [1] valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator, [2] bool )

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

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

.locals init ( [0] valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator, [1] bool )

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

stloc.1 ldloc.1

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

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

{{1}}

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

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

为什么反编译代码包含foreach-loop？

2 个答案: