Значение ключевого слова урожая добавляется?

Урожай позволяет Вам создавать методы, которые производят данные, не имея необходимость собирать все перед возвратом. Думайте о нем как возвращающий несколько значений по пути.

Вот несколько методов, которые иллюстрируют тезис

public IEnumerable<String> LinesFromFile(String fileName)
{
    using (StreamReader reader = new StreamReader(fileName))
    {
        String line;
        while ((line = reader.ReadLine()) != null)
            yield return line;
    }
}

public IEnumerable<String> LinesWithEmails(IEnumerable<String> lines)
{
    foreach (String line in lines)
    {
        if (line.Contains("@"))
            yield return line;
    }
}

Ни один из этих двух методов не считает целое содержание файла в память, все же можно использовать их как это:

foreach (String lineWithEmail in LinesWithEmails(LinesFromFile("test.txt")))
    Console.Out.WriteLine(lineWithEmail);

Можно использовать yield создавать любой итератор. Это могло быть лениво оцененным рядом (читающий строки из файла или базы данных, например, не читая все сразу, которое могло быть слишком много для содержания в памяти), или мог выполнять итерации по существующим данным, таким как a List<T>.

C# подробно имеет бесплатную главу (6) все о блоках итератора.

Я также вел блог совсем недавно об использовании yield для умных алгоритмов "в лоб".

Для примера ленивого средства чтения файлов:

    static IEnumerable<string> ReadLines(string path) {
        using (StreamReader reader = File.OpenText(path)) {
            string line;
            while ((line = reader.ReadLine()) != null) {
                yield return line;
            }
        }
    }

Это совершенно "лениво"; ничто не читается, пока Вы не начинаете перечислять, и только одна строка когда-либо сохранена в памяти.

Обратите внимание, что LINQ к объектам делает широкое применение блоков итератора (yield). Например, Where расширение по существу:

   static IEnumerable<T> Where<T>(this IEnumerable<T> data, Func<T, bool> predicate) {
        foreach (T item in data) {
            if (predicate(item)) yield return item;
        }
    }

И снова, полностью ленивый - разрешение Вас к цепочке вместе несколько операций, не вынуждая все быть загруженным в память.

Вы не можете всегда хотеть использовать урожай вместо того, чтобы возвратить список, и в Вашем примере Вы используете урожай для фактического возврата списка целых чисел. В зависимости от того, хотите ли Вы изменяемый список или неизменную последовательность, Вы могли бы использовать список или итератор (или некоторый другой набор muttable/immutable).

Но существуют преимущества для использования урожая.

• Урожай обеспечивает простой способ создать ленивые оцененные итераторы. (Значение только код для получения следующего элемента в последовательности выполнен, когда MoveNext () метод называют затем возвратами итератора, делающими больше вычислений, пока метод не называют снова),

• Урожай создает конечный автомат под покрытиями, и это сохраняет Вас, выделяют работы, не имея необходимость кодировать состояния Вашего универсального генератора => более краткий/простой код.

• Урожай автоматически создает оптимизированные и ориентированные на многопотоковое исполнение итераторы, экономя Вас детали о том, как создать их.

• Урожай намного более мощен, чем это кажется на первый взгляд и может использоваться для намного больше, чем просто создание простых итераторов, проверить это видео для наблюдения Jeffrey Richter и его AsyncEnumerator и как урожай используется, делают кодирование с помощью асинхронного легкого шаблона.

урожай позволяет Вам обрабатывать наборы, которые потенциально бесконечны в размере, потому что весь набор никогда не загружается в память сразу, в отличие от основанного на списке подхода. Например, IEnumerable <> всех простых чисел мог быть замедлен соответствующим алгоритмом для нахождения начал, тогда как подход Списка всегда будет конечным в размере и поэтому неполным. В этом примере, с помощью урожая также позволяет обрабатывать, чтобы следующий элемент был задержан, пока он не требуется.

Реальная ситуация для меня, когда я хочу обработать набор, который требует времени для заполнения более гладко.

Вообразите что-то вдоль строк (psuedo код):

public IEnumberable<VerboseUserInfo> GetAllUsers()
{
    foreach(UserId in userLookupList)
    {
        VerboseUserInfo info = new VerboseUserInfo();

        info.Load(ActiveDirectory.GetLotsOfUserData(UserId));
        info.Load(WebSerice.GetSomeMoreInfo(UserId));

        yield return info;
    }
}

