Collections (C#)Collections (C#)

Pour de nombreuses applications, vous voulez créer et gérer des groupes d’objets connexes.For many applications, you want to create and manage groups of related objects. Il existe deux manières de grouper des objets : en créant des tableaux d’objets ou des collections d’objets.There are two ways to group objects: by creating arrays of objects, and by creating collections of objects.

Les tableaux sont particulièrement utiles pour la création et l’utilisation d’un nombre fixe d’objets fortement typés.Arrays are most useful for creating and working with a fixed number of strongly-typed objects. Pour plus d’informations sur les tableaux, consultez Tableaux.For information about arrays, see Arrays.

Les collections offrent plus de souplesse quand il s’agit d’utiliser des groupes d’objets.Collections provide a more flexible way to work with groups of objects. Contrairement aux tableaux, le groupe d’objets que vous utilisez peut être développé et réduit de manière dynamique selon les modifications de l’application.Unlike arrays, the group of objects you work with can grow and shrink dynamically as the needs of the application change. Pour certaines collections, vous pouvez affecter une clé à tout objet que vous placez dans la collection de sorte à pouvoir récupérer rapidement l’objet à l’aide de la clé.For some collections, you can assign a key to any object that you put into the collection so that you can quickly retrieve the object by using the key.

Une collection est une classe, vous devez déclarer une instance de la classe avant de pouvoir ajouter des éléments à la collection.A collection is a class, so you must declare an instance of the class before you can add elements to that collection.

Si votre collection contient des éléments d’un seul type de données, vous pouvez utiliser une des classes dans l’espace de noms System.Collections.Generic.If your collection contains elements of only one data type, you can use one of the classes in the System.Collections.Generic namespace. Une collection générique applique la cohérence des types pour éviter qu’un autre type puisse y être ajouté.A generic collection enforces type safety so that no other data type can be added to it. Quand vous récupérez un élément d’une collection générique, il n’est pas utile de déterminer son type de données ou de le convertir.When you retrieve an element from a generic collection, you do not have to determine its data type or convert it.

Notes

Pour les exemples de cette rubrique, ajoutez des instructions using pour les espaces de noms System.Collections.Generic et System.Linq.For the examples in this topic, include using directives for the System.Collections.Generic and System.Linq namespaces.

Dans cette rubriqueIn this topic

Utilisation d’une collection simpleUsing a Simple Collection

Les exemples de cette section utilisent la classe List<T> générique, qui vous permet d’utiliser une liste d’objets fortement typée.The examples in this section use the generic List<T> class, which enables you to work with a strongly typed list of objects.

L’exemple suivant crée une liste de chaînes, puis itère au sein des chaînes à l’aide d’une instruction foreach.The following example creates a list of strings and then iterates through the strings by using a foreach statement.

// Create a list of strings.
var salmons = new List<string>();
salmons.Add("chinook");
salmons.Add("coho");
salmons.Add("pink");
salmons.Add("sockeye");

// Iterate through the list.
foreach (var salmon in salmons)
{
    Console.Write(salmon + " ");
}
// Output: chinook coho pink sockeye

Si le contenu d’une collection est connu d’avance, vous pouvez utiliser un initialiseur de collection pour initialiser la collection.If the contents of a collection are known in advance, you can use a collection initializer to initialize the collection. Pour plus d’informations, consultez Initialiseurs d’objets et de collections.For more information, see Object and Collection Initializers.

L’exemple suivant est identique à l’exemple précédent, à la différence qu’un initialiseur de collection est utilisé pour ajouter des éléments à la collection.The following example is the same as the previous example, except a collection initializer is used to add elements to the collection.

// Create a list of strings by using a
// collection initializer.
var salmons = new List<string> { "chinook", "coho", "pink", "sockeye" };

// Iterate through the list.
foreach (var salmon in salmons)
{
    Console.Write(salmon + " ");
}
// Output: chinook coho pink sockeye

Vous pouvez utiliser une instruction for au lieu d’une instruction foreach pour itérer au sein d’une collection.You can use a for statement instead of a foreach statement to iterate through a collection. Pour cela, accédez aux éléments de la collection à la position d’index.You accomplish this by accessing the collection elements by the index position. L’index des éléments commence à 0 et se termine au nombre d’éléments moins 1.The index of the elements starts at 0 and ends at the element count minus 1.

L’exemple suivant itère au sein des éléments d’une collection à l’aide de for au lieu de foreach.The following example iterates through the elements of a collection by using for instead of foreach.

// Create a list of strings by using a
// collection initializer.
var salmons = new List<string> { "chinook", "coho", "pink", "sockeye" };

for (var index = 0; index < salmons.Count; index++)
{
    Console.Write(salmons[index] + " ");
}
// Output: chinook coho pink sockeye

L’exemple suivant supprime un élément de la collection en spécifiant l’objet à supprimer.The following example removes an element from the collection by specifying the object to remove.

// Create a list of strings by using a
// collection initializer.
var salmons = new List<string> { "chinook", "coho", "pink", "sockeye" };

// Remove an element from the list by specifying
// the object.
salmons.Remove("coho");

// Iterate through the list.
foreach (var salmon in salmons)
{
    Console.Write(salmon + " ");
}
// Output: chinook pink sockeye

L’exemple suivant supprime les éléments d’une liste générique.The following example removes elements from a generic list. À la place d’une instruction foreach, une instruction for, qui itère dans l’ordre décroissant, est utilisée.Instead of a foreach statement, a for statement that iterates in descending order is used. En effet, avec la méthode RemoveAt, les éléments après l’élément supprimé ont une valeur d’index moins élevée.This is because the RemoveAt method causes elements after a removed element to have a lower index value.

var numbers = new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

// Remove odd numbers.
for (var index = numbers.Count - 1; index >= 0; index--)
{
    if (numbers[index] % 2 == 1)
    {
        // Remove the element by specifying
        // the zero-based index in the list.
        numbers.RemoveAt(index);
    }
}

// Iterate through the list.
// A lambda expression is placed in the ForEach method
// of the List(T) object.
numbers.ForEach(
    number => Console.Write(number + " "));
// Output: 0 2 4 6 8

Pour le type d’éléments de List<T>, vous pouvez également définir votre propre classe.For the type of elements in the List<T>, you can also define your own class. Dans l’exemple suivant, la classe Galaxy qui est utilisée par List<T> est définie dans le code.In the following example, the Galaxy class that is used by the List<T> is defined in the code.

private static void IterateThroughList()
{
    var theGalaxies = new List<Galaxy>
        {
            new Galaxy() { Name="Tadpole", MegaLightYears=400},
            new Galaxy() { Name="Pinwheel", MegaLightYears=25},
            new Galaxy() { Name="Milky Way", MegaLightYears=0},
            new Galaxy() { Name="Andromeda", MegaLightYears=3}
        };

    foreach (Galaxy theGalaxy in theGalaxies)
    {
        Console.WriteLine(theGalaxy.Name + "  " + theGalaxy.MegaLightYears);
    }

    // Output:
    //  Tadpole  400
    //  Pinwheel  25
    //  Milky Way  0
    //  Andromeda  3
}

public class Galaxy
{
    public string Name { get; set; }
    public int MegaLightYears { get; set; }
}

Types de collectionsKinds of Collections

Plusieurs collections courantes sont fournies par le .NET Framework.Many common collections are provided by the .NET Framework. Chaque type de collection est conçu dans un but spécifique.Each type of collection is designed for a specific purpose.

Certaines des classes de collection courantes sont décrites dans cette section :Some of the common collection classes are described in this section:

Classes System.Collections.GenericSystem.Collections.Generic Classes

Vous pouvez créer une collection générique en utilisant l’une des classes dans l’espace de noms System.Collections.Generic.You can create a generic collection by using one of the classes in the System.Collections.Generic namespace. Une collection générique est utile quand chaque élément de la collection a le même type de données.A generic collection is useful when every item in the collection has the same data type. Une collection générique applique un typage fort en autorisant uniquement l’ajout des types de données souhaités.A generic collection enforces strong typing by allowing only the desired data type to be added.

Le tableau suivant liste quelques classes de l’espace de noms System.Collections.Generic fréquemment utilisées :The following table lists some of the frequently used classes of the System.Collections.Generic namespace:

ClasseClass DescriptionDescription
Dictionary<TKey,TValue> Représente une collection de paires clé/valeur organisées en fonction de la clé.Represents a collection of key/value pairs that are organized based on the key.
List<T> Représente une liste d’objets accessibles par index.Represents a list of objects that can be accessed by index. Fournit des méthodes de recherche, de tri et de modification de listes.Provides methods to search, sort, and modify lists.
Queue<T> Représente une collection d’objets premier entré, premier sorti (FIFO).Represents a first in, first out (FIFO) collection of objects.
SortedList<TKey,TValue> Représente une collection de paires clé/valeur triées par clé en fonction de l'implémentation IComparer<T> associée.Represents a collection of key/value pairs that are sorted by key based on the associated IComparer<T> implementation.
Stack<T> Représente une collection d’objets dernier entré, premier sorti (LIFO).Represents a last in, first out (LIFO) collection of objects.

Pour plus d’informations, consultez Types de collections couramment utilisés, Sélection d’une classe de collection et System.Collections.Generic.For additional information, see Commonly Used Collection Types, Selecting a Collection Class, and System.Collections.Generic.

Classes System.Collections.ConcurrentSystem.Collections.Concurrent Classes

Dans .NET Framework 4 ou ultérieur, les collections de l’espace de noms System.Collections.Concurrent fournissent des opérations thread-safe efficaces pour accéder aux éléments de collection à partir de plusieurs threads.In the .NET Framework 4 or newer, the collections in the System.Collections.Concurrent namespace provide efficient thread-safe operations for accessing collection items from multiple threads.

Les classes de l’espace de noms System.Collections.Concurrent doivent être utilisées à la place des types correspondants dans les espaces de noms System.Collections.Generic et System.Collections chaque fois que plusieurs threads accèdent simultanément à la collection.The classes in the System.Collections.Concurrent namespace should be used instead of the corresponding types in the System.Collections.Generic and System.Collections namespaces whenever multiple threads are accessing the collection concurrently. Pour plus d’informations, consultez Collections thread-safe et System.Collections.Concurrent.For more information, see Thread-Safe Collections and System.Collections.Concurrent.

Certaines classes incluses dans l’espace de noms System.Collections.Concurrent sont BlockingCollection<T>, ConcurrentDictionary<TKey,TValue>, ConcurrentQueue<T> et ConcurrentStack<T>.Some classes included in the System.Collections.Concurrent namespace are BlockingCollection<T>, ConcurrentDictionary<TKey,TValue>, ConcurrentQueue<T>, and ConcurrentStack<T>.

Classes System.CollectionsSystem.Collections Classes

Les classes de l’espace de noms System.Collections ne stockent pas les éléments comme des objets spécifiquement typés, mais comme des objets de type Object.The classes in the System.Collections namespace do not store elements as specifically typed objects, but as objects of type Object.

Si possible, vous devez utiliser les collections génériques dans l’espace de noms System.Collections.Generic ou System.Collections.Concurrent à la place des types hérités de l’espace de noms System.Collections.Whenever possible, you should use the generic collections in the System.Collections.Generic namespace or the System.Collections.Concurrent namespace instead of the legacy types in the System.Collections namespace.

Le tableau suivant répertorie certaines des classes fréquemment utilisées de l’espace de noms System.Collections :The following table lists some of the frequently used classes in the System.Collections namespace:

ClasseClass DescriptionDescription
ArrayList Représente un tableau d’objets dont la taille est augmentée de manière dynamique selon les besoins.Represents an array of objects whose size is dynamically increased as required.
Hashtable Représente une collection de paires clé/valeur qui sont organisées en fonction du code de hachage de la clé.Represents a collection of key/value pairs that are organized based on the hash code of the key.
Queue Représente une collection d’objets premier entré, premier sorti (FIFO).Represents a first in, first out (FIFO) collection of objects.
Stack Représente une collection d’objets dernier entré, premier sorti (LIFO).Represents a last in, first out (LIFO) collection of objects.

L’espace de noms System.Collections.Specialized fournit des classes de collection spécialisées et fortement typées, telles que les collections à chaîne unique et les dictionnaires de liste liée et hybrides.The System.Collections.Specialized namespace provides specialized and strongly typed collection classes, such as string-only collections and linked-list and hybrid dictionaries.

Implémentation d’une collection de paires clé/valeurImplementing a Collection of Key/Value Pairs

La collection générique Dictionary<TKey,TValue> vous permet d’accéder aux éléments d’une collection à l’aide de la clé de chaque élément.The Dictionary<TKey,TValue> generic collection enables you to access to elements in a collection by using the key of each element. Chaque ajout au dictionnaire se compose d’une valeur et de sa clé associée.Each addition to the dictionary consists of a value and its associated key. La récupération d’une valeur à l’aide de sa clé est très rapide, car la classe Dictionary est implémentée en tant que table de hachage.Retrieving a value by using its key is fast because the Dictionary class is implemented as a hash table.

L’exemple suivant crée une collection Dictionary et itère au sein du dictionnaire à l’aide d’une instruction foreach.The following example creates a Dictionary collection and iterates through the dictionary by using a foreach statement.

private static void IterateThruDictionary()
{
    Dictionary<string, Element> elements = BuildDictionary();

    foreach (KeyValuePair<string, Element> kvp in elements)
    {
        Element theElement = kvp.Value;

        Console.WriteLine("key: " + kvp.Key);
        Console.WriteLine("values: " + theElement.Symbol + " " +
            theElement.Name + " " + theElement.AtomicNumber);
    }
}

private static Dictionary<string, Element> BuildDictionary()
{
    var elements = new Dictionary<string, Element>();

    AddToDictionary(elements, "K", "Potassium", 19);
    AddToDictionary(elements, "Ca", "Calcium", 20);
    AddToDictionary(elements, "Sc", "Scandium", 21);
    AddToDictionary(elements, "Ti", "Titanium", 22);

    return elements;
}

private static void AddToDictionary(Dictionary<string, Element> elements,
    string symbol, string name, int atomicNumber)
{
    Element theElement = new Element();

    theElement.Symbol = symbol;
    theElement.Name = name;
    theElement.AtomicNumber = atomicNumber;

    elements.Add(key: theElement.Symbol, value: theElement);
}

public class Element
{
    public string Symbol { get; set; }
    public string Name { get; set; }
    public int AtomicNumber { get; set; }
}

Au lieu d’utiliser un initialiseur de collection pour générer la collection Dictionary, vous pouvez remplacer les méthodes BuildDictionary et AddToDictionary par la méthode suivante.To instead use a collection initializer to build the Dictionary collection, you can replace the BuildDictionary and AddToDictionary methods with the following method.

private static Dictionary<string, Element> BuildDictionary2()
{
    return new Dictionary<string, Element>
    {
        {"K",
            new Element() { Symbol="K", Name="Potassium", AtomicNumber=19}},
        {"Ca",
            new Element() { Symbol="Ca", Name="Calcium", AtomicNumber=20}},
        {"Sc",
            new Element() { Symbol="Sc", Name="Scandium", AtomicNumber=21}},
        {"Ti",
            new Element() { Symbol="Ti", Name="Titanium", AtomicNumber=22}}
    };
}

L’exemple suivant utilise la méthode ContainsKey et la propriété Item[TKey] de Dictionary pour rechercher rapidement un élément par clé.The following example uses the ContainsKey method and the Item[TKey] property of Dictionary to quickly find an item by key. En C#, la propriété Item vous permet d’accéder à un élément de la collection elements à l’aide d’elements[symbol].The Item property enables you to access an item in the elements collection by using the elements[symbol] in C#.

private static void FindInDictionary(string symbol)
{
    Dictionary<string, Element> elements = BuildDictionary();

    if (elements.ContainsKey(symbol) == false)
    {
        Console.WriteLine(symbol + " not found");
    }
    else
    {
        Element theElement = elements[symbol];
        Console.WriteLine("found: " + theElement.Name);
    }
}

L’exemple suivant utilise à la place la méthode TryGetValue pour rechercher rapidement un élément par clé.The following example instead uses the TryGetValue method quickly find an item by key.

private static void FindInDictionary2(string symbol)
{
    Dictionary<string, Element> elements = BuildDictionary();

    Element theElement = null;
    if (elements.TryGetValue(symbol, out theElement) == false)
        Console.WriteLine(symbol + " not found");
    else
        Console.WriteLine("found: " + theElement.Name);
}

Utilisation de LINQ pour accéder à une collectionUsing LINQ to Access a Collection

LINQ (Language-Integrated Query) peut être utilisé pour accéder aux collections.LINQ (Language-Integrated Query) can be used to access collections. Les requêtes LINQ fournissent des fonctionnalités de filtrage, de classement et de regroupement.LINQ queries provide filtering, ordering, and grouping capabilities. Pour plus d’informations, consultez Bien démarrer avec LINQ en C#.For more information, see Getting Started with LINQ in C#.

L’exemple suivant exécute une requête LINQ sur un List générique.The following example runs a LINQ query against a generic List. La requête LINQ retourne une autre collection qui contient les résultats.The LINQ query returns a different collection that contains the results.

private static void ShowLINQ()
{
    List<Element> elements = BuildList();

    // LINQ Query.
    var subset = from theElement in elements
                 where theElement.AtomicNumber < 22
                 orderby theElement.Name
                 select theElement;

    foreach (Element theElement in subset)
    {
        Console.WriteLine(theElement.Name + " " + theElement.AtomicNumber);
    }

    // Output:
    //  Calcium 20
    //  Potassium 19
    //  Scandium 21
}

private static List<Element> BuildList()
{
    return new List<Element>
    {
        { new Element() { Symbol="K", Name="Potassium", AtomicNumber=19}},
        { new Element() { Symbol="Ca", Name="Calcium", AtomicNumber=20}},
        { new Element() { Symbol="Sc", Name="Scandium", AtomicNumber=21}},
        { new Element() { Symbol="Ti", Name="Titanium", AtomicNumber=22}}
    };
}

public class Element
{
    public string Symbol { get; set; }
    public string Name { get; set; }
    public int AtomicNumber { get; set; }
}

Tri d’une collectionSorting a Collection

L’exemple suivant illustre une procédure de tri d’une collection.The following example illustrates a procedure for sorting a collection. L’exemple trie les instances de la classe Car stockées dans un List<T>.The example sorts instances of the Car class that are stored in a List<T>. La classe Car implémente l’interface IComparable<T>, ce qui implique l’implémentation de la méthode CompareTo.The Car class implements the IComparable<T> interface, which requires that the CompareTo method be implemented.

Chaque appel à la méthode CompareTo effectue une comparaison unique qui est utilisée pour le tri.Each call to the CompareTo method makes a single comparison that is used for sorting. Le code écrit par l’utilisateur dans la méthode CompareTo retourne une valeur pour chaque comparaison de l’objet actuel avec un autre objet.User-written code in the CompareTo method returns a value for each comparison of the current object with another object. La valeur retournée est inférieure à zéro si l’objet actuel est inférieur à l’autre objet, supérieure à zéro l’objet actuel est supérieur à l’autre et égale à zéro s’ils sont égaux.The value returned is less than zero if the current object is less than the other object, greater than zero if the current object is greater than the other object, and zero if they are equal. Cela vous permet de définir dans le code les critères définissant « supérieur à », « inférieur à » et « égal à ».This enables you to define in code the criteria for greater than, less than, and equal.

Dans la méthode ListCars, l’instruction cars.Sort() trie la liste.In the ListCars method, the cars.Sort() statement sorts the list. Cet appel à la méthode Sort de List<T> entraîne l’appel automatique de la méthode CompareTo pour les objets Car dans List.This call to the Sort method of the List<T> causes the CompareTo method to be called automatically for the Car objects in the List.

private static void ListCars()
{
    var cars = new List<Car>
    {
        { new Car() { Name = "car1", Color = "blue", Speed = 20}},
        { new Car() { Name = "car2", Color = "red", Speed = 50}},
        { new Car() { Name = "car3", Color = "green", Speed = 10}},
        { new Car() { Name = "car4", Color = "blue", Speed = 50}},
        { new Car() { Name = "car5", Color = "blue", Speed = 30}},
        { new Car() { Name = "car6", Color = "red", Speed = 60}},
        { new Car() { Name = "car7", Color = "green", Speed = 50}}
    };

    // Sort the cars by color alphabetically, and then by speed
    // in descending order.
    cars.Sort();

    // View all of the cars.
    foreach (Car thisCar in cars)
    {
        Console.Write(thisCar.Color.PadRight(5) + " ");
        Console.Write(thisCar.Speed.ToString() + " ");
        Console.Write(thisCar.Name);
        Console.WriteLine();
    }

    // Output:
    //  blue  50 car4
    //  blue  30 car5
    //  blue  20 car1
    //  green 50 car7
    //  green 10 car3
    //  red   60 car6
    //  red   50 car2
}

public class Car : IComparable<Car>
{
    public string Name { get; set; }
    public int Speed { get; set; }
    public string Color { get; set; }

    public int CompareTo(Car other)
    {
        // A call to this method makes a single comparison that is
        // used for sorting.

        // Determine the relative order of the objects being compared.
        // Sort by color alphabetically, and then by speed in
        // descending order.

        // Compare the colors.
        int compare;
        compare = String.Compare(this.Color, other.Color, true);

        // If the colors are the same, compare the speeds.
        if (compare == 0)
        {
            compare = this.Speed.CompareTo(other.Speed);

            // Use descending order for speed.
            compare = -compare;
        }

        return compare;
    }
}

Définition d’une collection personnaliséeDefining a Custom Collection

Vous pouvez définir une collection en implémentant l’interface IEnumerable<T> ou IEnumerable.You can define a collection by implementing the IEnumerable<T> or IEnumerable interface.

Même si vous pouvez définir une collection personnalisée, il est généralement préférable d’utiliser les collections comprises dans le .NET Framework, lesquelles sont décrites dans Types de collections, plus haut dans cette rubrique.Although you can define a custom collection, it is usually better to instead use the collections that are included in the .NET Framework, which are described in Kinds of Collections earlier in this topic.

L’exemple suivant définit une classe de collection personnalisée nommée AllColors.The following example defines a custom collection class named AllColors. Cette classe implémente l’interface IEnumerable, ce qui implique l’implémentation de la méthode GetEnumerator.This class implements the IEnumerable interface, which requires that the GetEnumerator method be implemented.

La méthode GetEnumerator retourne une instance de la classe ColorEnumerator.The GetEnumerator method returns an instance of the ColorEnumerator class. ColorEnumerator implémente l’interface IEnumerator, ce qui implique l’implémentation de la propriété Current, la méthode MoveNext et la méthode Reset.ColorEnumerator implements the IEnumerator interface, which requires that the Current property, MoveNext method, and Reset method be implemented.

private static void ListColors()
{
    var colors = new AllColors();

    foreach (Color theColor in colors)
    {
        Console.Write(theColor.Name + " ");
    }
    Console.WriteLine();
    // Output: red blue green
}

// Collection class.
public class AllColors : System.Collections.IEnumerable
{
    Color[] _colors =
    {
        new Color() { Name = "red" },
        new Color() { Name = "blue" },
        new Color() { Name = "green" }
    };

    public System.Collections.IEnumerator GetEnumerator()
    {
        return new ColorEnumerator(_colors);

        // Instead of creating a custom enumerator, you could
        // use the GetEnumerator of the array.
        //return _colors.GetEnumerator();
    }

    // Custom enumerator.
    private class ColorEnumerator : System.Collections.IEnumerator
    {
        private Color[] _colors;
        private int _position = -1;

        public ColorEnumerator(Color[] colors)
        {
            _colors = colors;
        }

        object System.Collections.IEnumerator.Current
        {
            get
            {
                return _colors[_position];
            }
        }

        bool System.Collections.IEnumerator.MoveNext()
        {
            _position++;
            return (_position < _colors.Length);
        }

        void System.Collections.IEnumerator.Reset()
        {
            _position = -1;
        }
    }
}

// Element class.
public class Color
{
    public string Name { get; set; }
}

IteratorsIterators

Un itérateur est utilisé pour exécuter une itération personnalisée sur une collection.An iterator is used to perform a custom iteration over a collection. Un itérateur peut être une méthode ou un accesseur get.An iterator can be a method or a get accessor. Un itérateur utilise une instruction yield return pour retourner chaque élément de la collection un par un.An iterator uses a yield return statement to return each element of the collection one at a time.

Vous appelez un itérateur en utilisant une instruction foreach.You call an iterator by using a foreach statement. Chaque itération de la boucle foreach appelle l’itérateur.Each iteration of the foreach loop calls the iterator. Quand une instruction yield return est atteinte dans l’itérateur, une expression est retournée et la localisation actuelle dans le code est retenue.When a yield return statement is reached in the iterator, an expression is returned, and the current location in code is retained. L’exécution est redémarrée à partir de cet emplacement la prochaine fois que l’itérateur est appelé.Execution is restarted from that location the next time that the iterator is called.

Pour plus d’informations, consultez Itérateurs (C#).For more information, see Iterators (C#).

L'exemple suivant utilise une méthode Iterator.The following example uses an iterator method. La méthode Iterator a une instruction yield return qui se trouve à l’intérieur d’une boucle for.The iterator method has a yield return statement that is inside a for loop. Dans la méthode ListEvenNumbers, chaque itération du corps de l’instruction foreach crée un appel à la méthode Iterator, qui continue sur l’instruction yield return suivante.In the ListEvenNumbers method, each iteration of the foreach statement body creates a call to the iterator method, which proceeds to the next yield return statement.

private static void ListEvenNumbers()
{
    foreach (int number in EvenSequence(5, 18))
    {
        Console.Write(number.ToString() + " ");
    }
    Console.WriteLine();
    // Output: 6 8 10 12 14 16 18
}

private static IEnumerable<int> EvenSequence(
    int firstNumber, int lastNumber)
{
    // Yield even numbers in the range.
    for (var number = firstNumber; number <= lastNumber; number++)
    {
        if (number % 2 == 0)
        {
            yield return number;
        }
    }
}

Voir aussiSee also