Compartilhar via

instrução yield – fornecer o próximo elemento

  • Artigo

Use a instrução yield em um iterador para fornecer o próximo valor ou sinalizar o fim de uma iteração. A instrução yield tem as duas seguintes formas:

  • yield return: para fornecer o próximo valor na iteração, como mostra o seguinte exemplo:

    foreach (int i in ProduceEvenNumbers(9))
{
    Console.Write(i);
    Console.Write(" ");
}
// Output: 0 2 4 6 8

IEnumerable<int> ProduceEvenNumbers(int upto)
{
    for (int i = 0; i <= upto; i += 2)
    {
        yield return i;
    }
}

  • yield break: para sinalizar explicitamente o fim da iteração, como mostra o seguinte exemplo:

    Console.WriteLine(string.Join(" ", TakeWhilePositive(new int[] {2, 3, 4, 5, -1, 3, 4})));
// Output: 2 3 4 5

Console.WriteLine(string.Join(" ", TakeWhilePositive(new int[] {9, 8, 7})));
// Output: 9 8 7

IEnumerable<int> TakeWhilePositive(IEnumerable<int> numbers)
{
    foreach (int n in numbers)
    {
        if (n > 0)
        {
            yield return n;
        }
        else
        {
            yield break;
        }
    }
}

    A iteração também é concluída quando o controle atinge o final de um iterador.

Nos exemplos anteriores, o tipo de retorno dos iteradores é IEnumerable<T> (em casos não genéricos, use IEnumerable como o tipo de retorno de um iterador). Você também pode usar IAsyncEnumerable<T> como tipo de retorno de um iterador. Isso torna o iterador assíncrono. Use a instruçãoawait foreach para iterar sobre o resultado do iterador, como mostra o seguinte exemplo:

await foreach (int n in GenerateNumbersAsync(5))
{
    Console.Write(n);
    Console.Write(" ");
}
// Output: 0 2 4 6 8

async IAsyncEnumerable<int> GenerateNumbersAsync(int count)
{
    for (int i = 0; i < count; i++)
    {
        yield return await ProduceNumberAsync(i);
    }
}

async Task<int> ProduceNumberAsync(int seed)
{
    await Task.Delay(1000);
    return 2 * seed;
}

IEnumerator<T> ou IEnumerator também podem ser o tipo de retorno de um iterador. Use esses tipos de retorno quando você implementar o método GetEnumerator nos seguintes cenários:

  • Você projeta o tipo que implementa a interface IEnumerable<T> ou IEnumerable.

  • Adicione uma instância ou método de extensão GetEnumerator para permitir a iteração sobre a instância do tipo com a foreachdeclaração, como mostra o exemplo a seguir:

    public static void Example()
{
    var point = new Point(1, 2, 3);
    foreach (int coordinate in point)
    {
        Console.Write(coordinate);
        Console.Write(" ");
    }
    // Output: 1 2 3
}

public readonly record struct Point(int X, int Y, int Z)
{
    public IEnumerator<int> GetEnumerator()
    {
        yield return X;
        yield return Y;
        yield return Z;
    }
}

Você não pode usar instruções yield em:

  • métodos com os parâmetros in, ref ou out
  • expressões lambda e métodos anônimos
  • blocos inseguros. Antes do C# 13, yield era inválido em qualquer método com um bloco unsafe. A partir do C# 13, você pode usar yield em métodos com blocos unsafe, mas não no bloco unsafe.
  • yield return e yield break não pode ser usado em blocos catch e finally , ou em blocos try com um bloco correspondente catch . As yield return instruções and yield break podem ser usadas em um try bloco sem catch blocos, apenas um finally bloco.

Execução de um iterador

A chamada de um iterador não o executa imediatamente, como mostra o seguinte exemplo:

var numbers = ProduceEvenNumbers(5);
Console.WriteLine("Caller: about to iterate.");
foreach (int i in numbers)
{
    Console.WriteLine($"Caller: {i}");
}

IEnumerable<int> ProduceEvenNumbers(int upto)
{
    Console.WriteLine("Iterator: start.");
    for (int i = 0; i <= upto; i += 2)
    {
        Console.WriteLine($"Iterator: about to yield {i}");
        yield return i;
        Console.WriteLine($"Iterator: yielded {i}");
    }
    Console.WriteLine("Iterator: end.");
}
// Output:
// Caller: about to iterate.
// Iterator: start.
// Iterator: about to yield 0
// Caller: 0
// Iterator: yielded 0
// Iterator: about to yield 2
// Caller: 2
// Iterator: yielded 2
// Iterator: about to yield 4
// Caller: 4
// Iterator: yielded 4
// Iterator: end.

Como mostra o exemplo anterior, quando você começa a iterar sobre o resultado de um iterador, o iterador é executado até que a primeira instrução yield return seja atingida. Em seguida, a execução de um iterador é suspensa e o chamador obtém o primeiro valor de iteração e o processa. Em cada iteração subsequente, a execução de um iterador é retomada após a instrução yield return que causou a suspensão anterior e continua até que a próxima instrução yield return seja atingida. A iteração é concluída quando o controle atinge o final de um iterador ou uma instrução yield break.

Especificação da linguagem C#

Para saber mais, confira a seção A instrução yield na Especificação da linguagem C#.

Confira também