收益率工作模式

Question

当我有一个代码块时，

static void Main()
{

  foreach (int i in YieldDemo.SupplyIntegers())
  {
    Console.WriteLine("{0} is consumed by foreach iteration", i);
  }
}


 class YieldDemo
  {
    public static IEnumerable<int> SupplyIntegers()
     {
         yield return 1;
         yield return 2;
          yield return 3;
       }
   }

我可以将yield return背后的原理解释为

1. Main()调用SupplyIntegers()
2. |1| |2| |3|存储在连续的内存块中。“IEnumerator”的指针移动到 |1|
3. 控制从 SupplyInteger() 返回到 Main()。
4. Main() 打印值
5. Pointer Moves to |2|，依此类推。

说明：

(1) 通常我们会在函数内部允许有一个有效的 return 语句。 当存在多个yield return、yield return、...语句时，C# 会如何处理？

(2) 一旦遇到返回，控制就无法再次返回 SupplyIntegers()，如果允许，Yield 不会再次从 1 开始吗？我的意思是收益率1？

Answer 1

不——远非如此；我给你写一个长手写的版本……太蹩脚了！

---

请注意，如果您了解 foreach 实际上是有帮助的：

using(var iterator = YieldDemo.SupplyIntegers().GetEnumerator()) {
    int i;
    while(iterator.MoveNext()) {
        i = iterator.Current;
         Console.WriteLine("{0} is consumed by foreach iteration", i);
    }
}

---

using System;
using System.Collections;
using System.Collections.Generic;
static class Program
{
    static void Main()
    {

        foreach (int i in YieldDemo.SupplyIntegers())
        {
            Console.WriteLine("{0} is consumed by foreach iteration", i);
        }
    }
}

 class YieldDemo
  {

    public static IEnumerable<int> SupplyIntegers()
     {
         return new YieldEnumerable();
       }
    class YieldEnumerable : IEnumerable<int>
    {
        public IEnumerator<int> GetEnumerator()
        {
            return new YieldIterator();
        }
        IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); }
    }
    class YieldIterator : IEnumerator<int>
    {
        private int state = 0;
        private int value;
        public int Current { get { return value; } }
        object IEnumerator.Current { get { return Current; } }
        void IEnumerator.Reset() { throw new NotSupportedException(); }
        void IDisposable.Dispose() { }
        public bool MoveNext()
        {
            switch (state)
            {
                case 0: value = 1; state = 1;  return true;
                case 1: value = 2; state = 2;  return true;
                case 2: value = 3; state = 3; return true;
                default: return false;
            }
        }
    }
}

如您所见，它在迭代器中构建一个状态机，状态机通过 MoveNext 进行。我使用了带有 state 字段的模式，您可以看到这对于更复杂的迭代器是如何工作的。

重要的是：

• 如果你有一个finally块（包括using），迭代器块中的任何变量都会成为状态机上的字段
• ，它会进入 Dispose()
• 导致 yield return 的
• 部分代码变成 case （粗略地） yield break 变成 <代码>状态=-1； return false; （或类似）

C# 编译器执行此操作的方式非常复杂，但它使编写迭代器变得轻而易举。

Answer 2

它只是一个语法糖，.net 为您生成 IEnumerator 类并实现 MoveNext、Current 和 Reset 方法，然后生成 IEnumarable 类 GetEnumerator，其中返回 IEnumerator，您可以通过 .net Reflector 或 ildasm 看到这些魔术类。

另请参阅此处

Answer 3

简而言之，迭代器块（或者带有 yield 语句的方法，如果可以的话）被编译器转换为编译器生成的类。此类实现 IEnumerator 且 yield 语句转换为该类的“状态”。

例如，这：

yield return 1;
yield return 2;
yield return 3;

可能会转换成类似于：

switch (state)
{
    case 0: goto LABEL_A;
    case 1: goto LABEL_B;
    case 2: goto LABEL_C;
}
LABEL_A:
    return 1;
LABEL_B:
    return 2;
LABEL_C:
    return 3;

迭代器块可以被视为抽象状态机。此代码将由 IEnumerator 的方法调用。

Answer 4

简而言之，（当您等待 marc 的长手版本时）当编译器看到yield 语句时，它会在幕后为您构建一个自定义类的新实例，该实例实现一个名为 IEnumerator 的接口，该实例具有方法 Current() 和 MoveNext()，并跟踪您当前在迭代过程中的位置...在上面的示例中，它将还跟踪要枚举的列表中的值。