I>>>Ажно 11 раз, и те в документации и тестах

public System.Collections.Generic.IEnumerable<T>
  GetNotNullEnumerator()
{
  if((First == null) || (Second == null))
  {
    yield break;
  }
  yield return Second;
  yield return First;
}

public class Pair<T> : IPair<T>, IEnumerable<T>
{
  // ...
  // The iterator is expanded into the following
  // code by the compiler.
  public virtual IEnumerator<T> GetEnumerator()
  {
    __ListEnumerator result = new __ListEnumerator(0);
    result._Pair = this;
    return result;
  }
  public virtual System.Collections.IEnumerator
    System.Collections.IEnumerable.GetEnumerator()
  {
    return new GetEnumerator();
  }
  private sealed class __ListEnumerator<T> : IEnumerator<T>
  {
    public __ListEnumerator(int itemCount)
    {
      _ItemCount = itemCount;
    }
    Pair<T> _Pair;
    T _Current;
    int _ItemCount;
    public object Current
    {
      get
      {
        return _Current;
      }
    }
    public bool MoveNext()
    {
      switch (_ItemCount)
      {
        case 0:
          _Current = _Pair.First;
          _ItemCount++;
          return true;
        case 1:
          _Current = _Pair.Second;
          _ItemCount++;
          return true;
        default:
          return false;
      }
    }
  }
}

Можно сказать, что каждый блок кода, между операторами yield return выполняется отложенно (lazily) только после очередного вызова метода MoveNext. Именно на этом основана ленивость библиотеки LINQ, которая построена в виде методов расширения интерфейсов IEnumerable и IEnumerable<T>.

I>А ты, упорный. Раз я с тобой не согласен, значит — против yield

I> Что значит "ленивое создание итераторов" ? Он и до введения yield создавался только по требованию, т.е. ленивым образом. А сам итератор и без тебя ленивый.

var results = items.Where(i => i % 10 == 0)
                   .Select(i => i + 5);

IEnumerable<int> LinqOptimizer(int [] input)
{
    var collector = new Nessos.LinqOptimizer.Core.ArrayCollector<int>();
    for (int counter = 0; counter < input.Length; counter++)
    {
        var i = input[counter];
        if (i % 10 == 0)
        {
            var result = i + 5;
            collector.Add(result);
        }
    }
    return collector;
}

IEnumerable<int> RoslynLinqRewriteWhereSelect_ProceduralLinq1(int[] _linqitems)
{
    if (_linqitems == null)
        throw new System.ArgumentNullException();
    for (int _index = 0; _index < _linqitems.Length; _index++)
    {
        var _linqitem = _linqitems[_index];
        if (_linqitem % 10 == 0)
        {
            var _linqitem1 = _linqitem + 5;
            yield return _linqitem1;
        }
    }
}

var counter = 0;
            foreach (var result in results)
            {
                counter += result;
            }

            return counter;

S>var results = items.Where(i => i % 10 == 0)
S>                   .Select(i => i + 5);
S>

while(true) {
  yield i++;
}

let state = initial();
let i = 0;

while(true) {
    i++;
    state = state.next(i);
    if(isGoodEnough(state, i)) {
           return {state, i};
        }
}

То есть можно работать с ODATA полностью на Linq

var result = (from Тестовый in context.Catalog_Тестовый

                          where Тестовый.Ref_Key == new Guid("aada18ad-5308-11e5-8e05-c86000c70663")

                          select Тестовый).SingleOrDefault();

GET /Catalog_Тестовый?
   $filter=Ref_Key eq aada18ad-5308-11e5-8e05-c86000c70663
   &$select=Тестовый
   &$top=1

const iterator = new CoolIterator(); // уп, нет того списка, который якобы надо создать :-) 
// вот здесь у нас отработал только конструктор итератора, и ничего больше. Никакого копирования данных, вообще ничего нет.

iterator.MoveNext() // вот здесь обработали первую порцию данных. Ровно одну, и ничего больше.

I>>А ты, упорный. Раз я с тобой не согласен, значит — против yield

public class CoolIterator : IEnumerator
{
    int i = 0;

    public CoolIterator()
    {
        _people = list;
    }

    public bool MoveNext()
    {
        i++;
        return true;
    }

    public void Reset()
    {
        i = 0;
    }

    object IEnumerator.Current
    {
        get
        {
            return Current;
        }
    }

    public Person Current
    {
        get
        {
           return i; 
        }
    }
}

I>> Что значит "ленивое создание итераторов" ? Он и до введения yield создавался только по требованию, т.е. ленивым образом. А сам итератор и без тебя ленивый.

S>>var results = items.Where(i => i % 10 == 0)
S>>                   .Select(i => i + 5);
S>>

I>Я не сильно понимаю эти результаты. Что такое удавы и какой код получил 3 удава? Самый быстрый это 3 или 5 ?

I>while(true) {
I>  yield i++;
I>}
I>

if (_linqitem % 10 == 0)
        {
            var _linqitem1 = _linqitem + 5;
            yield return _linqitem1;
        }

public int Iterative()
        {
            var counter = 0;
            foreach (var item in items)
            {
                if (item % 10 == 0)
                    counter += item;
            }

            return counter;
        }

IEnumerable<int> results = compiledWhereSelectQuery(items);
            var counter = 0;
            foreach (var result in results)
            {
                counter += result;
            }