switch

int choice = 2; guarda el entero 2. Luego switch (choice) compara ese número con etiquetas fijas. Cuando choice es 2, corre case 2 y Console.WriteLine("mid") escribe mid. La pantalla es una línea. Mantén el nombre de la clase pública Pine.

Un valor, varias etiquetas fijas

Abre el archivo Pine. El nombre de la clase sigue siendo Pine. Esta página no renombra el tipo. Borra bool ready si esa línea sigue ahí, incluyendo if (ready), pass, wait y todo bloque else de la página anterior. Borra bool both si sigue. Borra cualquier línea ReadLine. El archivo que guardas no espera escritura, no tiene ready y no tiene bifurcación if / else. La pantalla solo la escribe una línea de escritura bajo el case que coincide o bajo default.

Dentro de Main, guarda un entero antes del switch: int choice = 2;. int es la palabra de tipo. choice es el nombre y empieza con c minúscula. No hay comillas alrededor de 2. El punto y coma termina la línea de guardado. Esa línea no escribe la pantalla. Después viene el propio switch:
switch (choice) {
case 1:
Console.WriteLine("low");
break;
case 2:
Console.WriteLine("mid");
break;
case 3:
Console.WriteLine("high");
break;
default:
Console.WriteLine("none");
break;
}
La palabra switch va en minúsculas. Dentro de los paréntesis va el nombre choice — el valor que C# compara con cada etiqueta case. Cada línea case termina con dos puntos, no con punto y coma. Bajo case 2 va Console.WriteLine("mid"); luego la palabra break y un punto y coma. Cuando choice guarda 2, C# entra en case 2, escribe mid, llega a break y sale de todo el switch. case 3 y default no corren en esta ejecución. Guarda el archivo.

El archivo que guardas

Mantén esta forma de enseñanza. Una palabra de tipo, int. Un nombre, choice, guardado como 2. Un switch con paréntesis alrededor de choice. Cases 1, 2 y 3, cada uno con una línea de escritura y un break. Un default que escribe none. No hay línea ready, no hay if y no se escribe suelto el dígito 2 fuera de los cases.

Léelo desde arriba. using System; prepara nombres cortos. public class Pine nombra el tipo. public static void Main() es donde arranca la ejecución. int choice = 2; guarda 2. No escribe nada. switch (choice) empieza la comparación. case 2 coincide, así que corre Console.WriteLine("mid");, luego break; sale del switch. Una línea en pantalla: mid. Sin comillas en pantalla. Sin segunda línea. En el archivo que guardas no hay línea bool ready.

Ejecútalo con dotnet run. El programa escribe mid. No espera a que escribas. El número guardado y el switch ya estaban en el archivo. Si dotnet run espera, ReadLine sigue en el archivo. Borra esa línea y deja int choice = 2; y el switch de arriba. El programa termina después de la línea de escritura elegida. La pantalla muestra mid. Una línea. Si la pantalla muestra 2, aún escribes el propio número. Si la pantalla muestra pass o wait, el archivo if / else sigue en su sitio. Borra la bifurcación ready. Si la pantalla muestra none, choice es un valor que no coincide con ningún case — ese es el segundo archivo de esta página, no el que guardas. Si la pantalla muestra las letras switch (choice), una línea de escritura tiene comillas alrededor de esos caracteres. No reinstales el .NET SDK por una línea mala en pantalla.

¿Por qué mid y no low ni high? Porque el valor entre paréntesis era 2, y case 2 es la etiqueta que coincide. C# no escribe el dígito 2 en esta ejecución a menos que tú escribas una línea de escritura para ese dígito. Escribe la línea de escritura que corre bajo el case que coincide. Los paréntesis guardan el valor que se compara. Cada etiqueta case aquí es un entero fijo. break termina el switch para que los cases posteriores se queden quietos. default espera valores que no coinciden con ningún case — queda sin usarse mientras choice es 2.

Cuando ningún case coincide

