Itérateurs (Visual Basic)

2025-06-19

Un itérateur peut être utilisé pour parcourir des collections telles que des listes et des tableaux.

Une méthode d’itérateur ou bien un accesseur get effectue une itération personnalisée sur une collection. Une méthode d’itérateur utilise l’instruction Yield pour renvoyer chaque élément un à la fois. Lorsqu’une Yield instruction est atteinte, l’emplacement actuel dans le code est mémorisé. L’exécution est redémarrée à partir de cet emplacement la prochaine fois que la fonction itérateur est appelée.

Vous consommez un itérateur dans le code client à l'aide d'une instruction For Each…Next ou d'une requête LINQ.

Dans l’exemple suivant, la première itération de la For Each boucle entraîne l’exécution dans la SomeNumbers méthode itérateur jusqu’à ce que la première Yield instruction soit atteinte. Cette itération retourne une valeur de 3, et l’emplacement actuel de la méthode itérateur est conservé. Lors de l’itération suivante de la boucle, l’exécution dans la méthode itérateur continue à partir de l’endroit où elle s’est arrêtée, puis s’arrête à nouveau lorsqu’elle atteint une Yield instruction. Cette itération retourne une valeur de 5, et l’emplacement actuel dans la méthode itérateur est à nouveau conservé. La boucle se termine lorsque la fin de la méthode itérateur est atteinte.

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

Le type de retour d’une méthode itérateur ou get d’un accesseur peut être IEnumerable, IEnumerable<T>, IEnumerator, ou IEnumerator<T>.

Vous pouvez utiliser une instruction Exit Function ou Return pour mettre fin à l’itération.

Une fonction d’itérateur ou une déclaration d’accesseur get Visual Basic inclut un modificateur d’itérateur.

Les itérateurs ont été introduits dans Visual Basic dans Visual Studio 2012.

Remarque

Pour tous les exemples de l’article, à l’exception de l’exemple Iterator simple, incluez des instructions Imports pour les espaces de noms System.Collections et System.Collections.Generic.

Itérateur simple

L’exemple suivant contient une instruction unique Yield qui se trouve à l’intérieur d’une boucle Pour...Next. Dans Main, chaque itération du corps de l’instruction For Each crée un appel à la fonction itérateur, qui passe à l’instruction suivante Yield .

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

Création d’une classe de collection

Dans l’exemple suivant, la DaysOfTheWeek classe implémente l’interface IEnumerable , ce qui nécessite une GetEnumerator méthode. Le compilateur appelle implicitement la GetEnumerator méthode, qui retourne un IEnumerator.

La GetEnumerator méthode retourne chaque chaîne une à la fois à l’aide de l’instruction Yield , et un Iterator modificateur se trouve dans la déclaration de fonction.

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

L’exemple suivant crée une Zoo classe qui contient une collection d’animaux.

L’instruction For Each qui fait référence à l’instance de classe (theZoo) appelle implicitement la GetEnumerator méthode. Les instructions For Each qui se réfèrent aux propriétés Birds et Mammals utilisent la méthode d'itération nommée AnimalsForType.

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

Blocs Try

Visual Basic autorise une instruction Yield dans le bloc Try d’une Instruction Try...Catch...Finally. Un Try bloc qui a une Yield instruction peut contenir des blocs Catch et un bloc Finally.

L’exemple suivant inclut Try, Catchet Finally les blocs dans une fonction d’itérateur. Le Finally bloc de la fonction itérateur s’exécute avant la fin de l’itération For Each .

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

Une Yield instruction ne peut pas se trouver à l’intérieur d’un Catch bloc ou d’un Finally bloc.

Si le For Each corps (au lieu de la méthode itérateur) lève une exception, un bloc Catch dans la fonction d'itérateur n’est pas exécuté, mais un bloc Finally dans la fonction d'itérateur est exécuté. Un Catch bloc à l’intérieur d’une fonction d’itérateur intercepte uniquement les exceptions qui se produisent à l’intérieur de la fonction d’itérateur.

Méthodes anonymes

