C#: Les instructions

Introduction

• Un programme se compose d’une suite d’instructions. Au moment de l’exécution, ces instructions sont exécutées les unes après les autres, dans l’ordre dans lequel elles figurent dans le programme, de gauche à droite et de haut en bas.
• Une instruction peut être constituée d’une ligne unique de code qui se termine par un point-virgule, ou d’une série d’instructions sur une ligne dans un bloc.
• Un bloc d’instructions est placé entre accolades {} et peut contenir des blocs imbriqués ou un autre bloc imbriqué.
• Une variable déclarée dans un bloc est qualifiée de variable locale. La portée d’une variable locale s’étend de sa déclaration jusqu’à l’accolade fermante qui délimite la fin de son bloc.
• Dans C#, vous ne pouvez pas déclarer un nom de variable identique dans un bloc interne et externe.

Par exemple, le code suivant n’est pas autorisé :

int i;
{
int i; // Erreur : i déjà déclaré dans le bloc parent
...
}

• Vous pouvez toutefois déclarer des variables portant le même nom dans des blocs adjacents. Les blocs adjacents sont délimités par le même bloc parent et sont imbriqués au même niveau.

Exemple de déclaration autorisée

{
int i;
...
}
...
{
int i;
...
}

• Le langage C# est un langage de programmation structuré offrant des structures de contrôle :
  une sélection (alternative), une répétition (boucle) et un appel de méthode.
• La sélection permet d’exécuter ou non un bloc d’instructions selon une condition qui est vraie ou fausse.
• La répétition permet de répéter un bloc d’instructions un certain nombre de fois.
• L’appel de méthode permet de diriger le contrôle de l’exécution vers une autre section du code. Une fois la méthode terminée, le contrôle revient à l’instruction qui suit l’appel de cette méthode.

Les instructions de sélection

• Les instructions if et switch sont des instructions conditionnelles (également appelées instructions de
  sélection). Ces instructions prennent des décisions en fonction de la valeur des expressions et
  exécutent des instructions de manière sélective en fonction de ces décisions.
• Les instructions de sélection permettent de se brancher à différentes sections de code, en fonction d’une ou plusieurs conditions spécifiées.
• Une instruction de sélection fait en sorte que le contrôle du programme soit transféré à un flux spécifique selon si une certaine condition est true ou non.
• Les mots clés suivants sont utilisés dans des instructions de sélection :

if-else

Syntaxe:

if(expression boolean)
{
   /*déclaration (s ) sera exécutée
si l'expression booléenne est vraie */
}
else
{
   /* déclaration (s ) sera exécutée
si l'expression booléenne est fausse */
}

• Une instruction if identifie l’instruction à exécuter en fonction de la valeur d’une expression Boolean. Dans l’exemple suivant, la variable Booleanresult est définie sur true puis archivé dans l’instruction if.
• L’instruction if peut être associée à une clause else facultative, comme illustré ci-dessous :

if ( nombre == 10 )
{
resultat = 1 ;
}
else
{
resultat =0 ;
}

• L’instruction else if permet de traiter les instructions if en cascade.

if ( nombre == 10 )
{
resultat = 1 ;
}
else if (nombre == 9)
{
resultat =10 ;
}
else
{
resultat =0 ;
}

• L’instructions else if permet un nombre indéfini de branchements. Cependant, les instructions contrôlées par une instruction if en cascade étant mutuellement exclusives, une seule instruction de l’ensemble de constructions else if sera exécutée.

Exercice_apcpedagogie08

• Ecrire un programme C # qui accepte deux nombres saisie par l’utilisateur.
• Si l’utilisateur à pressé l’une des touches numériques (0-9), le programme affiche le nombre qui est pressé
• Si non le programme affichera “Touche non autorisée”.
• Si l’utilisateur à saisie les deux nombres le programme affichera :.
  • Le premier nombre est égal au deuxième nombre.
  • Le premier nombre est inférieure au deuxième nombre.
  • Le premier nombre est supérieure au deuxième nombre.

Solution




Exercice_ValeurAbsolue

• Ecrire un programme C# servant à calculer la valeur absolue d’un nombre réel x à partir de la définition de la valeur absolue ci-dessous.
• La valeur absolue d’un nombre réel x est le nombre réel |x| :
  |x| = x , si x>=0
  |x| = -x si x < 0.




switch

