0Pricing
C# Academy · Lección

Expresiones switch y comprobaciones exhaustivas con when (emulación de C# 6)

Emule expresiones switch con métodos clásicos que devuelven el resultado de switch, añada comprobaciones de guarda y use excepciones en default para detectar casos no gestionados durante la ejecución.

Expresiones switch y comprobaciones exhaustivas con when (emulación de C# 6) es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 2 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 3 lecciones en total.

Plan: emulación de switch

Objetivo: Imitar las expresiones switch modernas en C# 6.

  • Devuelva valores desde un switch clásico
  • Haga una comprobación previa con guardas
  • Falle rápidamente mediante default throw para garantizar que se contemplen todos los casos

Switch que devuelve un valor

Un switch que devuelve un valor funciona como una expresión switch. El default que lanza una excepción captura los valores desconocidos.

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” mediante guards

Use guards (ifs) para emular las cláusulas when. Valide primero las entradas y, después, ramifique según los rangos.

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

Auxiliar de exhaustividad

Añada un pequeño auxiliar Exhaustive.Unhandled y llámelo en default. Las pruebas fallarán cuando no se gestione un nuevo valor del enum.

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

Guards + switch por kind

Valide los datos de cada rama con pre-guards y, después, use switch sobre el discriminante. Esto imita when en los casos.

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

Consejos y dificultades

Consejos:

  • Prefiera métodos pequeños que devuelvan valores (con una sola responsabilidad)
  • Mantenga el default que lanza una excepción para detectar pronto los casos que falten
  • Coloque los guards antes del switch; funcionan como condiciones when

Emulación de la exhaustividad

Comprobación rápida: En C# 6, ¿cómo puede emular una gestión exhaustiva de switch similar a una expresión switch con when?

Repaso

Repaso: Devuelva valores desde un switch clásico como en una expresión switch, añada guards para “when” y mantenga un default que lance una excepción para dejar al descubierto los casos que falten.

Preguntas frecuentes

¿La lección «Expresiones switch y comprobaciones exhaustivas con when (emulación de C# 6)» es gratis?

Sí — el texto completo de «Expresiones switch y comprobaciones exhaustivas con when (emulación de C# 6)» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 3 lecciones en total.

¿Qué aprenderé en «Expresiones switch y comprobaciones exhaustivas con when (emulación de C# 6)»?

Emule expresiones switch con métodos clásicos que devuelven el resultado de switch, añada comprobaciones de guarda y use excepciones en default para detectar casos no gestionados durante la ejecución. Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 3.

¿Cuánto tiempo toma la lección «Expresiones switch y comprobaciones exhaustivas con when (emulación de C# 6)»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Patrones is y patrones relacionales y lógicos (emulación de C# 6)
  2. Expresiones switch y comprobaciones exhaustivas con when (emulación de C# 6)
  3. Modelado de dominios con uniones discriminadas (records) — emulación de C# 6
← Volver a C# Academy