Iterátorok (C#)

Az iterátor segítségével végiglépkedhet a gyűjteményeken, például listákon és tömbökön.

Az iterátor metódus vagy get tartozék egyéni iterációt hajt végre egy gyűjteményen keresztül. Az iterátor metódus a hozamvisszautasítást használja az egyes elemek egyenkénti visszaadásához. yield return utasítás elérésekor megjegyzik a kód aktuális helyét. A végrehajtás a következő iterátorfüggvény meghívásakor indul újra erről a helyről.

Az ügyfélkódból származó iterátort foreach utasítással vagy LINQ-lekérdezéssel használhatja.

Az alábbi példában a foreach hurok első iterációja azt eredményezi, hogy a végrehajtás az SomeNumbers iterátor metódusban folytatódik, amíg el nem éri az első yield return utasítást. Ez az iteráció 3 értéket ad vissza, és az iterátor metódus aktuális helye megmarad. A hurok következő iterációjában a végrehajtás az iterátor metódusban attól a helytől folytatódik, ahol abbahagyta, és ismét leáll, amikor eléri az utasítást yield return . Ez az iteráció 5 értéket ad vissza, és az iterátor metódus aktuális helye ismét megmarad. A ciklus akkor fejeződik be, amikor az iterátor metódus vége el van érve.

static void Main()
{
    foreach (int number in SomeNumbers())
    {
        Console.Write(number.ToString() + " ");
    }
    // Output: 3 5 8
    Console.ReadKey();
}

public static System.Collections.IEnumerable SomeNumbers()
{
    yield return 3;
    yield return 5;
    yield return 8;
}

Az iterátor metódus vagy get tartozék visszatérési típusa lehet IEnumerable, IEnumerable<T>IEnumeratorvagy IEnumerator<T>.

Egy utasítással yield break befejezheti az iterációt.

Megjegyzés:

A jelen témakör egyszerű iterátor példáján kívül az összes példában tartalmazzon használati direktívák System.Collections és System.Collections.Generic névterekre.

Egyszerű iterátor

Az alábbi példa egyetlen yield return utasítással rendelkezik, amely egy cikluson belül található. A Main utasítás törzsének minden egyes iterációja létrehoz egy hívást az foreach iterátorfüggvényhez, amely a következő yield return utasításra lép tovább.

static void Main()
{
    foreach (int number in EvenSequence(5, 18))
    {
        Console.Write(number.ToString() + " ");
    }
    // Output: 6 8 10 12 14 16 18
    Console.ReadKey();
}

public static System.Collections.Generic.IEnumerable<int>
    EvenSequence(int firstNumber, int lastNumber)
{
    // Yield even numbers in the range.
    for (int number = firstNumber; number <= lastNumber; number++)
    {
        if (number % 2 == 0)
        {
            yield return number;
        }
    }
}

Gyűjteményosztály létrehozása

Az alábbi példában az DaysOfTheWeek osztály implementálja az IEnumerable interfészt, amelyhez metódusra GetEnumerator van szükség. A fordító implicit módon meghívja a GetEnumerator metódust, amely egy IEnumerator ad vissza.

A GetEnumerator metódus az yield return kifejezés használatával egyenként ad vissza minden sztringet.

static void Main()
{
    DaysOfTheWeek days = new DaysOfTheWeek();

    foreach (string day in days)
    {
        Console.Write(day + " ");
    }
    // Output: Sun Mon Tue Wed Thu Fri Sat
    Console.ReadKey();
}

public class DaysOfTheWeek : IEnumerable
{
    private string[] days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];

    public IEnumerator GetEnumerator()
    {
        for (int index = 0; index < days.Length; index++)
        {
            // Yield each day of the week.
            yield return days[index];
        }
    }
}

Az alábbi példa egy Zoo állatgyűjteményt tartalmazó osztályt hoz létre.

Az foreach osztálypéldányra (theZoo) hivatkozó utasítás implicit módon meghívja a metódust GetEnumerator . A foreach utasítások, amelyek a Birds és Mammals tulajdonságokra hivatkoznak, a AnimalsForType nevesített iterátor metódust használják.

