Sélectionnez la bonne condition pour contrôler le déroulement de votre programme

À mesure que vos programmes vont gagner en sophistication, vous devrez peu à peu aller plus loin que l'écriture de lignes de code qui s'exécutent l'une après l'autre selon une séquence prédéfinie. C'est là qu'intervient le déroulement du programme.

Reprenons le programme Hello World sur lequel nous avons travaillé dans le chapitre précédent : ne serait-il pas agréable d'être un peu plus précis, par exemple dire bonjour à une personne réelle ? 🙋🏽🙋🏻‍♂️

Affichez des informations précises si elles sont disponibles

Au démarrage du programme, il se peut que vous ne connaissiez pas le nom d'un utilisateur. Alors, pourquoi ne pas utiliser quelque chose comme :

• If (si) nous connaissons le nom de la personne, l'afficher.

• Else (sinon), continuer à dire bonjour au monde entier.

Voilà à quoi servent les conditions.

Revenons à la toute première instruction qu'un programme exécute, la base de la fonction  Main  :

public static void Main(string[] args)

Avez-vous remarqué  string[] args  à l'intérieur des parenthèses  ()  ? Nous avons une variable  args  définie avec le type  string[]  qui est un array de chaînes de caractères. Cela signifie que la fonction  Main  est capable de recevoir des arguments que nous pouvons utiliser lorsque le programme est lancé.

La seconde phase consiste à envoyer les arguments à votre programme. Au lieu de simplement fournir le nom de la classe contenant la méthode  Main  , vous pouvez ajouter des arguments, séparés par un espace. Par exemple : HelloWorld.exe Esther.

Après le nom de la classe, nous avons ajouté la chaîne de caractères « Esther ». Au démarrage du programme, cette chaîne est contenue dans l'array  args  qui fait partie de la base de la fonction Main. Cependant, notre code d'origine ne s'en sert pas. Nous devons le modifier de sorte qu'il réalise les actions suivantes :

1. Vérifier si l'array  args  contient une valeur (la propriété  Length  fournie par les arrays peut nous y aider).

2. Si c'est le cas, appeler la méthode  DireBonjour  avec la valeur qu'il contient.

3. Sinon, continuer à appeler la méthode avec la chaîne de caractères « World ».

Voici ce que ça donne :

using System;

namespace Conditions
{
    /// <summary>
    /// Ce programme affiche :
    /// - Un message de salutation personnalisé si un argument a été envoyé lors de l'exécution du programme
    /// - Le message traditionnel « Hello world! » si ce n'est pas le cas
    /// </summary>
    /// <remarks>L'équipe éducative d'OpenClassrooms</remarks>
    public class BonjourConditionel
    {
        /// <summary>
        /// Le programme commence ici
        /// </summary>
        /// <param name="args">Arguments envoyés avec la ligne de commande</param>
        public static void Main(string[] args)
        {
            if (args.Length == 1)
            {
               DireBonjour(args[0]);
            }
            else
            {
               DireBonjour("World");
            }
        }
        
        /// <summary>
        /// Afficher un message de salutation au destinataire qui a été renseigné
        /// </summary>
        /// <param name="recipient">À qui dire bonjour</param>
        private static void DireBonjour(string destinataire)
        {
            Console.WriteLine("Hello " + destinataire + "!");
        }
    }
}

Testez par vous-même !

Prêt à coder ? Pour accéder à l’exercice, suivez ce lien. 

Ça fonctionne ! Voyons plus en détail comment fonctionne réellement cette instruction conditionnelle if.

Testez vos conditions avec des booléens

En C#, pour valider une condition, on utilise un type de données spécial appelé  booléen (  Boolean  )  . Une variable de type booléen ne peut contenir que deux valeurs : vrai (  true  ) ou faux (  false  ). Le booléen est le type de données le plus simple.

On utilise  bool  comme alias de la classe  Boolean  .

En C#, les types booléens utilisent des paires vrai/faux. Pour déclarer une variable booléenne, il faut spécifier le type  bool  . Déclarons quelques variables booléennes :

bool leCoursEstExcellent = true;
bool lAuteurEstHumble = false;

C'est logique, n'est-ce pas ? 😉

Le résultat de la condition exprimée à l'intérieur des parenthèses  ()  après le mot-clé  if  doit être un booléen. Cette condition peut être exprimée de la façon suivante :

1. Une valeur  true  ou  false .  Par exemple,  if(true)  .

2. Une variable de type  bool  . Par exemple,  if(maVariable)  où  maVariable  est de type  bool  .

3. Une expression qui se résout en une valeur booléenne. Cette expression peut être simplement le résultat d'un appel de méthode.

Par exemple :

string meteo = "Il fait beau";
meteo.StartsWith("Il fait"); // -> true

