Для чего используется ключевое слово yield в C#?

Итерация. Он создает конечный автомат «под покровом», который запоминает, где вы были в каждом дополнительном цикле функции, и продолжает с этого момента.

Это очень простой и легкий способ создать перечислимый объект для вашего объекта. Компилятор создает класс, который обертывает ваш метод и в данном случае реализует IEnumerable <object>. Без ключевого слова yield вам пришлось бы создать объект, реализующий IEnumerable <object>.

Он производит перечислимую последовательность. Фактически он создает локальную последовательность IEnumerable и возвращает ее как результат метода.

Интуитивно понятно, что ключевое слово возвращает значение из функции, не покидая его, т.е. в вашем примере кода оно возвращает текущее значение item, а затем возобновляет цикл. Более формально он используется компилятором для генерации кода для итератор. Итераторы - это функции, возвращающие объекты IEnumerable. MSDN имеет несколько статьи.

Ключевое слово yield на самом деле делает здесь довольно много.

Функция возвращает объект, реализующий интерфейс IEnumerable<object>. Если вызывающая функция запускает foreach для этого объекта, функция вызывается снова, пока она не «уступит». Это синтаксический сахар, введенный в C# 2.0. В более ранних версиях вам приходилось создавать собственные объекты IEnumerable и IEnumerator, чтобы делать подобные вещи.

Самый простой способ понять такой код - это ввести пример, установить несколько точек останова и посмотреть, что произойдет. Попробуйте выполнить этот пример:

public void Consumer()
{
    foreach(int i in Integers())
    {
        Console.WriteLine(i.ToString());
    }
}

public IEnumerable<int> Integers()
{
    yield return 1;
    yield return 2;
    yield return 4;
    yield return 8;
    yield return 16;
    yield return 16777216;
}

Когда вы пройдете по примеру, вы обнаружите, что первый вызов Integers() возвращает 1. Второй вызов возвращает 2, и строка yield return 1 больше не выполняется.

Вот пример из реальной жизни:

public IEnumerable<T> Read<T>(string sql, Func<IDataReader, T> make, params object[] parms)
{
    using (var connection = CreateConnection())
    {
        using (var command = CreateCommand(CommandType.Text, sql, connection, parms))
        {
            command.CommandTimeout = dataBaseSettings.ReadCommandTimeout;
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    yield return make(reader);
                }
            }
        }
    }
}

Недавно Раймонд Чен также опубликовал интересную серию статей о ключевом слове yield.

• Реализация итераторов на C# и ее последствия (часть 1)
• Реализация итераторов в C# и ее последствия (часть 2)
• Реализация итераторов на C# и ее последствия (часть 3)
• Реализация итераторов в C# и ее последствия (часть 4)

Хотя он номинально используется для простой реализации шаблона итератора, но может быть обобщен в конечный автомат. Нет смысла цитировать Раймонда, последняя часть также ссылается на другие применения (но пример в блоге Энтина особенно хорош, показывая, как писать безопасный асинхронный код).

Он пытается привнести немного Ruby Goodness :)
Концепция: Это пример кода Ruby, который распечатывает каждый элемент массива

 rubyArray = [1,2,3,4,5,6,7,8,9,10]
    rubyArray.each{|x| 
        puts x   # do whatever with x
    }

Реализация каждого метода массива дает передается вызывающей стороне («ставит x») с элементом каждый массива, аккуратно представленным как x. Затем вызывающий может делать с x все, что ему нужно.

Однако .Сеть здесь не идет полностью ... C#, похоже, объединил yield с IEnumerable, заставляя вас писать цикл foreach в вызывающей программе, как видно из ответа Мендельта. Немного менее элегантно.

//calling code
foreach(int i in obCustomClass.Each())
{
    Console.WriteLine(i.ToString());
}

// CustomClass implementation
private int[] data = {1,2,3,4,5,6,7,8,9,10};
public IEnumerable<int> Each()
{
   for(int iLooper=0; iLooper<data.Length; ++iLooper)
        yield return data[iLooper]; 
}

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

В JavaScript та же концепция называется генераторами.

У Yield есть два важных применения:

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

2. Это помогает выполнять итерацию с отслеживанием состояния.

