Правильное использование «доходности»


903

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

Из следующих двух частей кода, который является предпочтительным и почему?

Версия 1: Использование возврата доходности

public static IEnumerable<Product> GetAllProducts()
{
    using (AdventureWorksEntities db = new AdventureWorksEntities())
    {
        var products = from product in db.Product
                       select product;

        foreach (Product product in products)
        {
            yield return product;
        }
    }
}

Версия 2: вернуть список

public static IEnumerable<Product> GetAllProducts()
{
    using (AdventureWorksEntities db = new AdventureWorksEntities())
    {
        var products = from product in db.Product
                       select product;

        return products.ToList<Product>();
    }
}

38
yieldпривязан IEnumerable<T>и к своему виду. Это в некотором роде ленивая оценка
Jaider

Вот отличный ответ на аналогичный вопрос. stackoverflow.com/questions/15381708/…
Санджив Рай

1
Вот хороший пример использования: stackoverflow.com/questions/3392612/…
ValGe

6
Я вижу хороший случай для использования, yield returnесли код, который перебирает результаты, GetAllProducts()дает пользователю возможность преждевременно отменить обработку.
JMD

2
Я нашел эту тему действительно полезной: programmers.stackexchange.com/a/97350/148944
PiotrWolkowski

Ответы:


806

Я склонен использовать доходность при вычислении следующего элемента в списке (или даже следующей группы элементов).

Используя вашу версию 2, вы должны иметь полный список, прежде чем вернуться. Используя yield-return, вам действительно нужно иметь только следующий товар перед возвратом.

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

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

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


31
Я бы заметил, что в вашем примере в вопросе 3 объединены два преимущества. 1) Это распределяет вычислительные затраты (иногда выгода, иногда нет) 2) Это может лениво избегать вычислений бесконечно во многих случаях использования. Вы не упомянули о потенциальном недостатке, заключающемся в промежуточном состоянии. Если у вас есть значительное количество промежуточного состояния (скажем, HashSet для удаления дубликатов), то использование yield может привести к увеличению объема используемой памяти.
Кеннет Беленький

8
Кроме того, если каждый отдельный элемент очень большой, но к ним нужно обращаться только последовательно, доходность лучше.
Кеннет Беленький

2
И наконец ... есть немного странный, но иногда эффективный метод использования yield для написания асинхронного кода в очень сериализованной форме.
Кеннет Беленький

12
Другой пример, который может быть интересным, - это чтение довольно больших файлов CSV. Вы хотите прочитать каждый элемент, но вы также хотите извлечь свою зависимость. Выход возврата IEnumerable <> позволит вам возвращать каждую строку и обрабатывать каждую строку в отдельности. Нет необходимости читать 10 Мб файл в память. Всего одна строка за раз.
Максим Роуиллер

1
Yield returnКажется, это сокращение для написания вашего собственного класса итератора (реализовать IEnumerator). Следовательно, упомянутые преимущества также применимы к пользовательским классам итераторов. Во всяком случае, обе конструкции сохраняют промежуточное состояние. В его самой простой форме речь идет об удержании ссылки на текущий объект.
J. Ouwehand

641

Заполнение временного списка похоже на загрузку всего видео, а использование yield- на потоковое видео.


180
Я прекрасно понимаю, что этот ответ не является техническим ответом, но я считаю, что сходство между yield и потоковым видео служит хорошим примером при понимании ключевого слова yield. По этому поводу уже сказано все техническое, поэтому я попытался объяснить «другими словами». Существует ли правило сообщества, которое гласит, что вы не можете объяснить свои идеи нетехническими терминами?
Анар Халилов

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

22
Все еще понимая концепцию, это помогло привести ее к дальнейшему вниманию, хорошая аналогия.
Тони

11
Мне нравится этот ответ, но он не отвечает на вопрос.
Ноябрь

73

В качестве концептуального примера для понимания того, когда следует использовать yield, скажем, метод ConsumeLoop()обрабатывает элементы, возвращаемые / получаемые с помощью ProduceList():

void ConsumeLoop() {
    foreach (Consumable item in ProduceList())        // might have to wait here
        item.Consume();
}

IEnumerable<Consumable> ProduceList() {
    while (KeepProducing())
        yield return ProduceExpensiveConsumable();    // expensive
}

Без yieldэтого вызов ProduceList()может занять много времени, потому что вы должны заполнить список перед возвратом:

//pseudo-assembly
Produce consumable[0]                   // expensive operation, e.g. disk I/O
Produce consumable[1]                   // waiting...
Produce consumable[2]                   // waiting...
Produce consumable[3]                   // completed the consumable list
Consume consumable[0]                   // start consuming
Consume consumable[1]
Consume consumable[2]
Consume consumable[3]

