Iterátory (C# and Visual Basic)
Iterátor lze použít ke krokování kolekcí, například seznamy a pole.
Metodu iterátor nebo get přistupující objekt provádí vlastní iterace v kolekci.Používá metodu iterátor výnosu z (Visual Basic) nebo příkazu yield return (C#) příkaz vrátit každý prvek v čase.Když Yield nebo yield return prohlášení, je dosaženo, je zapamatované aktuální umístění v kódu.Spuštění z tohoto umístění restartován při příštím iterační funkce je volána.
Spotřebovat iterátor z klientského kódu pomocí For Each...Další (Visual Basic) nebo foreach prohlášení (C#) nebo pomocí dotazu LINQ.
V následujícím příkladu první opakování For Each nebo foreach smyčka způsobí spuštění pokračovat v SomeNumbers iterační metoda do prvního Yield nebo yield return prohlášení, je dosaženo.Tato iterace vrátí hodnotu 3 a zachovány aktuální umístění v iterační metodu.Na další opakování smyčky v iterační metoda pokračuje odkud byl přerušen, opět zastaven při dosažení Yield nebo yield return prohlášení.Tato iterace vrátí hodnotu 5 a znovu zachován aktuální umístění v iterační metodu.Když je dosaženo konce iterační metoda dokončení smyčky.
Sub Main()
For Each number As Integer In SomeNumbers()
Console.Write(number & " ")
Next
' Output: 3 5 8
Console.ReadKey()
End Sub
Private Iterator Function SomeNumbers() As System.Collections.IEnumerable
Yield 3
Yield 5
Yield 8
End Function
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;
}
Návratový typ metody iterace nebo get přistupující objekt může být IEnumerable, IEnumerable, IEnumerator, nebo IEnumerator.
Můžete použít Exit Function nebo Return prohlášení (Visual Basic) nebo yield break příkaz Ukončit iterace (C#).
A Visual Basic funkce iterační nebo get obsahuje deklaraci přistupujícího objektu iterátor modifikátor.
U iterátorů byly zavedeny v jazyce C# v Visual Studio 2005a byly zavedeny v Visual Basic v Visual Studio 2012.
V tomto tématu
Jednoduché iterátor
Vytvoření třídy kolekce
Zkuste bloky v jazyce Visual Basic
Anonymní metody v jazyce Visual Basic
Pomocí iterátorů obecný seznam
Informace o syntaxi
Technická implementace
Použití iterátorů.
Jednoduché iterátor
V následujícím příkladu má jeden Yield nebo yield return příkaz, který je uvnitř pro...Next (Visual Basic) or for (C#) loop.V Main, každé opakování For Each nebo foreach prohlášení subjektu vytvoří volání funkce iterátor, který pokračuje na další Yield nebo yield return prohlášení.
Sub Main()
For Each number As Integer In EvenSequence(5, 18)
Console.Write(number & " ")
Next
' Output: 6 8 10 12 14 16 18
Console.ReadKey()
End Sub
Private Iterator Function EvenSequence(
ByVal firstNumber As Integer, ByVal lastNumber As Integer) _
As System.Collections.Generic.IEnumerable(Of Integer)
' Yield even numbers in the range.
For number As Integer = firstNumber To lastNumber
If number Mod 2 = 0 Then
Yield number
End If
Next
End Function
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;
}
}
}
Vytvoření třídy kolekce
[!POZNÁMKA]
Zbývající příklady v tématu patří dovozy příkazy (Visual Basic) nebo pomocí směrnic (C#) pro System.Collections a System.Collections.Generic obory názvů.
V následujícím příkladu DaysOfTheWeek implementuje třída IEnumerable rozhraní, které vyžaduje GetEnumerator metoda.Kompilátor implicitně volá GetEnumerator metodu, která vrací IEnumerator.
GetEnumerator Metoda vrátí každý řetězec, jeden po druhém pomocí Yield nebo yield return prohlášení.V Visual Basic kód, Iterator Modifikátor je v deklaraci funkce.
Sub Main()
Dim days As New DaysOfTheWeek()
For Each day As String In days
Console.Write(day & " ")
Next
' Output: Sun Mon Tue Wed Thu Fri Sat
Console.ReadKey()
End Sub
Private Class DaysOfTheWeek
Implements IEnumerable
Public days =
New String() {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}
Public Iterator Function GetEnumerator() As IEnumerator _
Implements IEnumerable.GetEnumerator
' Yield each day of the week.
For i As Integer = 0 To days.Length - 1
Yield days(i)
Next
End Function
End Class
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];
}
}
}
Následující příklad vytvoří Zoo třída, která obsahuje kolekci zvířat.
For Each Nebo foreach příkaz, který odkazuje na instanci třídy (theZoo) implicitně volá GetEnumerator metoda.For Each Nebo foreach příkazy, které odkazují Birds a Mammals použití vlastnosti AnimalsForType s názvem iterační metodu.
Sub Main()
Dim theZoo As New Zoo()
theZoo.AddMammal("Whale")
theZoo.AddMammal("Rhinoceros")
theZoo.AddBird("Penguin")
theZoo.AddBird("Warbler")
For Each name As String In theZoo
Console.Write(name & " ")
Next
Console.WriteLine()
' Output: Whale Rhinoceros Penguin Warbler
For Each name As String In theZoo.Birds
Console.Write(name & " ")
Next
Console.WriteLine()
' Output: Penguin Warbler
For Each name As String In theZoo.Mammals
Console.Write(name & " ")
Next
Console.WriteLine()
' Output: Whale Rhinoceros
Console.ReadKey()
End Sub
Public Class Zoo
Implements IEnumerable
' Private members.
Private animals As New List(Of Animal)
' Public methods.
Public Sub AddMammal(ByVal name As String)
animals.Add(New Animal With {.Name = name, .Type = Animal.TypeEnum.Mammal})
End Sub
Public Sub AddBird(ByVal name As String)
animals.Add(New Animal With {.Name = name, .Type = Animal.TypeEnum.Bird})
End Sub
Public Iterator Function GetEnumerator() As IEnumerator _
Implements IEnumerable.GetEnumerator
For Each theAnimal As Animal In animals
Yield theAnimal.Name
Next
End Function
' Public members.
Public ReadOnly Property Mammals As IEnumerable
Get
Return AnimalsForType(Animal.TypeEnum.Mammal)
End Get
End Property
Public ReadOnly Property Birds As IEnumerable
Get
Return AnimalsForType(Animal.TypeEnum.Bird)
End Get
End Property
' Private methods.
Private Iterator Function AnimalsForType( _
ByVal type As Animal.TypeEnum) As IEnumerable
For Each theAnimal As Animal In animals
If (theAnimal.Type = type) Then
Yield theAnimal.Name
End If
Next
End Function
' Private class.
Private Class Animal
Public Enum TypeEnum
Bird
Mammal
End Enum
Public Property Name As String
Public Property Type As TypeEnum
End Class
End Class
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; }
}
}
Zkuste bloky v jazyce Visual Basic
Visual Basicumožňuje Yield prohlášení v Try blokovat z Try...Catch....Finally – příkaz (Visual Basic).A Try blok, který má Yield příkaz může mít Catch blokuje a může mít Finally bloku.
.gif "Poznámka k jazyku C#") Poznámka k jazyku C# |
|---|
C# umožňuje yield return prohlášení v try blokovat z try-finally prohlášení.A try blok, který má yield return prohlášení nemůže obsahovat ani catch bloky. |
Následující Visual Basic příklad obsahuje Try, Catch, a Finally blokuje v iterátor funkci.Finally Blok v iterační funkce provede před For Each nedokončí iterace.
Sub Main()
For Each number As Integer In Test()
Console.WriteLine(number)
Next
Console.WriteLine("For Each is done.")
' Output:
' 3
' 4
' Something happened. Yields are done.
' Finally is called.
' For Each is done.
Console.ReadKey()
End Sub
Private Iterator Function Test() As IEnumerable(Of Integer)
Try
Yield 3
Yield 4
Throw New Exception("Something happened. Yields are done.")
Yield 5
Yield 6
Catch ex As Exception
Console.WriteLine(ex.Message)
Finally
Console.WriteLine("Finally is called.")
End Try
End Function
A Yield příkaz nemůže být uvnitř Catch bloku nebo Finally bloku.
Pokud For Each subjektu (namísto metody iterace) vyvolá výjimku, Catch blok ve funkci iterátor není spuštěn, ale Finally blok ve funkci iterátor je proveden.A Catch bloku funkce jazyka iterátor zachytí pouze výjimky, ke kterým dochází uvnitř funkce iterační.
Anonymní metody v jazyce Visual Basic
V Visual Basic (ale ne v jazyce C#), anonymní funkce může být funkce jazyka iterátoru.Následující příklad ukazuje to.
Dim iterateSequence = Iterator Function() _
As IEnumerable(Of Integer)
Yield 1
Yield 2
End Function
For Each number As Integer In iterateSequence()
Console.Write(number & " ")
Next
' Output: 1 2
Console.ReadKey()
Následující Visual Basic příklad má bez iterační metodu, která ověřuje argumenty.Metoda vrátí výsledek anonymní iterátor, který popisuje prvky kolekce.
Sub Main()
For Each number As Integer In GetSequence(5, 10)
Console.Write(number & " ")
Next
' Output: 5 6 7 8 9 10
Console.ReadKey()
End Sub
Public Function GetSequence(ByVal low As Integer, ByVal high As Integer) _
As IEnumerable
' Validate the arguments.
If low < 1 Then
Throw New ArgumentException("low is too low")
End If
If high > 140 Then
Throw New ArgumentException("high is too high")
End If
' Return an anonymous iterator function.
Dim iterateSequence = Iterator Function() As IEnumerable
For index = low To high
Yield index
Next
End Function
Return iterateSequence()
End Function
Ověření se místo uvnitř funkce iterační až do zahájení prvního opakování nelze provést ověření For Each subjektu.
Pomocí iterátorů obecný seznam
V následujícím příkladu Stack(Of T) obecná třída implementuje IEnumerable obecné rozhraní.Push Metoda přiřadí hodnoty pole typu T.GetEnumerator Metoda vrátí hodnoty pole pomocí Yield nebo yield return prohlášení.
Kromě obecného GetEnumerator metoda, jiná než obecná GetEnumerator metoda musí být implementovány také.Důvodem je, že IEnumerable dědí z IEnumerable.Provádění jiných neobecných podřídí se Obecná implementace.
V příkladu je pojmenovaná iterátorů podporuje různé způsoby iterace stejné kolekce dat.S názvem iterátorů jsou TopToBottom a BottomToTop vlastností a TopN metoda.
BottomToTop Vlastnost používá iterovat v get přistupujícího objektu.V Visual Basic kód, obsahuje deklaraci vlastnosti Iterator klíčové slovo.
Sub Main()
Dim theStack As New Stack(Of Integer)
' Add items to the stack.
For number As Integer = 0 To 9
theStack.Push(number)
Next
' Retrieve items from the stack.
' For Each is allowed because theStack implements
' IEnumerable(Of Integer).
For Each number As Integer In theStack
Console.Write("{0} ", number)
Next
Console.WriteLine()
' Output: 9 8 7 6 5 4 3 2 1 0
' For Each is allowed, because theStack.TopToBottom
' returns IEnumerable(Of Integer).
For Each number As Integer In theStack.TopToBottom
Console.Write("{0} ", number)
Next
Console.WriteLine()
' Output: 9 8 7 6 5 4 3 2 1 0
For Each number As Integer In theStack.BottomToTop
Console.Write("{0} ", number)
Next
Console.WriteLine()
' Output: 0 1 2 3 4 5 6 7 8 9
For Each number As Integer In theStack.TopN(7)
Console.Write("{0} ", number)
Next
Console.WriteLine()
' Output: 9 8 7 6 5 4 3
Console.ReadKey()
End Sub
Public Class Stack(Of T)
Implements IEnumerable(Of T)
Private values As T() = New T(99) {}
Private top As Integer = 0
Public Sub Push(ByVal t As T)
values(top) = t
top = top + 1
End Sub
Public Function Pop() As T
top = top - 1
Return values(top)
End Function
' This function implements the GetEnumerator method. It allows
' an instance of the class to be used in a For Each statement.
Public Iterator Function GetEnumerator() As IEnumerator(Of T) _
Implements IEnumerable(Of T).GetEnumerator
For index As Integer = top - 1 To 0 Step -1
Yield values(index)
Next
End Function
Public Iterator Function GetEnumerator1() As IEnumerator _
Implements IEnumerable.GetEnumerator
Yield GetEnumerator()
End Function
Public ReadOnly Property TopToBottom() As IEnumerable(Of T)
Get
Return Me
End Get
End Property
Public ReadOnly Iterator Property BottomToTop As IEnumerable(Of T)
Get
For index As Integer = 0 To top - 1
Yield values(index)
Next
End Get
End Property
Public Iterator Function TopN(ByVal itemsFromTop As Integer) _
As IEnumerable(Of T)
' Return less than itemsFromTop if necessary.
Dim startIndex As Integer =
If(itemsFromTop >= top, 0, top - itemsFromTop)
For index As Integer = top - 1 To startIndex Step -1
Yield values(index)
Next
End Function
End Class
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];
}
}
}
Informace o syntaxi
Iterace může dojít jako metoda nebo get přistupujícího objektu.Iterace nelze provést v události, konstruktor instance, statického konstruktoru nebo statické destruktor.
Výraz Type musí existovat implicitní převod Yield (Visual Basic) nebo yield return prohlášení (C#), návratový typ iterace.
V Visual Basic, metodu iterátor nemůže obsahovat ani ByRef parametry.V jazyce C# metodu iterátor nemůže mít ref nebo out parametry.
V Visual Basic, "Výnos" je vyhrazené slovo a má zvláštní význam pouze v případě, že je používán Iterator metoda nebo get přistupujícího objektu.V jazyce C# "výnos" je vyhrazené slovo a má zvláštní význam pouze v případě, že se používá před return nebo break klíčové slovo.
Technická implementace
I když píšete iterátor jako metoda, kompilátor převede jej do vnořené třídy to znamená, ve skutečnosti stavový stroj.Tato třída uchovává informace o pozici iterátor jako dlouhý For Each...Next nebo foreach pokračuje smyčky v klientském kódu.
Chcete-li zjistit, co znamená kompilátor, umožňuje zobrazit kód Microsoft intermediate language, který je generován pro metodu iterátor nástroj Ildasm.exe.
Při vytváření iterátor pro třídy nebo struktury, není nutné provádět celou IEnumerator rozhraní.Když kompilátor zjistí iterace, automaticky generuje Current, MoveNext, a Dispose metody IEnumerator nebo IEnumerator rozhraní.
Při každém opakování po sobě For Each…Next nebo foreach smyčky (nebo přímé volání IEnumerator.MoveNext), další body kódu iterátor pokračuje po předchozím Yield nebo yield return prohlášení.Bude pokračovat na další Yield nebo yield return prohlášení, dokud není dosaženo konce iterátor subjektu, nebo dokud Exit Function nebo Return prohlášení (Visual Basic) nebo yield break zjistil prohlášení (C#).
U iterátorů nepodporují IEnumerator.Reset metoda.K re-iterate od začátku, je nutné získat nový iterátor.
Další informace najdete Specifikace jazyka Visual Basic nebo Specifikace jazyka C#.
Použití iterátorů.
U iterátorů umožňují zachovat jednoduchost For Each opakovat, když potřebujete komplexní kód použít k naplnění seznamu pořadí.To může být užitečné, když chcete provést následující:
Změnit pořadí seznamu po prvním For Each iteraci smyčky.
Vyhnout se plně načítání velkého seznamu před první iterace For Each smyčky.Příkladem je stránkovaného načtení načíst listu řádky tabulky.Dalším příkladem je EnumerateFiles metodu, která implementuje iterátorů v rámci rozhraní.NET Framework.
Zapouzdření, vytváření seznamu iterace.Metody iterace můžete sestavit seznam a potom výnosu z každého výsledku ve smyčce.
Následující C# blogy poskytovat další informace o použití iterátorů.
Viz také
Referenční dokumentace
For Each...Next – příkaz (Visual Basic)
foreach, in (Referenční dokumentace jazyka C#)
yield (Referenční dokumentace jazyka C#)
Použití příkazu foreach s poli (Průvodce programováním v C#)