Cambia solo el valor guardado: int choice = 9;. Deja la estructura switch igual. Ahora ninguno de case 1, case 2 o case 3 coincide. C# pasa a default y ejecuta Console.WriteLine("none");. La pantalla debe mostrar none, una línea.

Este es el segundo archivo. No es el que guardas. Ejecuta dotnet run. La pantalla muestra none. Una línea. No muestra mid. No muestra 9 a menos que escribas ese dígito a propósito. Si la pantalla muestra mid, sigues en el archivo que guardas, donde choice es 2. Después de ver none, vuelve al archivo guardado: int choice = 2; y el mismo switch que escribe mid en case 2. Ambas versiones son C# válido. Enseñan la misma forma switch con un case que coincide y con default.

Lee otra vez la ejecución default en orden. choice guarda 9. Empieza switch (choice). case 1 no coincide. case 2 no coincide. case 3 no coincide. El control sigue en default. Se ejecuta Console.WriteLine("none");. Una línea en pantalla. El propio dígito 9 no aparece a menos que lo escribas a propósito.

break corta los case posteriores

break no es adorno. Sin él, C# puede seguir ejecutando las líneas del case siguiente después de una coincidencia. Ese fall-through sorprende a principiantes. Aquí va un demo corto que olvida break a propósito después de case 2 — no es el archivo que guardas:

Con choice igual a 2 y sin break bajo case 2, la pantalla puede mostrar mid en una línea y high en la siguiente. case 2 coincidió, escribió mid, luego cayó en case 3 y escribió high. El archivo que guardas pone break bajo cada case para que cada camino escriba exactamente una línea. Pon break otra vez antes de tratar el archivo Pine como el archivo de lección guardado.

Reglas que dejan las etiquetas claras

Los paréntesis alrededor del valor del switch son obligatorios. Escribir switch choice { … } sin paréntesis hace que el build escriba un error. Cada etiqueta case de esta página es una constante entera: case 1:, case 2:, case 3:. Tras la etiqueta van dos puntos. Escribir case 2; con punto y coma en vez de dos puntos no es la forma que construye esta lección. default no lleva valor después — solo default: y luego las líneas de «nada coincidió».

switch no es la misma herramienta que if. if (ready) hace una pregunta true o false. switch (choice) hace coincidir un valor con una lista de etiquetas fijas. No escribas switch (ready) con un bool y esperes la misma forma de lección que la página anterior. Mantén los demos de esta página en un int llamado choice y etiquetas case enteras. Comparaciones como if (score > 10) siguen siendo de if cuando necesitas un rango; switch brilla cuando los valores son discretos y conocidos de antemano.

Una confusión frecuente es escribir la propia sintaxis: Console.WriteLine("switch (choice)");. Eso escribe los caracteres switch (choice). No elige un case. Otra confusión es dejar un demo if / else en el mismo Main y preguntarte por qué la pantalla muestra pass en vez de mid. El Main de esta sesión debe guardar solo el int y el switch.

Usa la tabla como comprobación después de una ejecución, no en lugar de una. choice 2 con el archivo que guardas escribe mid. choice 9 con el segundo archivo escribe none. choice 1 escribe low. choice 3 escribe high. Si aparecen mid y high para choice 2, falta un break bajo case 2 — arregla los breaks en vez de reinstalar el .NET SDK.

Ya puedes guardar un entero, ponerlo en switch (…), y dar a cada valor fijo su propio case con una línea de escritura y un break. Cuando un case coincide, corre esa línea; cuando nada coincide, corre default. La siguiente página es for, donde el mismo bloque de líneas puede correr una y otra vez mientras un contador cambia.

La pantalla es el case que coincide

El archivo que guardas escribe mid. El nombre choice está en los paréntesis, y choice no está en pantalla. El dígito 2 está en la línea de guardado, y 2 no está en pantalla. Los otros cases están en el archivo, y no corren en la ejecución guardada. Las comillas alrededor de switch (choice) escriben letras, no un case que coincide.