foreach, instruction (C#)foreach, in (C# reference)

L' foreach instruction exécute une instruction ou un bloc d’instructions pour chaque élément d’une instance du type qui implémente l' System.Collections.IEnumerable System.Collections.Generic.IEnumerable<T> interface ou, comme le montre l’exemple suivant :The foreach statement executes a statement or a block of statements for each element in an instance of the type that implements the System.Collections.IEnumerable or System.Collections.Generic.IEnumerable<T> interface, as the following example shows:

var fibNumbers = new List<int> { 0, 1, 1, 2, 3, 5, 8, 13 };
int count = 0;
foreach (int element in fibNumbers)
{
    count++;
    Console.WriteLine($"Element #{count}: {element}");
}
Console.WriteLine($"Number of elements: {count}");

L' foreach instruction n’est pas limitée à ces types.The foreach statement isn't limited to those types. Vous pouvez l’utiliser avec une instance de n’importe quel type répondant aux conditions suivantes :You can use it with an instance of any type that satisfies the following conditions:

  • un type a la méthode sans paramètre public GetEnumerator dont le type de retour est de type classe, struct ou interface.a type has the public parameterless GetEnumerator method whose return type is either class, struct, or interface type,
  • le type de retour de la méthode GetEnumerator contient la propriété publique Current et la méthode sans paramètre publique MoveNext, dont le type de retour est Boolean.the return type of the GetEnumerator method has the public Current property and the public parameterless MoveNext method whose return type is Boolean.

L’exemple suivant utilise l' foreach instruction avec une instance du System.Span<T> type, qui n’implémente aucune interface :The following example uses the foreach statement with an instance of the System.Span<T> type, which doesn't implement any interfaces:

public class IterateSpanExample
{
    public static void Main()
    {
        Span<int> numbers = new int[] { 3, 14, 15, 92, 6 };
        foreach (int number in numbers)
        {
            Console.Write($"{number} ");
        }
        Console.WriteLine();
    }
}

À compter de C# 7,3, si la propriété de l’énumérateur Current retourne une valeur de retour de référence ( ref TT est le type d’un élément de collection), vous pouvez déclarer une variable d’itération avec le ref ref readonly modificateur ou, comme le montre l’exemple suivant :Beginning with C# 7.3, if the enumerator's Current property returns a reference return value (ref T where T is the type of a collection element), you can declare an iteration variable with the ref or ref readonly modifier, as the following example shows:

public class ForeachRefExample
{
    public static void Main()
    {
        Span<int> storage = stackalloc int[10];
        int num = 0;
        foreach (ref int item in storage)
        {
            item = num++;
        }

        foreach (ref readonly var item in storage)
        {
            Console.Write($"{item} ");
        }
        // Output:
        // 0 1 2 3 4 5 6 7 8 9
    }
}

À compter de C# 8,0, vous pouvez utiliser l' await foreach instruction pour consommer un flux de données asynchrone, autrement dit, le type de collection qui implémente l' IAsyncEnumerable<T> interface.Beginning with C# 8.0, you can use the await foreach statement to consume an asynchronous stream of data, that is, the collection type that implements the IAsyncEnumerable<T> interface. Chaque itération de la boucle peut être interrompue pendant que l’élément suivant est récupéré de manière asynchrone.Each iteration of the loop may be suspended while the next element is retrieved asynchronously. L’exemple suivant montre comment utiliser l' await foreach instruction :The following example shows how to use the await foreach statement:

await foreach (var item in GenerateSequenceAsync())
{
    Console.WriteLine(item);
}

Par défaut, les éléments de flux sont traités dans le contexte capturé.By default, stream elements are processed in the captured context. Si vous souhaitez désactiver la capture du contexte, utilisez la TaskAsyncEnumerableExtensions.ConfigureAwait méthode d’extension.If you want to disable capturing of the context, use the TaskAsyncEnumerableExtensions.ConfigureAwait extension method. Pour plus d’informations sur les contextes de synchronisation et la capture du contexte actuel, consultez utilisation du modèle asynchrone basé sur des tâches.For more information about synchronization contexts and capturing the current context, see Consuming the Task-based asynchronous pattern. Pour plus d’informations sur les flux asynchrones, consultez la section Streams asynchrones de l’article nouveautés de C# 8,0 .For more information about asynchronous streams, see the Asynchronous streams section of the What's new in C# 8.0 article.

À tout moment dans le bloc d’instructions foreach, vous pouvez sortir de la boucle à l’aide de l’instruction break, ou passer à l’itération suivante de la boucle à l’aide de l’instruction continue.At any point within the foreach statement block, you can break out of the loop by using the break statement, or step to the next iteration in the loop by using the continue statement. Vous pouvez également quitter une foreach boucle à l’aide des instructions goto, Returnou throw .You can also exit a foreach loop by the goto, return, or throw statements.

Si l’instruction foreach est appliquée à null, une NullReferenceException est levée.If the foreach statement is applied to null, a NullReferenceException is thrown. Si la collection source de l' foreach instruction est vide, le corps de la foreach boucle n’est pas exécuté et ignoré.If the source collection of the foreach statement is empty, the body of the foreach loop isn't executed and skipped.

Type d’une variable d’itérationType of an iteration variable

Vous pouvez utiliser le var mot clé pour permettre au compilateur de déduire le type d’une variable d’itération dans l' foreach instruction, comme le montre le code suivant :You can use the var keyword to let the compiler infer the type of an iteration variable in the foreach statement, as the following code shows:

foreach (var item in collection) { }

Vous pouvez également spécifier explicitement le type d’une variable d’itération, comme le montre le code suivant :You can also explicitly specify the type of an iteration variable, as the following code shows:

IEnumerable<T> collection = new T[5];
foreach (V item in collection) { }

Dans le formulaire précédent, le type T d’un élément de collection doit être implicitement ou explicitement convertible en type V d’une variable d’itération.In the preceding form, type T of a collection element must be implicitly or explicitly convertible to type V of an iteration variable. Si une conversion explicite de T en V échoue au moment de l’exécution, l' foreach instruction lève une exception InvalidCastException .If an explicit conversion from T to V fails at run time, the foreach statement throws an InvalidCastException. Par exemple, si T est un type de classe non scellé, V peut être n’importe quel type d’interface, même celui qui T n’est pas implémenté.For example, if T is a non-sealed class type, V can be any interface type, even the one that T doesn't implement. Au moment de l’exécution, le type d’un élément de collection peut être celui qui dérive de T et implémente réellement V .At run time, the type of a collection element may be the one that derives from T and actually implements V. Si ce n’est pas le cas, une InvalidCastException exception est levée.If that's not the case, an InvalidCastException is thrown.

spécification du langage C#C# language specification

Pour plus d’informations, voir la section Instruction foreach de la spécification du langage C#.For more information, see The foreach statement section of the C# language specification.

Voir aussiSee also