Чтобы более наглядно объяснить два вышеупомянутых пункта, я создал простое видео, которое вы можете посмотреть здесь

yield return используется с перечислителями. При каждом вызове оператора yield управление возвращается вызывающей стороне, но это гарантирует, что состояние вызываемого сохраняется. Из-за этого, когда вызывающий элемент перечисляет следующий элемент, он продолжает выполнение в методе вызываемого объекта from сразу после оператора yield.

Попробуем разобраться в этом на примере. В этом примере для каждой строки я упомянул порядок выполнения.

static void Main(string[] args)
{
    foreach (int fib in Fibs(6))//1, 5
    {
        Console.WriteLine(fib + " ");//4, 10
    }            
}

static IEnumerable<int> Fibs(int fibCount)
{
    for (int i = 0, prevFib = 0, currFib = 1; i < fibCount; i++)//2
    {
        yield return prevFib;//3, 9
        int newFib = prevFib + currFib;//6
        prevFib = currFib;//7
        currFib = newFib;//8
    }
}

Кроме того, состояние сохраняется для каждого перечисления. Предположим, у меня есть еще один вызов метода Fibs(), тогда состояние для него будет сброшено.

На первый взгляд, возврат дохода - это сахар .СЕТЬ, чтобы вернуть IEnumerable.

Без yield создаются сразу все элементы коллекции:

class SomeData
{
    public SomeData() { }

    static public IEnumerable<SomeData> CreateSomeDatas()
    {
        return new List<SomeData> {
            new SomeData(), 
            new SomeData(), 
            new SomeData()
        };
    }
}

Тот же код с использованием yield, он возвращает элемент за элементом:

class SomeData
{
    public SomeData() { }

    static public IEnumerable<SomeData> CreateSomeDatas()
    {
        yield return new SomeData();
        yield return new SomeData();
        yield return new SomeData();
    }
}

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

Оператор yield позволяет создавать элементы по мере необходимости. Это хорошая причина использовать его.

Реализация списка или массива немедленно загружает все элементы, тогда как реализация yield предоставляет решение отложенного выполнения.

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

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

• Масштабируемость, надежность и предсказуемость, вероятно, улучшится, поскольку количество записей существенно не влияет на требования приложения к ресурсам.
• Производительность и отзывчивость, вероятно, улучшится, поскольку обработка может начаться немедленно, а не ждать, пока вся коллекция будет загружена первой.
• Возможность восстановления и утилизация, вероятно, улучшится, поскольку приложение может быть остановлено, запущено, прервано или завершится ошибкой. Только выполняемые элементы будут потеряны по сравнению с предварительной выборкой всех данных, когда фактически использовалась только часть результатов.
• Непрерывная обработка возможен в средах, где добавляются постоянные потоки рабочей нагрузки.

Вот сравнение между сборкой первой коллекции, такой как список, и использованием yield.

Пример списка

    public class ContactListStore : IStore<ContactModel>
    {
        public IEnumerable<ContactModel> GetEnumerator()
        {
            var contacts = new List<ContactModel>();
            Console.WriteLine("ContactListStore: Creating contact 1");
            contacts.Add(new ContactModel() { FirstName = "Bob", LastName = "Blue" });
            Console.WriteLine("ContactListStore: Creating contact 2");
            contacts.Add(new ContactModel() { FirstName = "Jim", LastName = "Green" });
            Console.WriteLine("ContactListStore: Creating contact 3");
            contacts.Add(new ContactModel() { FirstName = "Susan", LastName = "Orange" });
            return contacts;
        }
    }

    static void Main(string[] args)
    {
        var store = new ContactListStore();
        var contacts = store.GetEnumerator();

        Console.WriteLine("Ready to iterate through the collection.");
        Console.ReadLine();
    }

Консольный вывод
ContactListStore: Создание контакта 1
ContactListStore: Создание контакта 2
ContactListStore: Создание контакта 3
Готовы перебрать коллекцию.

Примечание: вся коллекция была загружена в память, даже не запрашивая ни одного элемента в списке.

Пример доходности

