Есть ли причина не использовать yield return при возврате IEnumerable?

Блоки итераторов выполняют "живую" оценку каждый раз при повторении.

Иногда, однако, вы хотите, чтобы результаты были «моментальным снимком» в определенный момент времени. В этих случаях вы, вероятно, не захотите использовать yield return, а вместо этого вернете List<> или Set или какую-нибудь другую постоянную коллекцию.

Также нет необходимости использовать yield return, если вы имеете дело с объектами запроса напрямую. Это часто случается с запросами LINQ - лучше просто вернуть IEnumerable<> из запроса, а не выполнять итерацию и yield return анализ результатов самостоятельно. Например:

var result = from obj in someCollection
             where obj.Value < someValue
             select new { obj.Name, obj.Value };

foreach( var item in result )
   yield return item; // THIS IS UNNECESSARY....

// just return {result} instead...

Одна очевидная причина не использовать счетчик - это когда вам нужно IEnumerator<>.Reset() для работы.

Итераторы очень хороши, но они не могут избежать принципа «бесплатного обеда нет». Вы не найдете их используемых в коде коллекции .NET framework. Для этого есть веская причина, они не могут быть такими же эффективными, как специализированная реализация. Теперь, когда проектировщики .NET имели значение, они не могли предсказать, когда важна эффективность. Вы можете знать, находится ли ваш код на критическом пути вашей программы.

Итераторы чуть более чем в два раза медленнее, чем специализированная реализация. По крайней мере, это то, что я измерил, тестируя List<> итератор. Следите за микрооптимизациями, они по-прежнему очень быстрые, и их большое О остается таким же.

Я включу тестовый код, чтобы вы могли убедиться в этом сами:

using System;
using System.Collections.Generic;
using System.Diagnostics;

class Program {
    static void Main(string[] args) {
        var lst = new MyList<int>();
        for (int ix = 0; ix < 10000000; ++ix) lst.Add(ix);
        for (int test = 0; test < 20; ++test) {
            var sw1 = Stopwatch.StartNew();
            foreach (var item in lst) ;
            sw1.Stop();
            var sw2 = Stopwatch.StartNew();
            foreach (var item in lst.GetItems()) ;
            sw2.Stop();
            Console.WriteLine("{0} {1}", sw1.ElapsedMilliseconds, sw2.ElapsedMilliseconds);
        }
        Console.ReadLine();

    }
}

class MyList<T> : IList<T> {
    private List<T> lst = new List<T>();

    public IEnumerable<T> GetItems() {
        foreach (T item in lst)
            yield return item;
    }

    public int IndexOf(T item) { return lst.IndexOf(item); }
    public void Insert(int index, T item) { lst.Insert(index, item); }
    public void RemoveAt(int index) { lst.RemoveAt(index); }
    public T this[int index] {
        get { return lst[index]; }
        set { lst[index] = value; }
    }
    public void Add(T item) { lst.Add(item); }
    public void Clear() { lst.Clear(); }
    public bool Contains(T item) { return lst.Contains(item); }
    public void CopyTo(T[] array, int arrayIndex) { lst.CopyTo(array, arrayIndex); }
    public int Count { get { return lst.Count; } }
    public bool IsReadOnly { get { return ((IList<T>)lst).IsReadOnly; } }
    public bool Remove(T item) { return lst.Remove(item); }
    public IEnumerator<T> GetEnumerator() { return lst.GetEnumerator(); }
    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return GetEnumerator(); }
}

Странный вопрос. Если ваш метод возвращает IEnumerable, полученный откуда-то еще, очевидно, что он не будет использовать yield return. Если вашему методу необходимо собрать конкретную структуру данных, представляющую результаты, чтобы выполнить какие-либо манипуляции с ней перед возвратом, то я думаю, вы также не будете использовать yield return там.

Я так не думаю. Как предлагает @LBushkin, если вы собираетесь вернуть что-то целиком, вы вернете IList или что-то еще. Если вы возвращаете IEnumerable, люди ожидают отложенного выполнения, поэтому я думаю, вам всегда следует использовать yield в этом случае.

Не читая ответов, я скажу вам, что использование yield в службе WCF испортит ваше исключение FaultException!

Мне потребовалось некоторое время, чтобы выяснить, что виной всему урожай. Мне просто нужен был быстрый способ запустить некоторые ошибки. Правильный способ, конечно, - включить в ответ объект Error, но мне это нужно было быстро. Я сделал: выбросил новое исключение FaultException («Нет подписки с идентификатором:» + subscriptionId.ToString ());

Но использование yield, даже ниже фактического выброса, вызвало регулярное исключение, сеть