¿Cómo funcionan los iteradores y la palabra clave yield?

Question

Accepted Answer

**Los iteradores** permiten generar una secuencia de valores de manera perezosa, uno a la vez, usando la palabra clave **`yield`** — sin construir la colección completa en memoria. Un método que usa `yield return` se convierte en un iterador que genera valores bajo demanda, ideal para secuencias grandes o infinitas e iteración personalizada. ## yield return — generación perezosa de secuencias ```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` produce un valor y **pausa** el método, reanudándose donde se quedó en la siguiente iteración (conservando el estado). Los valores se generan **bajo demanda** — nada se calcula hasta que se solicita, y un `break` detiene la generación anticipadamente. ## El beneficio de memoria (perezoso vs. ávido) ```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; } ``` ## Secuencias infinitas (imposibles con una 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 y 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 qué es importante Los iteradores y la palabra clave `yield` son características importantes de C# para **generación perezosa y eficiente en memoria de secuencias**, y comprenderlos es valioso para procesar grandes conjuntos de datos y para entender cómo funciona LINQ. El beneficio principal es producir secuencias **perezosamente, un valor a la vez, bajo demanda** — en lugar de construir una colección completa en memoria — lo cual es esencial para grandes conjuntos de datos (donde materializar todo agotaría la memoria), escenarios de streaming/procesamiento, e incluso **secuencias infinitas** (como generar números de Fibonacci, imposible con una lista pero trivial con un iterador perezoso, tomando solo lo que necesitas). El mecanismo `yield return` (producir un valor, pausar, reanudar con estado preservado) hace que escribir tales generadores perezosos sea limpio y natural. Comprender iteradores también ilumina cómo funciona la **ejecución diferida de LINQ** — los operadores de LINQ usan iteradores internamente para procesar elementos perezosamente a medida que se enumera el resultado, lo cual explica el comportamiento perezoso de LINQ. Conocer iteradores (generación perezosa con `yield`, los beneficios de memoria sobre construcción de colecciones ávidas, secuencias infinitas, y la conexión a la ejecución diferida de LINQ) es valioso para escribir código de procesamiento de datos eficiente en memoria y para entender el modelo de evaluación perezosa de C#. Aunque no es necesario en todos los escenarios, los iteradores son importantes al procesar grandes cantidades de datos eficientemente o construir secuencias perezosas personalizadas, y comprenderlos profundiza tu comprensión de LINQ y evaluación perezosa — convirtiéndolos en conocimiento útil y prácticamente relevante para C# eficiente y un tema que refleja comprensión de las capacidades de ejecución diferida del lenguaje.