El operador clásico switch

1. Introducción

Imagínate que eres barista en una cafetería famosa. Llega un cliente y te dice una de sus cinco bebidas favoritas. No te pones a filosofar, simplemente miras el menú y respondes rápido: «¿Capuchino? ¡Por supuesto! ¡Aquí tienes tu capuchino!». Si comprobaras cada opción con un if separado, tu código sería como una pila de tazas después de la hora punta: voluminoso y nada cómodo.

El operador switch te permite comprobar el valor de una variable de forma elegante y ejecutar diferentes acciones según el resultado. Solo funciona con ciertos tipos de datos (de eso hablamos más abajo), pero para la mayoría de menús de usuario, comandos simples o reconocimiento de estados es la herramienta ideal.

2. Sintaxis clásica de switch en C#

Aquí tienes el diagrama de bloques mínimo:

switch (Expresión) {
    case Valor1:
        // acciones
        break;
    case Valor2:
        // acciones
        break;
    ...
    default:
        // acciones por defecto
        break;
}

Ejemplo 1: menú clásico

Console.WriteLine("Elige una bebida: 1 - Café, 2 - Té, 3 - Cacao");
string input = Console.ReadLine();
int choice = int.Parse(input);

switch (choice)
{
    case 1:
        Console.WriteLine("Has elegido café. ¡Buena elección!");
        break;
    case 2:
        Console.WriteLine("El té también está bien.");
        break;
    case 3:
        Console.WriteLine("¡Cacao es para los que aman la comodidad!");
        break;
    default:
        Console.WriteLine("No hay esa bebida en el menú.");
        break;
}

• El bloque switch comprueba choice para ver si es igual a los valores después de case.
• Después de cada opción hay que poner break; — si no, la ejecución sigue al siguiente case (de esto hablamos más abajo).
• El bloque default es como else; se ejecuta si no coincide ningún case.

¿Cómo funciona switch por dentro? — Paso a paso

1. Primero se evalúa la expresión entre paréntesis después de switch (en nuestro ejemplo — la variable choice).
2. El programa la compara con cada valor (case) uno por uno.
3. Si coincide — se ejecutan las instrucciones de ese bloque. Luego aparece break y el programa sale del bloque switch.
4. Si no coincide con ningún case, se ejecuta el bloque default (si existe).

Esquema visual

«+» — este bloque se ejecuta

3. ¿Qué tipos soporta el switch clásico?

En la sintaxis clásica (o sea, sin "Pattern Matching" ni cosas modernas, ¡de eso hablamos después!) switch soporta:

• Tipos enteros simples (int, byte, char, long, short, sbyte, ushort, uint, ulong)
• Cadenas (string)
• Enumeraciones (enum)
• Caracteres (char)

Ejemplo 2: switch con strings

Console.WriteLine("Elige un comando: start, stop, pause");
string command = Console.ReadLine();

switch (command)
{
    case "start":
        Console.WriteLine("¡Programa iniciado!");
        break;
    case "stop":
        Console.WriteLine("Programa detenido.");
        break;
    case "pause":
        Console.WriteLine("Programa en pausa.");
        break;
    default:
        Console.WriteLine("Comando desconocido.");
        break;
}

4. ¿Por qué hace falta break y qué pasa si lo olvidas?

El bug más típico de los que empiezan a programar es olvidarse del break; dentro de un case. Vamos a ver qué pasa si te lo saltas.

Ejemplo 3: caída al siguiente bloque (fall-through)

int day = 2;

switch (day)
{
    case 1:
        Console.WriteLine("Lunes");
        break;
    case 2:
        Console.WriteLine("Martes");
    case 3:
        Console.WriteLine("Miércoles");
        break;
    default:
        Console.WriteLine("Día desconocido");
        break;
}

¿Qué va a pasar?

• Al principio day = 2.
• Primero se ejecuta la línea: "Martes"
• No hay break — la ejecución pasa directamente al case 3 y ejecuta: "Miércoles"
• Luego aparece el break; — y sale.

En pantalla verás:

Martes
Miércoles

¡Este es un error típico!

• Si solo quieres ejecutar UNA acción, pon break; en cada case.
• Si (rara vez) quieres que varias opciones hagan lo mismo, puedes “pegarlas” (mira abajo).

5. Agrupación de valores case

A veces varios valores deben comportarse igual. ¿Para qué copiar el mismo código?

Ejemplo 4: misma reacción para varios case

char grade = 'B';

switch (grade)
{
    case 'A':
    case 'B':
    case 'C':
        Console.WriteLine("¡Aprobado!");
        break;
    case 'D':
    case 'E':
        Console.WriteLine("Todavía puedes mejorar.");
        break;
    default:
        Console.WriteLine("Nota incorrecta.");
        break;
}

¿Qué pasa aquí?

• Si grade es 'A', 'B' o 'C', se ejecuta el primer bloque: "¡Aprobado!".
• Si es 'D' o 'E' — el segundo bloque.
• Si es otro — default.

6. Qué se puede y qué no se puede hacer en el switch clásico

Se puede:

• Usar literales (constantes) en case, por ejemplo: case 1:, case 'A':, case "stop":.
• Comparar enum (enumeraciones).
• Omitir default, pero normalmente es útil.

No se puede:

• Usar variables en case (solo constantes).
• Comparar por rangos (case >= 5:, case x > 10: — ¡eso no se puede!).
• Usar double, float y otros valores decimales — solo enteros, string, char, enum.
• Poner varios valores separados por coma en un case (case 1, 2: eso no vale; pon varios case seguidos).

7. Particularidades y errores típicos

En proyectos reales switch se usa mucho para menús, manejo de estados, comandos, códigos de error y mil cosas más. Pero, como cualquier herramienta, tiene sus matices.

Errores típicos:

• Olvidar el break (ya lo comentamos).
• Tipo incorrecto en la expresión del switch (por ejemplo, intentar usar double).
• No coincidir mayúsculas/minúsculas en strings (case "Start": no coincide con "start") — ¡las cadenas distinguen entre mayúsculas y minúsculas!
• Valor no manejado (olvidaste el default, el usuario puso algo raro).

Trampa con switches anidados
Aunque puedes encontrarte con ese código, normalmente es difícil de leer. Si te pillas metiendo un switch dentro de otro, igual es hora de sacar ese código a un método aparte o incluso usar OOP/enum/array.