Sdílet prostřednictvím

U iterátorů (C# a Visual Basic)

  • Článek

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<T>, IEnumerator, nebo IEnumerator<T>.

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 Zkuste...Úlovek...Nakonec prohlášení (Visual Basic).A Try blok, který má Yield příkaz může mít Catch blokuje a může mít Finally bloku.

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<T> 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<T> 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<T> 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

Pro každý...Další příkaz (Visual Basic)

foreach (C# odkazu)

Příkaz yield (Visual Basic)

výnos (C#-Reference)

Iterace (Visual Basic)

Pomocí foreach s poli (C# program televize)

Generics (Příručka programování C#)

System.Collections.Generic

IEnumerable<T>