C# Academy · Leçon

Expressions switch et vérifications d’exhaustivité avec when (émulation en C# 6)

Expressions switch et vérifications d’exhaustivité avec when (émulation en C# 6) est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 3. 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 3 leçons au total.

Plan : émulation du commutateur

Objectif : reproduire les expressions de commutation modernes en C# 6.

Renvoyer des valeurs depuis un commutateur classique
Effectuer une vérification préalable avec des gardes
Échouer rapidement avec une levée d’exception par défaut pour garantir l’exhaustivité

Commutateur renvoyant une valeur

Une instruction switch qui renvoie une valeur se comporte comme une expression switch. La levée d’exception par défaut intercepte les valeurs inconnues.

using System;

public enum Grade { A, B, C, D, F }

public class Program
{
  static string Describe(Grade g)
  {
    switch (g)
    {
      case Grade.A: return "Excellent";
      case Grade.B: return "Good";
      case Grade.C: return "Average";
      case Grade.D: return "Below average";
      case Grade.F: return "Fail";
      default: throw new ArgumentOutOfRangeException("g");
    }
  }

  public static void Main(string[] args)
  {
    Console.WriteLine(Describe(Grade.A));
    Console.WriteLine(Describe(Grade.F));
  }
}

« when » via des gardes

Utilisez des vérifications de garde (conditions if) pour simuler les clauses when. Validez d’abord les entrées, puis effectuez une sélection selon des plages de valeurs.

using System;

public class Program
{
  // Emulate: switch(score) { case var s when s >= 90: ... } using pre-guards
  static string LabelScore(int score)
  {
    if (score < 0 || score > 100) throw new ArgumentOutOfRangeException("score");

    if (score >= 90) return "A";
    if (score >= 80) return "B";
    if (score >= 70) return "C";
    if (score >= 60) return "D";
    return "F";
  }

  public static void Main(string[] args)
  {
    Console.WriteLine(LabelScore(92)); // A
    Console.WriteLine(LabelScore(77)); // C
  }
}

Assistant d’exhaustivité

Ajoutez un petit assistant Exhaustive.Unhandled et appelez-le dans le cas default. Les tests échoueront lorsqu’une nouvelle valeur d’énumération n’est pas prise en charge.

using System;

public enum Status { New, Active, Closed }

public static class Exhaustive
{
  public static Exception Unhandled(object x)
  {
    return new InvalidOperationException("Unhandled case: " + x);
  }
}

public class Program
{
  static int ToHttp(Status s)
  {
    switch (s)
    {
      case Status.New: return 201;
      case Status.Active: return 200;
      case Status.Closed: return 410;
      default: throw Exhaustive.Unhandled(s);
    }
  }

  public static void Main(string[] args)
  {
    Console.WriteLine(ToHttp(Status.Active)); // 200
  }
}

Gardes + switch sur le type

Validez les données propres à chaque branche avec des gardes préalables, puis effectuez le switch sur le discriminant. Cela reproduit un « when » sur les cas.

using System;

public enum ShapeKind { Circle, Square }

public sealed class Shape
{
  public ShapeKind Kind;
  public double Radius; // for circle
  public double Side;   // for square
}

public class Program
{
  static double Area(Shape s)
  {
    if (s == null) throw new ArgumentNullException("s");

    // “when” guards (validate needed fields)
    if (s.Kind == ShapeKind.Circle && s.Radius < 0) throw new ArgumentException("Radius must be >= 0");
    if (s.Kind == ShapeKind.Square && s.Side < 0) throw new ArgumentException("Side must be >= 0");

    switch (s.Kind)
    {
      case ShapeKind.Circle: return Math.PI * s.Radius * s.Radius;
      case ShapeKind.Square: return s.Side * s.Side;
      default: throw new InvalidOperationException("Unhandled shape: " + s.Kind);
    }
  }

  public static void Main(string[] args)
  {
    Shape c = new Shape { Kind = ShapeKind.Circle, Radius = 2.0 };
    Console.WriteLine("Area circle = " + Area(c));
  }
}

Conseils et pièges

Conseils :

Privilégiez les petites méthodes qui renvoient une valeur (à responsabilité unique)
Conservez la levée d’exception par défaut pour révéler rapidement les cas manquants
Placez les gardes avant le switch ; elles jouent le rôle de conditions when

Simulation de l’exhaustivité

Vérification rapide : dans C# 6, comment pouvez-vous simuler une gestion exhaustive avec un switch, comme avec une expression switch utilisant when ?

Récapitulatif

Récapitulatif : renvoyez une valeur depuis un switch classique comme dans une expression switch, ajoutez des gardes pour simuler « when » et conservez une levée d’exception par défaut afin de détecter les cas manquants.

Questions Fréquemment Posées

La leçon « Expressions switch et vérifications d’exhaustivité avec when (émulation en C# 6) » est-elle gratuite ?

Oui — le texte complet de « Expressions switch et vérifications d’exhaustivité avec when (émulation en C# 6) » 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 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Expressions switch et vérifications d’exhaustivité avec when (émulation en C# 6) » ?

Émulez les expressions switch avec des méthodes classiques qui renvoient le résultat d’un switch, ajoutez des contrôles préalables et utilisez des exceptions par défaut pour détecter à l’exécution le… 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 2 sur 3.

Combien de temps prend la leçon « Expressions switch et vérifications d’exhaustivité avec when (émulation en C# 6) » ?

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

Modèles is, relationnels et logiques (émulation en C# 6)
Expressions switch et vérifications d’exhaustivité avec when (émulation en C# 6)
Modélisation du domaine avec des unions discriminées (enregistrements) — émulation en C# 6

← Retour à C# Academy