C# Academy · Lezione

Espressioni switch; controlli di esaustività con when (emulazione in C# 6)

Emulate le espressioni switch con metodi classici che restituiscono il risultato, aggiungete controlli di guardia e usate eccezioni nel ramo default per intercettare a runtime i casi non gestiti.

Lezione 2 di 38 passaggi

Espressioni switch; controlli di esaustività con when (emulazione in C# 6) è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 2 di 3. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C# Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C# Academy include 3 lezioni in totale.

Piano: emulazione di switch

Obiettivo: emulare le moderne espressioni switch in C# 6.

Restituire valori da uno switch classico
Preverificare con controlli di guardia
Fallire rapidamente tramite default throw per garantire la copertura di tutti i casi

Switch con restituzione di un valore

Uno switch che restituisce un valore si comporta come un'espressione switch. Il default throw intercetta i valori sconosciuti.

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” tramite guardie

Utilizzi i controlli di guardia (if) per simulare le clausole when. Convalidi prima gli input, quindi diriga il flusso in base agli intervalli.

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
  }
}

Helper per la gestione esaustiva

Aggiunga un piccolo helper Exhaustive.Unhandled e lo richiami nel ramo default. I test falliranno quando un nuovo valore dell'enum non sarà gestito.

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
  }
}

Guardie + switch su kind

Convalidi i dati specifici di ogni ramo con controlli preliminari, quindi esegua lo switch sul discriminante. In questo modo si rispecchia il comportamento di “when” sui casi.

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));
  }
}

Suggerimenti e problemi comuni

Suggerimenti:

Preferisca metodi piccoli che restituiscono un valore (responsabilità singola)
Mantenga il default con eccezione per individuare subito i casi mancanti
Inserisca le guardie prima dello switch: si comportano come condizioni when

Simulazione della gestione esaustiva

Verifica rapida: in C# 6, come si può simulare una gestione esaustiva dello switch, simile a un'espressione switch con when?

Rispondi nella lezione interattiva

Riepilogo

Riepilogo: restituisca valori da uno switch classico come in un'espressione switch, aggiunga le guardie per simulare “when” e mantenga un default throw per evidenziare i casi mancanti.

Gratis per iniziare

Impara C# con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 93
Lezioni: 346

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Espressioni switch; controlli di esaustività con when (emulazione in C# 6)» è gratuita?

Sì — il testo completo di «Espressioni switch; controlli di esaustività con when (emulazione in C# 6)» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C# Academy, passa a CoddyKit PRO. Il corso C# Academy include 3 lezioni in totale.

Cosa imparerò in «Espressioni switch; controlli di esaustività con when (emulazione in C# 6)»?

Emulate le espressioni switch con metodi classici che restituiscono il risultato, aggiungete controlli di guardia e usate eccezioni nel ramo default per intercettare a runtime i casi non gestiti. Eserciti C# Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C# Academy?

Non è richiesta alcuna esperienza precedente. C# Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 3.

Quanto tempo richiede la lezione «Espressioni switch; controlli di esaustività con when (emulazione in C# 6)»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C# Academy?

Sì. Ogni lezione C# Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Pattern is; pattern relazionali e logici (emulazione in C# 6)
Espressioni switch; controlli di esaustività con when (emulazione in C# 6)
Modellazione del dominio con unioni discriminate (record) — emulazione in C# 6

← Torna a C# Academy