Introdução ao Yield em C# - O que é, como usar e quando é útil

Introdução à palavra-chave Yield em C

Tim começa apresentando a palavra-chave yield e destacando que ela pode ser confusa para desenvolvedores que a encontram pela primeira vez. Ele explica que a instrução yield permite que um método pause a execução, mantenha seu estado e continue de onde parou na próxima chamada. Tim enfatiza que entender o conceito de rendimento é fundamental para processar dados de forma eficiente, especialmente ao lidar com grandes conjuntos de dados ou implementar lógica de iteração personalizada.

Configurando um exemplo simples: Programa de classe e método estático void main

Para eliminar distrações, Tim cria um aplicativo de console simples no Visual Studio, chamado "YieldDemoApp".

O que o comando yield realmente faz em C

Tim então aprofunda-se na teoria. Aos 2:04, ele descreve o comportamento do yield: em vez de processar uma coleção inteira de uma só vez, a instrução yield reserva um espaço — como colocar o polegar em um livro — para que a execução possa pausar e ser retomada mais tarde.

Esse comportamento é crucial para a execução adiada, onde os valores são gerados somente quando necessário, em vez de pré-computar tudo antecipadamente. A descrição de Tim estabelece claramente a base para a compreensão de como funciona o retorno do rendimento.

Escrevendo código de demonstração

No método estático void Main da classe Program, ele configura mensagens básicas de início e fim, como "Início do aplicativo" e "Fim do aplicativo", usando Console.WriteLine, o que ajuda a visualizar o fluxo com clareza ao trabalhar com um loop foreach posteriormente.

Este exemplo de código inicial foca-se exclusivamente na implementação do yield, sem envolver quaisquer complexidades da interface do utilizador.

Criando a classe PersonModel

Para demonstrar, Tim cria uma classe PersonModel com propriedades FirstName e LastName e um construtor. Quando um objeto PersonModel é criado, uma mensagem é exibida, indicando qual usuário foi inicializado. Isso ajuda a visualizar quando os objetos estão sendo criados em comparação com quando estão sendo consumidos.

Esta simples etapa de geração de código prepara o terreno para trabalhar com iteradores personalizados.

Construindo a classe DataAccess com um retorno de lista tradicional

Às 5:06, Tim passa para uma classe DataAccess com um método GetPeople que retorna um IEnumerable. . Inicialmente, o valor retornado é uma lista preenchida com três instâncias do modelo PersonModel: Tim Corey, Sue Storm e Jane Smith.

Esse método iterador carrega todos os objetos imediatamente na memória antes do início da iteração — um ponto importante que Tim posteriormente contrasta com o uso de yield.

Demonstrando o uso da memória com uma lista

Após executar o loop foreach, Tim mostra que todos os três usuários são criados antes mesmo do primeiro elemento ser lido. Isso destaca um problema potencial ao lidar com grandes coleções ou grandes conjuntos de dados — o alto consumo de memória.

Tim explica que, se tivéssemos, digamos, mil usuários, teríamos criado mil objetos mesmo que precisássemos apenas de alguns, resultando em alocação de memória ineficiente.

Alteração para Retorno de Renda para Execução Diferida

Às 10h01, Tim modifica o método GetPeople para usar yield return em vez de criar uma coleção temporária (uma lista). Cada instrução yield return emite diretamente um PersonModel por vez.

Este código crucial dentro do método permite a avaliação preguiçosa, onde o próximo elemento é gerado somente quando necessário pelo loop foreach.

Tim também esclarece que o tipo de retorno do método deve ser IEnumerable. E usar uma lista anularia o propósito da execução adiada.

Depuração: Como o compilador gera código para Yield

Tim usa pontos de interrupção para percorrer o processo passo a passo. Ele demonstra que, antes da primeira chamada MoveNext, a sequência está vazia. Somente quando o loop foreach precisa do próximo valor é que o compilador aciona o bloco iterador e executa a linha yield return num, que inicializa e retorna o PersonModel.

Tim destaca que o compilador gera máquinas de estado especiais internamente para gerenciar a execução pausada e retomada.

