Vários casos na instrução switch

Existe uma maneira de passar por várias instruções de caso sem declarar case value:repetidamente?

Eu sei que isso funciona:

switch (value)
{
   case 1:
   case 2:
   case 3:
      // Do some stuff
      break;
   case 4:
   case 5:
   case 6:
      // Do some different stuff
      break;
   default:
       // Default stuff
      break;
}

mas eu gostaria de fazer algo assim:

switch (value)
{
   case 1,2,3:
      // Do something
      break;
   case 4,5,6:
      // Do something
      break;
   default:
      // Do the Default
      break;
}

É esta sintaxe que estou pensando em um idioma diferente ou estou perdendo alguma coisa?

Não há sintaxe em C ++ nem C # para o segundo método que você mencionou.

Não há nada errado com o seu primeiro método. Se, no entanto, você tiver intervalos muito grandes, basta usar uma série de instruções if.

Eu acho que isso já foi respondido. No entanto, acho que você ainda pode misturar as duas opções de uma maneira sintaticamente melhor fazendo:

switch (value)
{
    case 1: case 2: case 3:          
        // Do Something
        break;
    case 4: case 5: case 6: 
        // Do Something
        break;
    default:
        // Do Something
        break;
}

Essa sintaxe é da instrução de caso Visual Basic Select ... :

Dim number As Integer = 8
Select Case number
    Case 1 To 5
        Debug.WriteLine("Between 1 and 5, inclusive")
        ' The following is the only Case clause that evaluates to True.
    Case 6, 7, 8
        Debug.WriteLine("Between 6 and 8, inclusive")
    Case Is < 1
        Debug.WriteLine("Equal to 9 or 10")
    Case Else
        Debug.WriteLine("Not between 1 and 10, inclusive")
End Select

Você não pode usar esta sintaxe em c #. Em vez disso, você deve usar a sintaxe do seu primeiro exemplo.

No C # 7 (disponível por padrão no Visual Studio 2017 / .NET Framework 4.6.2), a comutação baseada em intervalo agora é possível com a instrução switch e ajudaria no problema do OP.

Exemplo:

int i = 5;

switch (i)
{
    case int n when (n >= 7):
        Console.WriteLine($"I am 7 or above: {n}");
        break;

    case int n when (n >= 4 && n <= 6 ):
        Console.WriteLine($"I am between 4 and 6: {n}");
        break;

    case int n when (n <= 3):
        Console.WriteLine($"I am 3 or less: {n}");
        break;
}

// Output: I am between 4 and 6: 5

Notas:

• Os parênteses (e )não são necessários na whencondição, mas são usados ​​neste exemplo para destacar as comparações.
• vartambém pode ser usado no lugar de int. Por exemplo: case var n when n >= 7:.

Você pode deixar de fora a nova linha que fornece:

case 1: case 2: case 3:
   break;

mas considero esse estilo ruim.

O .NET Framework 3.5 possui intervalos:

Enumerable.Range do MSDN

você pode usá-lo com "contains" e a instrução IF, pois, como alguém disse, a instrução SWITCH usa o operador "==".

Aqui está um exemplo:

int c = 2;
if(Enumerable.Range(0,10).Contains(c))
    DoThing();
else if(Enumerable.Range(11,20).Contains(c))
    DoAnotherThing();

Mas acho que podemos nos divertir mais: como você não precisará dos valores de retorno e essa ação não aceita parâmetros, você pode facilmente usar ações!

public static void MySwitchWithEnumerable(int switchcase, int startNumber, int endNumber, Action action)
{
    if(Enumerable.Range(startNumber, endNumber).Contains(switchcase))
        action();
}

O exemplo antigo com este novo método:

MySwitchWithEnumerable(c, 0, 10, DoThing);
MySwitchWithEnumerable(c, 10, 20, DoAnotherThing);

Como você está passando ações, não valores, você deve omitir os parênteses, é muito importante. Se você precisar de função com argumentos, basta alterar o tipo de Actionpara Action<ParameterType>. Se você precisar de valores de retorno, use Func<ParameterType, ReturnType>.

No C # 3.0, não existe um Aplicativo Parcial fácil para encapsular o fato de que o parâmetro case é o mesmo, mas você cria um pequeno método auxiliar (um pouco detalhado, em inglês).

public static void MySwitchWithEnumerable(int startNumber, int endNumber, Action action){ 
    MySwitchWithEnumerable(3, startNumber, endNumber, action); 
}

Aqui está um exemplo de como a nova declaração importada funcional é IMHO mais poderosa e elegante do que a antiga e imperativa.

Aqui está a solução completa em C # 7 ...

switch (value)
{
   case var s when new[] { 1,2,3 }.Contains(s):
      // Do something
      break;
   case var s when new[] { 4,5,6 }.Contains(s):
      // Do something
      break;
   default:
      // Do the default
      break;
}

