Programmation en C# – Les structures conditionnelles

Les structures conditionnelles exigent que le programmeur spécifie une ou plusieurs conditions à évaluer ou à tester par le programme, et consiste à décider l’ordre d’exécution des déclarations en fonction de certaines conditions ou à répéter un groupe d’instruction jusqu’à ce que certaines conditions spécifiées soient remplies.

Voir ci-dessous la figure qui montre la forme générale d’une structures conditionnelles typique trouvée dans la plupart des langages de programmation

 
 

Description de chaque déclaration
Déclaration if Consiste en une expression booléenne suivie d’une ou plusieurs instructions.
Déclaration if…else L’instruction « if » peut être suivie d’une instruction optionnelle « else », qui s’exécute lorsque l’expression booléenne est false.
Déclaration if imbriqués  Vous pouvez utiliser une instruction « if » ou « else if » dans une autre instruction « if » ou « else if ».
Déclaration switch L’instruction switch permet de tester l’égalité d’une variable à une liste de valeurs.
Déclaration imbriqués switch Vous pouvez utiliser une instruction switch dans une autre instruction switch (s).

Déclaration if

if (expression_booléenne)
{
    /* L'instructions à exécuter si l'expression booléenne est vraie */
}

Si l’expression booléenne est vraie, alors le bloc de code à l’intérieur de l’instruction if est exécuté. Si l’expression booléenne est évaluée comme fausse, le premier ensemble de code après la fin de l’instruction if (après l’accolade de fermeture) est exécuté.

Exemple :

using System;
namespace IF
{
   class Test
   {
      static void main(string[] args)
      {
         /* Définition de la variable locale */
         int a = 20;
         /* vérifie la condition booléenne en utilisant l'instruction if */
         if (a < 30)
         {
            /* Si la condition est vraie, affichez : a est inférieur à 30 */
            Console.WriteLine("a est inférieur à 30");
         }
         Console.WriteLine("valeur de a est : {0}", a);
         Console.ReadLine();
      }
   }
}

La sortie :

a est inférieur à 30
valeur de a est : 20

 
 
Déclaration if…else

La forme générale de l’instruction if … else.

if( expression )
{
   Bloc-instructions-1;
}else
{
   Bloc-instructions-2;
}

Si l’expression est vraie, le ‘Bloc-instructions-1’ est exécuté, sinon ‘Bloc-instructions-1’ est ignoré et ‘Bloc-instructions-2’ est exécuté.

Exemple :

using System;
namespace DecisionIfElse
{
   class Test
   {
      static void Main(string[] args)
      {
         /* Définition de la variable locale */
         int a = 200;
         
         /* Vérifier la condition booléenne */
         if (a < 30)
         {
            /* Si la condition est vraie, affichez : a est inférieur à 30 */
            Console.WriteLine("a est inférieur à 30");
         }
         else
         {
            /* Si la condition est fausse, affichez : a n'est pas inférieur à 30 */
            Console.WriteLine("a n'est pas inférieur à 30");
         }
         Console.WriteLine("valeur de a est : {0}", a);
         Console.ReadLine();
      }
   }
}

La sortie :

a est inférieur à 30
valeur de a est : 200

Déclaration if imbriqués 

La forme générale de l’instruction imbriquée if … else.

if( expression )
{
  if( expression1 )
   {
       Bloc-instructions1;
   }
  else 
   {
       Bloc-instructions2;
   }
}else
{
    Bloc-instructions3;
}

Si ‘expression’ est fausse, ‘Bloc-instructions3’ sera exécuté, sinon il continue à effectuer le test pour ‘expression 1’. Si l ‘expression 1 est vraie, ‘Bloc-instructions1’ est exécutée sinon ‘Bloc-instructions2’ est exécutée.

Exemple :

using System;
namespace DecisionImbriquer
{
   class Test
   {
      static void main(string[] args)
      {
         //* définition de la variable locale */
         int a = 200;
         int b = 300;
         
         /* vérifier la condition booléenne */
         if (a == 200)
         {
            /* si la condition est vraie, vérifiez l'instruction dans le bloc */
            if (b == 300)
            {
               /* Si la condition est vraie, affichez la chaine suivante */
               Console.WriteLine("La valeur de a est 200 et b est 300");
            }
         }
         Console.WriteLine("La valeur exacte de a est : {0}", a);
         Console.WriteLine("La valeur exacte de b est : {0}", b);
         Console.ReadLine();
      }
   }
}  

La sortie :

La valeur de a est 200 et b est 300
La valeur exacte de a est : 200
La valeur exacte de b est : 300

 
 

L’ opérateur ? :

Nous avons parlé de l’opérateur conditionnel ? : Dans le chapitre précédent, qui peut être utilisé pour remplacer les instructions if … else. Il a la forme générale suivante

Exp1 ? Exp2 : Exp3;

Exp1, Exp2 et Exp3 sont des expressions.

Si Exp1 est vrai donc Exp2 sera exécuter sinon Exp3 qui sera exécuter.

 

Les points à retenir

1- Dans une déclaration if, si on a une seule instruction à l’intérieur donc vous n’êtes pas obliger de  fermer les accolades {}

int a = 5;
if(a > 4)
  Console.WriteLine("success");

Aucun accolade n’est nécessaire dans le cas ci-dessus, mais si nous avons plus d’une déclaration à l’intérieur nous devons fermer les accolades.

2- L’opérateur == doit être utilisé pour la comparaison dans l’expression if , si vous utilisez l’expression =  renverra toujours true, car elle effectue l’affectation et non la comparaison.

3- Toutes les valeurs sont considérées comme vraies sauf 0 (zéro).

if(45)
 Console.WriteLine("Hello World");

Dans l’exemple ci-dessus, Hello World sera affichée.