public class ContactYieldStore : IStore<ContactModel>
{
    public IEnumerable<ContactModel> GetEnumerator()
    {
        Console.WriteLine("ContactYieldStore: Creating contact 1");
        yield return new ContactModel() { FirstName = "Bob", LastName = "Blue" };
        Console.WriteLine("ContactYieldStore: Creating contact 2");
        yield return new ContactModel() { FirstName = "Jim", LastName = "Green" };
        Console.WriteLine("ContactYieldStore: Creating contact 3");
        yield return new ContactModel() { FirstName = "Susan", LastName = "Orange" };
    }
}

static void Main(string[] args)
{
    var store = new ContactYieldStore();
    var contacts = store.GetEnumerator();

    Console.WriteLine("Ready to iterate through the collection.");
    Console.ReadLine();
}

Консольный вывод
Готовы перебрать коллекцию.

Примечание: сборка вообще не выполнялась. Это связано с характером "отложенного выполнения" IEnumerable. Создание предмета будет происходить только тогда, когда это действительно необходимо.

Давайте снова вызовем коллекцию и изменим поведение при получении первого контакта в коллекции.

static void Main(string[] args)
{
    var store = new ContactYieldStore();
    var contacts = store.GetEnumerator();
    Console.WriteLine("Ready to iterate through the collection");
    Console.WriteLine("Hello {0}", contacts.First().FirstName);
    Console.ReadLine();
}

Консольный вывод
Готовы пройтись по коллекции
ContactYieldStore: Создание контакта 1
Привет Боб

Отлично! Только первый контакт был установлен, когда клиент «вытащил» предмет из коллекции.

У этого связь есть простой пример

Еще более простые примеры здесь

public static IEnumerable<int> testYieldb()
{
    for(int i=0;i<3;i++) yield return 4;
}

Обратите внимание, что метод yield return не возвращается из метода. Можно даже поставить WriteLine после yield return

Вышеупомянутое дает IEnumerable из 4 целых 4,4,4,4

Здесь с WriteLine. Добавит 4 в список, напечатает abc, затем добавит 4 в список, затем завершит метод и действительно вернется из метода (после завершения метода, как это произошло бы с процедурой без возврата). Но это будет иметь значение, список IEnumerable из int, который он возвращает по завершении.

public static IEnumerable<int> testYieldb()
{
    yield return 4;
    console.WriteLine("abc");
    yield return 4;
}

Также обратите внимание, что когда вы используете yield, то, что вы возвращаете, не того же типа, что и функция. Это тип элемента в списке IEnumerable.

Вы используете yield с типом возвращаемого значения метода IEnumerable. Если тип возвращаемого значения метода - int или List<int> и вы используете yield, он не будет компилироваться. Вы можете использовать возвращаемый тип метода IEnumerable без yield, но кажется, что вы не можете использовать yield без возвращаемого типа метода IEnumerable.

И чтобы заставить его выполнить, вы должны назвать его особым образом.

static void Main(string[] args)
{
    testA();
    Console.Write("try again. the above won't execute any of the function!\n");

    foreach (var x in testA()) { }


    Console.ReadLine();
}



// static List<int> testA()
static IEnumerable<int> testA()
{
    Console.WriteLine("asdfa");
    yield return 1;
    Console.WriteLine("asdf");
}

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

Подумайте об этом так: Вы идете к мясному прилавку и хотите купить фунт нарезанной ветчины. Мясник берет 10-фунтовую ветчину на спину, кладет ее на слайсер, нарезает целиком, затем приносит вам кучу ломтиков и отмеряет фунт. (СТАРЫЙ способ). С yield мясник подносит слайсер к прилавку и начинает нарезать и «сдавать» каждый ломтик на весы, пока он не достигнет 1 фунта, затем заворачивает его для вас, и все готово. Старый способ может быть лучше для мясника (позволяет ему организовать свое оборудование так, как ему нравится), но новый способ явно более эффективен в большинстве случаев для потребителя.

Ключевое слово yield позволяет вам создать IEnumerable<T> в форме на блок итератора. Этот блок итератора поддерживает отложенное исполнение, и если вы не знакомы с концепцией, он может показаться почти волшебным. Однако, в конце концов, это просто код, который выполняется без каких-либо странных уловок.

