switch

int choice = 2; guarda o número inteiro 2. Depois switch (choice) compara esse número com rótulos fixos. Quando choice é 2, case 2 roda e Console.WriteLine("mid") escreve mid. A tela é uma linha. Mantenha a classe pública com o nome Pine.

Um valor, vários rótulos fixos

Abra o arquivo Pine. O nome da classe continua Pine. Esta página não renomeia o tipo. Apague bool ready se essa linha ainda estiver lá, incluindo if (ready), pass, wait, e qualquer bloco else da página anterior. Apague bool both se essa linha ainda estiver lá. Apague qualquer linha ReadLine. O arquivo que você guarda não espera digitação, não tem ready, e não tem bifurcação if / else. A tela só é escrita por uma linha de escrita sob o case correspondente ou sob default.

Dentro de Main, guarde um número inteiro antes do switch: int choice = 2;. int é a palavra de tipo. choice é o nome, e começa com c minúsculo. Não há aspas em volta de 2. O ponto e vírgula termina a linha de guardar. Essa linha não escreve a tela. Depois vem o próprio 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;
}
A palavra switch é minúscula. Dentro dos parênteses fica o nome choice — o valor que o C# vai comparar com cada rótulo case. Cada linha case termina com dois-pontos, não com ponto e vírgula. Sob case 2 fica Console.WriteLine("mid"); depois a palavra break e um ponto e vírgula. Quando choice guarda 2, o C# entra em case 2, escreve mid, encontra break, e sai do switch inteiro. case 3 e default não rodam nesta execução. Salve o arquivo.

O arquivo que você guarda

Mantenha esta forma de ensino. Uma palavra de tipo, int. Um nome, choice, guardado como 2. Um switch com parênteses em volta de choice. Cases 1, 2, e 3, cada um com uma linha de escrita e um break. Um default que escreve none. Não há linha ready, nem if, nem escrita nua do dígito 2 fora dos cases.

Leia de cima. using System; prepara nomes curtos. public class Pine nomeia o tipo. public static void Main() é onde o runtime começa. int choice = 2; guarda 2. Não escreve nada. switch (choice) começa a comparação. case 2 corresponde, então Console.WriteLine("mid"); roda, depois break; sai do switch. Uma linha na tela: mid. Sem aspas na tela. Sem segunda linha. Não há linha bool ready no arquivo que você guarda.

Execute com dotnet run. O programa escreve mid. Não espera você digitar. O número guardado e o switch já estavam no arquivo. Se dotnet run esperar, ReadLine ainda está no arquivo. Apague essa linha e mantenha int choice = 2; e o switch acima. O programa termina depois da linha de escrita escolhida. A tela mostra mid. Uma linha. Se a tela mostrar 2, você ainda está escrevendo o próprio número. Se a tela mostrar pass ou wait, o arquivo if / else ainda está no lugar. Apague a bifurcação ready. Se a tela mostrar none, choice é um valor que não corresponde a nenhum case — esse é o segundo arquivo desta página, não o arquivo que você guarda. Se a tela mostrar switch (choice) como letras, uma linha de escrita tem aspas em volta desses caracteres. Você não reinstala o SDK .NET por uma tela que mostra a linha errada.

Por que mid e não low ou high? Porque o valor nos parênteses era 2, e case 2 é o rótulo que corresponde. O C# não escreve o dígito 2 nesta execução a menos que você escreva uma linha de escrita para esse dígito. Escreve a linha de escrita que roda sob o case correspondente. Parênteses guardam o valor sendo comparado. Cada rótulo case aqui é um número inteiro fixo. break termina o switch para que os cases seguintes fiquem quietos. default espera valores que não correspondem a nenhum case — fica sem uso enquanto choice é 2.

Quando nenhum case corresponde

Mude só o valor guardado: int choice = 9;. Deixe a estrutura switch como está. Agora nenhum de case 1, case 2, ou case 3 corresponde. O C# vai para default e executa Console.WriteLine("none");. A tela deve mostrar none, uma linha.

