Partager via

Itérateurs (C# et Visual Basic)

  • Article

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

Une méthode d'itérateur ou un accesseur get effectue une itération au sein d'une collection.Une méthode d'itérateur utilise l'instruction Yield (Visual Basic) ou yield return (C#) pour retourner les éléments un par un.Lorsqu'une instruction Yield ou yield return est atteinte, la position actuelle dans le code est conservée.L'exécution redémarrera à partir de cet emplacement la prochaine fois que l'itérateur est appelé.

Vous consommez un itérateur de code client à l'aide d'une instruction d' For each… next (Visual Basic) ou d' foreach (c) ou à l'aide d'une requête LINQ.

Dans l'exemple suivant, la première itération de la boucle d' For Each ou d' foreach fait continuer l'exécution de la méthode d'itérateur d' SomeNumbers jusqu'à ce que le premier Yield ou l'instruction d' yield return est atteinte.Cette itération retourne une valeur de 3, et la position actuelle dans la méthode d'itérateur est conservée.Dans l'itération suivante de la boucle, l'exécution de la méthode d'itérateur continue à laquelle elle a été arrêté, de nouveau arrêtant lorsqu'elle atteint une instruction d' Yield ou d' yield return .Cette itération retourne une valeur de 5, et la position actuelle dans la méthode d'itérateur est encore conservée.La boucle se termine lorsque la fin de la méthode d'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

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;
}

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

Vous pouvez utiliser une instruction Exit Function ou Return (Visual Basic) ou une instruction yield break (C#) pour terminer l'itération.

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

Les itérateurs ont été introduits dans C# dans Visual Studio 2005, et ont été introduits dans Visual Basic dans Visual Studio 2012.

Dans cette rubrique

  • Itérateur simple

  • Création d'une classe Collection

  • Bloc try en Visual Basic

  • Méthodes anonymes en Visual Basic

  • Utilisation des itérateurs avec une liste générique

  • Les informations de syntaxe

  • Implémentation technique

  • Utilisation des itérateurs

Itérateur simple

L'exemple suivant a une déclaration unique Yield ou yield return qui est à l'intérieur d'une boucle For… next (Visual Basic) ou de pour (C#).Dans Main, chaque itération For Each ou foreach crée un appel à la fonction itérateur, qui avance a la prochaine déclaration Yield ou yield return .

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;
        }
    }
}

Création d'une classe Collection

[!REMARQUE]

Pour obtenir les exemples restants dans la rubrique, ajoutez les instructions importations (Visual Basic) ou les directives d' utilisation (C#) pour System.Collections et les espaces de noms System.Collections.Generic .

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

La méthode GetEnumerator retourne chaque chaîne une par une à l'aide de l'instruction Yield ou yield return .Dans le code de Visual Basic , un modificateur Iterator est 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

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];
        }
    }
}

l'exemple suivant crée une classe Zoo qui contient une collection d'animaux.

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

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; }
    }
}

Bloc try en Visual Basic

Visual Basic autorise une instruction Yield dans le bloc Try de Try...Catch...Finally, instruction (Visual Basic).Un bloc Try qui a une instruction Yield peut avoir des blocs Catch , et peut avoir un bloc Finally .

Remarque pour C#Remarque pour C#

C# permet une instruction yield return dans le bloc try d'une instruction try-finally .Un bloc try qui a une instruction yield return n'a peut-être pas de blocs catch .

L'exemple suivant Visual Basic inclut Try, Catch, et les blocs Finally dans un itérateur fonctionnent.Le bloc Finally dans la fonction d'itérateur s'éxé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 instruction Yield ne peut pas être dans un bloc Catch ou un bloc Finally .

