Utilizando o switch case no C#

Dentre as várias estruturas de controle de fluxo disponíveis no C#, neste artigo vamos apresentar o switch/case. Disponível desde a primeira versão da linguagem. Mostraremos exemplos simples e práticos para a utilização do switch case, de acordo com a respectiva versão do C#.

1 - Uma breve introdução sobre estruturas de controle de fluxo

Estruturas de controle de fluxo, estrutura de decisão, ou estruturas condicionais, são recursos disponibilizados na maioria das linguagens de programação, os quais permitem que o programador, baseando-se nas regras de negócio do sistema, decida quando, e se determinadas partes do código serão executadas, de acordo com as condições estabelecidas por estas regras de negócio.

2 - Alguns exemplos de estrutura de decisão disponíveis no c#:

2.1. Estruturas de Seleção:

if: Permite executar um bloco de código se uma condição for verdadeira;
else: Permite executar um bloco de código se uma condição for falsa (opcional);
elif: Permite executar um bloco de código se uma condição for verdadeira, após verificar outras condições com if (opcional);
switch/case: Permite executar um bloco de código específico com base em um valor único.

2.2. Estruturas de Repetição:

while: Executa um bloco de código enquanto uma condição for verdadeira;
do/while: Executa um bloco de código pelo menos uma vez e depois repete enquanto uma condição for verdadeira;
for: Executa um bloco de código um número específico de vezes ou até que uma condição seja satisfeita.

2.3. Estruturas de Saída:

break: Sai de um loop ou switch.
continue: Pula para a próxima iteração de um loop.

Como o foco deste artigo é apresentar a estrutura switch/case, veremos a seguir, exemplos práticos de sua utilização.

3 - Como funciona o switch/case no C#

A estrutura switch/case em C# é usada para selecionar um bloco de código a ser executado entre vários blocos possíveis, com base no valor de uma expressão ou variável. A sintaxe básica é:

switch(expression)  
{
case value1:
  // Bloco de código para value1
  break;
case value2:
  // Bloco de código para value2
  break;
...
default:
  // Bloco de código se nenhum caso corresponder
  break;
}

4. A evolução da estrutura switch/case no C#

A estrutura switch/case está disponível desde a primeira versão do C#, lançada em 2002. Ela é uma ferramenta poderosa para tomar decisões em seu código, com base em um valor único.

Ao longo das diferentes versões do C#, a estrutura switch/case foi sendo aprimorada com novas funcionalidades:

Versão 1.0 (2002):

Introdução da estrutura básica switch/case com case e default;
Suporte para tipos primitivos e strings.

// Escrevendo o dia da semana, usando switch/case clássico

int dia = DateTime.Now.DayOfWeek;

switch (dia)
{
case 0:
  Console.WriteLine("Domingo");
  break;
case 1:
  Console.WriteLine("Segunda-feira");
  break;
case 2:
  Console.WriteLine("Terça-feira");
  break;
case 3:
  Console.WriteLine("Quarta-feira");
  break;
case 4:
  Console.WriteLine("Quinta-feira");
  break;
case 5:
  Console.WriteLine("Sexta-feira");
  break;
case 6:
  Console.WriteLine("Sábado");
  break;
default:
  Console.WriteLine("Dia inválido!");
  break;
}

Versão 2.0 (2005):

Suporte para tipos enumerados.

// Identificando a estação do ano, com base em um enumerador, utilizando o switch/case

public enum Meses
{
Janeiro,
Fevereiro,
Marco,
Abril,
Maio,
Junho,
Julho,
Agosto,
Setembro,
Outubro,
Novembro,
Dezembro
}

Meses mes = DateTime.Now.Month;

switch (mes)
{
case Meses.Janeiro:
  Console.WriteLine("Verão");
  break;
case Meses.Fevereiro:
  Console.WriteLine("Verão");
  break;
case Meses.Marco:
  Console.WriteLine("Outono");
  break;
case Meses.Abril:
  Console.WriteLine("Outono");
  break;
case Meses.Maio:
  Console.WriteLine("Outono");
  break;
case Meses.Junho:
  Console.WriteLine("Inverno");
  break;
case Meses.Julho:
  Console.WriteLine("Inverno");
  break;
case Meses.Agosto:
  Console.WriteLine("Inverno");
  break;
case Meses.Setembro:
  Console.WriteLine("Primavera");
  break;
case Meses.Outubro:
  Console.WriteLine("Primavera");
  break;
case Meses.Novembro:
  Console.WriteLine("Primavera");
  break;
case Meses.Dezembro:
  Console.WriteLine("Verão");
  break;
}

