为什么 Enumerator.MoveNext 在与 using 和 async-await 一起使用时无法正常工作？

Question

我想通过List<int> 枚举并调用异步方法。

如果我这样做：

public async Task NotWorking() {
  var list = new List<int> {1, 2, 3};

  using (var enumerator = list.GetEnumerator()) {
    Trace.WriteLine(enumerator.MoveNext());
    Trace.WriteLine(enumerator.Current);

    await Task.Delay(100);
  }
}

结果是：

True
0

但我希望它是：

True
1

如果我删除 using 或 await Task.Delay(100):

public void Working1() {
  var list = new List<int> {1, 2, 3};

  using (var enumerator = list.GetEnumerator()) {
    Trace.WriteLine(enumerator.MoveNext());
    Trace.WriteLine(enumerator.Current);
  }
}

public async Task Working2() {
  var list = new List<int> {1, 2, 3};

  var enumerator = list.GetEnumerator();
  Trace.WriteLine(enumerator.MoveNext());
  Trace.WriteLine(enumerator.Current);

  await Task.Delay(100);
}

输出如预期：

True
1

谁能向我解释这种行为？

Answer 1

这是这个问题的短板。接下来是更长的解释。

• List<T>.GetEnumerator() 返回一个结构体，一个值类型。
• 此结构是可变的 (always a recipe for disaster)
• 当存在using () {} 时，该结构存储在底层生成类的字段中以处理await 部分。
• 通过该字段调用.MoveNext() 时，会从底层对象加载字段值的副本，因此当代码读取.Current 时，就好像从未调用过MoveNext

正如 Marc 在 cmets 中提到的，既然您知道了问题所在，一个简单的“修复”就是重写代码以显式地装箱该结构，这将确保可变结构与此代码中各处使用的相同，而不是到处变异新的副本。

using (IEnumerator<int> enumerator = list.GetEnumerator()) {

---

那么，这里发生了什么真的。

方法的async / await 特性对方法有一些作用。具体来说，就是将整个方法提升到一个新生成的类上，变成一个状态机。

在你看到await 的任何地方，该方法都是“拆分”的，因此该方法必须像这样执行：

1. 调用初始部分，直到第一个等待
2. 下一部分必须由MoveNext 处理，有点像IEnumerator
3. 下一部分（如果有）以及所有后续部分都由这个MoveNext 部分处理

这个MoveNext方法是在这个类上生成的，来自原始方法的代码被放置在其中，零碎地适应方法中的各种序列点。

因此，该方法的任何本地变量都必须从一次调用此MoveNext 方法到下一次继续存在，并且它们作为私有字段被“提升”到此类。 p>

然后，示例中的类可以非常简单地被重写为如下内容：

public class <NotWorking>d__1
{
    private int <>1__state;
    // .. more things
    private List<int>.Enumerator enumerator;

    public void MoveNext()
    {
        switch (<>1__state)
        {
            case 0:
                var list = new List<int> {1, 2, 3};
                enumerator = list.GetEnumerator();
                <>1__state = 1;
                break;

            case 1:
                var dummy1 = enumerator;
                Trace.WriteLine(dummy1.MoveNext());
                var dummy2 = enumerator;
                Trace.WriteLine(dummy2.Current);
                <>1__state = 2;
                break;

此代码与正确代码相差甚远，但足够接近此目的。

这里的问题是第二种情况。由于某种原因，生成的代码将此字段作为副本读取，而不是作为对该字段的引用。因此，对 .MoveNext() 的调用是在此副本上完成的。原来的字段值保持原样，所以当读取.Current时，会返回原来的默认值，在本例中为0。

---

那么我们来看看这个方法生成的IL。我在LINQPad 中执行了原始方法（仅将Trace 更改为Debug），因为它能够转储生成的IL。

这里就不贴整个IL代码了，我们来看看枚举器的用法：

这里是var enumerator = list.GetEnumerator()：

IL_005E:  ldfld       UserQuery+<NotWorking>d__1.<list>5__2
IL_0063:  callvirt    System.Collections.Generic.List<System.Int32>.GetEnumerator
IL_0068:  stfld       UserQuery+<NotWorking>d__1.<enumerator>5__3

这是MoveNext的电话：

IL_007F:  ldarg.0     
IL_0080:  ldfld       UserQuery+<NotWorking>d__1.<enumerator>5__3
IL_0085:  stloc.3     // CS$0$0001
IL_0086:  ldloca.s    03 // CS$0$0001
IL_0088:  call        System.Collections.Generic.List<System.Int32>+Enumerator.MoveNext
IL_008D:  box         System.Boolean
IL_0092:  call        System.Diagnostics.Debug.WriteLine

ldfld 这里读取字段值并将值压入堆栈。然后这个副本被存储在.MoveNext()方法的一个局部变量中，然后这个局部变量通过调用.MoveNext()进行变异。

由于最终结果（现在在此局部变量中）被更新存储回字段中，因此字段保持原样。

---

这是一个不同的例子，它使问题“更清楚”，因为枚举器是一个结构，对我们来说有点隐藏：

async void Main()
{
    await NotWorking();
}

public async Task NotWorking()
{
    using (var evil = new EvilStruct())
    {
        await Task.Delay(100);
        evil.Mutate();
        Debug.WriteLine(evil.Value);
    }
}

public struct EvilStruct : IDisposable
{
    public int Value;
    public void Mutate()
    {
        Value++;
    }

    public void Dispose()
    {
    }
}

这也会输出0。

Answer 2

看起来像旧编译器中的一个错误，可能是由于在 using 和 async 中执行的代码转换的一些干扰造成的。

与 VS2015 一起提供的编译器似乎可以正确理解这一点。