我已经实现了一个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循环？
答案 0 :(得分：7)
这是我编译的代码，这使得查看差异更容易：
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循环。
答案 1 :(得分：1)
当非优化时，foreach-loop内部由（最多）三个变量组成。
.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变量，因此，反编译器可以在两个循环之间产生差异。