StartsWith  est une méthode de la classe  String  qui renvoie  true  si la chaîne commence par le préfixe spécifié. Elle peut donc être utilisée comme une condition.

Pour créer un booléen, vous pouvez également utiliser des opérateurs de comparaison.

Opérateurs de comparaison

Comme leur nom l'indique, les opérateurs de comparaison sont utilisés pour comparer deux valeurs. Ils sont au nombre de six :

• ==  Égal à (identité parfaite) ;

• !=  Non égal à (différence, quelle qu'elle soit) ;

• <  Inférieur à ;

• <=  Inférieur ou égal à ;

• >  Supérieur à ;

• >=  Supérieur ou égal à.

Voici quelques exemples de comparaisons numériques :

2 == 2 // -> true
2 == 3 // -> false

4 != 4 // -> false
4 != 5 // -> true

1 < 2 // -> true
1 < 1 // -> false

1 <= 1 // -> true
3 > 4 // -> false

5 > 4 // -> true
5 >= 4 // -> true

On affecte ces résultats à une variable. Par exemple :

int age = 15;
if(age >= 21)
{
    // Exécuter cette partie du code uniquement si l'âge est d'au moins 21 ans.
}

Enfin, vous voudrez peut-être avoir des conditions plus compliquées, où la décision dépend du résultat d'une combinaison d'expressions différentes. C'est ici que les opérateurs logiques entrent en jeu.

Opérateurs logiques

Ces opérateurs vous permettent de combiner des valeurs booléennes : soit des valeurs booléennes spécifiques, soit des résultats d'expressions. Ils sont au nombre de trois :

• &&  ET logique
  Le résultat n'est vrai que si toutes les parties impliquées sont vraies.
  Exemple : le résultat de  expression1 && expression2  n'est vrai que si  expression1  est vraie ET expression2est également vraie.

• ||  OU logique
  Le résultat est vrai si au moins une des parties impliquées est vraie.
  Exemple : le résultat de  expression1 || expression2  est vrai si  expression1  est vraie OU  expression2  est vraie. Il sera aussi vrai si les deux expressions sont vraies !

• !  NON logique
  Il inverse simplement l'expression donnée.
  Exemple : le résultat de  !expression1  est vrai si  expression1  est fausse ; le résultat est faux si  expression1  est vraie.

Voici quelques exemples :

true && true // true
true && false // false
false && false // false

true || false // true
true || true // true
false || false // false

!true // false
!false // true

Les mêmes règles s'appliquent si plus de deux expressions sont enchaînées les unes après les autres :

true && true && true // true
true && true && false // false

true || false || false// true
false || false || false// false

Comme pour les opérateurs numériques, les opérateurs logiques respectent les règles de priorité des opérations : l'opérateur d'inversion  !  est prioritaire et suivi de l'opérateur ET  &&  , puis de l'opérateur OU  ||  . Par exemple :

false || true && true // true
!false && true || false // true

Comme pour les opérateurs numériques, utilisez les parenthèses  ()  pour changer cet ordre :

(true && false) || true // true
!(true && false || !true) // true

Pour vous entraîner, pouvez-vous calculer le résultat des expressions suivantes ?

!true && false
!(true && false)
4 < 3 || 4 >= 4
(!(1 == 2) || 3 != 3) && 35 > 34

Voici la réponse :

!true && false // false
!(true && false) // true
4 < 3 || 4 >= 4 // true
(!(1 == 2) || 3 != 3) && 35 > 34 // true

La forme générale d'une instruction conditionnelle en C# est  if (condition)  . La condition est une valeur booléenne, une variable de type bool ou le résultat de toute expression qui produit une valeur booléenne.

Dans notre exemple Hello World!, nous avons défini une alternative. Mais comment procéder pour prendre des décisions plus complexes, basées sur plusieurs valeurs possibles ?

Gérez une chaîne de conditions

Nous avons personnalisé notre message de salutation, mais comment faire pour ne pas se limiter à un seul prénom ?

Une première possibilité consiste à créer une chaîne de conditions. En voici la forme générale :

if (condition1)
{
    // Instructions
}
else if (condition2)
{
    // Instructions
}
else
{
    // Instructions
}

Dans notre exemple Hello World!, nous pourrions envoyer deux chaînes de caractères après le nom de la classe lors de l'exécution du programme. L'array  args  contiendrait alors deux éléments. Nous pourrions alors envoyer une chaîne concaténant ces deux chaînes à notre fonction  DireBonjour  :

public static void Main(string[] args)
{
    if (args.Length == 1)
    {
       DireBonjour(args[0]);
    }
    else if (args.Length == 2)
    {
       DireBonjour(args[0] + "-" + args[1]);
    }
    else
    {
       DireBonjour("World");
    }
}

Dans cet exemple, notre code évalue les différentes valeurs d'une condition particulière (la taille de l'array  args  ). Dans ce cas, C# fournit une construction spécifique qui ne fait l'évaluation qu'une seule fois : l'instruction  switch  .