Syntaxe

 switch (expression)
{
    case  constante :
         instructions;
         break;

   [default : 
        instructions; 
        break;]
}
//Les [ ] indiquent que cette section est facultative.
//expression :sélecteur qui peut être de type entier ou de type chaîne 
//instruction(s):les instructions à exécuter lorsque le contrôle est  transféré au case ou à default.
//break :instruction de saut qui transfère le contrôle à la fin du switch.

• L’instruction switch est une séquence de contrôle qui sélectionne une section switch à exécuter dans une liste de candidats.
• L’instruction switch offre une méthode de traitement des conditions complexes plus élégante que les
  instructions if imbriquées.
• Chaque section switch contient un ou plusieurs noms de cas suivis d’une ou de plusieurs instructions.
• Elle se compose de plusieurs blocs de case, chaque bloc spécifiant une
  constante unique et une étiquette case associée.
• Un bloc switch peut contenir des déclarations. La portée d’une variable locale ou d’une constante
  déclarée dans un bloc switch s’étend depuis sa déclaration jusqu’à la fin du bloc switch.
• L’exemple suivant montre une instruction switch simple qui a trois sections switch. Chaque section switch a un nom de cas, tel que case 1 et une liste de deux instructions.

int caseSwitch = 1;
switch (caseSwitch)
{
    case 1:
        Console.WriteLine("Case 1");
        break;
    case 2:
        Console.WriteLine("Case 2");
        break;
    default:
        Console.WriteLine("Default case");
        break;
}

• L’instruction switch transfère le contrôle à la section switch dont l’étiquette case correspond à la valeur de l’expression switch (caseSwitch dans l’exemple).
• Si aucun nom de cas ne contient de valeur correspondante, le contrôle est transféré vers la section default, s’il y en a une. S’il n’y a aucune section default, aucune action n’est effectuée et le contrôle est transféré à l’extérieur de l’instruction switch.
• Dans l’exemple précédent, les instructions dans la première section commutateur sont exécutées car case 1 correspond à la valeur caseSwitch.
• L’instruction switch évalue uniquement les types d’expressions suivants : tous les entiers, char, enum et string. Vous pouvez toutefois évaluer d’autres types d’expressions à l’aide de l’instruction switch du moment qu’il existe précisément une conversion implicite définie par l’utilisateur du type non autorisé vers les types autorisés.

Exercices d’applications

Exercice_apcpedagogie02

• Ecrire un programme C # pour détecter les touches pressées par l’utilisateur.
• Si l’utilisateur presse l’une des touches numériques (0-9), le programme affiche le nombre qui est pressé
• Si non le programme affichera “Touche non autorisée”.

Solution

 

Exercice_apcpedagogie04

• Ecrire un programme C # qui permet à l’utilisateur de choisir la bonne réponse d’une question.
• Quelle est la bonne façon de déclarer une variable pour stocker une valeur entière en C #?
  • a: 1x int = 10;
  • b: int x = 10;
  • c: float x = 10.0f;
  • d: string x=”10″;
• Choisissez la lettre de réponse juste:

Solution

 

Exercice Instructions switch 003

• Ecrire un programme C # qui permet à l’utilisateur de saisir une lettre, et le programme vérifie si c’est bien une lettre de l’alphabet en premier temps puis il teste si la lettre saisie est la première d’un grade en deuxième lieu.
• le programme affiche le grade suivant le tableau suivant:
  • e: Excellent;
  • t: Trés bien;
  • b: Bien;
  • m: Mauvais;
  • p:Passable;
  • l:la Moyenne;
  • a:non Admis;
  • s:Succès;
• Grade non trouvé:

Solution




switch. . .case

• L’instruction switch . . .case est une sélection à n branches.
• Elle est utilisée dans le cas où l’on doit vérifier si une variable ou une expression est égale à des valeurs déterminées.
• Les instructions à effectuer sont indiquées pour chacune des valeurs (case) de la variable ou de l’expression.
• Le switch est un raccourci d’écriture d’un if imbriqué dont les conditions sont des comparaisons d’égalité sur la même variable ou expression.
• Il peut y avoir un nombre quelconque d’étiquettes case.
• Les étiquettes case ne peuvent pas avoir la même valeur.
• L’instruction de saut break est nécessaire après chaque bloc.
• Les étiquettes case sont exécutées dans l’ordre. Placer le cas qui se produit le plus souvent au début.
• S’il n’y a pas d’étiquette default, le contrôle est transféré à l’extérieur du switch.
• Il est possible d’empiler les étiquettes case. Voir les cas “Très Petit” et “Petit” dans l’exemple #1 ci-dessous.
• Dans l’exemple si-dessous la comparaison est effectuée avec la variable choix Grandeur de type string.

