C # Continuer la déclaration

C # est un langage de programmation qui restreint ses programmeurs à suivre strictement le format approprié. En langue C #, la compilation est effectuée ligne par ligne. Mais parfois, lorsque nous utilisons une boucle et que nous devons arrêter la boucle ou que nous voulons qu'elle revienne à la boucle et saute une valeur, nous ne pouvons pas faire cela. Mais il existe quelques méthodes qui nous aident à le faire. La méthode de rupture brise la boucle, elle est utilisée lorsqu'une condition devient vraie et nous devons terminer la boucle. La déclaration «continuer» est une autre façon mais dans «continue», elle n'arrête pas la boucle. Il remonte à la boucle et exécute la prochaine itération. L'itération est le nombre de fois, la boucle se répète jusqu'à ce que la condition donnée soit rencontrée. Dans ce guide, nous allons délibérer la déclaration «continuer». L'instruction «Continuer» ne peut pas résilier la boucle, elle saute simplement l'itération pour le nombre requis de fois. La déclaration «Continuer» est simple à utiliser, écrivez simplement le terme continuer; Après la condition. Lorsque le compilateur atteint ce «continue», il remonte à la boucle et démarre la nouvelle itération en incrémentant l'itérateur. Cette déclaration peut être utilisée lorsque nous avons plus d'une itération.

Exemple non. 1:

Nous observerons le fonctionnement de la commande «Continuer» dans la boucle «pour».

Utilisation du système;
Programme de classe_0

statique void main ()
pour (int i = 0; i<9; i++)

si (i == 5)

continuer;

Console.WriteLine ("L'index" + i + "est ici");

Console.WriteLine ("\ n5 est manquant");

Dans ce cas, nous utilisons une boucle «pour» pour itérer autant de fois que nous le souhaitons. Ainsi, nous déclarons et initialisons un itérateur qui répéterons la boucle «pour». Et donnez une condition que la boucle se répétera jusqu'à ce que «je» atteigne 8 parce que la condition dit que «je» doit être inférieure à 9. À l'intérieur de la boucle 'for' définit une condition en utilisant l'instruction conditionnelle 'if', où nous définissons i == 5. Le corps de la déclaration «if» utilise la déclaration «continuer». En dehors de la déclaration «si», utilisez la console.Méthode writeLine () Pour afficher un texte avec la valeur de «i».

Maintenant, le code fonctionnera, la boucle commence et la valeur de «i» est 0. Comme la condition de boucle est vraie, alors elle entre dans le corps de la boucle «pour», il y a une condition «si», et il vérifie si la condition spécifiée est vraie ou non. Ici, l'état de l'instruction «if» est faux parce que la valeur en «i» est 0, il ignore donc l'instruction «IF» et exécute l'instruction suivante qui est la console.WriteLine (). D'où un message et la valeur de «i» sont imprimés sur la console. Maintenant, la valeur de «i» est incrémentée et le processus se répétera. Lorsque la valeur de «i» devient 5, alors la déclaration «si» devient vraie et que son corps sera mis en œuvre. Le corps de «If» ne contient qu'une seule déclaration qui est la commande «Continuer». Le contrôle reviendra à la boucle «pour» et répétera le processus jusqu'à l'état de «pour» des tours de faux. Lorsque la condition deviendra fausse, le contrôle va sortir du corps et exécuter l'instruction suivante (un message pour la console) et le programme se termine ici.

Exemple non. 2:

Ici, la commande «Continuer» est utilisée dans la boucle «While».

Utilisation du système;
Programme de classe_1

statique void main ()
int i = 5;
while (i10 && i<13)

Console.WriteLine ("le nombre" + i + "est manquant");
continuer;

Console.WriteLine ("le nombre" + i + "est rencontré");

