Maîtriser l'instruction Continue C# : Comment ignorer efficacement les itérations de boucle

Maîtriser l'instruction Continue C# : Comment ignorer efficacement les itérations de boucle

Ce guide explique comment l'instruction continue fonctionne en C#, avec des exemples pratiques pour les boucles for, while, foreach et imbriquées.

En C#, le mot-clé continue permet à une boucle d'ignorer immédiatement le reste de l'itération courante et de passer au cycle suivant. Lorsqu'il est rencontré, le contrôle passe à la condition de test de la boucle (ou à l'expression de mise à jour dans une boucle for) avant que la prochaine itération ne commence.

La syntaxe est simple :

continue;

Avant de plonger dans continue, assurez-vous d'être à l'aise avec ces fondamentaux :

• boucle for
• boucle while
• if…else

---

Exemple 1 : Utilisation de continue avec une boucle for

using System;
namespace ContinueLoop {
    class Program {
        static void Main(string[] args) {
            for (int i = 1; i <= 5; ++i) {
                if (i == 3) {
                    continue;
                }
                Console.WriteLine(i);
            }
        }
    }
}

Sortie

1
2
4
5

Ici, la boucle affiche les nombres 1 à 5 mais ignore 3 car l'instruction continue est déclenchée quand i == 3.

Note : continue est plus efficace lorsqu'il est associé à une logique conditionnelle comme if…else.

---

Exemple 2 : Utilisation de continue avec une boucle while

using System;
namespace ContinueWhile {
    class Program {
        static void Main(string[] args) {
            int i = 0;
            while (i < 5) {
                i++;
                if (i == 3) {
                    continue;
                }
                Console.WriteLine(i);
            }
        }
    }
}

Sortie

1
2
4
5

Le comportement reflète l'exemple for : l'itération 3 est ignorée.

---

Fonctionnement de l'instruction continue

---

Utilisation de continue dans les boucles imbriquées

Les boucles imbriquées sont courantes lors du traitement de données multidimensionnelles. continue peut être appliqué à la boucle interne pour ignorer des itérations internes spécifiques.

using System;
namespace ContinueNested {
    class Program {
        static void Main(string[] args) {
            int sum = 0;
            // boucle externe
            for (int i = 1; i <= 3; i++) {
                // boucle interne
                for (int j = 1; j <= 3; j++) {
                    if (j == 2) {
                        continue;
                    }
                    Console.WriteLine("i = " + i + " j = " + j);
                }
            }
        }
    }
}

Sortie

i = 1 j = 1
i = 1 j = 3
i = 2 j = 1
i = 2 j = 3
i = 3 j = 1
i = 3 j = 3

L'instruction à l'intérieur de la boucle interne ignore l'itération où j == 2, empêchant ce couple spécifique d'être affiché.

Pour plus d'informations sur les boucles imbriquées, voir l'article dédié Boucles imbriquées C#.

---

Utilisation de continue avec une boucle foreach

La construction foreach prend aussi en charge continue, vous permettant d'ignorer des éléments spécifiques dans une collection.

using System;
namespace ContinueForeach {
    class Program {
        static void Main(string[] args) {
            int[] num = { 1, 2, 3, 4, 5 };
            foreach (int number in num) {
                if (number == 3) {
                    continue;
                }
                Console.WriteLine(number);
            }
        }
    }
}

Sortie

1
2
4
5

Quand la boucle rencontre la valeur 3, l'instruction continue fait ignorer le reste de cette itération, donc 3 n'apparaît jamais dans la sortie.