Si le corps de la boucle For Each (au lieu de la méthode d'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 bloc Catch à 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 en Visual Basic

Dans Visual Basic (mais pas dans C#), une fonction anonyme peut être une fonction d'itérateur.L'exemple suivant illustre ce comportement.

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 Visual Basic a une méthode non itérateurs qui valide les arguments.La méthode retourne le résultat d'un itérateur anonyme qui décrit les éléments de la 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 est à la place à l'intérieur de la fonction d'itérateur, la validation ne peut pas être exécutée avant le début de la première itération du corps de la boucle For Each .

Utilisation des itérateurs avec une liste générique

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

En plus de la méthode générique GetEnumerator , la méthode non générique GetEnumerator doit également être implémentée.En effet 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' l'itération via la même collection de données.Ces itérateurs nommés sont les propriétés TopToBottom et BottomToTop , et la méthode TopN .

La propriété BottomToTop utilise un itérateur dans un accesseur get .Dans le code de Visual Basic, la déclaration de la propriété inclut le mot-clé 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

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];
        }
    }

}

Les informations de syntaxe

Un itérateur peut se produire en tant que méthode ou accesseur get .Un itérateur ne peut pas apparaître dans un événement, un constructeur d'instance, un constructeur statique, ou un destructeur statique.

Une conversion implicite doit exister dans l'expression dans l'instruction Yield (Visual Basic) ou yield return (C#) au type de retour de l'itérateur.

Dans Visual Basic, une méthode d'itérateur ne peut avoir acune paramètre ByRef .En C#, une méthode d'itérateur ne peut pas avoir pas de paramètres ref ou out .

Dans Visual Basic, « Yield » n'est pas un mot réservé et a une signification particulière uniquement lorsqu'il est utilisé dans une méthode d' Iterator ou un accesseur get .En C#, "yield" n'est pas un sens spécial uniquement lorsqu'il est utilisé avant un mot-clé return ou break .

Implémentation technique

Bien que vous écriviez un itérateur comme une méthode, le compilateur le traduit en une classe imbriquée qui est, en fait, un ordinateur d'état.Cette classe effectue le suivi de la position de l'itérateur tant que la boucle For Each...Next ou foreach continue dans le client.

Pour consulter l'action du compilateur en arrière-plan, utilisez l'outil ILDASM.exe pour afficher le code IL (Intermediate Language) généré pour une méthode d'itérateur.

Lorsque vous créez un itérateur pour votre classe ou struct, vous n'avez pas à implémenter l'ensemble de l'interface 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>.

Pour chaque itération consécutive de la boucle For Each…Next ou foreach (ou de l'appel direct à IEnumerator.MoveNext), le prochain code du corps de l'itérateur recommence apres le précédent Yield ou yield return .Il continue ensuite jusqu'a la prochaine instruction Yield ou yield return jusqu'a la fin du corps de l'itérateur est atteint ou jusqu'a ce que l'on atteint une déclaration Exit Function ou Return (Visual Basic) ou une instruction yield break (C#).

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

Pour plus d'informations, consultez Spécification du langage Visual Basic ou Spécification du langage C#.

Utilisation des itérateurs

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

  • Modifiez la séquence de liste après la première itération de la boucle For Each .

  • Éviter de charger complètement une grande liste avant la première itération d'une boucle For Each .Un exemple est une récupération paginée pour charger une série de lignes de table.Un autre exemple est la méthode EnumerateFiles , qui implémente des itérateurs dans le .NET Framework.

  • Encapsulez la construction de la liste dans l'itérateur.Dans la méthode d'itérateur, vous pouvez générer la liste puis affecter chaque résultat dans une boucle.

Les blogs C# suivants fournissent des informations supplémentaires sur l'utilisation des itérateurs.

Voir aussi

Référence

For Each...Next, instruction (Visual Basic)

foreach, in (référence C#)

yield, instruction (Visual Basic)

yield (Référence C#)

Itérateur (Visual Basic)

Utilisation de foreach avec des tableaux (Guide de programmation C#)

Génériques (guide de programmation C#)

System.Collections.Generic

IEnumerable<T>