C# Academy · Lektion

Iteratormetoder med yield return

Generér sekvenser ét element ad gangen.

Lektion 1 af 413 trin

Iteratormetoder med yield return er en gratis C# Academy-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i C# Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. C# Academy-kurset indeholder 4 lektioner i alt.

Hvad er en iteratormetode

En iteratormetode producerer en sekvens af værdier én ad gangen ved hjælp af yield return. Compileren omdanner den til en tilstandsmaskine, så du ikke selv behøver at opbygge og administrere en liste.

Dit første yield return

Hvert yield return afleverer én værdi til den kaldende kode og sætter metoden på pause. Udførelsen fortsætter lige efter denne sætning ved næste gennemløb.

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 i en løkke

De fleste iteratorer leverer værdier fra en løkke. Her genererer vi de første count lige tal uden nogensinde at oprette en samling.

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

Metoden returnerer IEnumerable

En iteratormetode skal returnere IEnumerable<T> eller IEnumerator<T> (eller de ikke-generiske versioner). Du skriver aldrig return med en værdi; du bruger kun 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);
    }
}

Udførelsen sættes på pause og genoptages

Tilstanden mellem yield return-udtrykkene bevares automatisk. Lokale variabler beholder deres værdier under pauserne, og det er det, der gør det så nemt at generere løbende totaler.

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

Generering af uendelige sekvenser

Fordi værdierne produceres efter behov, kan en iterator på sikker vis beskrive en uendelig sekvens. Den kaldende kode bestemmer, hvornår den vil stoppe med at hente værdier.

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

Transformation af en inddata-sekvens

Iteratorer er velegnede til at opbygge behandlingskæder: læs elementer fra én sekvens, omdan dem, og lever resultaterne dovent.

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

Filtrering med iteratorer

For at filtrere skal du blot levere de elementer, du ønsker. Udeladte elementer bliver aldrig produceret, så efterfølgende kode ser dem aldrig.

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

Compileren opbygger en tilstandsmaskine

Bag kulisserne omskriver compileren din iterator til en klasse, der implementerer IEnumerator<T>, og som holder styr på et skjult tilstandsfelt og en Current-værdi. Du får hele denne mekanik automatisk.

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

Sammensætning af flere iteratorer

Iteratorer kan naturligt kædes sammen, fordi hver af dem returnerer en IEnumerable<T>. Giv uddataene fra én iterator videre til den næste for at opbygge læselige behandlingskæder.

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

Prøv selv

Skriv en iterator, der opdeler en inddata-sekvens i blokke med fast størrelse. Den leverer lister efter behov og viser, hvor meget logik der kan være i én enkel iterator.

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

Hurtigt tjek

Husk, hvordan iteratormetoder fungerer.

Besvar den i den interaktive lektion

Opsummering

Iteratormetoder bruger yield return til at producere sekvenser efter behov.

Metoden returnerer IEnumerable<T> eller IEnumerator<T>.
Hvert yield return leverer én værdi og sætter metoden på pause, mens den lokale tilstand bevares.
De kan på sikker vis beskrive uendelige sekvenser.
Compileren genererer tilstandsmaskinen for dig.

Gratis at komme i gang

Lær C# med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 93
Lektioner: 346

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Iteratormetoder med yield return” gratis?

Ja — hele teksten til “Iteratormetoder med yield return” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af C# Academy-kurset, skal du opgradere til CoddyKit PRO. C# Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Iteratormetoder med yield return”?

Generér sekvenser ét element ad gangen. Du øver dig i C# Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på C# Academy?

Der kræves ingen tidligere erfaring. C# Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.

Hvor lang tid tager lektionen “Iteratormetoder med yield return”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne C# Academy-lektion?

Ja. Alle C# Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til C# Academy