Module C#.5 – Conditions

Objectif

Maîtriser les structures conditionnelles C# : if/else, switch, switch expressions, et tous les opérateurs de comparaison et logiques pour contrôler le flux d'exécution.

Théorie

if / else

Structure de base :

if (condition)
{
    // Code si condition vraie
}

if / else :

if (age >= 18)
{
    Console.WriteLine("Majeur");
}
else
{
    Console.WriteLine("Mineur");
}

if / else if / else :

if (note >= 16)
{
    Console.WriteLine("Très bien");
}
else if (note >= 14)
{
    Console.WriteLine("Bien");
}
else if (note >= 12)
{
    Console.WriteLine("Assez bien");
}
else
{
    Console.WriteLine("À améliorer");
}

Expression ternaire :

string message = age >= 18 ? "Majeur" : "Mineur";

// Ternaire imbriqué
string appreciation = note >= 16 ? "Très bien" 
                   : note >= 14 ? "Bien"
                   : note >= 12 ? "Assez bien"
                   : "À améliorer";

Opérateurs de comparaison

==  // Égalité
!=  // Différent
>   // Plus grand
<   // Plus petit
>=  // Plus grand ou égal
<=  // Plus petit ou égal

Attention avec les objets :

string s1 = "test";
string s2 = "test";
s1 == s2;        // true (string compare le contenu)
s1.Equals(s2);   // true

object o1 = new object();
object o2 = new object();
o1 == o2;        // false (comparaison de références)

Opérateurs logiques

&&  // ET
||  // OU
!   // NON

Court-circuit :

if (nom != null && nom.Length > 0)
{
    // Si nom est null, nom.Length n'est pas évalué
    Console.WriteLine(nom);
}

Priorité :

1. ! (NOT)
2. && (AND)
3. || (OR)

Utilisez des parenthèses pour clarifier :

if ((age >= 18 && estAbonne) || estAdmin)
{
    // Plus clair avec parenthèses
}

switch

Le switch permet de tester une valeur contre plusieurs cas.

Switch classique

switch (note)
{
    case 16:
    case 17:
    case 18:
    case 19:
    case 20:
        Console.WriteLine("Très bien");
        break;
    case 14:
    case 15:
        Console.WriteLine("Bien");
        break;
    default:
        Console.WriteLine("Autre");
        break;
}

Important : Ne pas oublier break (sauf avec return).

Switch avec return

string ObtenirAppreciation(int note)
{
    switch (note)
    {
        case 16:
        case 17:
        case 18:
        case 19:
        case 20:
            return "Très bien";
        case 14:
        case 15:
            return "Bien";
        default:
            return "Autre";
    }
}

Switch expressions (C# 8.0+)

Syntaxe moderne et concise.

string appreciation = note switch
{
    >= 16 => "Très bien",
    >= 14 => "Bien",
    >= 12 => "Assez bien",
    _ => "À améliorer"
};

Pattern matching :

string resultat = obj switch
{
    int i when i > 0 => $"Nombre positif : {i}",
    int i when i < 0 => $"Nombre négatif : {i}",
    int => "Zéro",
    string s => $"Chaîne : {s}",
    null => "Null",
    _ => "Autre type"
};

Opérateurs null

Null-coalescing (??) :

string? nom = null;
string resultat = nom ?? "Inconnu";  // "Inconnu"

Null-coalescing assignment (??=) :

string? nom = null;
nom ??= "Inconnu";  // Assigné seulement si null

Null-conditional (?.) :

string? nom = null;
int? longueur = nom?.Length;  // null si nom est null
string majuscules = nom?.ToUpper() ?? "Vide";

Exercice

1. Conditions

   • Créez des conditions if/else complexes
   • Utilisez l'expression ternaire
   • Testez les opérateurs logiques

2. Switch

   • Testez switch classique
   • Utilisez switch expressions (si C# 8+)
   • Testez le pattern matching

3. Opérateurs null

   • Utilisez ??, ??=, ?.
   • Testez avec valeurs nullable
   • Comprenez le comportement

4. Cas pratiques

   • Créez un système de validation
   • Implémentez un menu interactif
   • Gèrez les valeurs null

5. Comparaisons

   • Testez == avec différents types
   • Comprenez value vs reference
   • Utilisez Equals() appropriément

Quiz

1. Que fait break dans un switch ?

   • Continue au cas suivant
   • Sort du switch
   • Répète le cas

2. Quelle est la différence entre switch classique et switch expression ?

   • Aucune différence
   • Switch expression retourne une valeur
   • Switch expression est plus rapide

3. Que fait l'opérateur ?? ?

   • Compare deux valeurs
   • Valeur par défaut si null
   • Force non-null

4. Que fait ?. ?

   • Accès normal
   • Accès sécurisé (retourne null si null)
   • Force l'accès

5. Quelle est la priorité entre && et || ?

   • || en premier
   • && en premier
   • Même priorité

Mini défi

Mission : Créer un système de gestion d'accès complet

Créez un système qui gère l'accès selon plusieurs critères :

Règles :

• Admin : Accès à tout
• Modérateur : Accès modéré (pas admin)
• Utilisateur : Accès limité (doit être vérifié)
• Visiteur : Accès public uniquement

Critères supplémentaires :

• Age minimum : 13 ans
• Compte vérifié (pour utilisateur+)
• Abonnement actif (pour certaines sections)

Fonctionnalités :

1. Fonction VerifierAcces(role, age, verifie, abonne, section)
2. Retourne true/false selon les critères
3. Utilisez switch expressions si possible
4. Messages d'erreur explicites

Sections :

• "public" : Accessible à tous
• "membre" : Utilisateur vérifié minimum
• "premium" : Abonné minimum
• "moderation" : Modérateur minimum
• "admin" : Admin uniquement

Critères :

• ✅ Utilisation de if/elseif/else
• ✅ Utilisation de switch/switch expressions
• ✅ Opérateurs logiques appropriés
• ✅ Code clair et lisible
• ✅ Gestion de tous les cas

Objectif : Maîtriser les conditions complexes et créer une logique d'accès robuste.

---

Validation : Vous pouvez passer au module suivant quand vous maîtrisez if/else, switch, et les opérateurs logiques.