static void Main()
{
    Zoo theZoo = new Zoo();

    theZoo.AddMammal("Whale");
    theZoo.AddMammal("Rhinoceros");
    theZoo.AddBird("Penguin");
    theZoo.AddBird("Warbler");

    foreach (string name in theZoo)
    {
        Console.Write(name + " ");
    }
    Console.WriteLine();
    // Output: Whale Rhinoceros Penguin Warbler

    foreach (string name in theZoo.Birds)
    {
        Console.Write(name + " ");
    }
    Console.WriteLine();
    // Output: Penguin Warbler

    foreach (string name in theZoo.Mammals)
    {
        Console.Write(name + " ");
    }
    Console.WriteLine();
    // Output: Whale Rhinoceros

    Console.ReadKey();
}

public class Zoo : IEnumerable
{
    // Private members.
    private List<Animal> animals = new List<Animal>();

    // Public methods.
    public void AddMammal(string name)
    {
        animals.Add(new Animal { Name = name, Type = Animal.TypeEnum.Mammal });
    }

    public void AddBird(string name)
    {
        animals.Add(new Animal { Name = name, Type = Animal.TypeEnum.Bird });
    }

    public IEnumerator GetEnumerator()
    {
        foreach (Animal theAnimal in animals)
        {
            yield return theAnimal.Name;
        }
    }

    // Public members.
    public IEnumerable Mammals
    {
        get { return AnimalsForType(Animal.TypeEnum.Mammal); }
    }

    public IEnumerable Birds
    {
        get { return AnimalsForType(Animal.TypeEnum.Bird); }
    }

    // Private methods.
    private IEnumerable AnimalsForType(Animal.TypeEnum type)
    {
        foreach (Animal theAnimal in animals)
        {
            if (theAnimal.Type == type)
            {
                yield return theAnimal.Name;
            }
        }
    }

    // Private class.
    private class Animal
    {
        public enum TypeEnum { Bird, Mammal }

        public string Name { get; set; }
        public TypeEnum Type { get; set; }
    }
}

Iterátorok használata általános listával

Az alábbi példában az Stack<T> általános osztály implementálja az IEnumerable<T> általános felületet. A Push metódus értékeket rendel egy típustömbhöz T. A GetEnumerator metódus a yield return utasítás használatával adja vissza a tömbértékeket.

Az általános GetEnumerator módszer mellett a nem általános GetEnumerator módszert is végre kell hajtani. Ennek az az oka, hogy IEnumerable<T> örökli a IEnumerable. A nem generikus implementáció áttér a generikus implementációra.

A példa nevesített iterátorokkal támogatja az azonos adatgyűjteményen keresztüli iterálás különböző módjait. Ezek az elnevezett iterátorok a TopToBottom és BottomToTop tulajdonságok, és a TopN metódus.

A BottomToTop tulajdonság egy iterátort használ a get tartozékban.

static void Main()
{
    Stack<int> theStack = new Stack<int>();

    //  Add items to the stack.
    for (int number = 0; number <= 9; number++)
    {
        theStack.Push(number);
    }

    // Retrieve items from the stack.
    // foreach is allowed because theStack implements IEnumerable<int>.
    foreach (int number in theStack)
    {
        Console.Write("{0} ", number);
    }
    Console.WriteLine();
    // Output: 9 8 7 6 5 4 3 2 1 0

    // foreach is allowed, because theStack.TopToBottom returns IEnumerable(Of Integer).
    foreach (int number in theStack.TopToBottom)
    {
        Console.Write("{0} ", number);
    }
    Console.WriteLine();
    // Output: 9 8 7 6 5 4 3 2 1 0

    foreach (int number in theStack.BottomToTop)
    {
        Console.Write("{0} ", number);
    }
    Console.WriteLine();
    // Output: 0 1 2 3 4 5 6 7 8 9

    foreach (int number in theStack.TopN(7))
    {
        Console.Write("{0} ", number);
    }
    Console.WriteLine();
    // Output: 9 8 7 6 5 4 3

    Console.ReadKey();
}

