Maîtriser les boucles While et Do-While en C# : Syntaxe, exemples et bonnes pratiques

Maîtriser les boucles While et Do-While en C#

Explorez comment implémenter les boucles while et do…while en C#, comprenez leurs différences et apprenez les bonnes pratiques pour écrire un code propre et efficace.

Dans le développement logiciel, l'exécution répétée d'un bloc de code est courante, que ce soit pour itérer sur des collections, gérer l'entrée utilisateur ou effectuer des calculs. Si la répétition manuelle est sujette aux erreurs et illisible, les boucles fournissent une solution concise et évolutive. Cet article examine les deux constructions de boucle principales en C# — while et do…while — et met en évidence leurs comportements distincts.

---

Boucle while en C#

Le mot-clé while initie une boucle qui évalue sa condition avant d'exécuter le corps. Sa syntaxe reflète celle de nombreux langages modernes :

while (expressionTest) {
    // corps de la boucle
}

Fonctionnement de la boucle while

1. Une expression booléenne expressionTest est évaluée.
2. Si l'expression est true, le corps de la boucle s'exécute, puis l'expression est réévaluée.
3. La boucle se termine quand l'expression devient false.

Diagramme de flux While

Exemple 1 : Boucle while de base

using System;
namespace Loop {
    class WhileLoop {
        public static void Main(string[] args) {
            int i = 1;
            while (i <= 5) {
                Console.WriteLine("Boucle While C# : Itération {0}", i);
                i++;
            }
        }
    }
}

Sortie :

Boucle While C# : Itération 1
Boucle While C# : Itération 2
Boucle While C# : Itération 3
Boucle While C# : Itération 4
Boucle While C# : Itération 5

La boucle commence avec i défini à 1. Elle continue tant que i est inférieur ou égal à 5, incrémentant i à chaque cycle. Quand i devient 6, la condition échoue et la boucle se termine.

Exemple 2 : Somme des cinq premiers nombres naturels

using System;
namespace Loop {
    class WhileLoop {
        public static void Main(string[] args) {
            int i = 1, sum = 0;
            while (i <= 5) {
                sum += i;
                i++;
            }
            Console.WriteLine("Somme = {0}", sum);
        }
    }
}

Sortie :

Somme = 15

Dans cet exemple, la boucle accumule la valeur de i dans sum jusqu'à ce que i dépasse 5. Le résultat final est 15, confirmant la formule bien connue pour la somme des cinq premiers nombres naturels.

---

Boucle do…while en C#

La construction do…while est similaire à while, mais la condition est évaluée après l'exécution du corps de la boucle. Cela garantit que le corps s'exécute au moins une fois, indépendamment de la condition initiale.

do {
    // corps de la boucle
} while (expressionTest);

Fonctionnement de la boucle do…while

1. Le corps de la boucle s'exécute en premier.
2. L'expressionTest est évaluée.
3. Si true, le corps se répète.
4. Quand false, la boucle se termine.

Diagramme de flux Do…While

Exemple 3 : Table de multiplication avec do…while

using System;
namespace Loop {
    class DoWhileLoop {
        public static void Main(string[] args) {
            int i = 1, n = 5, product;
            do {
                product = n * i;
                Console.WriteLine("{0} * {1} = {2}", n, i, product);
                i++;
            } while (i <= 10);
        }
    }
}

Sortie :

5 * 1 = 5
5 * 2 = 10
5 * 3 = 15
5 * 4 = 20
5 * 5 = 25
5 * 6 = 30
5 * 7 = 35
5 * 8 = 40
5 * 9 = 45
5 * 10 = 50

Le programme affiche la table de 5 de 1 à 10. Notez que le corps de la boucle s'exécute avant de vérifier i <= 10, assurant les 10 itérations.

---

Boucles infinies en C#

Lorsque la condition de boucle ne devient jamais false, la boucle s'exécute indéfiniment. De telles boucles infinies sont intentionnelles dans des scénarios comme les boucles d'événements, les boucles de jeu ou les services de longue durée.

Boucle while infinie

while (true) {
    // corps de la boucle
}

Boucle do…while infinie

do {
    // corps de la boucle
} while (true);

Utilisez les boucles infinies avec parcimonie et fournissez toujours une stratégie de sortie claire (par exemple, une instruction break ou une condition externe) pour éviter l'épuisement des ressources.