Megosztás a következőn keresztül:

Iterátorok (Visual Basic)

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 Hozam utasítással egyenként adja vissza az egyes elemeket. Yield 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 iterátort a klienskódból a For Each…Next utasítás vagy egy LINQ-lekérdezés használatával használja.

Az alábbi példában a For Each 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 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 . 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.

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

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

Az iteráció befejezéséhez használhat egy Exit Function vagy Return utasítást.

A Visual Basic iterátorfüggvények vagy get tartozékdeklarációk iterátor-módosítót tartalmaznak.

Az iterátorokat a Visual Studio 2012 Visual Basicben vezették be.

Megjegyzés:

Az Egyszerű iterátor példa kivételével a cikkben szereplő összes példa tartalmazza az Imports utasításokat a System.Collections és System.Collections.Generic névterekhez.

Egyszerű iterátor

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

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

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 a Yield utasítás használatával egyenként adja vissza a sztringeket, és a függvény deklarációjában szerepel egy Iterator módosító.

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

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

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

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

Blokkok kipróbálás

A Visual Basic lehetővé teszi egy Yield utasítást a Try blokkban egy Try...Catch...Finally utasításban. Az Try utasítással Yield rendelkező blokkok blokkokat tartalmazhatnak Catch , és blokkokat is tartalmazhatnak Finally .

Az alábbi példa Try, Catch és Finally blokkokat tartalmaz egy iterátorfüggvényben. Az Finally iterátorfüggvény blokkja az For Each iteráció befejezése előtt fut.

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

Az Yield utasítás nem lehet blokkban Catch vagy blokkban Finally .

Ha a For Each törzs (az iterátor metódus helyett) kivételt dob, az iterátor függvény Catch blokkja nem kerül végrehajtásra, hanem az iterátor függvény Finally blokkja fog végrehajtásra kerülni. Az Catch iterátorfüggvényen belüli blokkok csak az iterátorfüggvényben előforduló kivételeket rögzítik.

Névtelen metódusok

A Visual Basicben a névtelen függvények iterátorfüggvények lehetnek. Az alábbi példa ezt szemlélteti.

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()

Az alábbi példa egy nem iterátor metódussal rendelkezik, amely ellenőrzi az argumentumokat. A metódus egy névtelen iterátor eredményét adja vissza, amely leírja a gyűjtemény elemeit.

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

Ha az érvényesítés inkább az iterátor függvényen belül történik, az érvényesítést nem lehet végrehajtani addig, amíg meg nem kezdődik a törzs első iterációja For Each.

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

Az alábbi példában az Stack(Of 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 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ágdeklaráció tartalmazza a kulcsszót Iterator .

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

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 destruktorban.

Implicit átalakításnak kell léteznie az utasítás kifejezéstípusától Yield az iterátor visszatérési típusához.

A Visual Basicben egy iterátor metódus nem rendelkezhet ByRef paraméterekkel.

A Visual Basicben a "Yield" nem foglaltszó, és csak akkor van különleges jelentése, ha egy Iterator metódusban vagy get hozzáférőben 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 For Each...Next ü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 struktúrahoz, 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 For Each…Next 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 utasítás után folytatódik. Ezután folytatja a következő Yield utasítással, amíg el nem éri az iterátor törzsének végét, vagy amíg egy Exit Function vagy Return utasítást nem talál.

Az iterátorok nem támogatják a metódust IEnumerator.Reset . Az elejétől kezdve újra kell iterálnia, be kell szereznie egy új iterátort.

További információ: Visual Basic Language Specification.

Iterátorok használata

Az iterátorok lehetővé teszik a hurkok egyszerűségének megőrzését For Each, 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ő For Each ciklus iterációja után.

  • Kerülje el, hogy egy nagy listát teljesen betöltsön, mielőtt egy For Each 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-keretrendszeren belül.

  • É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