C# Academy · Les

Iteratormethoden met yield return

Genereer reeksen één element tegelijk.

Les 1 van 413 stappen

Iteratormethoden met yield return is een gratis C# Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject C# Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus C# Academy bevat in totaal 4 lessen.

Wat is een iteratormethode?

Een iteratormethode produceert één voor één een reeks waarden met behulp van yield return. De compiler zet deze om in een toestandsmachine, zodat je niet zelf een lijst hoeft te bouwen en beheren.

Je eerste yield return

Elke yield return geeft één waarde terug aan de aanroeper en pauzeert de methode. Bij de volgende iteratie gaat de uitvoering verder direct na die instructie.

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 een lus

De meeste iterators leveren waarden vanuit een lus. Hier genereren we de eerste count even getallen zonder ooit een verzameling toe te wijzen.

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

De methode retourneert IEnumerable

Een iteratormethode moet IEnumerable<T> of IEnumerator<T> retourneren, of de niet-generieke varianten daarvan. Je schrijft nooit return met een waarde; je gebruikt alleen 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);
    }
}

De uitvoering wordt gepauzeerd en hervat

De toestand tussen yield-instructies wordt automatisch bewaard. Lokale variabelen behouden hun waarden tijdens pauzes, waardoor het eenvoudig wordt om lopende totalen te genereren.

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

Oneindige reeksen genereren

Omdat waarden op aanvraag worden geproduceerd, kan een iterator veilig een oneindige reeks beschrijven. De aanroeper bepaalt wanneer deze stopt met het opvragen van waarden.

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

Een invoerreeks transformeren

Iterators zijn uitstekend geschikt voor het bouwen van pijplijnen: lees elementen uit één reeks, transformeer ze en lever de resultaten lui op.

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

Filteren met iterators

Om te filteren lever je eenvoudig alleen de gewenste elementen op. Overgeslagen elementen worden nooit geproduceerd, dus de volgende code ziet ze nooit.

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

De compiler bouwt een toestandsmachine

Achter de schermen herschrijft de compiler je iterator tot een klasse die IEnumerator<T> implementeert en een verborgen toestandsveld en een waarde voor Current bijhoudt. Je krijgt al dat mechanisme zonder extra werk.

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

Meerdere iterators samenstellen

Iterators kunnen natuurlijk aan elkaar worden gekoppeld, omdat elke iterator een IEnumerable<T> retourneert. Geef de uitvoer van de ene iterator door aan de volgende om leesbare pijplijnen te bouwen.

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

Probeer het zelf

Schrijf een iterator die een invoerreeks opdeelt in blokken met een vaste grootte. De iterator levert op aanvraag lijsten op en laat zien hoeveel logica in één overzichtelijke iterator past.

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

Korte controle

Haal je voor de geest hoe iteratormethoden werken.

Beantwoord dit in de interactieve les

Samenvatting

Iteratormethoden gebruiken yield return om op aanvraag reeksen te produceren.

De methode retourneert IEnumerable<T> of IEnumerator<T>.
Elke yield return levert één waarde op en pauzeert de uitvoering, waarbij de lokale toestand behouden blijft.
Ze kunnen veilig oneindige reeksen beschrijven.
De compiler genereert de toestandsmachine voor je.

Gratis beginnen

Leer C# met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 93
Lessen: 346

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Iteratormethoden met yield return” gratis?

Ja — de volledige tekst van “Iteratormethoden met yield return” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus C# Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus C# Academy bevat in totaal 4 lessen.

Wat leer ik in “Iteratormethoden met yield return”?

Genereer reeksen één element tegelijk. Je oefent met C# Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met C# Academy te beginnen?

Ervaring vooraf is niet nodig. C# Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “Iteratormethoden met yield return”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over C# Academy?

Ja. Elke les over C# Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar C# Academy