decimal cout = 0;
string  choixGrandeur = "";
...
switch (choixGrandeur)
{
   case "Très Petit" :
   case "Petit" :
       cout += 1.75;
       break;
   case "Moyen"  :
       cout += 2.25;
       break;
   case "Grand"  :
       cout += 3.75;
       break;
   default :
       cout += 4.50;
       break;              
  }//fin du switch
// Le switch est équivalent à la structure if imbriqué.
decimal cout =0;
if( choixGrandeur == "Très Petit" || choixGrandeur == "Petit" )
  cout += 1.75;
else if ( choixGrandeur == "Moyen" )
    cout += 2.25;
else if ( choixGrandeur == "Grand" )
    cout += 3.75;
else
    cout += 4.50;

Dans l’exemple suivante la comparaison est effectuée avec la variable choix de type int.

decimal prixItem = 0;
int     quantite = 0;
...
switch ( choix )
{
    case 0 :
        prixItem = 0.40m;
        quantite = 150;
        break;
    case 1 :
        prixItem = 0.50m;
        quantite = 250;
        break;
    case 2 :
        prixItem = 0.60m;
        quantite = 350;
        break;
   case 3 :
        prixItem = 0.70m;
        quantite = 450;
        break;
}//fin du switch
// Le switch est équivalent un if imbriqué.

decimal prixItem = 0;
int     quantite = 0;

if( choix == 0 )
{
   prixItem = 0.40m;
   quantite = 150;
}
else if ( choix == 1 )
{
   prixItem = 0.50m;
   quantite = 250;
}
else if ( choix == 2 )
{
   prixItem = 0.60m;
   quantite = 350;
}
else if ( choix == 3 )
{
   prixItem = 0.70m;
   quantite = 450;
}

Dans l’exemple suivante la comparaison est effectuée avec la variable cote de type char.

char cote;
...
switch ( cote )
{
  case 'A' :
      Console.WriteLine("Excellent!");
      break;
  case 'B' :
      Console.WriteLine("C'est bien!");
      break;
  case 'C' :
   case 'D' :            
          Console.WriteLine("Passable...");
      break;
  case 'E' :
      Console.WriteLine("Échec!");
      break;
}//fin du switch
// Le switch est équivalent un if imbriqué.

if( cote == 'A' )
{
   Console.WriteLine("Excellent!");
}
else if ( cote == 'B' )
{
   Console.WriteLine("C'est bien!");
}
else if ( cote == 'C' || cote == 'D' )
{
   Console.WriteLine("Passable...");
}
else if ( cote =='E' )
{
   Console.WriteLine("Échec!");
}

• Les instructions d’itération font exécuter des instructions incorporées un certain nombre de fois, selon les critères de terminaison des boucles.
• Ces instructions sont exécutées dans l’ordre, sauf quand une instruction de saut est rencontrée.
• Les mots clés suivants sont utilisés dans des instructions d’itération :

• do
• for
• foreach
• in
• while

L’instruction while

Syntaxe

////tant que l'expression est vraie, exécuter le bloc d'instructions. 
while(expression booléenne)
{
    instruction(s);
}
//Ici , l'instruction(s ) peut être une simple déclaration ou un bloc d'instructions.
//La condition peut être toute expression.

• L’instruction de répétition while sert à exécuter un bloc d’instructions, un nombre de fois non connu.
• En programmation, la boucle while, francisée en boucle tant que, est une structure de contrôle permettant d’exécuter un ensemble d’instructions de façon répétée sur la base d’une condition booléenne.
• La boucle while peut être considérée comme une répétition de l’instruction if.
• Une déclaration de boucle while en C # exécute à plusieurs reprises une déclaration cible tant qu’une condition donnée est vraie.



• Parmi les instructions d’itération, while est la plus simple à utiliser. Elle exécute une instruction incorporée tant que l’expression booléenne est vraie.
• L’instruction while répète une instruction ou un bloc
  d’instructions jusqu’à ce qu’une expression spécifique corresponde à la valeur false.
