C# Academy · Lektion

Iterator-Methoden mit yield return

Erzeugen Sie Sequenzen Element für Element.

Iterator-Methoden mit yield return ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C# Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist eine Iteratormethode?

Eine Iteratormethode erzeugt mithilfe von yield return nacheinander eine Folge von Werten. Der Compiler wandelt sie in eine Zustandsmaschine um, sodass Sie nicht selbst eine Liste erstellen und verwalten müssen.

Ihr erstes yield return

Jedes yield return gibt einen Wert an die aufrufende Person zurück und pausiert die Methode. Bei der nächsten Iteration wird die Ausführung direkt nach dieser Anweisung fortgesetzt.

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 in einer Schleife

Die meisten Iteratoren liefern Werte innerhalb einer Schleife. Hier erzeugen wir die ersten count geraden Zahlen, ohne jemals eine Collection zu allokieren.

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

Die Methode gibt IEnumerable zurück

Eine Iteratormethode muss IEnumerable<T> oder IEnumerator<T> zurückgeben – oder die nicht generischen Varianten. Sie schreiben niemals return mit einem Wert, sondern verwenden ausschließlich 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);
    }
}

Die Ausführung wird pausiert und fortgesetzt

Der Zustand zwischen den einzelnen Ausgaben bleibt automatisch erhalten. Lokale Variablen behalten ihre Werte über die Pausen hinweg, wodurch sich laufende Summen so einfach erzeugen lassen.

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

Unendliche Sequenzen erzeugen

Da Werte bei Bedarf erzeugt werden, kann ein Iterator sicher eine unendliche Sequenz beschreiben. Die aufrufende Person entscheidet, wann sie keine weiteren Werte mehr abruft.

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

Eine Eingabesequenz transformieren

Iteratoren eignen sich hervorragend zum Erstellen von Pipelines: Sie lesen Elemente aus einer Sequenz, transformieren sie und geben die Ergebnisse verzögert aus.

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

Mit Iteratoren filtern

Zum Filtern geben Sie einfach nur die gewünschten Elemente aus. Übersprungene Elemente werden nie erzeugt, sodass nachgelagerter Code sie nicht zu sehen bekommt.

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

Der Compiler erstellt eine Zustandsmaschine

Hinter den Kulissen schreibt der Compiler Ihren Iterator in eine Klasse um, die IEnumerator<T> implementiert und ein verborgenes Zustandsfeld sowie einen Current-Wert verwaltet. Diese gesamte Infrastruktur erhalten Sie kostenlos.

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

Mehrere Iteratoren kombinieren

Iteratoren lassen sich ganz natürlich verketten, da jeder ein IEnumerable<T> zurückgibt. Leiten Sie die Ausgabe eines Iterators an den nächsten weiter, um übersichtliche Pipelines zu erstellen.

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

Probieren Sie es selbst aus

Schreiben Sie einen Iterator, der eine Eingabesequenz in Blöcke fester Größe aufteilt. Er gibt Listen bei Bedarf aus und zeigt, wie viel Logik in einen einzigen übersichtlichen Iterator passt.

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

Kurze Überprüfung

Rufen Sie sich ins Gedächtnis, wie Iteratormethoden funktionieren.

Zusammenfassung

Iteratormethoden verwenden yield return, um Sequenzen bei Bedarf zu erzeugen.

Die Methode gibt IEnumerable<T> oder IEnumerator<T> zurück.
Jedes yield return gibt einen Wert aus und pausiert die Methode, wobei der lokale Zustand erhalten bleibt.
Sie können sicher unendliche Sequenzen beschreiben.
Der Compiler erzeugt die Zustandsmaschine für Sie.

Häufig gestellte Fragen

Ist die Lektion „Iterator-Methoden mit yield return“ kostenlos?

Ja — der vollständige Text von „Iterator-Methoden mit yield return“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C# Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Iterator-Methoden mit yield return“?

Erzeugen Sie Sequenzen Element für Element. Du übst C# Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C# Academy zu starten?

Keine Vorkenntnisse erforderlich. C# Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Iterator-Methoden mit yield return“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C# Academy-Lektion Code schreiben und ausführen?

Ja. Jede C# Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C# Academy