Notes
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
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 de retour de rendement pour renvoyer chaque élément un à la fois. Lorsqu’une yield return 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 à partir du code client en utilisant une instruction foreach ou une requête LINQ.
Dans l’exemple suivant, la première itération de la foreach boucle entraîne l’exécution dans la SomeNumbers méthode itérateur jusqu’à ce que la première yield return 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 return 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.
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 itérateur ou get d’un accesseur peut être IEnumerable, IEnumerable<T>, IEnumerator, ou IEnumerator<T>.
Vous pouvez utiliser une yield break instruction pour mettre fin à l’itération.
Remarque
Tous les exemples de cette rubrique, à l’exception de l’exemple de l’itérateur simple, incluent des directives using pour les espaces de noms System.Collections et System.Collections.Generic.
Itérateur simple
L’exemple suivant comporte une instruction unique yield return qui se trouve à l’intérieur d’une boucle for . Dans Main, chaque itération du corps de l’instruction foreach crée un appel à la fonction itérateur, qui passe à l’instruction suivante yield return .
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 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 return .
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 Zoo classe qui contient une collection d’animaux.
L’instruction foreach qui fait référence à l’instance de classe (theZoo) appelle implicitement la GetEnumerator méthode. Les instructions foreach qui se réfèrent aux propriétés Birds et Mammals utilisent la méthode d'itération nommée AnimalsForType.
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; }
}
}
Utilisation d’itérateurs avec une liste générique
Dans l’exemple suivant, la Stack<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 return .
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 BottomToTop propriété utilise un itérateur dans un get accesseur.
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];
}
}
}
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 finaliseur statique.
Il doit y avoir une conversion implicite entre le type d’expression dans l’instruction yield return et l’argument de type pour l’IEnumerable<T> retourné par l’itérateur.
En C#, une méthode d’itérateur ne peut pas avoir de paramètres in, ref ou out.
En C#, yield n’est pas un mot réservé et a une signification spéciale uniquement lorsqu’il est utilisé avant un mot-clé return ou break.
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 foreach 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 foreach (ou de l’appel direct à IEnumerator.MoveNext), le corps du code de l’itérateur suivant reprend après l’instruction yield return précédente. Il passe ensuite à l’instruction suivante yield return jusqu’à ce que la fin du corps de l’itérateur soit atteinte, ou jusqu’à ce qu’une yield break instruction soit rencontrée.
Les itérateurs ne prennent pas en charge la IEnumerator.Reset méthode. Pour répéter dès le début, vous devez obtenir un nouvel itérateur. L’appel de Reset sur l’itérateur retourné par une méthode d’itérateur lève un NotSupportedException.
Pour plus d’informations, consultez la spécification du langage C#.
Utilisation d’itérateurs
Les itérateurs vous permettent de maintenir la simplicité d’une foreach 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
foreachitération de boucle.Évitez de charger entièrement une liste volumineuse avant la première itération d’une
foreachboucle. 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 .NET.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.
Voir aussi
Collaborer avec nous sur GitHub
La source de ce contenu se trouve sur GitHub, où vous pouvez également créer et examiner les problèmes et les demandes de tirage. Pour plus d’informations, consultez notre guide du contributeur.
