0Pricing
C# Academy · Lección

Expresiones switch

switch concisos que devuelven valores

Expresiones switch es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 1 de 4. 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 4 lecciones en total.

¿Qué es una expresión switch?

Una expresión switch evalúa una entrada comparándola con una serie de patrones y devuelve un valor. A diferencia de la instrucción switch clásica, es una expresión, por lo que produce un resultado que puede asignar o devolver.

Utiliza la palabra clave switch después del valor, con ramas escritas como pattern => result. Esto hace que la lógica de ramificación sea compacta y funcional.

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

Instrucción frente a expresión

La antigua instrucción switch utiliza etiquetas case y break. La nueva expresión switch elimina por completo esas palabras clave.

Las ramas se separan mediante comas, el conjunto termina con un punto y coma y cada rama produce un valor en lugar de ejecutar bloques con caída implícita. Esto elimina toda una categoría de errores causados por olvidar break.

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

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

La rama de descarte

El guion bajo _ es el patrón de descarte. Coincide con cualquier valor y actúa como el caso predeterminado.

Las expresiones switch deben ser exhaustivas: si ninguna rama coincide en tiempo de ejecución, se produce una SwitchExpressionException. Añadir una rama _ garantiza una coincidencia para cualquier entrada posible.

using System;

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

Patrones constantes

La rama más sencilla utiliza un patrón constante: un valor literal con el que se compara la entrada mediante igualdad.

Las constantes pueden ser números, cadenas, caracteres, miembros de enumeraciones o constantes con nombre. Se evalúan de arriba abajo, así que coloque primero las ramas más específicas o más habituales.

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

Devolver desde un método

Las expresiones switch resultan especialmente útiles dentro de los métodos. Como todo el conjunto es una expresión, puede devolverlo directamente, a menudo como un método de una sola línea con cuerpo de expresión.

Esto mantiene la lógica de mapeo legible y centralizada, en lugar de dispersar cadenas de if/else if por el cuerpo.

using System;

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

Usar switch con enumeraciones

Las enumeraciones se combinan naturalmente con las expresiones switch. Cada rama especifica un miembro de la enumeración, y el compilador puede advertirle si falta un caso cuando omite la rama de descarte.

Aun así, es recomendable conservar una rama _ para que los valores futuros de la enumeración no provoquen el cierre de la aplicación en tiempo de ejecución.

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

Cláusulas de guarda con when

Una guarda when añade una condición booleana a una rama. La rama solo coincide si tanto el patrón como la guarda son verdaderos.

Esto permite refinar las coincidencias con lógica arbitraria que un patrón por sí solo no puede expresar, como comprobaciones de rangos combinadas con otras 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);

El orden es importante

Las ramas se prueban en el orden en que aparecen en el código. Gana la primera rama que coincide, por lo que los patrones más específicos deben colocarse antes que los más generales.

Si una rama general precede a una específica, el compilador informa de que la rama posterior es inalcanzable. Lea las ramas de arriba abajo, como un embudo que va de lo específico a lo general.

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

Exhaustividad y excepciones

Si no se cubren todas las entradas y ninguna rama coincide, el tiempo de ejecución produce System.Runtime.CompilerServices.SwitchExpressionException.

El compilador emite la advertencia CS8509 cuando no puede demostrar la exhaustividad. Tómese en serio esa advertencia: añada una rama de descarte o cubra los valores que faltan para que la expresión sea total.

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

Combinar varias entradas

Para usar switch con más de un valor, envuélvalos en una tupla. Entonces, las ramas coinciden con patrones de tupla y comparan cada posición.

Esto resulta ideal para máquinas de estados o tablas de decisión cuyo resultado depende de un par de factores. Exploraremos los patrones de tupla en profundidad en una lección posterior.

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

Cuerpos de expresión legibles

Las expresiones switch se combinan bien con LINQ y los miembros con cuerpo de expresión, lo que permite crear canalizaciones concisas.

Como cada rama devuelve un valor, puede usar una expresión switch directamente dentro de una proyección Select o como argumento de un método, evitando variables temporales.

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

Comprobación rápida

Compruebe cuánto entiende las expresiones switch.

Repaso

Las expresiones switch devuelven un valor mediante input switch { pattern => result, ... }, con ramas separadas por comas.

Use _ como valor predeterminado y when para las guardas, y recuerde que las ramas se prueban de arriba abajo. Asegúrese de que sean exhaustivas para evitar excepciones en tiempo de ejecución. A continuación, exploraremos los patrones de tipo y de propiedades.

Preguntas frecuentes

¿La lección «Expresiones switch» es gratis?

Sí — el texto completo de «Expresiones switch» 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 4 lecciones en total.

¿Qué aprenderé en «Expresiones switch»?

switch concisos que devuelven valores 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 1 de 4.

¿Cuánto tiempo toma la lección «Expresiones switch»?

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. Expresiones switch
  2. Patrones de tipos y propiedades
  3. Patrones relacionales y lógicos
  4. Patrones de listas y tuplas
← Volver a C# Academy