Вместо того, чтобы иметь необходимость ожидать минута набора для заполнения, прежде чем я смогу начать обрабатывать объекты в нем. Я смогу запуститься сразу, и затем сообщить пользовательскому интерфейсу, как это происходит.

Вы могли бы хотеть выполнить итерации через различные наборы:

public IEnumerable<ICustomer> Customers()
{
        foreach( ICustomer customer in m_maleCustomers )
        {
            yield return customer;
        }

        foreach( ICustomer customer in m_femaleCustomers )
        {
            yield return customer;
        }

        // or add some constraints...
        foreach( ICustomer customer in m_customers )
        {
            if( customer.Age < 16 )
            {
                yield return customer;
            }
        }

        // Or....            
        if( Date.Today == 1 )
        {
            yield return m_superCustomer;
        }

}

Я соглашаюсь со всем, что все сказали здесь об отложенных вычислениях и использовании памяти и хотели добавить другой сценарий, где я нашел итераторы с помощью yield полезное ключевое слово. Я столкнулся с некоторыми случаями, где я должен сделать последовательность потенциально дорогой обработки на некоторых данных, где чрезвычайно полезно использовать итераторы. Вместо того, чтобы сразу обработать весь файл или прокрутить мой собственный конвейер обработки, я могу просто использовать итераторы что-то вроде этого:

IEnumerable<double> GetListFromFile(int idxItem)
{
    // read data from file
    return dataReadFromFile;
}

IEnumerable<double> ConvertUnits(IEnumerable<double> items)
{
    foreach(double item in items)
        yield return convertUnits(item);
}

IEnumerable<double> DoExpensiveProcessing(IEnumerable<double> items)
{
    foreach(double item in items)
        yield return expensiveProcessing(item);
}

IEnumerable<double> GetNextList()
{
    return DoExpensiveProcessing(ConvertUnits(GetListFromFile(curIdx++)));
}

Преимущество здесь состоит в том что путем хранения ввода и вывода ко всем функциям IEnumerable<double>, мой конвейер обработки абсолютно компонуем, легок читать, и ленивый оцененный, таким образом, я только должен сделать обработку, я действительно должен сделать. Это позволяет мне поместить почти всю свою обработку в потоке GUI, не влияя на скорость отклика, таким образом, я не должен волноваться ни о каких проблемах поточной обработки.

Я придумал это, чтобы преодолеть недостаток .net, когда нужно вручную копировать список.

Я использую это:

static public IEnumerable<SpotPlacement> CloneList(List<SpotPlacement> spotPlacements)
{
    foreach (SpotPlacement sp in spotPlacements)
    {
        yield return (SpotPlacement)sp.Clone();
    }
}

И в другое место:

public object Clone()
{
    OrderItem newOrderItem = new OrderItem();
    ...
    newOrderItem._exactPlacements.AddRange(SpotPlacement.CloneList(_exactPlacements));
    ...
    return newOrderItem;
}

Я попытался придумать один лайнер, который делает это, но это невозможно из-за того, что yield не работает внутри блоков анонимных методов.

РЕДАКТИРОВАТЬ:

Еще лучше использовать универсальный клонер списка:

class Utility<T> where T : ICloneable
{
    static public IEnumerable<T> CloneList(List<T> tl)
    {
        foreach (T t in tl)
        {
            yield return (T)t.Clone();
        }
    }
}

Используемый в yield метод экономии памяти за счет обработки элементов на лету хорош, но на самом деле это просто синтаксический сахар. Он существует уже давно. В любом языке, где есть указатели функций или интерфейсов (даже в Си и ассемблере), вы можете получить тот же эффект, используя функцию/интерфейс обратного вызова.

Эти модные штучки:

static IEnumerable<string> GetItems()
{
    yield return "apple";
    yield return "orange";
    yield return "pear";
}

foreach(string item in GetItems())
{
    Console.WriteLine(item);
}

по сути эквивалентны старомодным:

interface ItemProcessor
{
    void ProcessItem(string s);
};

class MyItemProcessor : ItemProcessor
{
    public void ProcessItem(string s)
    {
        Console.WriteLine(s);
    }
};

static void ProcessItems(ItemProcessor processor)
{
    processor.ProcessItem("apple");
    processor.ProcessItem("orange");
    processor.ProcessItem("pear");
}

ProcessItems(new MyItemProcessor());