Como funcionam iteradores e a palavra-chave yield?

Question

Accepted Answer

**Iteradores** permitem que você produza uma sequência de valores de forma preguiçosa (lazy), um de cada vez, usando a palavra-chave **`yield`** — sem construir toda a coleção na memória. Um método usando `yield return` se torna um iterador que gera valores sob demanda, ideal para sequências grandes ou infinitas e iteração personalizada. ## Geracao de sequencia preguiçosa com yield return ```csharp // a method with `yield return` is an ITERATOR — produces values one at a time public IEnumerable GetNumbers(int n) { for (int i = 0; i < n; i++) { yield return i; // produce a value, PAUSE here, resume on the next request } } foreach (var num in GetNumbers(1000000)) // generates lazily — minimal memory { Console.WriteLine(num); if (num > 5) break; // only generated 7 values — the rest were never computed } ``` `yield return` produz um valor e **pausa** o método, retomando de onde parou na próxima iteração (preservando estado). Valores são gerados **sob demanda** — nada é computado até ser solicitado, e um `break` interrompe a geração antecipadamente. ## O benefício de memória (preguiçoso vs entusiasmado) ```csharp // ❌ eager — builds the WHOLE list in memory first public List GetAll(int n) { var list = new List(); for (int i = 0; i < n; i++) list.Add(i); // all n values in memory return list; } // ✅ iterator — generates lazily, constant memory regardless of n public IEnumerable GetAll(int n) { for (int i = 0; i < n; i++) yield return i; } ``` ## Sequências infinitas (impossível com uma lista) ```csharp public IEnumerable Fibonacci() { int a = 0, b = 1; while (true) // infinite — but lazy, so it's fine { yield return a; (a, b) = (b, a + b); } } var first10 = Fibonacci().Take(10); // take only what you need ``` ## yield e LINQ ```text LINQ's deferred execution is built on iterators — Where/Select use yield internally to process elements lazily, one at a time, as the result is enumerated. ``` ## Por que isso importa Iteradores e a palavra-chave `yield` são recursos importantes do C# para **geração de sequência eficiente em memória e preguiçosa**, e entendê-los é valioso para processar grandes conjuntos de dados e para compreender como o LINQ funciona. O benefício central é produzir sequências **de forma preguiçosa, um valor de cada vez, sob demanda** — em vez de construir uma coleção inteira na memória — o que é essencial para grandes conjuntos de dados (onde materializar tudo esgotaria a memória), cenários de streaming/processamento e até **sequências infinitas** (como gerar números de Fibonacci, impossível com uma lista mas trivial com um iterador preguiçoso, pegando apenas o que você precisa). O mecanismo `yield return` (produzindo um valor, pausando, retomando com estado preservado) torna a escrita de geradores preguiçosos limpa e natural. Entender iteradores também ilumina como **a execução adiada do LINQ funciona** — operadores LINQ usam iteradores internamente para processar elementos de forma preguiçosa conforme o resultado é enumerado, o que explica o comportamento preguiçoso do LINQ. Conhecer iteradores (geração preguiçosa com `yield`, os benefícios de memória sobre construção entusiasmada de coleções, sequências infinitas e a conexão com a execução adiada do LINQ) é valioso para escrever código de processamento de dados eficiente em memória e para entender o modelo de avaliação preguiçosa do C#. Embora não seja necessário em cada cenário, iteradores são importantes ao processar grandes quantidades de dados eficientemente ou ao construir sequências preguiçosas personalizadas, e entendê-los aprofunda sua compreensão do LINQ e da avaliação preguiçosa — tornando-os conhecimento útil e praticamente relevante para C# eficiente e um tópico que reflete compreensão das capacidades de execução adiada da linguagem.