Uso adequado do 'retorno do rendimento'

A palavra-chave yield é uma daquelas palavras-chave em C # que continuam me intrigando, e nunca tive certeza de que estou usando-a corretamente.

Dos dois pedaços de código a seguir, qual é o preferido e por quê?

Versão 1: Usando retorno de rendimento

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

Versão 2: retornar a lista

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

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

Costumo usar o retorno do rendimento quando calculo o próximo item da lista (ou mesmo o próximo grupo de itens).

Usando sua versão 2, você deve ter a lista completa antes de retornar. Ao usar o retorno do rendimento, você realmente só precisa do próximo item antes de retornar.

Entre outras coisas, isso ajuda a espalhar o custo computacional de cálculos complexos por um período maior. Por exemplo, se a lista estiver conectada a uma GUI e o usuário nunca for para a última página, você nunca calculará os itens finais na lista.

Outro caso em que o retorno do rendimento é preferível é se o IEnumerable representa um conjunto infinito. Considere a lista de números primos ou uma lista infinita de números aleatórios. Você nunca pode retornar o IEnumerable completo de uma só vez, portanto, use yield-return para retornar a lista incrementalmente.

No seu exemplo específico, você tem a lista completa de produtos, portanto, eu usaria a Versão 2.

Preencher uma lista temporária é como baixar o vídeo inteiro, enquanto usar yieldé como transmitir esse vídeo.

Como um exemplo conceitual para entender quando você deve usar yield, digamos que o método ConsumeLoop()processe os itens retornados / produzidos por ProduceList():

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

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

Sem yield, a chamada para ProduceList()pode demorar muito, pois você precisa concluir a lista antes de retornar:

//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]

Usando yield, torna-se reorganizado, meio que trabalhando "em paralelo":

//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

E, finalmente, como muitos já sugeriram, você deve usar a versão 2, porque você já tem a lista completa de qualquer maneira.

Sei que essa é uma pergunta antiga, mas gostaria de oferecer um exemplo de como a palavra-chave yield pode ser usada de forma criativa. Eu realmente me beneficiei dessa técnica. Espero que isso ajude qualquer pessoa que tropeça nessa questão.

Nota: Não pense na palavra-chave yield como sendo apenas outra maneira de criar uma coleção. Uma grande parte do poder do rendimento vem do fato de a execução ser pausada em seu método ou propriedade até que o código de chamada itere sobre o próximo valor. Aqui está o meu exemplo:

O uso da palavra-chave yield (ao lado da implementação Caliburn.Micro coroutines de Rob Eisenburg ) permite expressar uma chamada assíncrona para um serviço da Web como este:

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

O que isso fará é ativar meu BusyIndicator, chamar o método Login no meu serviço da web, definir meu sinalizador IsLoggedIn com o valor de retorno e desativar o BusyIndicator.

Eis como isso funciona: IResult possui um método Execute e um evento Completed. Caliburn.Micro pega o IEnumerator da chamada para HandleButtonClick () e o passa para um método Coroutine.BeginExecute. O método BeginExecute começa a iterar pelos IResults. Quando o primeiro IResult é retornado, a execução é pausada dentro de HandleButtonClick () e BeginExecute () anexa um manipulador de eventos ao evento Completed e chama Execute (). IResult.Execute () pode executar uma tarefa síncrona ou assíncrona e dispara o evento Concluído quando terminar.

O LoginResult é mais ou menos assim:

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

Pode ajudar a configurar algo assim e avançar na execução para observar o que está acontecendo.

Espero que isso ajude alguém! Eu realmente gostei de explorar as diferentes maneiras pelas quais o rendimento pode ser usado.

Isso vai parecer uma sugestão bizarra, mas eu aprendi como usar a yieldpalavra - chave em C # lendo uma apresentação sobre geradores em Python: David M. Beazley's http://www.dabeaz.com/generators/Generators.pdf . Você não precisa conhecer muito Python para entender a apresentação - eu não. Achei muito útil explicar não apenas como os geradores funcionam, mas por que você deveria se importar.

O retorno do rendimento pode ser muito poderoso para algoritmos nos quais você precisa iterar através de milhões de objetos. Considere o exemplo a seguir, onde você precisa calcular possíveis viagens para compartilhamento de viagens. Primeiro, geramos possíveis viagens:

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

Em seguida, percorra cada viagem:

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

Se você usar Lista em vez de rendimento, precisará alocar 1 milhão de objetos na memória (~ 190mb) e este exemplo simples levará ~ 1400ms para executar. No entanto, se você usar yield, não precisará colocar todos esses objetos temporários na memória e obterá uma velocidade do algoritmo significativamente mais rápida: este exemplo levará apenas ~ 400ms para ser executado sem nenhum consumo de memória.

Os dois pedaços de código estão realmente fazendo duas coisas diferentes. A primeira versão puxará os membros conforme você precisar. A segunda versão carregará todos os resultados na memória antes de você começar a fazer alguma coisa.