Também funciona com cordas ...

switch (mystring)
{
   case var s when new[] { "Alpha","Beta","Gamma" }.Contains(s):
      // Do something
      break;
...
}

O código abaixo não funciona:

case 1 | 3 | 5:
// Not working do something

A única maneira de fazer isso é:

case 1: case 2: case 3:
// Do something
break;

O código que você procura funciona no Visual Basic, onde você pode facilmente colocar intervalos ... na noneopção da switchinstrução ou nos if elseblocos convenientes, sugiro, em um ponto extremo, criar .dll com o Visual Basic e importar de volta para o seu projeto c #.

Nota: o equivalente do comutador no Visual Basic é Select Case .

Outra opção seria usar uma rotina. Se todos os casos 1 a 3 executarem a mesma lógica, envolva essa lógica em uma rotina e chame-a para cada caso. Sei que isso não se livra das declarações de caso, mas implementa um bom estilo e mantém a manutenção no mínimo ...

[Editar] Adicionada implementação alternativa para corresponder à pergunta original ... [/ Editar]

switch (x)
{
   case 1:
      DoSomething();
      break;
   case 2:
      DoSomething();
      break;
   case 3:
      DoSomething();
      break;
   ...
}

private void DoSomething()
{
   ...
}

Alt

switch (x)
{
   case 1:
   case 2:
   case 3:
      DoSomething();
      break;
   ...
}

private void DoSomething()
{
   ...
}

Uma faceta menos conhecida do switch em C # é que ele depende do operador = e, como pode ser substituído, você pode ter algo assim:

string s = foo();

switch (s) {
  case "abc": /*...*/ break;
  case "def": /*...*/ break;
}

O gcc implementa uma extensão para a linguagem C para suportar intervalos seqüenciais:

switch (value)
{
   case 1...3:
      //Do Something
      break;
   case 4...6:
      //Do Something
      break;
   default:
      //Do the Default
      break;
}

Edit : Acabei de notar a tag C # na pergunta, então presumivelmente uma resposta do GCC não ajuda.

No C # 7, agora temos a correspondência de padrões para que você possa fazer algo como:

switch (age)
{
  case 50:
    ageBlock = "the big five-oh";
    break;
  case var testAge when (new List<int>()
      { 80, 81, 82, 83, 84, 85, 86, 87, 88, 89 }).Contains(testAge):
    ageBlock = "octogenarian";
    break;
  case var testAge when ((testAge >= 90) & (testAge <= 99)):
    ageBlock = "nonagenarian";
    break;
  case var testAge when (testAge >= 100):
    ageBlock = "centenarian";
    break;
  default:
    ageBlock = "just old";
    break;
}

Na verdade, eu também não gosto do comando GOTO, mas está nos materiais oficiais da Microsoft e aqui estão todas as sintaxes permitidas.

Se o ponto final da lista de instruções de uma seção de opção estiver acessível, ocorrerá um erro em tempo de compilação. Isso é conhecido como regra "sem falhas". O exemplo

switch (i) {
case 0:
   CaseZero();
   break;
case 1:
   CaseOne();
   break;
default:
   CaseOthers();
   break;
}

é válido porque nenhuma seção de chave possui um ponto final acessível. Diferentemente de C e C ++, a execução de uma seção de chave não é permitida "cair" para a próxima seção de chave e o exemplo

switch (i) {
case 0:
   CaseZero();
case 1:
   CaseZeroOrOne();
default:
   CaseAny();
}

resulta em um erro em tempo de compilação. Quando a execução de uma seção de chave deve ser seguida pela execução de outra seção de chave, é necessário usar um caso explícito goto case ou goto default:

switch (i) {
case 0:
   CaseZero();
   goto case 1;
case 1:
   CaseZeroOrOne();
   goto default;
default:
   CaseAny();
   break;
}

Múltiplas etiquetas são permitidas em uma seção de chave. O exemplo

switch (i) {
case 0:
   CaseZero();
   break;
case 1:
   CaseOne();
   break;
case 2:
default:
   CaseTwo();
   break;
}

Acredito que neste caso em particular, o GOTO pode ser usado, e é realmente a única maneira de avançar.

Fonte: http://msdn.microsoft.com/en-us/library/aa664749%28v=vs.71%29.aspx

Parece que muito trabalho foi feito para encontrar maneiras de fazer com que uma das sintaxes menos usadas do C # parecesse melhor ou funcionasse melhor. Pessoalmente, acho que raramente vale a pena usar a instrução switch. Eu sugiro fortemente analisar quais dados você está testando e os resultados finais que deseja.