Este é o segundo arquivo. Não é o arquivo que você guarda. Execute dotnet run. A tela mostra none. Uma linha. Não mostra mid. Não mostra 9 a menos que você escreva esse dígito de propósito. Se a tela mostrar mid, você ainda está no arquivo que guarda, onde choice é 2. Depois de ver none, coloque de volta o arquivo guardado: int choice = 2; e o mesmo switch que escreve mid em case 2. As duas versões são C# válido. Ensinam a mesma forma switch com um case correspondente e com default.

Leia a execução default mais uma vez em ordem. choice guarda 9. switch (choice) começa. case 1 não corresponde. case 2 não corresponde. case 3 não corresponde. O controle continua em default. Console.WriteLine("none"); executa. Uma linha na tela. O próprio dígito 9 nunca aparece a menos que você o escreva de propósito.

break para os cases seguintes

break não é enfeite. Sem ele, o C# pode continuar executando as linhas do próximo case depois de uma correspondência. Esse fall-through surpreende iniciantes. Aqui está um demo curto que esquece break de propósito depois de case 2 — não é o arquivo que você guarda:

Com choice igual a 2 e sem break sob case 2, a tela pode mostrar mid numa linha e high na seguinte. case 2 correspondeu, escreveu mid, depois caiu em case 3 e escreveu high. O arquivo que você guarda coloca break sob cada case para que cada caminho escreva exatamente uma linha. Coloque break de volta antes de tratar o arquivo Pine de novo como o arquivo guardado da lição.

Regras que mantêm os rótulos claros

Parênteses em volta do valor do switch são obrigatórios. Escrever switch choice { … } sem parênteses faz o build escrever um erro. Cada rótulo case nesta página é uma constante de número inteiro: case 1:, case 2:, case 3:. Dois-pontos seguem o rótulo. Escrever case 2; com ponto e vírgula em vez de dois-pontos não é a forma que esta lição monta. default não tem valor depois — só default: depois as linhas de “nada correspondeu”.

switch não é a mesma ferramenta que if. if (ready) faz uma pergunta true ou false. switch (choice) compara um valor com uma lista de rótulos fixos. Não escreva switch (ready) com um bool e espere a mesma forma de lição da página anterior. Mantenha os demos desta página num int chamado choice e rótulos case de número inteiro. Comparações como if (score > 10) ainda pertencem ao if quando você precisa de um intervalo; switch brilha quando os valores são discretos e conhecidos de antemão.

Uma confusão comum é escrever a própria sintaxe: Console.WriteLine("switch (choice)");. Isso escreve os caracteres switch (choice). Não escolhe um case. Outra confusão é deixar um demo if / else no mesmo Main e se perguntar por que a tela mostra pass em vez de mid. O Main desta sessão deve guardar só o int e o switch.

Use a tabela como checagem depois de uma execução, não no lugar dela. choice 2 com o arquivo que você guarda escreve mid. choice 9 com o segundo arquivo escreve none. choice 1 escreve low. choice 3 escreve high. Se mid e high aparecerem juntos para choice 2, falta um break sob case 2 — corrija os breaks em vez de reinstalar o SDK .NET.

Agora você pode guardar um número inteiro, colocá-lo em switch (…), e dar a cada valor fixo o seu próprio case com uma linha de escrita e um break. Quando um case corresponde, essa linha roda; quando nada corresponde, default roda. A página seguinte é for, onde o mesmo bloco de linhas pode rodar de novo e de novo enquanto um contador muda.

A tela é o case correspondente

O arquivo que você guarda escreve mid. O nome choice está nos parênteses, e choice não está na tela. O dígito 2 está na linha de guardar, e 2 não está na tela. Os outros cases estão no arquivo, e não rodam na execução guardada. Aspas em volta de switch (choice) escrevem letras, não um case correspondente.