Используя yield, он становится переставленным, работает как бы «параллельно»:

//pseudo-assembly
Produce consumable[0]
Consume consumable[0]                   // immediately Consume
Produce consumable[1]
Consume consumable[1]                   // consume next
Produce consumable[2]
Consume consumable[2]                   // consume next
Produce consumable[3]
Consume consumable[3]                   // consume next

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


30

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

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

Использование ключевого слова yield (наряду с реализацией сопрограмм Caliburn.Micro Роба Айзенбурга ) позволяет мне выразить асинхронный вызов веб-службы следующим образом:

public IEnumerable<IResult> HandleButtonClick() {
    yield return Show.Busy();

    var loginCall = new LoginResult(wsClient, Username, Password);
    yield return loginCall;
    this.IsLoggedIn = loginCall.Success;

    yield return Show.NotBusy();
}

Для этого нужно включить мой BusyIndicator, вызвать метод Login в моей веб-службе, установить для моего флага IsLoggedIn возвращаемое значение, а затем снова отключить BusyIndicator.

Вот как это работает: IResult имеет метод Execute и событие Completed. Caliburn.Micro извлекает IEnumerator из вызова HandleButtonClick () и передает его в метод Coroutine.BeginExecute. Метод BeginExecute начинает перебирать IResults. Когда возвращается первый IResult, выполнение приостанавливается внутри HandleButtonClick (), и BeginExecute () присоединяет обработчик события к событию Completed и вызывает Execute (). IResult.Execute () может выполнять либо синхронную, либо асинхронную задачу и запускает событие Completed, когда оно выполнено.

LoginResult выглядит примерно так:

public LoginResult : IResult {
    // Constructor to set private members...

    public void Execute(ActionExecutionContext context) {
        wsClient.LoginCompleted += (sender, e) => {
            this.Success = e.Result;
            Completed(this, new ResultCompletionEventArgs());
        };
        wsClient.Login(username, password);
    }

    public event EventHandler<ResultCompletionEventArgs> Completed = delegate { };
    public bool Success { get; private set; }
}

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

Надеюсь, это поможет кому-то! Я действительно любил исследовать различные способы, которыми можно использовать урожай.


1
Ваш пример кода является отличным примером того, как использовать yield OUTSIDE для блока for или foreach. Большинство примеров показывают доходность внутри итератора. Очень полезно, так как я только собирался задать вопрос о SO Как использовать yield вне итератора!
Shelbypereira

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

27

Это может показаться странным предложением, но я узнал, как использовать yieldключевое слово в C #, прочитав презентацию о генераторах в Python: http://www.dabeaz.com/generators/Generators.pdf Дэвида М. Бизли . Вам не нужно много знать Python, чтобы понять презентацию - я не знал. Мне было очень полезно объяснить не только, как работают генераторы, но и почему вы должны заботиться.


1
Презентация предоставляет простой обзор. Детали того, как это работает в C #, обсуждаются Рэем Ченом в ссылках на stackoverflow.com/a/39507/939250 . Первая ссылка подробно объясняет, что есть второй, неявный возврат в конце методов возврата доходности.
Донал Лафферти

18

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

    static IEnumerable<Trip> CreatePossibleTrips()
    {
        for (int i = 0; i < 1000000; i++)
        {
            yield return new Trip
            {
                Id = i.ToString(),
                Driver = new Driver { Id = i.ToString() }
            };
        }
    }

Затем повторяйте каждую поездку:

    static void Main(string[] args)
    {
        foreach (var trip in CreatePossibleTrips())
        {
            // possible trip is actually calculated only at this point, because of yield
            if (IsTripGood(trip))
            {
                // match good trip
            }
        }
    }

Если вы используете List вместо yield, вам понадобится выделить 1 миллион объектов в память (~ 190 МБ), и для этого простого примера потребуется ~ 1400 мс. Однако, если вы используете yield, вам не нужно помещать все эти временные объекты в память, и вы получите значительно более высокую скорость алгоритма: этот пример займет всего ~ 400 мс для запуска без использования памяти вообще.


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

1
@rolls yieldработает под прикрытием, внедряя конечный автомат внутри. Вот SO ответ с 3 подробными сообщениями в блоге MSDN, которые объясняют реализацию очень подробно. Автор Раймонд Чен @ MSFT
Шива

13

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

Там нет правильного или неправильного ответа на этот. Какой из них предпочтительнее, зависит только от ситуации. Например, если у вас есть ограничение по времени для выполнения запроса, и вам нужно сделать что-то сложное с результатами, вторая версия может быть предпочтительнее. Но остерегайтесь больших наборов результатов, особенно если вы запускаете этот код в 32-битном режиме. Я был укушен исключениями OutOfMemory несколько раз при выполнении этого метода.

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


