À 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.
Comment pouvons-nous donc connaître le nom de cette personne ?
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 :
Vérifier si l'array
argscontient une valeur (la propriétéLengthfournie par les arrays peut nous y aider).Si c'est le cas, appeler la méthode
DireBonjouravec la valeur qu'il contient.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 :
Une valeur
trueoufalse. Par exemple,if(true).Une variable de type
bool. Par exemple,if(maVariable)oùmaVariableest de typebool.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"); // -> trueStartsWith 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 // -> trueOn 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 deexpression1 && expression2n'est vrai que siexpression1est vraie ETexpression2est également vraie.||OU logique
Le résultat est vrai si au moins une des parties impliquées est vraie.
Exemple : le résultat deexpression1 || expression2est vrai siexpression1est vraie OUexpression2est 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!expression1est vrai siexpression1est fausse ; le résultat est faux siexpression1est 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 // trueLes 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// falseComme 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 // trueComme pour les opérateurs numériques, utilisez les parenthèses () pour changer cet ordre :
(true && false) || true // true
!(true && false || !true) // truePour 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 > 34Voici la réponse :
!true && false // false
!(true && false) // true
4 < 3 || 4 >= 4 // true
(!(1 == 2) || 3 != 3) && 35 > 34 // trueLa 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.Lengthn'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 instructionbreak.La clause
defaultest 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 commetrue.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
Maindans l'arrayargs.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
switchest 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.