Não há resposta certa ou errada para esta. Qual deles é preferível depende apenas da situação. Por exemplo, se houver um limite de tempo para concluir sua consulta e você precisar fazer algo semi-complicado com os resultados, a segunda versão poderá ser preferível. Mas tenha cuidado com grandes conjuntos de resultados, especialmente se você estiver executando esse código no modo de 32 bits. Fui mordido por exceções OutOfMemory várias vezes ao fazer esse método.

O principal a ter em mente é o seguinte: as diferenças estão na eficiência. Portanto, você provavelmente deve escolher o que simplificar seu código e alterá-lo somente após a criação de perfil.

O rendimento tem dois grandes usos

Ajuda a fornecer iteração personalizada sem criar coleções temporárias. (carregando todos os dados e fazendo loop)

Ajuda a fazer iteração com estado. ( transmissão)

Abaixo está um vídeo simples que eu criei com demonstração completa para apoiar os dois pontos acima

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

É o que Chris Sells conta sobre essas declarações na linguagem de programação C # ;

Às vezes esqueço que o retorno de rendimento não é o mesmo que retorno, pois o código após um retorno de rendimento pode ser executado. Por exemplo, o código após o primeiro retorno aqui nunca pode ser executado:

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

Por outro lado, o código após o primeiro retorno de rendimento aqui pode ser executado:

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

Isso geralmente me morde em uma declaração if:

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

Nesses casos, lembrar que o retorno do rendimento não é "final", como o retorno é útil.

Supondo que a classe LINQ de seus produtos use um rendimento semelhante para enumerar / iterar, a primeira versão é mais eficiente, pois apenas gera um valor por cada iteração.

O segundo exemplo é converter o enumerador / iterador em uma lista com o método ToList (). Isso significa que itera manualmente sobre todos os itens no enumerador e, em seguida, retorna uma lista simples.

Isso está além do ponto, mas como a pergunta está marcada como boas práticas, vou adiante e coloco meus dois centavos. Para esse tipo de coisa, prefiro transformá-lo em uma propriedade:

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

            return products;
        }
    }
}

Claro, é um pouco mais resistente, mas o código que usa isso parecerá muito mais limpo:

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

vs

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

Nota: Eu não faria isso por nenhum método que demore um pouco para fazer seu trabalho.

E isso?

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

        return products.ToList();
    }
}

Eu acho que isso é muito mais limpo. Não tenho o VS2008 em mãos para verificar. Em qualquer caso, se Products implementa IEnumerable (como parece - é usado em uma instrução foreach), eu a retornaria diretamente.

Eu teria usado a versão 2 do código neste caso. Como você tem a lista completa de produtos disponíveis e é isso que o "consumidor" espera dessa chamada de método, seria necessário enviar as informações completas de volta ao chamador.

Se o chamador deste método exigir "uma" informação de cada vez e o consumo da próxima informação for sob demanda, seria benéfico usar o retorno de rendimento que garantirá que o comando de execução seja retornado ao chamador quando uma unidade de informação está disponível.

Alguns exemplos em que se poderia usar retorno de rendimento são:

1. Cálculo complexo, passo a passo, em que o chamador aguarda os dados de uma etapa por vez
2. Paginação na GUI - onde o usuário pode nunca chegar à última página e apenas um subconjunto de informações é necessário para ser divulgado na página atual

Para responder suas perguntas, eu teria usado a versão 2.

Retorne a lista diretamente. Benefícios:

• Está mais claro
• A lista é reutilizável. (o iterador não é) não é verdade, obrigado Jon

Você deve usar o iterador (rendimento) a partir de quando achar que provavelmente não precisará repetir todo o caminho até o final da lista ou quando ele não tiver fim. Por exemplo, a chamada do cliente procurará o primeiro produto que satisfaça algum predicado, você pode considerar usar o iterador, embora esse seja um exemplo artificial e provavelmente haja maneiras melhores de realizá-lo. Basicamente, se você souber com antecedência que toda a lista precisará ser calculada, faça-a com antecedência. Se você acha que não, considere usar a versão do iterador.

A frase-chave de retorno de rendimento é usada para manter a máquina de estado para uma coleção específica. Sempre que o CLR vê a frase-chave de retorno de rendimento sendo usada, o CLR implementa um padrão de enumerador para esse trecho de código. Esse tipo de implementação ajuda o desenvolvedor de todo o tipo de canalização que, de outra forma, teríamos que fazer na ausência da palavra-chave.

Suponha que, se o desenvolvedor estiver filtrando alguma coleção, iterando pela coleção e extraindo esses objetos em alguma nova coleção. Esse tipo de encanamento é bastante monótono.

Mais sobre a palavra-chave aqui neste artigo .

O uso de yield é semelhante à palavra-chave return , exceto que ela retornará um gerador . E o objeto gerador irá percorrer apenas uma vez .

produção tem dois benefícios:

1. Você não precisa ler esses valores duas vezes;
2. Você pode obter muitos nós filhos, mas não precisa colocá-los na memória.

Há outra explicação clara que talvez o ajude.