Utilisez l'instruction switch

Parfois, vous devez parcourir plusieurs conditions, dont une seule peut être  true  dans la séquence. Dans ce cas, la technique switch est plus pratique. Switch utilise ce qu'on appelle des cas permettant de comparer une valeur et de décider si un bloc de code associé doit être exécuté. Réécrivons notre exemple if/else if/else en utilisant l’instruction switch :

public static void Main(string[] args)
{
    switch(args.Length)
    {
        case 0: // Aucun argument n'a été envoyé
            DireBonjour("World");
            break;
        case 1: // L'utilisateur a fourni un argument dans le terminal
            DireBonjour(args[0]);
            break;
        case 2: // L'utilisateur a fourni 2 arguments
            DireBonjour(args[0] + "-" + args[1]);
            break;
        default: // L'utilisateur a fourni plus d'arguments que nous ne pouvons en gérer !
            Console.WriteLine("Désolé, je ne sais pas comment gérer plus de deux prénoms !");
            break;
    }
}

Caractéristiques de l'instruction  switch  :

• L'expression conditionnelle  args.Length  n'est évaluée qu'une seule fois.

• Chaque cas compare le résultat de l'expression à une valeur spécifique.

• Par défaut, une fois qu'un cas est évalué  true  , tous les cas suivants sont également considérés comme true (fonctionnement en cascade). Pour éviter cela, terminez chaque cas par une instruction  break  .

• La clause  default  est considérée comme true si aucun autre cas ne l'est.

L'instruction switch rend votre intention plus claire qu'une chaîne de if/else, et vous permet d'évaluer l'état une seule fois. C'est cool. 😎 Mais ce n'est pas fini ! Il y a encore un autre type de données : les énumérations.

Utilisez le type enum

Les énumérations sont des listes de cas prédéfinis destinés à vous aider pendant le développement. Elles améliorent la lisibilité du code et diminuent les risques d'erreurs. Prenons un exemple dans lequel nous définissons toutes les directions possibles (nord, est, sud, ouest) dans une énumération, et utilisons-les dans un  switch  . Comme le  switch  doit couvrir tous les cas possibles, nous pouvons utiliser deux approches.

La première consiste à lister tous les cas de l'énumération dans l'instruction  switch  de façon à ne pas avoir à utiliser la clause default :

public class MaDirection
{
    /// <summary>
    /// Énumérer toutes les directions possibles
    /// </summary>
    enum Direction
    {
        nord,
        est,
        sud,
        ouest
    }
    
    /// <summary>
    /// Trouver le nord
    /// </summary>
    public static void Main(string[] args)
    {
        Direction direction = Direction.nord;
        
        switch (direction)
        {
            case Direction.nord:
                Console.WriteLine("Vous allez au nord");
                break;
            case Direction.est:
                Console.WriteLine("Vous allez à l'est");
                break;
            case Direction.sud:
                Console.WriteLine("Vous allez au sud");
                break;
            case Direction.ouest:
                Console.WriteLine("Vous allez à l'ouest");
                break;
        }
    }
}

Dans ce cas, nous couvrons toutes les directions, nous n'avons donc pas besoin de la clause  default  .

Autre possibilité, définir un cas d'utilisation dans lequel nous ne devrions nous diriger que vers le nord :

public static void Main(string[] args)
{
    Direction direction = Direction.nord;

    switch (direction)
    {
        case Direction.nord:
            Console.WriteLine("Vous allez au nord");
            break;
        default:
            Console.WriteLine("Vous êtes perdu !");
            break;
    }
}

Testez par vous-même !

Prêt à coder ? Pour accéder à l’exercice, suivez ce lien. 

En résumé 

• Les conditions vous permettent d'exécuter un bloc de code uniquement si une valeur  bool  , une variable ou une expression est évaluée comme  true  .

• Un moyen de fournir des valeurs à un programme est d'envoyer des arguments sur la ligne de commande. Ces arguments sont mis à la disposition de la fonction  Main  dans l'array  args  .

• Les expressions conditionnelles utilisent l'arithmétique booléenne, notamment les opérateurs de comparaison et les opérateurs logiques.

• Vous pouvez évaluer plusieurs conditions en créant une série d'instructions if/ else if/else.

• L'instruction  switch  est une façon plus propre d'exécuter du code en fonction des différentes valeurs possibles d'une condition particulière.

• Les énumérations vous permettent de définir un ensemble de valeurs possibles pour rendre votre code encore plus propre.

Dans le chapitre suivant, vous apprendrez une autre façon de gérer le déroulement de votre application : les boucles.