C# Academy · Aula

Métodos iteradores com yield return

Gere sequências um elemento por vez.

Métodos iteradores com yield return é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 4 aulas no total.

O que é um método iterador

Um método iterador produz uma sequência de valores, um de cada vez, usando yield return. O compilador o transforma em uma máquina de estados, para que você não precise criar e gerenciar uma lista por conta própria.

Seu primeiro yield return

Cada yield return devolve um valor ao chamador e pausa o método. A execução é retomada logo depois dessa instrução na iteração seguinte.

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 um laço

A maioria dos iteradores produz valores dentro de um laço. Aqui, geramos os primeiros count números pares sem nunca alocar uma coleção.

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

O método retorna IEnumerable

Um método iterador deve retornar IEnumerable<T> ou IEnumerator<T>, ou as versões não genéricas. Você nunca escreve return com um valor; usa apenas 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);
    }
}

A execução é pausada e retomada

O estado entre os pontos de produção é preservado automaticamente. As variáveis locais mantêm seus valores entre as pausas, o que facilita a geração de totais 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);
    }
}

Gerando sequências infinitas

Como os valores são produzidos sob demanda, um iterador pode descrever com segurança uma sequência infinita. O chamador decide quando parar 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;
        }
    }
}

Transformando uma sequência de entrada

Os iteradores são excelentes para criar fluxos: leia itens de uma sequência, transforme-os e produza os resultados com avaliação tardia.

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

Filtrando com iteradores

Para filtrar, basta produzir apenas os itens desejados. Os itens ignorados nunca são produzidos, portanto o código posterior não os vê.

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

O compilador cria uma máquina de estados

Nos bastidores, o compilador reescreve seu iterador como uma classe que implementa IEnumerator<T>, rastreando um campo de estado oculto e um valor Current. Você recebe toda essa estrutura automaticamente.

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

Compondo vários iteradores

Os iteradores são naturalmente encadeáveis porque cada um retorna um IEnumerable<T>. Passe a saída de um iterador para o próximo para criar fluxos legíveis.

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

Experimente

Escreva um iterador que agrupe uma sequência de entrada em blocos de tamanho fixo. Ele produz listas sob demanda, demonstrando quanto de lógica cabe em um único iterador organizado.

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

Verificação rápida

Relembre como funcionam os métodos iteradores.

Recapitulação

Os métodos iteradores usam yield return para produzir sequências sob demanda.

O método retorna IEnumerable<T> ou IEnumerator<T>.
Cada yield return emite um valor e pausa a execução, preservando o estado local.
Eles podem descrever sequências infinitas com segurança.
O compilador gera a máquina de estados para você.

Perguntas Frequentes

A aula “Métodos iteradores com yield return” é grátis?

Sim — o texto completo de “Métodos iteradores com yield return” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 4 aulas no total.

O que vou aprender em “Métodos iteradores com yield return”?

Gere sequências um elemento por vez. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Métodos iteradores com yield return”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C# Academy