Digamos, por exemplo, que você deseja testar rapidamente valores em um intervalo conhecido para ver se são números primos. Você deseja evitar que seu código faça cálculos desnecessários e pode encontrar uma lista de números primos no intervalo que deseja online. Você pode usar uma instrução de comutação massiva para comparar cada valor com números primos conhecidos.

Ou você pode simplesmente criar um mapa de matriz de números primos e obter resultados imediatos:

    bool[] Primes = new bool[] {
        false, false, true, true, false, true, false,    
        true, false, false, false, true, false, true,
        false,false,false,true,false,true,false};
    private void button1_Click(object sender, EventArgs e) {
        int Value = Convert.ToInt32(textBox1.Text);
        if ((Value >= 0) && (Value < Primes.Length)) {
            bool IsPrime = Primes[Value];
            textBox2.Text = IsPrime.ToString();
        }
    }

Talvez você queira ver se um caractere em uma string é hexadecimal. Você pode usar uma declaração de chave feia e um tanto grande.

Ou você pode usar expressões regulares para testar o char ou usar a função IndexOf para procurar o char em uma sequência de letras hexadecimais conhecidas:

        private void textBox2_TextChanged(object sender, EventArgs e) {
        try {
            textBox1.Text = ("0123456789ABCDEFGabcdefg".IndexOf(textBox2.Text[0]) >= 0).ToString();
        } catch {
        }
    }

Digamos que você queira executar uma das três ações diferentes, dependendo de um valor que esteja no intervalo de 1 a 24. Eu sugeriria o uso de um conjunto de instruções IF. E se isso se tornar muito complexo (ou os números forem maiores, como 5 ações diferentes, dependendo de um valor no intervalo de 1 a 90), use uma enumeração para definir as ações e criar um mapa de matriz das enumerações. O valor seria então usado para indexar no mapa da matriz e obter a enumeração da ação que você deseja. Em seguida, use um pequeno conjunto de instruções IF ou uma instrução switch muito simples para processar o valor de enumeração resultante.

Além disso, o bom de um mapa de matriz que converte um intervalo de valores em ações é que ele pode ser facilmente alterado por código. Com código com fio, você não pode alterar facilmente o comportamento em tempo de execução, mas com um mapa de matriz é fácil.

Apenas para adicionar à conversa, usando o .NET 4.6.2, também pude fazer o seguinte. Testei o código e funcionou para mim.

Você também pode fazer várias instruções "OU", como abaixo:

            switch (value)
            {
                case string a when a.Contains("text1"):
                    // Do Something
                    break;
                case string b when b.Contains("text3") || b.Contains("text4") || b.Contains("text5"):
                    // Do Something else
                    break;
                default:
                    // Or do this by default
                    break;
            }

Você também pode verificar se ele corresponde a um valor em uma matriz:

            string[] statuses = { "text3", "text4", "text5"};

            switch (value)
            {
                case string a when a.Contains("text1"):
                    // Do Something
                    break;
                case string b when statuses.Contains(value):                        
                    // Do Something else
                    break;
                default:
                    // Or do this by default
                    break;
            }

Se você tiver uma quantidade muito grande de seqüências de caracteres (ou qualquer outro tipo) fazendo a mesma coisa, recomendo o uso de uma lista de seqüências combinada com a propriedade string.Contains.

Então, se você tem uma declaração de switch grande assim:

switch (stringValue)
{
    case "cat":
    case "dog":
    case "string3":
    ...
    case "+1000 more string": // Too many string to write a case for all!
        // Do something;
    case "a lonely case"
        // Do something else;
    .
    .
    .
}

Você pode substituí-lo por uma ifdeclaração como esta:

// Define all the similar "case" string in a List
List<string> listString = new List<string>(){ "cat", "dog", "string3", "+1000 more string"};
// Use string.Contains to find what you are looking for
if (listString.Contains(stringValue))
{
    // Do something;
}
else
{
    // Then go back to a switch statement inside the else for the remaining cases if you really need to
}

Essa escala é boa para qualquer número de casos de cadeia.

Eu acho que este é melhor em C # 7 ou acima.

switch (value)
{
    case var s when new[] { 1,2 }.Contains(s):
    // Do something
     break;

    default:
    // Do the default
    break;
 }

Você também pode verificar o intervalo no caso de switch C #: Switch case: posso usar um intervalo em vez de um número ou se você quiser entender o básico do caso do switch C #

Para isso, você usaria uma instrução goto. Tal como:

    switch(value){
    case 1:
        goto case 3;
    case 2:
        goto case 3;
    case 3:
        DoCase123();
    //This would work too, but I'm not sure if it's slower
    case 4:
        goto case 5;
    case 5:
        goto case 6;
    case 6:
        goto case 7;
    case 7:
        DoCase4567();
    }