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 Az utasítás elérésekor a kód aktuális helye meg lesz jegyezve. 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 hurok első iterációja miatt a foreach 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.
Feljegyzés
A jelen témakör egyszerű iterátor példáján kívül az összes példában szerepeljen a névterekre és System.Collections.Generic a System.Collections névterekre vonatkozó irányelvek használata.
Egyszerű iterátor
Az alábbi példa egyetlen yield return utasítással rendelkezik, amely egy cikluson belül található. Az Mainutasítás törzsének minden iterációja foreach létrehoz egy hívást az iterátorfüggvényhez, amely a következő yield return utasításra folytatódik.
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.
A GetEnumerator metódus az utasítás használatával egyenként adja vissza az yield return egyes sztringeket.
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 hivatkozó és Mammals a Birds tulajdonságokra hivatkozó utasítások a nevesített iterátor metódust AnimalsForType 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 az utasítással adja vissza a yield return 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 általános implementáció a generikus implementációval szembetűn.
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 metódus és BottomToTop a TopToBottom tulajdonságokTopN.
A BottomToTop tulajdonság egy tartozék iterátorát get használja.
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 paraméterekkel invagy out paraméterekkelref.
A C#-ban nem egy fenntartott szó, yield és csak akkor van különleges jelentése, ha egy vagy break több return 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átori 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 az Currentillesztő vagy IEnumerator<T> felület IEnumerator , MoveNextés Dispose metódusait.
A ciklus minden egymást követő iterációján foreach (vagy a közvetlen híváson IEnumerator.MoveNext) a következő iterátor kódtörzse folytatódik az előző yield return utasítás után. Ezután a következő yield return utasítást folytatja az iterátor törzsének végéig vagy az utasítás eléréséig yield break .
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 által visszaadott iterátor NotSupportedExceptionmeghívása Reset egy .
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 hurok egyszerűségét foreach , ha összetett kóddal kell feltöltenie egy listaütemezést. Ez akkor lehet hasznos, ha a következőket szeretné elvégezni:
Módosítsa a listaütemezést az első
foreachciklus iterációja után.Kerülje a nagy lista teljes betöltését a ciklus első iterációja
foreachelőtt. Ilyen például egy lapszámozott beolvasás, amely táblázatsorok kötegét tölti be. Egy másik példa a EnumerateFiles metódus, amely iterátorokat implementál a .NET-ben.Foglalja össze a listát az iterátorban. Az iterátor metódusban létrehozhatja a listát, majd minden eredményt egy hurokban hozhat létre.
