Sdílet prostřednictvím

yield statement - provide the next element

  • Článek

Příkaz v iterátoru yield použijete k zadání další hodnoty nebo signálu na konci iterace. Příkaz yield má dvě následující formy:

  • yield return: chcete-li zadat další hodnotu v iteraci, jak ukazuje následující příklad:

    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: explicitně signalizovat konec iterace, jak ukazuje následující příklad:

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

    Iterace se také dokončí, když ovládací prvek dosáhne konce iterátoru.

V předchozíchpříkladch IEnumerable<T> IEnumerable Můžete také použít IAsyncEnumerable<T> jako návratový typ iterátoru. Díky tomu je iterátor asynchronní. await foreach Příkaz použijte k iteraci výsledku iterátoru, jak ukazuje následující příklad:

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> nebo IEnumerator může být také návratový typ iterátoru. Tyto návratové typy použijte při implementaci GetEnumerator metody v následujících scénářích:

  • Navrhujete typ, který implementuje IEnumerable<T> nebo IEnumerable rozhraní.

  • Přidáním instance nebo metody rozšíření GetEnumerator povolíte iteraci přes instanci typu pomocí foreach příkazu, jak ukazuje následující příklad:

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

Příkazy nemůžete použít yield v:

  • metod s parametry in, ref nebo out
  • výrazy lambda a anonymní metody
  • nebezpečných bloků. Před jazykem C# 13 yield byla v jakékoli metodě s blokem neplatná unsafe . Počínaje jazykem C# 13 můžete používat yield metody s unsafe bloky, ale ne v unsafe bloku.
  • yield return a yield break nelze jej použít v blokech catch a finally nebo v blocích try s odpovídajícím catch blokem. Příkazy yield return a příkazy lze použít v try bloku bez catch bloků, pouze bloku finally yield break.

Spuštění iterátoru

Volání iterátoru ho nespustí okamžitě, jak ukazuje následující příklad:

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.

Jak ukazuje předchozí příklad, když začnete iterovat výsledek iterátoru, iterátor se spustí, dokud nedosáhnete prvního yield return příkazu. Pak se spuštění iterátoru pozastaví a volající získá první hodnotu iterace a zpracuje ji. Při každé další iteraci se spuštění iterátoru obnoví po yield return příkazu, který způsobil předchozí pozastavení a pokračuje až do dosažení dalšího yield return příkazu. Iterace se dokončí, když ovládací prvek dosáhne konce iterátoru yield break nebo příkazu.

specifikace jazyka C#

Další informace naleznete v části příkaz výnosu specifikace jazyka C#.

Viz také