Iteratorer (C#)
En iterator kan användas för att gå igenom samlingar som listor och matriser.
En iteratormetod eller get -accessor utför en anpassad iteration över en samling. En iteratormetod använder avkastningsreturinstrukturen för att returnera varje element ett i taget. När en yield return instruktion har nåtts sparas den aktuella platsen i koden. Körningen startas om från den platsen nästa gång iteratorfunktionen anropas.
Du använder en iterator från klientkoden med hjälp av en foreach-instruktion eller med hjälp av en LINQ-fråga.
I följande exempel gör den första iterationen av loopen att körningen foreachSomeNumbers fortsätter i iteratormetoden tills den första yield return instruktionen har nåtts. Den här iterationen returnerar värdet 3 och den aktuella platsen i iteratormetoden behålls. Vid nästa iteration av loopen fortsätter körningen i iteratormetoden från där den slutade och stoppas igen när den når en yield return -instruktion. Den här iterationen returnerar värdet 5 och den aktuella platsen i iteratormetoden behålls igen. Loopen slutförs när iteratormetodens slut har nåtts.
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;
}
Returtypen för en iteratormetod eller get -accessor kan vara IEnumerable, IEnumerable<T>, IEnumeratoreller IEnumerator<T>.
Du kan använda en yield break -instruktion för att avsluta iterationen.
Kommentar
För alla exempel i det här avsnittet förutom simple iterator-exemplet inkluderar du att använda direktiv för System.Collections namnrymderna och System.Collections.Generic .
Enkel iterator
I följande exempel finns en enda yield return instruktion som finns i en for-loop . I Mainskapar varje iteration av instruktionstexten foreach ett anrop till iteratorfunktionen, som fortsätter till nästa yield return instruktion.
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;
}
}
}
Skapa en samlingsklass
I följande exempel DaysOfTheWeek implementerar IEnumerable klassen gränssnittet, som kräver en GetEnumerator metod. Kompilatorn anropar GetEnumerator implicit metoden, som returnerar en IEnumerator.
Metoden GetEnumerator returnerar varje sträng en i taget med hjälp av -instruktionen yield return .
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];
}
}
}
I följande exempel skapas en Zoo klass som innehåller en samling djur.
Instruktionen foreach som refererar till klassinstansen (theZoo) anropar GetEnumerator implicit metoden. De foreach instruktioner som refererar till Birds egenskaperna och Mammals använder den namngivna AnimalsForType iteratormetoden.
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; }
}
}
Använda iteratorer med en allmän lista
I följande exempel implementerar den Stack<T> generiska klassen det IEnumerable<T> generiska gränssnittet. Metoden Push tilldelar värden till en matris av typen T. Metoden GetEnumerator returnerar matrisvärdena med hjälp av -instruktionen yield return .
Förutom den generiska GetEnumerator metoden måste även den icke-generiska GetEnumerator metoden implementeras. Det beror på att IEnumerable<T> ärver från IEnumerable. Den icke-generiska implementeringen skjuter upp den allmänna implementeringen.
I exemplet används namngivna iteratorer för att stödja olika sätt att iterera genom samma datainsamling. Dessa namngivna iteratorer är TopToBottom egenskaperna och BottomToTop och TopN metoden.
Egenskapen BottomToTop använder en iterator i en get accessor.
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];
}
}
}
Syntaxinformation
En iterator kan ske som en metod eller get accessor. En iterator kan inte inträffa i en händelse, instanskonstruktor, statisk konstruktor eller statisk finaliserare.
En implicit konvertering måste finnas från uttryckstypen i -instruktionen yield return till typargumentet för den IEnumerable<T> som returneras av iteratorn.
I C# kan en iteratormetod inte ha några inparametrar , refeller out parametrar.
I C# yield är inte ett reserverat ord och har särskild betydelse endast när det används före ett eller break ett return nyckelord.
Teknisk implementering
Även om du skriver en iterator som en metod översätter kompilatorn den till en kapslad klass som i själva verket är en tillståndsdator. Den här klassen håller reda på iteratorns position så länge loopen foreach i klientkoden fortsätter.
Om du vill se vad kompilatorn gör kan du använda verktyget Ildasm.exe för att visa den vanliga mellanliggande språkkoden som genereras för en iteratormetod.
När du skapar en iterator för en klass eller struct behöver du inte implementera hela IEnumerator gränssnittet. När kompilatorn identifierar iteratorn genereras Currentautomatiskt metoderna IEnumerator , MoveNextoch och Dispose i gränssnittet.IEnumerator<T>
På varje efterföljande iteration av loopen foreach (eller direktanropet till IEnumerator.MoveNext) återupptas nästa iteratorkodtext efter föregående yield return instruktion. Den fortsätter sedan till nästa yield return -instruktion tills slutet av iteratortexten har nåtts, eller tills en yield break instruktion påträffas.
Iteratorer stöder IEnumerator.Reset inte metoden. Om du vill upprepa från början måste du skaffa en ny iterator. Anropar Reset iteratorn som returneras av en iteratormetod genererar en NotSupportedException.
Mer information finns i C#-språkspecifikationen.
Användning av iteratorer
Med iteratorer kan du upprätthålla enkelheten i en foreach loop när du behöver använda komplex kod för att fylla i en listsekvens. Detta kan vara användbart när du vill göra följande:
Ändra listsekvensen efter den första
foreachloop-iterationen.Undvik att helt läsa in en stor lista före den första iterationen av en
foreachloop. Ett exempel är en sidhämtning för att läsa in en batch med tabellrader. Ett annat exempel är metoden EnumerateFiles som implementerar iteratorer i .NET.Kapsla in att skapa listan i iteratorn. I iteratormetoden kan du skapa listan och sedan ge varje resultat i en loop.