Блок итератора можно описать как синтаксический сахар, когда компилятор генерирует конечный автомат, который отслеживает, насколько далеко продвинулось перечисление перечисляемого. Чтобы перечислить перечислимое, вы часто используете цикл foreach. Однако петля foreach также является синтаксическим сахаром. Итак, вы - две абстракции, удаленные из реального кода, поэтому поначалу может быть трудно понять, как все это работает вместе.

Предположим, у вас есть очень простой блок итератора:

IEnumerable<int> IteratorBlock()
{
    Console.WriteLine("Begin");
    yield return 1;
    Console.WriteLine("After 1");
    yield return 2;
    Console.WriteLine("After 2");
    yield return 42;
    Console.WriteLine("End");
}

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

Для перечисления блока итератора используется цикл foreach:

foreach (var i in IteratorBlock())
    Console.WriteLine(i);

Вот результат (здесь никаких сюрпризов):

Begin
1
After 1
2
After 2
42
End

Как указано выше, foreach - это синтаксический сахар:

IEnumerator<int> enumerator = null;
try
{
    enumerator = IteratorBlock().GetEnumerator();
    while (enumerator.MoveNext())
    {
        var i = enumerator.Current;
        Console.WriteLine(i);
    }
}
finally
{
    enumerator?.Dispose();
}

Пытаясь распутать это, я создал диаграмму последовательности с удаленными абстракциями:

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

Каждый раз, когда вы вызываете свой блок итератора, создается новый экземпляр конечного автомата. Однако ни один из ваших кодов в блоке итератора не выполняется до первого выполнения enumerator.MoveNext(). Так работает отложенное выполнение. Вот (довольно глупый) пример:

var evenNumbers = IteratorBlock().Where(i => i%2 == 0);

На данный момент итератор не запущен. Предложение Where создает новый IEnumerable<T>, который является оболочкой для IEnumerable<T>, возвращаемого IteratorBlock, но это перечислимое число еще не было перечислено. Это происходит, когда вы выполняете цикл foreach:

foreach (var evenNumber in evenNumbers)
    Console.WriteLine(eventNumber);

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

Обратите внимание, что такие методы LINQ, как ToList(), ToArray(), First(), Count() и т. д., Будут использовать цикл foreach для перечисления перечисляемого. Например, ToList() перечислит все элементы перечисляемого и сохранит их в списке. Теперь вы можете получить доступ к списку, чтобы получить все элементы перечисляемого без повторного выполнения блока итератора. Существует компромисс между использованием ЦП для многократного создания элементов перечисления и памяти для хранения элементов перечисления для многократного доступа к ним при использовании таких методов, как ToList().

Если я правильно понимаю, вот как я бы сформулировал это с точки зрения функции, реализующей IEnumerable с yield.

• Вот один.
• Позвоните еще раз, если вам понадобится еще один.
• Я запомню то, что я тебе уже дал.
• Я узнаю, смогу ли я дать тебе еще один, когда ты снова позвонишь.

Одним из основных моментов ключевого слова Yield является Ленивое выполнение. Под ленивым исполнением я подразумеваю выполнение при необходимости. Лучше выразиться, приведя пример

Пример: без использования Yield, т.е. без ленивого выполнения.

public static IEnumerable<int> CreateCollectionWithList()
{
    var list =  new List<int>();
    list.Add(10);
    list.Add(0);
    list.Add(1);
    list.Add(2);
    list.Add(20);

    return list;
}

Пример: использование Yield, т.е. Lazy Execution.

public static IEnumerable<int> CreateCollectionWithYield()
{
    yield return 10;
    for (int i = 0; i < 3; i++) 
    {
        yield return i;
    }

    yield return 20;
}

Теперь, когда я вызываю оба метода.

var listItems = CreateCollectionWithList();
var yieldedItems = CreateCollectionWithYield();

вы заметите, что listItems будет содержать 5 элементов (наведите указатель мыши на listItems во время отладки). В то время как yieldItems будет иметь ссылку только на метод, а не на элементы. Это означает, что он не выполнил процесс получения элементов внутри метода. Очень эффективный способ получения данных только при необходимости. Фактическую реализацию yield можно увидеть в ORM, например Entity Framework, NHibernate и т. д.