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

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-loop.

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

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

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

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

我想我做错了,因此使工具能够访问更多信息,从而正确地告诉我正在使用foreach循环.那么,为什么我使用IEnumerator.MoveNext看到foreach循环而不是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 - 再次,循环中的属性是stloc.1/ ldloc.1pair .Currentforeach

手工制作的IL

我从"不能分辨版本"中取出了IL,只是更改了.locals部分并添加stloc.1/ ldloc.1进入混音,宾果游戏 - Reflector认为它又是一个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循环.