C# Language
Les itérateurs

Remarques

Exemple d'itérateur numérique simple

Un cas d'usage courant pour les itérateurs est d'effectuer certaines opérations sur une collection de nombres. L'exemple ci-dessous montre comment chaque élément d'un tableau de nombres peut être imprimé individuellement sur la console.

Cela est possible car les tableaux implémentent l'interface IEnumerable , permettant aux clients d'obtenir un itérateur pour le tableau à l'aide de la méthode GetEnumerator() . Cette méthode retourne un énumérateur , qui est un curseur en lecture seule, en avant uniquement sur chaque nombre du tableau.

int[] numbers = { 1, 2, 3, 4, 5 };

IEnumerator iterator = numbers.GetEnumerator();

while (iterator.MoveNext())
{
    Console.WriteLine(iterator.Current);
}

Sortie

1
2
3
4
5

Il est également possible d'obtenir les mêmes résultats en utilisant une déclaration foreach :

foreach (int number in numbers)
{
    Console.WriteLine(number);
}

Création d'itérateurs à l'aide du rendement

Les itérateurs produisent des enquêteurs. En C #, les énumérateurs sont produits en définissant des méthodes, des propriétés ou des indexeurs contenant yield instructions de yield .

La plupart des méthodes renverront le contrôle à leur appel via des instructions de return normales, qui éliminent tous les états locaux de cette méthode. En revanche, les méthodes qui utilisent yield instructions de yield leur permettent de renvoyer plusieurs valeurs à l'appelant sur demande tout en conservant l'état local entre ces valeurs. Ces valeurs renvoyées constituent une séquence. Il existe deux types d’énoncés de yield utilisés dans les itérateurs:

• yield return , qui retourne le contrôle à l'appelant mais conserve l'état. L'appelé continuera l'exécution de cette ligne quand le contrôle lui sera renvoyé.

• yield break , qui fonctionne de manière similaire à une instruction de return normale - cela signifie la fin de la séquence. Les instructions de return normales elles-mêmes sont illégales dans un bloc itérateur.

Cet exemple ci-dessous illustre une méthode d'itérateur pouvant être utilisée pour générer la séquence de Fibonacci :

IEnumerable<int> Fibonacci(int count)
{
    int prev = 1;
    int curr = 1;
    
    for (int i = 0; i < count; i++)
    {
        yield return prev;
        int temp = prev + curr;
        prev = curr;
        curr = temp;
    }
}

Cet itérateur peut ensuite être utilisé pour produire un énumérateur de la séquence de Fibonacci pouvant être consommé par une méthode d'appel. Le code ci-dessous montre comment les dix premiers termes de la séquence de Fibonacci peuvent être énumérés:

void Main()
{
    foreach (int term in Fibonacci(10))
    {
        Console.WriteLine(term);
    }
}

Sortie

1
1
2
3
5
8
13
21
34
55