Boucles en C# : maîtriser for, while et foreach

Une boucle répète une instruction. La bonne structure dépend de ce que vous connaissez : un nombre d’itérations, une condition d’arrêt ou simplement une collection à parcourir.

for : compter les itérations

for (int i = 10; i >= 0; i--)
{
    Console.WriteLine(i == 0 ? "Décollage !" : i.ToString());
}

Les deux branches d’un ternaire doivent avoir un type commun : d’où le ToString() sur l’entier.

Une boucle for réunit l’initialisation, la condition et l’évolution du compteur. Elle convient lorsque le nombre d’itérations est connu ou lorsque l’index est utile.

while : tester avant d’exécuter

int tentatives = 0;
bool trouve = false;

while (!trouve && tentatives < 5)
{
    Console.Write("Nombre entre 1 et 10 : ");
    trouve = int.TryParse(Console.ReadLine(), out int valeur)
        && valeur == 7;
    tentatives++;
}

La condition est vérifiée avant le premier passage. Le corps peut donc ne jamais s’exécuter.

do while : exécuter au moins une fois

bool continuer;

do
{
    Console.WriteLine("Traitement en cours…");
    Console.Write("Continuer ? (O/N) : ");
    continuer = Console.ReadKey().Key == ConsoleKey.O;
    Console.WriteLine();
} while (continuer);

Le test a lieu après le corps. Cette boucle est adaptée aux menus et aux saisies qui doivent être proposées au moins une fois.

foreach : parcourir une collection

string[] fruits = ["Pomme", "Banane", "Poire"];

foreach (string fruit in fruits)
{
    Console.WriteLine(fruit);
}

foreach évite de manipuler un index et exprime directement l’intention : traiter chaque élément.

Contrôler la boucle avec break et continue

for (int i = 0; i < 10; i++)
{
    if (i == 3) continue;
    if (i == 7) break;
    Console.WriteLine(i);
}

continue passe à l’itération suivante. break quitte immédiatement la boucle la plus proche.

Imbriquer des boucles

Une table de multiplication utilise deux dimensions :

for (int i = 1; i <= 5; i++)
{
    for (int j = 1; j <= 10; j++)
    {
        Console.WriteLine($"{i} × {j} = {i * j}");
    }
}

Le corps intérieur s’exécute entièrement pour chaque valeur de i. Deux boucles de tailles n et m réalisent donc jusqu’à n × m passages.

Quelle boucle choisir ?

Performance et lisibilité

Une boucle foreach sur une List<T> ou un tableau est aussi rapide qu’un for dans la grande majorité des cas : choisissez d’abord la forme la plus lisible. Les vrais problèmes de performance viennent plutôt du travail fait dans la boucle : un appel réseau ou une requête SQL par itération transforme 1 000 éléments en 1 000 allers-retours. Regroupez ces appels avant d’optimiser la boucle elle-même ; la méthode est détaillée dans le guide performance .NET : mesurer, profiler puis optimiser.

Exercice : le nombre mystère

Le programme tire un nombre entre 1 et 100. L’utilisateur a 7 essais ; après chaque proposition, le programme répond « plus grand » ou « plus petit ». Les saisies invalides ne consomment pas d’essai.

int secret = Random.Shared.Next(1, 101);
const int EssaisMax = 7;
int essais = 0;

while (essais < EssaisMax)
{
    Console.Write($"Essai {essais + 1}/{EssaisMax} : ");
    string? saisie = Console.ReadLine();

    if (saisie is null)
    {
        break; // fin du flux d’entrée
    }

    if (!int.TryParse(saisie, out int proposition) || proposition is < 1 or > 100)
    {
        Console.WriteLine("Entrez un entier entre 1 et 100.");
        continue;
    }

    essais++;

    if (proposition == secret)
    {
        Console.WriteLine($"Trouvé en {essais} essai(s) !");
        return;
    }

    Console.WriteLine(proposition < secret ? "Plus grand" : "Plus petit");
}

Console.WriteLine($"Perdu, le nombre était {secret}.");

Erreurs fréquentes

• oublier de modifier la condition d’un while et créer une boucle infinie ;
• écrire i <= collection.Length, ce qui dépasse le dernier index ;
• modifier une collection pendant son parcours avec foreach ;
• imbriquer des boucles coûteuses sans considérer le nombre total d’itérations.

Épisode précédent : switch et pattern matching. Épisode suivant : tableaux, listes et dictionnaires.

La série C# pour débutants

Cette série suit une progression : chaque épisode réutilise les notions des précédents.

1. Variables et types
2. Saisie utilisateur et TryParse
3. Conditions if, else et ternaire
4. Switch et pattern matching
5. Boucles for, while et foreach (vous êtes ici)
6. Tableaux, listes, dictionnaires et LINQ
7. Méthodes, paramètres et surcharges

Une fois ces bases acquises, le parcours C# et ASP.NET Core prolonge la série vers les API web, la validation et l’asynchrone.