Jump Intemations en C #
Dans les instructions C # Jump Contrôlez le flux d'un programme. Les instructions de saut permettent aux utilisateurs de transférer le contrôle d'une partie à une autre dans un code. Ils sont utiles dans des situations où vous souhaitez sauter du code ou répéter une section de code plusieurs fois.
Cet article couvre les différents types d'instructions de saut en C #, comment elles fonctionnent et quand les utiliser.
Table des matières
1: Jump Instatations en C #
2: Types d'instructions de saut en C #
-
- 1: déclaration GOTO
- 2: Déclaration de rupture
- 3: Continuer la déclaration
- 4: déclaration de retour
- 5: Déclaration de lancer
Conclusion
1: Jump Instatations en C #
Les instructions de saut sont une construction de programmation utilisée pour contrôler le flux d'exécution dans un bloc de code. Il permet au programme de sauter certaines sections de code ou de les répéter en fonction de certaines conditions. Les instructions de saut peuvent être utiles dans des situations telles que la gestion des erreurs ou les constructions de boucle.
2: Types d'instructions de saut en C #
En C #, il existe cinq types d'instructions de saut:
-
- déclaration GOTO
- défaut de rupture
- Continuer la déclaration
- déclaration de retour
- lancer une déclaration
Chacune de ces déclarations a sa fonctionnalité et son utilisation uniques. Voici une description détaillée de chaque déclaration de saut en C #.
1: déclaration goto en C #
L'instruction GOTO en C # vous permet de passer à une déclaration étiquetée dans votre programme. Pour l'utilisation aller à En C #, une étiquette est requise. L'étiquette est une déclaration que vous avez marquée d'un identifiant spécifique, et il doit être suivi d'un côlon.
Le syntaxe pour utiliser le aller à La déclaration en C # est la suivante:
étiquette Goto;
Ici, étiqueter est l'identifiant de la déclaration que vous souhaitez sauter. Il est essentiel de noter que la surutilisation de l'instruction GOTO peut rendre votre code plus difficile à lire et à maintenir.
Exemple: en utilisant l'instruction GOTO
Code suivant Expliquez l'utilisation de "aller à" déclaration en C #.
Utilisation du système;
ConsoleApplication de l'espace de noms
programme de classe
statique void main (String [] args)
Console.WriteLine ("Goto commence");
étiquette Goto;
Console.WriteLine ("Cette ligne sera ignorée");
étiqueter:
Console.WriteLine ("Cette ligne sera affichée");
Console.Lire();
Le programme commence par imprimer "Goto commence" à la console en utilisant le Console.WriteLine () méthode.
Ensuite, le programme utilise la déclaration «Goto» pour passer à une déclaration étiquetée intitulée «étiqueter". Étant donné que l'instruction «GOTO» transfère le contrôle de l'étiquette spécifiée, l'exécution du programme saute le Console.WriteLine () déclaration qui suit la déclaration «goto» et saute directement vers la déclaration étiquetée.
La déclaration étiquetée imprime "Cette ligne sera affichée«À la console à l'aide de la console.Méthode écrite de ligne. Enfin, le programme attend la saisie de l'utilisateur en utilisant le Console.Lire() méthode.
Lorsque l'utilisateur entre dans une entrée, le programme sort.
2: Break Statement en C #
Pour quitter une instruction en boucle ou commutateur en C # A casser La déclaration est utilisée. Après avoir utilisé une instruction BREAK, l'instruction LOP ou Switch est immédiatement terminée et le contrôle est transféré à l'instruction qui le suivant.
Voici le syntaxe de déclaration de pause en C #:
casser;
L'instruction Break est utilisée à l'intérieur d'une boucle ou d'une instruction Switch. Après l'exécution de l'instruction BREAK, le contrôle du programme est remis à la boucle qui est à côté. Notez que lorsqu'il y a plusieurs boucles imbriquées ensemble, l'instruction BREAK quittera seulement la seule itération de la boucle.
Exemple: Utilisation de l'instruction BREAK
Voici un exemple de code qui démontre l'utilisation de l'instruction de rupture dans C #.
Utilisation du système;
ConsoleApplication de l'espace de noms
programme de classe
statique void main (String [] args)
pour (int i = 1; i <= 10; i++)
si (i == 5)
casser;
Console.WriteLine ("la valeur de i est 0", i);
Console.Lire();
Le code ci-dessus commence par définir un pour Boucle qui commence à itération de 1 et se termine à 10. Pour chaque itération, la boucle pour vérifiera la valeur 5 en utilisant l'instruction if. Une fois que la boucle FOR atteint le numéro 5, l'instruction BRISE est exécutée, qui met fin à la boucle et passe à la déclaration suivante après la boucle.
Sinon, si le boucle la valeur n'est pas égale à 5, la boucle exécute le Console.WriteLine () Méthode, qui imprime la valeur actuelle de je à la console dans le format "La valeur de i est 0". Cette ligne est exécutée pour chaque itération de la boucle où je n'est pas égal à 5.
À la fin Console.Lire() Attendra la réponse de l'utilisateur après que le programme sort.
3: Continuer la déclaration en C #
En C #, l'instruction CONSTERAT SAUT L'IDÉRATION DE LA COURANT D'UNE BOUCHE ET POUR LE PLACH. Il est généralement utilisé pour sauter des valeurs ou des conditions spécifiques que vous ne souhaitez pas traiter dans votre boucle.
Le syntaxe Pour l'utilisation de l'instruction CONSTANT en C # est la suivante:
continuer;
Lorsque nous utilisons une instruction Continuer dans une boucle, il sautera certaines pièces de code sur des conditions spécifiques et définira le contrôle du programme au début de la boucle. En termes simples, cette instruction JUMP ignorera tout code restant et définira le pointeur pour démarrer la boucle.
Exemple: Utilisation de l'instruction CONSTANT
Vous trouverez ci-dessous un exemple de déclaration de poursuite en C #.
Utilisation du système;
ConsoleApplication de l'espace de noms
programme de classe
statique void main (String [] args)
pour (int i = 1; i <= 5; i++)
si (i == 3)
continuer;
Console.WriteLine ("la valeur de i est 0", i);
Console.Lire();
Ce code utilise un pour boucle qui commence par je réglé sur 1 et itère aussi longtemps que je est inférieur ou égal à 5. Pour chaque itération, la boucle vérifie si je est égal à 3 en utilisant l'instruction if. Lorsque la boucle atteint la valeur égale à 3, alors le Continuer la déclaration sera exécuté. Cela sautera toutes les autres déclarations définies à l'intérieur de la boucle pour cette itération particulière qui est i = 3 et passe à l'itération suivante.
Sinon, si je n'est pas égal à 3, la boucle exécute le Console.WriteLine () Méthode, qui imprime la valeur actuelle de je à la console dans le format "La valeur de i est 0". Cette ligne est exécutée pour chaque itération de la boucle où je n'est pas égal à 3.
À la fin Console.Lire() Attendra la contribution de l'utilisateur après cette sortie du programme.
4: Return Instruction en C #
L'instruction de retour en C # renvoie une fonction ou une valeur de méthode. Il termine l'exécution de la fonction ou de la méthode et donne la valeur spécifique à l'appel du code.
Le syntaxe Pour l'utilisation de l'instruction de retour en C # est la suivante:
return [val];
Ici, "Val" est la valeur que vous souhaitez retourner de la fonction ou de la méthode. Si l'instruction RETOUR est utilisée dans une méthode qui ne renvoie pas de valeur (void), le retour du mot-clé est utilisé sans valeur.
Exemple: Utilisation de l'instruction RETOUR
Ceci est un code C # qui explique l'utilisation des déclarations de retour.
Utilisation du système;
programme de classe
statique int add (numéro int)
Int result = nombre + numéro;
Résultat de retour;
statique void main (String [] args)
int num = 5;
Int result = add (num);
Console.WriteLine ("La somme de 0 et 0 est: 1", num, résultat);
Console.Lire();
Le programme définit une méthode appelée Ajouter() qui prend un numéro de paramètre entier, ajoute un nombre à lui-même et renvoie le résultat.
Dans le main (), une variable num est initialisée à 5, et la méthode add () est appelée avec nobs comme l'argument. Le retour valeur de Ajouter() est affecté à un résultat variable. Finalement, le Console.WriteLine () La méthode est utilisée pour imprimer un message à la console qui inclut la valeur d'origine de NUM et le résultat de l'addition.
Dans l'ensemble, ce programme montre comment une méthode peut effectuer un calcul et renvoyer une valeur qui peut être utilisée dans le code d'appel. L'instruction RETOUR quittera le programme et renverra une sortie à l'appelant.
5: Jetez la déclaration en C #
L'instruction Throw est un autre type d'instruction JUMP en C # qui peut lever une exception. Les exceptions incluent l'erreur qui survient lorsque le programme est exécuté, et ces erreurs entraînent la fin du programme de façon inattendue ou produisent des résultats incorrects.
Une fois une exception lancée, le runtime recherche un bloc de capture qui peut gérer l'exception. Si un bloc de capture est trouvé, le contrôle est transféré dans ce bloc et l'exception est manipulée. Si aucun bloc de capture n'est trouvé, le code se terminera avec l'affichage d'un message d'erreur.
La déclaration de lancer syntaxe est simple. Pour lancer une exception, vous utilisez simplement le mot clé à lancer suivi de l'objet d'exception que vous souhaitez lancer. Voici un exemple:
jeter e;
Un mot-clé de lancer est utilisé ici pour lancer une exception «E» qui dérive de la classe d'exception.
Exemple: Utilisation de l'instruction Throw
Voici un exemple de programme C # qui explique l'utilisation des déclarations de lancer.
Utilisation du système;
Classe Program
statique void main (String [] args)
int num1 = 10;
int num2 = 0;
essayer
if (num2 == 0)
Jetez un nouveau divideByZeroException ("ne peut pas diviser par zéro.");
INT Result = num1 / num2;
Console.WriteLine ("Résultat:" + Résultat);
catch (divideByZeroException e)
Console.WriteLine ("Erreur:" + E.Message);
Dans ce programme, nous essayons de diviser num1 par num2, Mais nous avons ajouté un bloc de coups d'essai pour gérer la possibilité d'un DivideByZeroException être jeté.
À l'intérieur du bloc d'essai, nous vérifions si num2 est égal à 0 et lorsque cette condition devient vraie, nous lançons une divisionByZeroException avec le message "Impossible de diviser par zéro".
Si aucune exception n'est lancée, le résultat de la division sera calculé et imprimé sur la console.
Si une exception est lancée, le bloc de capture le gérera en attrapant le divideByZeroException et en diffusant le message d'erreur à la console.
Conclusion
Les déclarations de saut sont une partie cruciale des langages de programmation, y compris C #. Dans cet article, nous avons examiné les différents types d'instructions de saut en C #, comment elles fonctionnent et quand les utiliser. Cependant, l'utilisation des instructions de saut en particulier Goto n'est pas recommandée car ils peuvent changer le flux du programme et rendre difficile la trace.