Pause en C#

Généralement, lorsque nous parlons de mettre fin à une exécution à ce moment-là, nous donnons des conditions pour le faire. 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 sur la prochaine instruction à venir. Cela nous aide à poursuivre l'exécution en évitant des opérations particulières à un certain stade. Dans les langages de programmation, nous rencontrons souvent les instructions break. Les instructions Break sont quelque chose qui ressemble à sa signification pour briser la logique ici. Comme d’autres langages de programmation, c# possède également une instruction break. Vous devez également avoir vu une instruction break dans le cas du 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 avance.

Syntaxe :

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

break;

Juste le mot-clé break et point-virgule. Définir une instruction break n'est rien d'autre que transmettre le contrôle à l'opération suivante dans la séquence. Les instructions de rupture sont la règle appliquée pour sortir d'une situation particulière à temps et arrêter toute exécution ultérieure.

Organigramme

• Ci-dessus, l'organigramme montre simplement le fonctionnement de l'instruction break, au début du flux, il vérifie la condition particulière. Si cela est satisfait, la boucle continue. Au point où la boucle reçoit une instruction break. Ou la condition dans laquelle cette boucle sort de la boucle avec l'utilisation d'une instruction break.
• Le flux est simple, il suffit de le comprendre en exécutant quelques exemples.
• La meilleure chose pour se familiariser avec l'instruction break est d'écrire le code et d'essayer le résultat avec différents scénarios.
• Les déclarations de pause sont très simples. Mais beaucoup de gens se sont trompés lorsqu'il sort de la boucle et démarre le processus d'exécution.
• Il existe de nombreux cas où nous utilisons ces instructions, notamment dans les boucles imbriquées. Dans la boucle imbriquée, la boucle interne obtient des instructions break lors d'un événement particulier pour sortir de la boucle.

Comment fonctionne l'instruction Break en C# ?

Supposons que nous ayons un programme et que nous exécutons 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 le code dans la séquence. Si vous regardez attentivement les exemples, les déclarations brisées sont plus susceptibles de fonctionner comme leur signification. Il interrompt le flux d'exécution à l'emplacement spécifié et le contrôle va passer à la prochaine opération requise.

Exemples d'instruction Break en C#

Des exemples d'instruction Break en C# sont donnés ci-dessous :

Exemple #1

Programme pour obtenir des non jusqu'à 10. S'il 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;
}
}
} }

Sortie :

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écutez davantage. Nous avons donné la condition if dans la boucle for selon laquelle si la valeur de i atteint 10, arrêtez l'exécution d'une boucle. Et ce scénario, nous l'avons réalisé grâce à l'instruction break. Essayez cet exemple dans un éditeur et vous obtiendrez un résultat 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;
}
}
}

Sortie :

Dans le programme ci-dessus, nous avons utilisé un boîtier de commutation. En cela, nous vérifions plusieurs cas. À partir du premier cas, nous vérifions le cas par rapport à la condition donnée. Si le cas switch ne correspond pas à la condition particulière, il rompt ce cas avec une instruction break et passe au cas suivant. Il s'exécute jusqu'à obtenir un cas correspondant. Si le cas correspond, il est exécuté et le résultat sera affiché. 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 switch case avec le mot-clé default. Après avoir exécuté à nouveau cette instruction, l'instruction break est obtenue et l'opération est terminée.

Exemple #3

Nous allons voir l'instruction break avec la 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();
}
}

Sortie :

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 rompons la boucle une fois qu'elle atteint 10. Mais nous avons la condition while pour la vérifier jusqu'à 20. Nous interrompons l'exécution au milieu de la boucle selon nos exigences. Jusqu'à présent, nous avons vu des exemples d'instruction break. Ce qui montre comment pouvons-nous utiliser l'instruction break avec différentes boucles et avec la condition if. Ce sont des exemples très basiques pour vérifier le travail des instructions break. Essayer ces exemples dans un éditeur adapté. Lorsque nous exécutons une boucle à l'intérieur du programme et que nous devons l'interrompre entre l'exécution à ce moment-là, 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 ce contrôle, on passe à l'instruction d'exécution suivante dans la séquence.

Conclusion

Chaque langage a une instruction break pour sortir de la boucle ou une condition à un moment donné. Cela dépend totalement des besoins. Il s'agit d'une instruction très petite mais utile dans n'importe quel langage et donc également pour C#. Essayez de vous salir les mains sur l'utilisation de l'instruction break.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!