Benefícios e Eficiência do Uso do Retorno de Rendimento

Tim explica por que o rendimento é tão eficiente:

• Você pode buscar um registro por vez.

• Você pode limitar a quantidade de números inteiros conforme necessário.

• Você evita carregar toda a coleção na memória.

• Você melhora a escalabilidade, especialmente ao trabalhar com processamento de arquivos grandes ou fluxos de dados.

Usando o método .Take(2) do LINQ, Tim demonstra como apenas dois objetos são inicializados, mesmo que existam três instruções yield return — destacando a execução adiada em ação.

Exemplo prático: Gerador de números primos usando rendimento

Tim cria um novo IEnumerable estático. Método GetPrimeNumbers() dentro de uma classe Generators. Nesse loop infinito, Tim usa uma função auxiliar IsPrimeNumber(int number) para verificar se um número é primo. Se o número for primo, ele usa yield return number para emiti-lo.

Este exemplo demonstra que o rendimento é crucial para lidar com sequências infinitas de forma segura.

Sem o comando yield, o código falharia devido ao consumo ilimitado de memória. Ao utilizar o recurso de yield, no entanto, a execução diferida garante que os números sejam gerados sob demanda.

Obtendo números primos com Take()

Tim então mostra como obter com segurança apenas um número fixo de números primos:

var primeNumbers = Generators.GetPrimeNumbers().Take(10000);

var primeNumbers = Generators.GetPrimeNumbers().Take(10000);

Este código escrito dentro do método static void Main busca eficientemente apenas 10.000 números primos.

Como o comando yield return gera números um a um, o uso de memória permanece baixo.

Iteração personalizada: usando GetEnumerator e MoveNext

Tim aprofunda o assunto, explicando como controlar a iteração manualmente.

Ele cria uma variável iterator = primeNumbers.GetEnumerator(), depois usa um loop for com um inteiro i e chama iterator.MoveNext() para buscar elementos manualmente.

Essa abordagem manual permite iterações personalizadas — solicitando o próximo valor somente quando necessário e mostrando que o método retoma exatamente de onde parou pela última vez.

Um erro comum: usar ToList() em coleções retornadas (Yield Collections)

Aos 36:45, Tim avisa: converter uma sequência yield em uma lista com .ToList() causa avaliação completa imediata.

Se você chamar o método .ToList() em uma sequência infinita, corre o risco de travar seu aplicativo.

Tim enfatiza que o retorno de yield destina-se à avaliação preguiçosa e que chamar .ToList() quebra esse padrão ao forçar a materialização completa da memória.

Ao trabalhar com métodos LINQ, Tim recomenda ter cautela ao introduzir o método .ToList().

Resumo: Por que o rendimento é uma ferramenta poderosa

Tim conclui reforçando que, embora a palavra-chave yield adicione uma pequena sobrecarga (mantendo uma máquina de estados), os benefícios da redução do uso de memória e da avaliação preguiçosa a tornam uma ferramenta poderosa ao trabalhar com:

• Grandes conjuntos de dados

• Arquivos grandes

• Iteradores personalizados

• Sequências infinitas

• Fluxos de dados

• Processamento diferido

Ele sugere praticar com rendimento em diferentes projetos para desenvolver uma compreensão mais profunda do retorno do investimento e evitar erros comuns.

Tim conclui convidando os espectadores a compartilhar como eles usaram o recurso "yield" em código de produção.

Conclusão

Ao analisarmos o vídeo de Tim Corey, vimos os imensos benefícios que a palavra-chave yield traz para o C#. Desde a criação de iteradores personalizados até o gerenciamento eficiente de grandes coleções, o yield return permite que os retornos de função sejam mais inteligentes e utilizem menos memória. Seja trabalhando com variáveis ​​como number, point, reader, connection ou grandes conjuntos de dados, dominar o yield pode elevar suas habilidades de programação em C# drasticamente.

Se você ainda não explorou o uso de yield, agora é o momento perfeito para praticá-lo com exemplos simples e entender melhor como o yield return funciona dentro do compilador C#. Não deixem de conferir o canal oficial do Tim no YouTube para mais vídeos interessantes.