Versão 3.0 (2007):

Suporte para coleções como List<T> e Dictionary<TKey, TValue>.

// Identificando o tipo do funcionário, utilizando coleções

public class User
{
  public string UserType { get; set; }
  // Outras propriedades do usuário
}

List<User> users = new List<User>
{
  new User { UserType = "Admin" },
  new User { UserType = "Manager" },
  new User { UserType = "Employee" }
};

foreach (User user in users)
{
  switch (user.UserType)
  {
      case "Admin":
          Console.WriteLine("Usuário é um administrador.");
          break;
      case "Manager":
          Console.WriteLine("Usuário é um gerente.");
          break;
      case "Employee":
          Console.WriteLine("Usuário é um funcionário.");
          break;
      default:
          Console.WriteLine("Tipo de usuário desconhecido.");
          break;
  }
}

Versão 4.0 (2010):

Suporte para expressões lambda como casos.

// Identificando a opção selecionada, com switch/case clássico

string opcao = Console.ReadLine();

switch (opcao)
{
case "1":
  Console.WriteLine("Opção 1 selecionada.");
  break;
case "2":
  Console.WriteLine("Opção 2 selecionada.");
  break;
default:
  Console.WriteLine("Opção inválida!");
  break;
}

// Simplificando com expressões lambda:

var funcaoOpcao = opcao =>
{
switch (opcao)
{
  case "1":
    return "Opção 1 selecionada.";
  case "2":
    return "Opção 2 selecionada.";
  default:
    return "Opção inválida!";
}
};

Console.WriteLine(funcaoOpcao(opcao));

Versão 6.0 (2015):

Suporte para goto case para pular para um caso específico.

// Utilizando o goto case

int number =  1;

switch (number)
{
  case  1:
      Console.WriteLine("Número é  1");
      goto case  2; // Vai para o case  2
  case  2:
      Console.WriteLine("Número é  2");
      break;
  default:
      Console.WriteLine("Número não é 1 nem 2");
      break;
}

Versão 7.0 (2017):

Introdução do switch com when para filtragem adicional.

// Identificando se o número é par ou ímpar, com switch/case com filtragem adicional

int number = 10;

switch (number)
{
case int n when n % 2 == 0:
  Console.WriteLine("O número é par.");
  break;
case int n when n % 2 != 0:
  Console.WriteLine("O número é ímpar.");
  break;
default:
  Console.WriteLine("O número não é nem par nem ímpar.");
  break;
}

Versão 8.0 (2019):

Introdução das expressões switch para simplificar a sintaxe.

// Simplificando a sintaxe das expressões switch/case, a partir da versão 8.0 do c#

int number = 5;

var result = number switch
{
1 => "Um",
2 => "Dois",
_ => "Outro"
};

Console.WriteLine(result); // Output: "Outro"

Versão 9.0 (2020):

Melhorias nas expressões switch com suporte para tipos de referência e nullable.

// Expressão switch/case com suporte a tipos anuláveis

string? input = null;

var result = input switch
{
null => "Nulo",
string s when s.Length > 0 => "Não nulo e não vazio",
_ => "Não nulo e vazio"
};

Console.WriteLine(result); // Output: "Nulo"

Versão 10.0 (2021):

Suporte para switch com pattern matching para maior flexibilidade.

// Exemplo de utilização do pattern matching, com o switch/case

object obj = new List<int>();

var result = obj switch
{
 int[] => "Array de inteiros",
 List<int> => "Lista de inteiros",
 _ => "Outro tipo"
};

Console.WriteLine(result); // Output: "Lista de inteiros"

Versão 11.0 (2022):

Melhorias no desempenho das expressões switch.

Como pudemos observar nos exemplos anteriores, a estrutura switch/case é uma parte fundamental da linguagem C# desde o início da linguagem, e continua a ser melhorada a cada nova versão.