public class Stack<T> : IEnumerable<T>
{
    private T[] values = new T[100];
    private int top = 0;

    public void Push(T t)
    {
        values[top] = t;
        top++;
    }
    public T Pop()
    {
        top--;
        return values[top];
    }

    // This method implements the GetEnumerator method. It allows
    // an instance of the class to be used in a foreach statement.
    public IEnumerator<T> GetEnumerator()
    {
        for (int index = top - 1; index >= 0; index--)
        {
            yield return values[index];
        }
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    public IEnumerable<T> TopToBottom
    {
        get { return this; }
    }

    public IEnumerable<T> BottomToTop
    {
        get
        {
            for (int index = 0; index <= top - 1; index++)
            {
                yield return values[index];
            }
        }
    }

    public IEnumerable<T> TopN(int itemsFromTop)
    {
        // Return less than itemsFromTop if necessary.
        int startIndex = itemsFromTop >= top ? 0 : top - itemsFromTop;

        for (int index = top - 1; index >= startIndex; index--)
        {
            yield return values[index];
        }
    }

}

Szintaxis adatai

Az iterátor módszerként vagy get tartozékként is előfordulhat. Iterátor nem fordulhat elő eseményben, példánykonstruktorban, statikus konstruktorban vagy statikus véglegesítőben.

Implicit átalakításnak kell léteznie az utasítás kifejezéstípusától yield return az iterátor által visszaadott típusargumentumig IEnumerable<T> .

A C#-ban egy iterátormetódus nem rendelkezhet in, ref vagy out paraméterekkel.

A C#-ban a yield nem fenntartott szó, és csak akkor van különleges jelentése, ha return vagy break kulcsszó előtt használják.

Technikai megvalósítás

Bár egy iterátort metódusként ír, a fordító beágyazott osztályba fordítja, amely tulajdonképpen állapotgép. Ez az osztály mindaddig nyomon követi az iterátor pozícióját, amíg az foreach ügyfélkód ciklusa folytatódik.

A fordító által végzett műveletek megtekintéséhez az Ildasm.exe eszközzel megtekintheti az iterátor metódushoz létrehozott közös köztes nyelvi kódot.

Amikor létrehoz egy iterátort egy osztályhoz vagy egy szerkezethez, nem kell implementálnia a teljes IEnumerator felületet. Amikor a fordító észleli az iterátort, automatikusan létrehozza a Current vagy MoveNext felület Dispose, IEnumerator és IEnumerator<T> metódusait.

Az foreach ciklus (vagy a IEnumerator.MoveNext közvetlen hívás) minden következő iterációjában a következő iterátor kódtörzse az előző yield return utasítás után folytatódik. Ezután a következő yield return utasítást hajtja végre az iterátor törzsének végéig, vagy amíg el nem ér egy yield break utasítást.

Az iterátorok nem támogatják a metódust IEnumerator.Reset . Az első lépések megismétléséhez be kell szereznie egy új iterátort. Az iterátor metódus által visszaadott iterátor esetében a Reset meghívása kivételt dob, a NotSupportedException.

További információkért lásd a C# nyelvi specifikációját.

Iterátorok használata

Az iterátorok lehetővé teszik a hurkok egyszerűségének megőrzését foreach, amikor összetett kódot kell használnia egy lista sorozat feltöltéséhez. Ez akkor lehet hasznos, ha a következőket szeretné elvégezni:

• Módosítsa a listaütemezést az első foreach ciklus iterációja után.

• Kerülje el, hogy egy nagy listát teljesen betöltsön, mielőtt egy foreach ciklus első iterációja megtörténik. Ilyen például egy lapozott adatlekérés, amely táblázatsorok tételét tölti be. Egy másik példa a EnumerateFiles metódus, amely iterátorokat implementál a .NET-ben.

• Építse be a lista összeállítását az iterátorba. Az iterátor metódusban létrehozhatja a listát, majd minden eredményt egy hurokban hozhat létre.

Lásd még

• System.Collections.Generic
• IEnumerable<T>
• foreach,
• Generikus típusok