• Une boucle while peut être terminée lorsqu’une instruction break, goto, return, ou throw transfère le contrôle à l’extérieur de la boucle.
• Pour transmettre le contrôle à la prochaine itération sans sortir de la boucle, utilisez l’instruction continue.
• Pour cet image, un point clé de la boucle while est que la boucle pourrait jamais fonctionner .
• Lorsque la condition est testé et le résultat est faux , le corps de la boucle est ignorée et la première déclaration après la boucle while est exécutée.

Une instruction while s’exécute comme suit :

1. L’expression booléenne qui contrôle l’instruction while est évaluée.
2. Si l’expression booléenne a la valeur true, l’instruction incorporée est exécutée. À la fin de cette
   exécution, le contrôle repasse implicitement au début de l’instruction while et l’expression booléenne
   est de nouveau analysée.
3. Si l’expression booléenne a la valeur false, le contrôle est transféré à la fin de l’instruction while.
   Par conséquent, le programme ré-exécute l’instruction incorporée tant que l’expression booléenne a la valeur true.
• L’expression booléenne étant testée au début de la boucle while, il est possible que l’instruction incorporée ne soit jamais exécutée.

• Exemple:

  Extraire les chiffres d’un nombre.

int unNombre = 782345;
int unChiffre = 0;

while (unNombre > 0)
{
    unChiffre = unNombre % 10;
    unNombre = unNombre / 10;
    Console.WriteLine(unChiffre);
}

• Exemple:Lors de la lecture dans un fichier texte, le nombre de lignes à lire n’est pas connu.
  La boucle while doit être utilisée.

StreamReader objVentesALire =  new StreamReader("ventes.txt");

while ( !objVentesALire.EndOfStream ) //Tant que ce n’est pas la fin du fichier.
{
    string ligneLue = objVentesALire.ReadLine();             
    . . . 
    . . . 
}
objVentesALire.Close();

• La boucle for est un cas particulier de la boucle while.
• Lorsqu’un compteur contrôle le nombre de répétitions, la boucle for est utilisée.
• Exemple: Afficher 5 fois le mot allo.

// While : pas la bonne structure à utiliser
// car le nombre de répétitions est connu.

int cptFois = 1;

while ( cptFois <= 5 )
{
   Console.WriteLine("allo");
   cptFois++
}
//Comparer le while et le for
// For : la bonne structure à utiliser
for( int cptFois = 1; cptFois <= 5; cptFois++ )
{
   Console.WriteLine("allo");
}

Exercice d’application:

Exercice_apcpedagogie013

• créer un mini-jeu “Le nombre mystère”sur console c# qui répond aux conditions suivants.

<ul

• Un nombre est tiré hasard entre 0 et 100 (les deux inclus : [0; 100]).
• On demande au joueur d’entrer un nombre.
• Si ce n’est pas un nombre entre 0 et 100, on indique qu’il y a une erreur.Sinon, on compare avec le nombre tiré au sort :
• Soit c’est le même, alors le jeu est terminé.
• soit le nombre entré ne convient pas et il faut indiquer au joueur si le bon nombre est inférieur ou supérieur au nombre mystère.

Solution

Exerciceinstruction While 001

• Ecrire un programme qui affiche la table de multiplication des entiers inférieur ou égaux à 10.
• Utiliser deux boucles whiles

<ul

Solution

L’instruction do

• L’instruction do est toujours accompagnée d’une instruction while.
• L’instruction de répétition do … while sert à exécuter un bloc d’instructions, un nombre de fois inconnu.
• Cependant, le bloc d’instructions est toujours exécuté au moins une fois car la condition est placée après le bloc d’instructions.
• La boucle do … while est souvent utilisée lorsqu’il faut valider des données.
• Elle est similaire à l’instruction while, à cette différence près que l’analyse de l’expression booléenne qui détermine la poursuite ou la sortie de la boucle s’effectue en fin de boucle, et non pas au début. Cela signifie que, contrairement à une instruction while qui est exécutée zéro ou plusieurs fois, une instruction do est exécutée une au moins fois.
Syntaxe :

      
     do 
     {
       instructions;

     } while (expression booléenne);  // tant que c'est vrai, recommencer le bloc d'instructions.

• Les instructions sont exécutées une fois avant que l’expression booléenne soit vérifiée.
• C’est la principale différence avec la boucle while.
• Si l’expression booléenne est évaluée à true, les instructions sont exécutées à nouveau.
• À la fin l’exécution du bloc d’instructions, l’expression booléenne est vérifiée.
• Dès qu’elle est évaluée à false, le contrôle passe à l’instruction suivant la boucle.
• Si la condition n’est jamais évaluée à false, c’est une boucle infinie.

