• 20 hours
  • Easy

Free online content available in this course.

Paperback available in this course

course.header.alt.is_certifying

You can get support and mentoring from a private teacher via videoconference on this course.

Got it!

Last updated on 11/28/19

Les instructions conditionnelles

Log in or subscribe for free to enjoy all this course has to offer!

Dans nos programmes C#, nous allons régulièrement avoir besoin de faire des opérations en fonction d'un résultat précédent. Par exemple, lors d'un processus de connexion à une application, si le login et le mot de passe sont bons, alors nous pouvons nous connecter, sinon nous afficherons une erreur.

Il s'agit de ce que l'on appelle une condition. Elle est évaluée lors de l'exécution et en fonction de son résultat (vrai ou faux) nous ferons telle ou telle chose.

Bien que relativement court, ce chapitre est très important. N'hésitez pas à le relire et à vous entraîner.

Les opérateurs de comparaison

Une condition se construit grâce à des opérateurs de comparaison. On dénombre plusieurs opérateurs de comparaisons, les plus courants sont :

Opérateur

Description

==

Egalité

!=

Différence

>

Supérieur à

<

Inférieur à

>=

Supérieur ou égal

<=

Inférieur ou égal

&&

ET logique

||

OU logique

!

Négation

Nous allons voir comment les utiliser en combinaison avec les instructions conditionnelles.

L'instruction "if"

L’instruction if permet d’exécuter du code si une condition est vraie (if = si en anglais).
Par exemple :

decimal compteEnBanque = 300;
if (compteEnBanque >= 0)
    Console.WriteLine("Votre compte est créditeur");

Ici, nous avons une variable contenant le solde de notre compte en banque. Si notre solde est supérieur ou égal à 0 alors nous affichons que le compte est créditeur.

Pour afficher que le compte est débiteur, on pourrait tester si la valeur de la variable est inférieure à 0 et afficher que le compte est débiteur :

decimal compteEnBanque = 300;
if (compteEnBanque >= 0)
    Console.WriteLine("Votre compte est créditeur");
if (compteEnBanque < 0)
    Console.WriteLine("Votre compte est débiteur");

Une autre solution est d’utiliser le mot clé else, qui veut dire « sinon » en anglais.

« Si la valeur est vraie, alors on fait quelque chose, sinon, on fait autre chose », ce qui se traduit en C# par :

decimal compteEnBanque = 300;
if (compteEnBanque >= 0)
    Console.WriteLine("Votre compte est créditeur");
else
    Console.WriteLine("Votre compte est débiteur");

Il faut bien se rendre compte que l’instruction if teste si une valeur est vraie (dans l’exemple précédent la comparaison compteEnBanque >= 0).

On a vu rapidement dans les chapitres précédents qu’il existait un type de variable qui permettait de stocker une valeur vraie ou fausse : le type bool, autrement appelé booléen (boolean en anglais).
Ainsi, il sera également possible de tester la valeur d’un booléen. L’exemple précédent peut aussi s’écrire :

decimal compteEnBanque = 300;
bool estCrediteur = (compteEnBanque >= 0);
if (estCrediteur)
    Console.WriteLine("Votre compte est créditeur");
else
    Console.WriteLine("Votre compte est débiteur");

À noter que les parenthèses autour de l’instruction de comparaison sont facultatives, je les ai écrites ici pour clairement identifier que la variable « estCrediteur » va contenir une valeur qui est le résultat de l’opération de comparaison « compte en banque est supérieur ou égal à 0 », en l’occurrence vrai.

Voici d’autres exemples pour vous permettre d’appréhender plus précisément le fonctionnement du type bool :

int age = 30;
bool estAgeDe30Ans = age == 30;
Console.WriteLine(estAgeDe30Ans); // affiche True
bool estSuperieurA10 = age > 10;
Console.WriteLine(estSuperieurA10); // affiche True
bool estDifferentDe30 = age != 30;
Console.WriteLine(estDifferentDe30); // affiche False

Un type bool peut prendre deux valeurs, vrai ou faux, qui s’écrivent avec les mots clés true et false.

bool estVrai = true;
if (estVrai)
    Console.WriteLine("C'est vrai !");
else
    Console.WriteLine("C'est faux !");

Il est également possible de combiner les tests grâce aux opérateurs de logique conditionnelle, par exemple && qui correspond à l’opérateur ET.

Dans l’exemple qui suit, nous affichons le message de bienvenue uniquement si le login est « Nicolas » ET que le mot de passe est « test ». Si l’un des deux ne correspond pas, nous irons dans l’instruction else.

string login = "Nicolas";
string motDePasse = "test";
if (login == "Nicolas" && motDePasse == "test")
    Console.WriteLine("Bienvenue Nicolas");
else
    Console.WriteLine("Login incorrect");

D’autres opérateurs de logiques existent, nous avons notamment l’opérateur || qui correspond au OU logique :

if (civilite == "Mme" || civilite == "Mlle")
    Console.WriteLine("Vous êtes une femme");
else
    Console.WriteLine("Vous êtes un homme");

L’exemple parle de lui-même ; si la civilité de la personne est Mme ou Mlle, alors nous avons à faire avec une femme.

A noter ici que si la première condition du if est vraie alors la deuxième ne sera pas évaluée. C’est un détail ici, mais cela peut s’avérer important dans certaines situations dont une que nous verrons dans le cours suivant.