Dans Visual Basic, une fonction anonyme peut être une fonction itérateur. L’exemple suivant illustre cela.

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

L’exemple suivant a une méthode non itérateur qui valide les arguments. La méthode retourne le résultat d’un itérateur anonyme qui décrit les éléments de collection.

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

Si la validation se trouve à l'intérieur de la fonction de l'itérateur, elle ne peut pas être effectuée avant le début de la première itération du corps For Each.

Utilisation d’itérateurs avec une liste générique

Dans l’exemple suivant, la Stack(Of T) classe générique implémente l’interface IEnumerable<T> générique. La Push méthode affecte des valeurs à un tableau de type T. La GetEnumerator méthode retourne les valeurs de tableau à l’aide de l’instruction Yield .

Outre la méthode générique GetEnumerator , la méthode non générique GetEnumerator doit également être implémentée. C’est parce que IEnumerable<T> hérite de IEnumerable. L’implémentation non générique s’en remet à l’implémentation générique.

L’exemple utilise des itérateurs nommés pour prendre en charge différentes façons d’itérer au sein de la même collection de données. Ces itérateurs nommés sont les propriétés TopToBottom et BottomToTop, ainsi que la méthode TopN.

La déclaration de BottomToTop propriété inclut le Iterator mot clé.

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

Informations de syntaxe

Un itérateur peut être une méthode ou un get accesseur. Un itérateur ne peut pas se produire dans un événement, un constructeur d’instance, un constructeur statique ou un destructeur statique.

Une conversion implicite doit exister du type d’expression de l’instruction Yield au type de retour de l’itérateur.

Dans Visual Basic, une méthode d’itérateur ne peut pas avoir de ByRef paramètres.

Dans Visual Basic, « Yield » n’est pas un mot réservé et a une signification particulière uniquement lorsqu’il est utilisé dans un Iterator méthode ou get accesseur.

Implémentation technique

Bien que vous écriviez un itérateur en tant que méthode, le compilateur le traduit en une classe imbriquée, en effet, une machine d’état. Cette classe effectue le suivi de la position de l’itérateur tant que la For Each...Next boucle dans le code client se poursuit.

Pour voir ce que fait le compilateur, vous pouvez utiliser l’outil Ildasm.exe pour afficher le code de langage intermédiaire commun généré pour une méthode d’itérateur.

Lorsque vous créez un itérateur pour une classe ou un struct, vous n’avez pas besoin d’implémenter l’interface entière IEnumerator . Lorsque le compilateur détecte l'itérateur, il génère automatiquement les méthodes Current, MoveNext, et Dispose de l’interface IEnumerator ou IEnumerator<T>.

À chaque itération successive de la boucle For Each…Next (ou de l’appel direct à IEnumerator.MoveNext), le corps du code de l’itérateur suivant reprend après l’instruction Yield précédente. Il passe ensuite à l’instruction suivante Yield jusqu’à ce que la fin du corps de l’itérateur soit atteinte, ou jusqu’à ce qu’une instruction Exit Function ou Return soit rencontrée.

Les itérateurs ne prennent pas en charge la IEnumerator.Reset méthode. Pour effectuer une nouvelle itération à partir du début, vous devez obtenir un nouvel itérateur.

Pour plus d’informations, consultez la spécification du langage Visual Basic.

Utilisation d’itérateurs

Les itérateurs vous permettent de maintenir la simplicité d’une For Each boucle lorsque vous devez utiliser du code complexe pour remplir une séquence de listes. Cela peut être utile lorsque vous souhaitez effectuer les opérations suivantes :

Modifiez la séquence de liste après la première For Each itération de boucle.
Évitez de charger entièrement une liste volumineuse avant la première itération d’une For Each boucle. Une extraction paginée pour charger un lot de lignes d’une table est un exemple. Un autre exemple est la EnumerateFiles méthode, qui implémente des itérateurs dans le .NET Framework.
Encapsuler la construction de la liste dans l’itérateur. Dans la méthode d’itérateur, vous pouvez générer la liste, puis générer chaque résultat dans une boucle.

Partager via