0Pricing
C# Academy · Lección

Métodos iteradores con yield return

Genere secuencias elemento a elemento.

Métodos iteradores con yield return es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 4 lecciones en total.

¿Qué es un método iterador?

Un método iterador produce una secuencia de valores, uno cada vez, mediante yield return. El compilador lo transforma en una máquina de estados, por lo que no tiene que crear y administrar una lista por su cuenta.

Su primer yield return

Cada yield return entrega un valor a quien llama y pausa el método. En la siguiente iteración, la ejecución se reanuda justo después de esa instrucción.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<int> FirstThree()
    {
        yield return 1;
        yield return 2;
        yield return 3;
    }

    public static void Main()
    {
        foreach (var n in FirstThree())
            Console.WriteLine(n);
    }
}

yield return dentro de un bucle

La mayoría de los iteradores producen valores desde dentro de un bucle. Aquí generamos los primeros count números pares sin asignar nunca una colección.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<int> Evens(int count)
    {
        for (int i = 0; i < count; i++)
            yield return i * 2;
    }

    public static void Main()
    {
        foreach (var n in Evens(5))
            Console.WriteLine(n);
    }
}

El método devuelve IEnumerable

Un método iterador debe devolver IEnumerable<T> o IEnumerator<T> (o sus versiones no genéricas). Nunca escribe return con un valor; solo usa yield return.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<string> Greetings()
    {
        yield return "hello";
        yield return "hi";
        yield return "hey";
    }

    public static void Main()
    {
        foreach (var g in Greetings())
            Console.WriteLine(g);
    }
}

La ejecución se pausa y se reanuda

El estado entre los distintos valores producidos se conserva automáticamente. Las variables locales mantienen sus valores durante las pausas, lo que facilita la generación de totales acumulados.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<int> RunningTotal(IEnumerable<int> nums)
    {
        int total = 0;
        foreach (var n in nums)
        {
            total += n;
            yield return total;
        }
    }

    public static void Main()
    {
        foreach (var t in RunningTotal(new[] { 1, 2, 3, 4 }))
            Console.WriteLine(t);
    }
}

Generar secuencias infinitas

Como los valores se producen bajo demanda, un iterador puede describir de forma segura una secuencia infinita. Quien llama decide cuándo dejar de solicitar valores.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<int> Naturals()
    {
        int i = 1;
        while (true) yield return i++;
    }

    public static void Main()
    {
        int taken = 0;
        foreach (var n in Naturals())
        {
            Console.WriteLine(n);
            if (++taken == 5) break;
        }
    }
}

Transformar una secuencia de entrada

Los iteradores son excelentes para crear canalizaciones: leen elementos de una secuencia, los transforman y producen los resultados de forma diferida.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<string> Labelled(IEnumerable<int> nums)
    {
        foreach (var n in nums)
            yield return "item-" + n;
    }

    public static void Main()
    {
        foreach (var s in Labelled(new[] { 10, 20, 30 }))
            Console.WriteLine(s);
    }
}

Filtrar con iteradores

Para filtrar, produzca únicamente los elementos que quiera. Los elementos omitidos nunca se producen, por lo que el código posterior no los ve.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<int> OnlyPositive(IEnumerable<int> nums)
    {
        foreach (var n in nums)
            if (n > 0) yield return n;
    }

    public static void Main()
    {
        foreach (var n in OnlyPositive(new[] { -2, 5, -1, 8 }))
            Console.WriteLine(n);
    }
}

El compilador crea una máquina de estados

Internamente, el compilador reescribe el iterador como una clase que implementa IEnumerator<T> y realiza el seguimiento de un campo de estado oculto y de un valor Current. Toda esa infraestructura se obtiene automáticamente.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<char> Letters()
    {
        yield return 'a';
        yield return 'b';
        yield return 'c';
    }

    public static void Main()
    {
        IEnumerator<char> e = Letters().GetEnumerator();
        while (e.MoveNext())
            Console.WriteLine(e.Current);
    }
}

Componer varios iteradores

Los iteradores se encadenan de forma natural porque cada uno devuelve un IEnumerable<T>. Pase la salida de un iterador al siguiente para crear canalizaciones fáciles de leer.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<int> Range(int start, int count)
    {
        for (int i = 0; i < count; i++) yield return start + i;
    }
    static IEnumerable<int> Squares(IEnumerable<int> nums)
    {
        foreach (var n in nums) yield return n * n;
    }

    public static void Main()
    {
        foreach (var n in Squares(Range(1, 4)))
            Console.WriteLine(n);
    }
}

Pruébelo usted mismo

Escriba un iterador que agrupe una secuencia de entrada en bloques de tamaño fijo. Produce listas bajo demanda y muestra cuánta lógica puede incluirse en un único iterador limpio.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<List<int>> Batch(IEnumerable<int> source, int size)
    {
        var bucket = new List<int>();
        foreach (var n in source)
        {
            bucket.Add(n);
            if (bucket.Count == size) { yield return bucket; bucket = new List<int>(); }
        }
        if (bucket.Count > 0) yield return bucket;
    }

    public static void Main()
    {
        foreach (var group in Batch(new[] { 1, 2, 3, 4, 5 }, 2))
            Console.WriteLine(string.Join(",", group));
    }
}

Comprobación rápida

Recuerde cómo funcionan los métodos iteradores.

Recapitulación

Los métodos iteradores usan yield return para producir secuencias bajo demanda.

  • El método devuelve IEnumerable<T> o IEnumerator<T>.
  • Cada yield return emite un valor y pausa la ejecución, conservando el estado local.
  • Pueden describir secuencias infinitas de forma segura.
  • El compilador genera la máquina de estados automáticamente.

Preguntas frecuentes

¿La lección «Métodos iteradores con yield return» es gratis?

Sí — el texto completo de «Métodos iteradores con yield return» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Métodos iteradores con yield return»?

Genere secuencias elemento a elemento. Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Métodos iteradores con yield return»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Métodos iteradores con yield return
  2. yield break y terminación anticipada
  3. Semántica de la evaluación diferida
  4. Enumerables personalizados
← Volver a C# Academy