Exemple : Afficher les nombres de 0 à 4.

      
     int cptLignes = 0;
do
{
   Console.WriteLine(cptLignes);
   cptLignes++;

} while (cptLignes < 5); // tant que c'est vrai, exécuter les instructions.
//Résultat
  0
  1
  2
  3
  4

Exercice instruction Do While 001

• Ecrire un programme c# qui vous permet de calculer la moyenne d’un nombre de notes, inconnu qu départ.
• Faite saisir au clavier des notes entre 0 et 20 (une note incorrecte ne sera pas prise en compte)
• A chaque note saisie ,demandez à l’utilisateur s’il souhaite continuer (réponse dans un caractère : O ou n)
• Afficher sur la console la moyenne des notes saisie

<ul

Solution

L’instruction for

• L’instruction for, aussi appelée boucle compteur, sert à exécuter un bloc d’instructions, un nombre déterminé de fois.
• La variable utilisée pour le nombre de fois est appelée un compteur et est de type int.
• La boucle for permet de répéter un certain nombre de fois des instructions

Syntaxe

       for ( initialisation ; condition ou  test_continuation ; incrémentation ou décrémentation)
    {
         instructions;
    }

//Clarifications:

• initialisation:assigne une valeur à la variable compteur
• condition:vérification de la condition : tant qu’elle est vraie, la boucle continue
• instructions:exécution si la condition est vraie
• incrémentation/décrémentation:augmentation ou diminution de la variable compteur avant de vérifier à nouveau la condition.

Exemple:Écrire 5 fois le mot “apcpedagogie.com” sur des lignes différentes(retour à la ligne).

for (int nbrFois = 1; nbrFois <= 5; nbrFois++)                     
{
     Console.WriteLine("apcpedagogie.com");
}

• Comme dans toutes les instructions de répétition, la condition d’un bloc for doit être une expression
  booléenne qui tient lieu de condition de poursuite de la boucle et non pas de condition de fin.
• Il existe une petite différence entre les instructions while et for : la portée d’une variable déclarée dans le code d’initialisation d’une instruction for est limitée au bloc for. Ainsi, l’exemple suivant génère une erreur de compilation :

for ( int i = 0; i < 10; i++ )
Console.WriteLine(i);
Console.WriteLine(i); // Erreur : i n'est plus dans la portée

Surcharge :

L’instruction foreach

• C# fournit l’instruction foreach, qui permet de parcourir chaque élément d’une collection sans recourir
  à une longue liste d’instructions.
• L’instruction foreach est une structure de contrôle permettant de parcourir automatiquement une collection sans utiliser un compteur.Le bloc d’instructions est exécuté pour chacun des items de la collection : du premier au dernier item.
• Plutôt que d’extraire explicitement chaque élément d’une collection avec une syntaxe spécifique à la collection, l’instruction foreach permet d’aborder le problème différemment.
• Ce n’est plus l’instruction incorporée qui est apportée à la collection, c’est la collection qui est apportée à l’instruction incorporée.

Syntaxe

       foreach( type item in Collection)
     {
         instructions;
     }

//Clarifications:

• type :le type de l’élément contenu dans la collection
• item :identificateur de variable locale utilisé comme nom associé à l’item courant
• in:opérateur d’accès à chacun des items de la collection
• Collection:nom de la collection à parcourir.
• instructions:les instructions contenues dans la boucle peuvent modifier le contenu d’un item de la collection,mais il ne faut pas ajouter et supprimer d’items.

Exemlpe:Compter le nombre de ‘c’ contenu dans une chaîne de caractère,”je lis mon cours dans apcpedagogie.com”.

string maChaine = "je lis mon cours dans apcpedagogie.com"; 

int nbrDeC= 0;
foreach (char caractereCourant in maChaine )
{
   if( caractereCourant == 'c')
   {
      nbrDeC++;
   }
}
Console.WriteLine("Nombre de c : " + nbrDeC);

 

Exercice Instructions for 001

Ecrire un programme en c# qui affiche les 31 jours du mois de Janvier à l’aide d’une boucle for.

Solution

 

Exercice Instructions for 002