Un autre opérateur très courant est la négation que l’on utilise avec l’opérateur « ! ». Par exemple :

bool estVrai = true;
if (!estVrai)
    Console.WriteLine("C'est faux !");
else
    Console.WriteLine("C'est vrai !");

Ce test pourrait se lire ainsi : « Si la négation de la variable estVrai est vraie, alors on écrira c’est faux ».
La variable « estVrai » étant égale à true, sa négation vaut false.
Dans cet exemple, le programme nous affichera donc l’instruction correspondant au else, à savoir « C’est vrai ! ».

Rappelez-vous, nous avons dit qu’une instruction se finissait en général par un point-virgule. Comment cela se fait-il alors qu’il n’y ait pas de point-virgule à la fin du if ou du else ?
Et si nous écrivions l’exemple précédent de cette façon ?

bool estVrai = true;
if (!estVrai) Console.WriteLine("C'est faux !");
else Console.WriteLine("C'est vrai !");

Ceci est tout à fait valable et permet de voir où s’arrête vraiment l’instruction grâce au point-virgule. Cependant, nous écrivons en général ces instructions de la première façon afin que celles-ci soient plus lisibles.
Vous aurez l’occasion de rencontrer dans les chapitres suivants d’autres instructions qui ne se terminent pas obligatoirement par un point-virgule.

Remarquons enfin qu'il est possible d’enchaîner les tests de manière à traiter plusieurs conditions en utilisant la combinaison else-if. Cela donne :

if (civilite == "Mme")
    Console.WriteLine("Vous êtes une femme");
else if (civilite == "Mlle")
    Console.WriteLine("Vous êtes une femme non mariée");
else if (civilite == "M.")
    Console.WriteLine("Vous êtes un homme");
else
    Console.WriteLine("Je n'ai pas pu déterminer votre civilité");

L'instruction "Switch"

L’instruction switch peut être utilisée lorsqu’une variable peut prendre beaucoup de valeurs. Elle permet de simplifier l’écriture.
Ainsi, l’instruction suivante :

string civilite = "M.";
if (civilite == "M.")
    Console.WriteLine("Bonjour monsieur");
if (civilite == "Mme")
    Console.WriteLine("Bonjour madame");
if (civilite == "Mlle")
    Console.WriteLine("Bonjour mademoiselle");

pourra s’écrire :

string civilite = "M.";
switch (civilite)
{
    case "M." :
        Console.WriteLine("Bonjour monsieur");
        break;
    case "Mme":
        Console.WriteLine("Bonjour madame");
        break;
    case "Mlle":
        Console.WriteLine("Bonjour mademoiselle");
        break;
}

Switch commence par évaluer la variable qui lui est passée entre parenthèses. Avec le mot clé case on énumère les différents cas possible pour la variable et on exécute les instructions correspondante jusqu’au mot clé break qui signifie que l’on sort du switch.

Nous pouvons également indiquer une valeur par défaut en utilisant le mot clé default, ainsi dans l’exemple suivant tout ce qui n’est pas « M. » ou « Mme » ou « Mlle » donnera l’affichage d’un « Bonjour inconnu » :

switch (civilite)
{
    case "M." :
        Console.WriteLine("Bonjour monsieur");
        break;
    case "Mme":
        Console.WriteLine("Bonjour madame");
        break;
    case "Mlle":
        Console.WriteLine("Bonjour mademoiselle");
        break;
    default:
        Console.WriteLine("Bonjour inconnu");
        break;
}

Nous pouvons également enchainer plusieurs cas pour qu’ils fassent la même chose, ce qui reproduit le fonctionnement de l’opérateur logique OU (« || »). Par exemple, on pourra remplacer l’exemple suivant :

string mois = "Janvier";
if (mois == "Mars" || mois == "Avril" ||  mois == "Mai")
    Console.WriteLine("C'est le printemps");
if (mois == "Juin" || mois == "Juillet" || mois == "Aout")
    Console.WriteLine("C'est l'été");
if (mois == "Septembre" || mois == "Octobre" || mois == "Novembre")
    Console.WriteLine("C'est l'automne");
if (mois == "Decembre" || mois == "Janvier" || mois == "Février")
    Console.WriteLine("C'est l'hiver");

par :

switch (mois)
{
    case "Mars":
    case "Avril":
    case "Mai":
        Console.WriteLine("C'est le printemps");
        break;
    case "Juin":
    case "Juillet":
    case "Aout":
        Console.WriteLine("C'est l'été");
        break;
    case "Septembre":
    case "Octobre":
    case "Novembre":
        Console.WriteLine("C'est l'automne");
        break;
    case "Décembre":
    case "Janvier":
    case "Février":
        Console.WriteLine("C'est l'hiver");
        break;
}

Qui allège quand même l’écriture et la rend beaucoup plus lisible.

En résumé
  • Les instructions conditionnelles permettent d'exécuter des instructions seulement si une condition est vérifiée.

  • On utilise en général le résultat d'une comparaison dans une instruction conditionnelle.

  • Le C# possède beaucoup d'opérateurs de comparaison, comme l'opérateur d'égalité ==, l'opérateur de supériorité >, d'infériorité <, etc.

Example of certificate of achievement
Example of certificate of achievement