Introduction à Break en C #

Généralement, lorsque nous parlons de mettre fin à une exécution à ce moment-là, nous en donnons la condition. Mais dans de nombreux cas, nous n'avons pas de condition exacte pour sortir d'une boucle ou d'une condition. Ici, avec l'instruction break, nous faisons correspondre la condition pour sortir de l'exécution en cours et passer le contrôle de la prochaine instruction à venir. Il nous aide à poursuivre l'exécution en évitant des opérations particulières à un certain stade. Dans les langages de programmation, nous avons souvent rencontré des instructions break. Les instructions Break sont quelque chose qui ressemble à sa signification pour briser la logique ici. Comme d'autres langages de programmation, c # a également une instruction break. Vous devez également avoir vu une instruction break dans le boîtier de commutateur. Dans les cas de commutation après chaque cas, nous constatons que cette instruction break sort de ce cas si elle ne correspond pas et va de l'avant.

Syntaxe:

L'instruction Break a une syntaxe très simple comme suit:

break;

Juste le mot-clé break et point-virgule. La définition d'une instruction break n'est rien d'autre que le transfert du contrôle à l'opération suivante dans l'ordre. Les instructions de pause sont la règle appliquée pour sortir à temps d'une situation particulière et arrêter l'exécution.

Représentation schématique

  • Ci-dessus, l'organigramme montre simplement le fonctionnement de l'instruction break, au début du flux, il vérifie la condition particulière. S'il est satisfait, la boucle continue. Au point où la boucle obtient une instruction break. Ou, la condition dans laquelle cette boucle sort de la boucle avec l'utilisation d'une instruction break.
  • Le flux est sans effort, il suffit de le comprendre en exécutant quelques exemples.
  • La meilleure chose à faire pour se familiariser avec l'instruction break est d'écrire le code et d'essayer la sortie avec différents scénarios.
  • Les déclarations de rupture sont très faciles. Mais beaucoup de gens se sont confondus avec lui alors qu'il sort de la boucle et commence un processus d'exécution supplémentaire.
  • Il existe de nombreux cas où nous utilisons ces instructions, en particulier dans les boucles imbriquées. Dans la boucle imbriquée, la boucle interne obtient des instructions break à un événement particulier pour sortir de la boucle.

Comment fonctionne Break Statement en C #?

Supposons que nous ayons un programme et que nous exécutions une boucle dans ce programme. Notre exigence est que si la boucle atteint 5, arrêtez l'exécution de la boucle et commencez à exécuter du code dans la séquence. Si vous regardez les exemples, brisez soigneusement les déclarations plus susceptibles de fonctionner comme un sens. Il rompt le flux d'exécution à l'emplacement spécifié et le contrôle va passer sur la prochaine opération requise.

Exemples de déclaration de rupture en C #

Des exemples de déclaration de rupture en C # sont donnés ci-dessous:

Exemple 1

Programmez pour obtenir des non jusqu'à 10. Si elle dépasse 10, rompez la boucle.

using System;
public class EvenNo (
public static void Main(string() args) (
for(int i=0;i<=20;i++)(
Console.WriteLine(i);
if(i==10)(
break;
)
)
) )

Production:

Dans le programme ci-dessus, nous en avons utilisé un pour une boucle. En cela, nous avons donné la condition si i est inférieur à 20, puis exécutons plus loin. Nous avons donné la condition if dans la boucle que si la valeur de i atteint 10, alors arrêtez l'exécution pour une boucle. Et ce scénario, nous avons atteint grâce à la déclaration de rupture. Essayez cet exemple dans un éditeur et vous obtiendrez une sortie comme ci-dessus.

Exemple # 2

Maintenant, nous allons voir la déclaration de rupture avec le boîtier de commutation

using System;
public class Switch
(
public static void Main(string() args)
(
int n=2;
switch (n)
(
case 1:
Console.WriteLine("Current value of n is: 1");
break;
case 2:
Console.WriteLine("Current value of n is: 2");
break;
case 3:
Console.WriteLine("Current value of n is: 3");
break;
case 4:
Console.WriteLine("Current value of n is: 4");
break;
default:
Console.WriteLine("Please give the correct no.");
break;
)
)
)

Production:

Dans le programme ci-dessus, nous avons utilisé un boîtier de commutation. En cela, nous vérifions plusieurs cas. Dans le premier cas, nous vérifions le cas par rapport à la condition donnée. Si le cas de commutateur ne correspond pas à la condition particulière, il casse ce cas avec une instruction break et passe au cas suivant. Il s'exécute jusqu'à l'obtention d'un cas correspondant. Si le cas est apparié, il est exécuté et la sortie sera affichée. Dans le pire des cas, si aucune des conditions n'est satisfaite, l'exécution obtient le cas par défaut mentionné dans les instructions de changement de cas avec le mot-clé default. Après avoir exécuté à nouveau cette instruction, elle obtient l'instruction break et l'opération est terminée.

Exemple # 3

Nous allons voir l'instruction break avec boucle do-while ici:

using System;
public class Program
(
public static void Main(string() args)
(
int i = 0;
do
(
Console.WriteLine("The value of i is :(0)", i);
i+=2;
if (i == 10)
break;
)while (i < 20);
Console.WriteLine("Press Enter Key to Exit..");
Console.ReadLine();
)
)

Production:

Dans le programme ci-dessus, nous avons utilisé une boucle do-while avec une instruction break. Nous avons vérifié une valeur de i. nous incrémentons la valeur de I de 2. Nous cassons la boucle une fois qu'elle atteint 10. Mais nous avons la condition de le vérifier jusqu'à 20. Nous interrompons l'exécution au milieu de la boucle selon nos besoins. Jusqu'à présent, nous avons vu des exemples d'une déclaration de rupture. Ce qui montre comment utiliser l'instruction break avec différentes boucles et avec la condition if. Ce sont des exemples très basiques pour vérifier le fonctionnement des instructions break. Pour essayer ces exemples dans un éditeur approprié. Lorsque nous exécutons une boucle à l'intérieur du programme et que nous devons la séparer de l'exécution à ce moment, nous utilisons l'instruction break avec le mot clé break et le point-virgule. A ce moment de la pause, l'instruction sort l'exécution de la boucle. Après cela, le contrôle passe à la prochaine instruction d'exécution de la séquence.

Conclusion

Chaque langue a une instruction break pour sortir de la boucle ou une condition à un point particulier. Cela dépend totalement de l'exigence. C'est une déclaration très petite mais utile dans n'importe quelle langue et donc, pour c # également. Essayez de vous salir les mains sur l'utilisation des instructions de pause.

Articles recommandés

Ceci est un guide pour Break Statement en C #. Nous discutons ici de l'introduction et du fonctionnement de l'instruction break en c # ainsi que de ses exemples. Vous pouvez également consulter les articles suivants pour en savoir plus -

  1. La syntaxe de la boucle C # while
  2. Commandes C # de base
  3. Comment fonctionne Loop en C?
  4. Comment vérifier le Palindrome dans le programme C ++?
  5. Boucles dans VBScript avec des exemples

Catégorie:

Développement de logiciels