работающая схема возврата урожая

Нет - далеко не так; Я напишу для вас длинную версию... она слишком безобразна!

Обратите внимание, что это также помогает, если вы понимаете, что 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 становится state = -1; return false; (или подобным)

Способ, которым компилятор C# делает это, очень сложен, но упрощает написание итераторов.

Это просто синтаксический сахар, .net генерирует для вас класс IEnumerator и реализует методы MoveNext, Current и Reset, а затем генерирует класс IEnumarable, GetEnumerator которого возвращает этот IEnumerator, вы можете увидеть эти магические классы с помощью отражателя .net или ildasm.

Также см. здесь

Проще говоря, блоки итераторов (или методы с операторами 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.

Короче говоря, (пока вы ждете полную версию от marc), когда компилятор видит операторы yield, за кулисами он создает для вас новый экземпляр пользовательского класса, который реализует интерфейс с именем IEnumerator, который имеет методы Current() и MoveNext(), и отслеживает, где вы сейчас находитесь в процессе итерации... В приведенном выше примере в качестве примера он также будет отслеживать значения в списке, которые будут перечислены.