11

У выхода есть два отличных применения

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

Это помогает делать итерацию с учетом состояния. (потоковое)

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

http://www.youtube.com/watch?v=4fju3xcm21M


10

Вот что говорит Крис Селлс об этих утверждениях на языке программирования C # ;

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

    int F() {
return 1;
return 2; // Can never be executed
}

Напротив, код после первого возврата может быть выполнен:

IEnumerable<int> F() {
yield return 1;
yield return 2; // Can be executed
}

Это часто кусает меня в утверждении if:

IEnumerable<int> F() {
if(...) { yield return 1; } // I mean this to be the only
// thing returned
yield return 2; // Oops!
}

В этих случаях полезно помнить, что возврат доходности не является «окончательным», как возврат.


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

@JohnoCrawford второй оператор yield будет выполняться, только если перечислено второе / следующее значение IEnumerable. Вполне возможно, что он не будет, например F().Any()- он вернется после попытки перечислить только первый результат. В общем, вы не должны полагаться на IEnumerable yieldизменение состояния программы, потому что оно может фактически не
Зак

8

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

Второй пример - преобразование перечислителя / итератора в список с помощью метода ToList (). Это означает, что он вручную перебирает все элементы в перечислителе, а затем возвращает плоский список.


8

Это своего рода помимо сути, но так как вопрос помечен как лучшие практики, я добавлю два своих цента. Для такого типа вещей я предпочитаю превратить его в свойство:

public static IEnumerable<Product> AllProducts
{
    get {
        using (AdventureWorksEntities db = new AdventureWorksEntities()) {
            var products = from product in db.Product
                           select product;

            return products;
        }
    }
}

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

prices = Whatever.AllProducts.Select (product => product.price);

против

prices = Whatever.GetAllProducts().Select (product => product.price);

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


7

И что по этому поводу?

public static IEnumerable<Product> GetAllProducts()
{
    using (AdventureWorksEntities db = new AdventureWorksEntities())
    {
        var products = from product in db.Product
                       select product;

        return products.ToList();
    }
}

Я думаю, это намного чище. У меня нет VS2008 под рукой, чтобы проверить, хотя. В любом случае, если Products реализует IEnumerable (как кажется - он используется в операторе foreach), я бы вернул его напрямую.


2
Пожалуйста, измените OP, чтобы включить больше информации вместо публикации ответов.
Брайан Расмуссен

Ну, вы должны сказать мне, что ОП означает именно :-) Спасибо
Петр К.

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

5

Я бы использовал версию 2 кода в этом случае. Поскольку у вас есть полный список доступных продуктов, и это то, что ожидает «потребитель» этого вызова метода, потребуется отправить полную информацию обратно вызывающей стороне.

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

Некоторые примеры, где можно использовать возвращение доходности:

  1. Сложный пошаговый расчет, при котором вызывающий одновременно ожидает данные шага
  2. Пейджинг в графическом интерфейсе - когда пользователь может никогда не дойти до последней страницы, и на текущей странице необходимо раскрыть только часть информации

Чтобы ответить на ваши вопросы, я бы использовал версию 2.


3

Верните список напрямую. Льготы:

  • Это более понятно
  • Список можно использовать повторно. (итератор не) на самом деле не правда, спасибо Джон

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


Не забывайте, что он возвращается в IEnumerable <T>, а не в IEnumerator <T> - вы можете снова вызвать GetEnumerator.
Джон Скит

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

1

Ключевая фраза yield return используется для поддержки конечного автомата для конкретной коллекции. В тех случаях, когда CLR видит используемую ключевую фразу yield return, CLR реализует шаблон Enumerator для этого фрагмента кода. Этот тип реализации помогает разработчику из всех типов сантехники, которые в противном случае пришлось бы делать в отсутствие ключевого слова.

Предположим, что разработчик фильтрует некоторую коллекцию, выполняет итерацию по коллекции и затем извлекает эти объекты в какую-то новую коллекцию. Этот вид сантехники довольно однообразен.

Подробнее о ключевом слове здесь в этой статье .


-4

Использование yield аналогично ключевому слову return , за исключением того, что оно возвращает генератор . И объект генератора будет проходить только один раз .

У выхода есть два преимущества:

  1. Вам не нужно читать эти значения дважды;
  2. Вы можете получить много дочерних узлов, но не обязательно помещать их все в память.

Есть еще одно четкое объяснение, может быть, вам поможет.

Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.