• Écrire un programme en c# qui affiche un calendrier pour une année entière.
• Utilisez les deux méthodes Console.Write() et Console.WriteLine().
• La représentation finale sera :
• (1 jours du mois 1;2 jours du mois 1;3 jours du mois 1;…..
• ————————–
• (1 jours du mois 2;2 jours du mois 2;3 jours du mois 2;…..
• ————————–
• (1 jours du mois 3;2 jours du mois 3;3 jours du mois 3;…..

Solution

Les instructions de saut passent le contrôle sans condition.

jump-statement
break-statement
continue-statement
goto-statement
return-statement
throw-statement

break-statement

• Une instruction break permet de sortir de la plus proche instruction switch, while, do, for ou foreach qui l’entoure.
• Lorsque l’instruction break est rencontrée dans une boucle, la boucle est immédiatement arrêtée et le contrôle du programme reprend à la prochaine instruction qui suit la boucle.
• Il peut être utilisé pour mettre fin à une affaire dans l’instruction switch.

Exemple:

using System;
namespace break 
{
   class Program
   {
      static void Main(string[] args)
      {
         /* définition de la variable locale */
         int a = 10;
         
         /* while loop exécution */
         while (a < 20)
         {
            Console.WriteLine("Valeur de a: {0}", a);
            a++;
            if (a > 15)
            {
               /* mettre fin à la boucle en utilisant 
              l'instruction break */
               break;
            }
         }
         Console.ReadLine();
      }
   }
} 
//Lorsque le code ci-dessus est compilé et exécuté,
//il donne le résultat suivant :
Valeur de a: 10
Valeur de a: 11
Valeur de a: 12
Valeur de a:13
Valeur de a: 14
Valeur de a: 15

continue-statement

• Une instruction continue Provoque la boucle pour passer le reste de son corps et immédiatement retester son état avant de réitérer.
• Une instruction continue provoque une nouvelle itération de la plus proche instruction switch, while, do, for ou foreach qui l’entoure.
• L’instruction continue en C # fonctionne un peu comme l’instruction break. Au lieu de forcer la fin, cependant, continuer les forces de la prochaine itération de la boucle de prendre place, sauter tout code entre les deux.


Exemple

using System;
namespace Loops
{
   class Program
   {
      static void Main(string[] args)
      {
         /*définition de la variable locale */
         int a = 10;
         
         /* do loop execution */
         do
         {
            if (a == 15)
            {
               /* Sauter l'itération */
               a = a + 1;
               continue;
            }
            Console.WriteLine("value of a: {0}", a);
            a++;
         } 
         while (a < 20);
         Console.ReadLine();
      }
   }
} 
//Lorsque le code ci-dessus est compilé et exécuté,
//il donne le résultat suivant :
Valeur de a: 10
Valeur de a: 11
Valeur de a: 12
Valeur de a:13
Valeur de a: 14
Valeur de a: 16
Valeur de a: 17
Valeur de a: 18
Valeur de a: 19

goto-statement

• Goto transfère le contrôle à une étiquette nommée . Il peut être utilisé pour sortir d’une boucle imbriquée .
• L’instruction goto est l’instruction de saut la plus primitive du langage C#. Elle permet de passer le contrôle d’exécution à une instruction marquée par une étiquette.
• L’étiquette doit exister et sa portée doit s’étendre à l’instruction goto. Plusieurs instructions goto peuvent transférer le contrôle d’exécution vers la même étiquette.
• La Déclaration Goto exige une étiquette pour identifier l’endroit où la branche doit être faite . Une étiquette est un nom de variable valide et doit être suivi par deux points (:) .
• Une étiquette est placée immédiatement avant l’état où le contrôle doit être transféré .
• L’ instruction goto peut transférer le contrôle à tout endroit dans un programme.

Exemple:

using System;
namespace ConsoleApplication
{
    class Program
    {
     
        static void Main(string[] args)
        {
            Console.WriteLine("Goto  Exemple départ");
            goto displayInfo;
            Console.WriteLine("Ce code a sauté le code");
            displayInfo:
            {
                Console.WriteLine("Il est le bloc displayInfo");
            }            
            Console.Read();
        }
    }
}

return-statement

Dans ce chapitre , vous serez capable de :
• Déclarer return en C #?
• Connaitre la fonctionnalité de la déclaration de return?
• Utiliser la déclaration de return dans la programmation?

• L’instruction return termine l’ exécution de la méthode dans laquelle elle apparaît et renvoie le contrôle à la méthode d’appel.
• Une déclaration de return est utilisé pour le retour de la valeur à l’appelant de la fonction appelée.
• Il peut également renvoyer une valeur facultative. Si la méthode est un type de vide, l’instruction de retour peut être omis.

Exemple:

using  System ; 
 using  System . Collections . Generic ; 
 using  System . Linq ; 
 using  System . Text ; 
 
 namespace   return_statements 
 { 
     class   Program 
     { 
         public   int   add ( int   num1 ,   int   num2 ) 
         { 
             // Retourner l'addition de num1 et num2 
             return   num1   +   num2 ; 
         } 
         static   void   Main ( string [ ]   args ) 
         { 
             Program   p   =   new   Program ( ) ; 
             int   result ; 
          //Appeler la fonction add qui sera de retour 9 au résultat valable .
             result   =   p . add ( 3 ,   6 ) ; 
             Console . WriteLine ( result ) ; 
             Console . ReadLine ( ) ; 
         } 
     } 
 } 
//Dans cet exemple, la variable resultat appelle la fonction add ()
//avec deux paramètres et la fonction add () retourne l'addition à la fois 
//le numéro à la variable de résultat en utilisant mot-clé return .

throw-statement

Dans ce chapitre , vous serez capable de :
• Connaitre l’instruction throw en C #?
• Connaitre la fonctionnalité de la déclaration de throw?
• Utiliser la déclaration de throw en C #?

• Pour lever une exception, le Runtime exécute une instruction throw et lève une exception définie par le système. L’exécution séquentielle normale du programme est interrompue immédiatement et le
  contrôle d’exécution est transféré sur le premier bloc catch capable de gérer l’exception, en fonction de
  sa classe.
• Les exceptions sont utilisées pour indiquer qu’une erreur est survenue lors de l’exécution du programme.
• Les objets d’exception qui décrivent une erreur sont créés puis jetés avec le Throw mot – clé.
• La déclaration Throw est utilisée pour jeter exception dans un programme.
• L’exception de projection est assurée par bloc catch.
• L’instruction throw est utilisé pour signaler l’apparition d’une situation anormale (d’exception) au cours de l’exécution du programme.
• Throw génère ou traduit des exceptions . En utilisant une instruction throw dans un bloc catch , nous pouvons changer l’exception résultant . Sinon, nous pouvons lancer une nouvelle exception . L’ instruction throw est polyvalent et essentiel.

Exemple:

using  System ; 
 using  System . Collections . Generic ; 
 using  System . Linq ; 
 using  System . Text ; 
 
 namespace   throw_statement 
 { 
     class   Program 
     { 
         static   void   Main ( string [ ]   args ) 
         { 
             int   num1 ,   num2 ,   result ; 
              Console . WriteLine ( "Entrez le premier nombre" ) ; 
             num1   =   Convert . ToInt32 ( Console . ReadLine ( ) ) ; 
             Console . WriteLine ( "Entrez le deuxième nombre" ) ; 
             num2   =   Convert . ToInt32 ( Console . ReadLine ( ) ) ; 
 
             try 
             { 
                 if   ( num2   ==   0 ) 
                 { 
                     throw   new   Exception ( "Vous ne pouvez pas diviser par zéro: Exception\n\n" ) ; 
                 } 
                 result   =   num1   /   num2 ; 
                 Console . WriteLine ( "{0} / {1} = {2}" ,   num1 ,   num2 ,   result ) ; 
             } 
             catch   ( Exception   e ) 
             { 
                 Console . WriteLine ( "Erreur : "   +   e . ToString ( ) ) ; 
             } 
             Console . ReadLine ( ) ; 
         } 
     } 
 } 

Lever vos propres exceptions

• Vous pouvez recourir à l’instruction throw pour lever vos propres exceptions :

if (minute = 60) {
string fault = minute + " n'est pas une minute valide";
throw new InvalidTimeException(fault);
// !!Pas atteint!!
}

• Dans cet exemple, l’instruction throw lève une exception définie par l’utilisateur,InvalidTimeException, si le temps analysé ne correspond pas à une valeur de temps correcte.
• En règle générale, les exceptions sont créées avec une chaîne de message significatif en paramètre.
• Ce message est affiché ou enregistré au moment où l’exception est détectée.
• Il est également recommandé de lever une classe d’exceptions appropriée.