0Pricing
C# Academy · Leçon

Expressions switch

Des switch concis qui renvoient une valeur.

Expressions switch est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 4 leçons au total.

Qu’est-ce qu’une expression de sélection

Une expression de sélection évalue une entrée par rapport à une série de patrons et renvoie une valeur. Contrairement à l’instruction de sélection classique, il s’agit d’une expression qui produit un résultat que vous pouvez affecter ou renvoyer.

Elle utilise le mot-clé switch après la valeur, avec des branches écrites sous la forme pattern => result. Cela rend la logique de branchement compacte et fonctionnelle.

int code = 2;
string name = code switch
{
    1 => "One",
    2 => "Two",
    _ => "Other"
};
System.Console.WriteLine(name);

Instruction ou expression

L’ancienne instruction de sélection utilise des étiquettes case et break. La nouvelle expression de sélection supprime entièrement ces mots-clés.

Les branches sont séparées par des virgules, l’ensemble se termine par un point-virgule et chaque branche produit une valeur au lieu d’exécuter des blocs qui s’enchaînent automatiquement. Cela élimine toute une catégorie de bogues liés à l’oubli de l’arrêt.

// Statement style
switch (code) { case 1: result = "One"; break; }

// Expression style
result = code switch { 1 => "One", _ => "?" };

La branche d’abandon

Le caractère de soulignement _ est le patron d’abandon. Il correspond à n’importe quelle valeur et joue le rôle de cas par défaut.

Les expressions de sélection doivent être exhaustives : si aucune branche ne correspond à l’exécution, une SwitchExpressionException est levée. Ajouter une branche _ garantit une correspondance pour toute entrée possible.

using System;

class Program {
    static void Main() {
        int n = 7;
        string size = n switch {
            < 5 => "small",
            _ => "big"
        };
        Console.WriteLine(size);
    }
}

Patrons de constantes

La branche la plus simple utilise un patron de constante : une valeur littérale à laquelle l’entrée est comparée par égalité.

Les constantes peuvent être des nombres, des chaînes, des caractères, des membres d’énumération ou des constantes nommées. Elles sont évaluées de haut en bas ; placez donc les branches les plus précises ou les plus courantes en premier.

char grade = 'B';
string label = grade switch
{
    'A' => "Excellent",
    'B' => "Good",
    'C' => "Fair",
    _   => "Needs work"
};
System.Console.WriteLine(label);

Renvoyer depuis une méthode

Les expressions de sélection sont particulièrement utiles dans les méthodes. Comme toute la construction est une expression, vous pouvez la renvoyer directement, souvent sous la forme d’une méthode à corps d’expression sur une seule ligne.

Cela garde la logique de conversion lisible et centralisée, au lieu de disperser des chaînes de conditions if/else if dans le corps.

using System;

class Program {
    static string Day(int d) => d switch {
        0 => "Sun", 6 => "Sat", _ => "Weekday"
    };
    static void Main() => Console.WriteLine(Day(6));
}

Sélectionner sur des énumérations

Les énumérations s’associent naturellement aux expressions de sélection. Chaque branche nomme un membre de l’énumération, et le compilateur peut signaler un cas manquant si vous omettez la branche d’abandon.

Il est toutefois prudent de conserver une branche _ afin que de futures valeurs d’énumération ne provoquent pas l’arrêt de votre application à l’exécution.

using System;

enum Light { Red, Yellow, Green }

class Program {
    static void Main() {
        Light l = Light.Green;
        string action = l switch {
            Light.Red => "Stop",
            Light.Yellow => "Slow",
            Light.Green => "Go",
            _ => "?"
        };
        Console.WriteLine(action);
    }
}

Clauses de garde conditionnelles

Une garde when ajoute une condition booléenne à une branche. La branche ne correspond que si le patron et la garde sont tous deux vrais.

Cela vous permet d’affiner les correspondances avec une logique arbitraire qu’un patron seul ne peut pas exprimer, comme des vérifications d’intervalles combinées à d’autres variables.

int temp = 30;
string weather = temp switch
{
    int t when t < 0  => "Freezing",
    int t when t < 20 => "Cool",
    _                 => "Warm"
};
System.Console.WriteLine(weather);

L’ordre est important

Les branches sont évaluées dans l’ordre du code source. La première branche correspondante l’emporte ; les patrons les plus précis doivent donc précéder les patrons plus généraux.

Si une branche générale précède une branche précise, le compilateur signale cette dernière comme inaccessible. Lisez vos branches de haut en bas, comme un entonnoir allant du plus étroit au plus large.

int score = 95;
string tier = score switch
{
    >= 90 => "Gold",
    >= 70 => "Silver",
    _     => "Bronze"
};
System.Console.WriteLine(tier);

Exhaustivité et exceptions

Si toutes les entrées ne sont pas couvertes et qu’aucune branche ne correspond, l’exécution lève System.Runtime.CompilerServices.SwitchExpressionException.

Le compilateur émet l’avertissement CS8509 lorsqu’il ne peut pas prouver l’exhaustivité. Prenez cet avertissement au sérieux : ajoutez une branche d’abandon ou couvrez les valeurs manquantes pour que l’expression traite tous les cas.

using System;

class Program {
    static void Main() {
        try {
            int x = 5;
            string s = x switch { 1 => "a", 2 => "b" };
            Console.WriteLine(s);
        } catch (Exception e) {
            Console.WriteLine(e.GetType().Name);
        }
    }
}

Combiner plusieurs entrées

Pour effectuer une sélection sur plusieurs valeurs, regroupez-les dans un tuple. Les branches correspondent alors à des patrons de tuple en comparant chaque position.

C’est idéal pour les machines à états ou les tables de décision dont le résultat dépend d’une paire de facteurs. Nous étudierons en détail les patrons de tuple dans une leçon ultérieure.

bool isWeekend = true; bool isRaining = false;
string plan = (isWeekend, isRaining) switch
{
    (true, false) => "Go hiking",
    (true, true)  => "Watch a movie",
    _             => "Work"
};
System.Console.WriteLine(plan);

Des corps d’expression lisibles

Les expressions de sélection se composent bien avec LINQ et les membres à corps d’expression, ce qui produit des chaînes de traitement concises.

Comme chaque branche renvoie une valeur, vous pouvez utiliser directement une expression de sélection dans une projection Select ou comme argument de méthode, sans créer de variables temporaires.

using System;
using System.Linq;

class Program {
    static void Main() {
        var nums = new[] { 1, 2, 3 };
        var labels = nums.Select(n => n switch {
            1 => "one", 2 => "two", _ => "many"
        });
        Console.WriteLine(string.Join(",", labels));
    }
}

Vérification rapide

Vérifiez votre compréhension des expressions de sélection.

Récapitulatif

Les expressions de sélection renvoient une valeur avec input switch { pattern => result, ... } et des branches séparées par des virgules.

Utilisez _ pour le cas par défaut et when pour les gardes, et souvenez-vous que les branches sont évaluées de haut en bas. Rendez-les exhaustives pour éviter les exceptions à l’exécution. Nous allons maintenant étudier les patrons de type et de propriété.

Questions Fréquemment Posées

La leçon « Expressions switch » est-elle gratuite ?

Oui — le texte complet de « Expressions switch » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Expressions switch » ?

Des switch concis qui renvoient une valeur. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Expressions switch » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Expressions switch
  2. Schémas de type et de propriété
  3. Schémas relationnels et logiques
  4. Schémas de listes et de tuples
← Retour à C# Academy