Définir une variable entière avec la valeur 5. Ensuite, appliquez une boucle «while» et définissez l'état de «while». Dans le corps de «tandis», incrémentez le «i» par 2, puis utilisez la boucle «if». Ici, nous définissons l'état de «si» et à l'intérieur de son corps, nous avons appelé une console de fonction.Écriture écrite () et «continuer». En dehors de la boucle «si», nous utilisons à nouveau la console.Méthode writeLine () pour représenter le message et les valeurs qui sont exécutées. Le programme fonctionnera car il vérifiera d'abord l'état de «tandis que». Si c'est vrai, il se déplacera à l'intérieur du corps de «tout en incrément le« je ». Ensuite, il vérifie l'état de la boucle «si». Et chaque fois que son état est faux, il se déplacera ensuite et affiche le texte requis sur la console. Mais lorsque l'état de «If» est vrai, il exécutera le corps de la boucle «If», donc il montre d'abord un message avec la valeur de «I». Après cela, il exécutera l'instruction «Continuer» et il ramènerait le contrôle à la boucle `` While '' et ce processus se répétera jusqu'à ce que la condition donnée soit remplie.

Le résultat montre tous les nombres avec le même message mais une déclaration est différente à cause de la condition «si». La condition «if» devient vraie sur cette valeur, il fait donc retourner le contrôle à la boucle while.

Exemple non. 3:

Cet exemple de code clarifiera l'emploi de la commande «Continuer» dans la boucle «Do-While».

Utilisation du système;
Classe Program_2

statique void main ()
int i = 5;
faire

i + = 5;
if (i == 10 || i == 20)

continuer;

Console.WriteLine ("le nombre" + i + "est rencontré");
alors que je<50);

Le code commence par déclarer une valeur entière et une boucle de «faire». Dans le corps de la boucle `` à faire '', nous avons incrémenté l'itérateur par 5 et spécifiés une condition «si». À l'intérieur de la condition «si», nous utilisons une déclaration «continuer». Il enverra le contrôle au début de la boucle et incrément l'itérateur. Lorsque l'état de «If» deviendra vrai, il sautera les valeurs définies et passera à la prochaine itération, c'est ce que «continue». Et lorsque la condition est fausse, le corps «tandis que» sera mis en œuvre. L'écran de sortie affichera les valeurs de 5 à 50 et inclut tous les multiples de 5 sauf 10 et 20 car pour ces deux valeurs, la condition «si» devient vraie et saute ces valeurs.

Exemple non. 4:

Ce programme démontrera l'utilisation de la déclaration «Continuer» et de la boucle «Foreach».

Utilisation du système;
programme de classe_3

statique void main ()
char [] array_0 = 'a', 'b', 'c', 'd', 'e';
foreach (char ch dans array_0)

if (ch == 'b')
continuer;
Console.WriteLine ("Le personnage stocké est" + ch);

Regardons le dernier code. Tout d'abord, définissez un tableau de caractères nommés 'array_0' et stockez-y cinq caractères. Ensuite, utilisez la boucle «ForEach» et définissez une variable avec un type de char qui sera utilisé pour obtenir les valeurs du tableau char. Dans le corps de la boucle «foreach», nous spécifions une condition «if» (ch == «b») et utilisons ensuite la déclaration «continuer». Il saute le personnage «B» et passe au personnage suivant. Lorsque nous écrivons une déclaration dans le corps de «Si», nous n'avons pas besoin de les enfermer dans des accolades bouclées. Lorsque l'état défini de «If» est faux, exécutez l'instruction à côté. La déclaration suivante représentera les caractères avec un message sur la console en utilisant la console.Méthode écrite de ligne.

Conclusion

Nous avons couvert la déclaration «continuer» que nous appliquons dans des boucles pour sauter quelques valeurs jusqu'à ce qu'une certaine condition soit terminée. Avec de nombreux exemples pratiques, l'utilisation de la déclaration «continuer» dans les boucles (pour, tandis que, do-while et foreach) est entièrement expliquée. Cette commande est utilisée dans la boucle pour renvoyer le contrôle au début de la boucle. L'instruction «Continuer» est une méthode utile où nous limitons l'exécution à quelques itérations.