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

А что насчет этого?

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), я бы вернул его напрямую.

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

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

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

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

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

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

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

Верните список напрямую. Преимущества:

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

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

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

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

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

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

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);

Примечание: Я бы не стал делать это для каких-либо методов, работа которых может занять некоторое время.

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

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

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

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; }
}

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

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

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

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

Вот несколько примеров использования yield return:

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

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

В качестве концептуального примера для понимания того, когда вам следует использовать 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 yield & Consume
Produce consumable[1]                   // ConsumeLoop iterates, requesting next item
Consume consumable[1]                   // consume next
Produce consumable[2]
Consume consumable[2]                   // consume next
Produce consumable[3]
Consume consumable[3]                   // consume next

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

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

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

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

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

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

https://thewikihow.com/video_4fju3xcm21M

Это то, что Крис Селлс сообщает об этих операторах в Язык программирования C#;

I sometimes forget that yield return is not the same as return , in that the code after a yield return can be executed. For example, the code after the first return here can never be executed:

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

In contrast, the code after the first yield return here can be executed:

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

This often bites me in an if statement:

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

In these cases, remembering that yield return is not “final” like return is helpful.

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

    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 мсек без потребления памяти вообще.

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

урожай имеет два преимущества:

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

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