Instruction Switch en C#

Personne ne sait si il est possible d'inclure une plage dans une instruction switch (et si oui, comment)?

Par exemple:

switch (x)
{
   case 1:
     //do something
     break;
   case 2..8:
     //do something else
     break;
   default:
     break;
}

Le compilateur ne semble pas aimer ce genre de syntaxe ni aime-t-il:

case <= 8:

OriginalL'auteur pm_2 | 2010-03-31

c#switch-statement

Non, ce n'est pas possible. Il existe quelques façons que j'ai fait dans le passé:

Fixe codage:

switch (x)
{
   case 1:
     //do something
     break;
   case 2:
   case 3:
   case 4:
   case 5:
   case 6:
   case 7:
   case 8:
     //do something else
     break;
   default:
     break;
}

En combinaison avec un if {} déclaration:

switch (x)
{
   case 1:
     //do something
     break;
   default:
     if (x <= 8)
     {
        //do something
     }
     else
     {
       //throw exception
     }
     break;
}

+1 pour le second exemple. Le premier qui me donne envie de blesser quelqu'un. 🙂
Le premier exemple semble étrange: je sais que c'est vrai pour, par exemple, Java, mais le MSDN entrée pour switch stipule explicitement que le compilateur ne permettra pas de “fall-through”. Ou ai-je raté quelque chose ici?
Bon, apparemment, c'est autorisé pour les "vides" cases.

OriginalL'auteur Andy Shellam

5

Non, mais vous pouvez écrire, si vous avez au moins éviter d'écrire le //do something else partie plusieurs fois.
```
switch (x)
{
   case 1:
     //do something
     break;
   case 2: case 3: case 4: case 5: case 6: case 7: case 8:
     //do something else
     break;
   default:
     break;
}
```
déjà mentionné ci-dessus, mais point important sur la mise en forme 🙂 je me soucie de la communication

OriginalL'auteur Marcelo Cantos
3

Réponse courte : pas. Il serait possible d'écrire tous les cas, là, mais une telle gamme de notation n'est pas pris en charge.

Je pense que vous devez utiliser if déclaration ici ou de passer à une langue où il y a un meilleur support pour les cas descrimination.

OriginalL'auteur Tomas Vana
2

Si vous avez si peu de cas, if serait bien préférable.

OriginalL'auteur leppie

Une possibilité est de convertir vos gammes en nombres entiers. Par exemple:

//assuming x>=9 or if (x <= 0) return;
        switch((x+12)/7)
        {   case 1:Console.WriteLine("one");
                break;
            case 2:Console.WriteLine("2 through 8 inclusive");
                break;
            case 3:Console.WriteLine("9 through 15 inclusive");
                break;
            default: Console.WriteLine("16 or more");
                break;
        }

OriginalL'auteur Peter Baum

1

Vous pouvez, gérer le cas explicites au cas par cas, et si vous avez seulement une gamme, de traiter avec elle, dans le cas par défaut.

OriginalL'auteur Samuel De Rycke

Alors que ce n'était pas possible quand j'ai d'abord posé cette question, par le miracle de C# Pattern Matching, c'est maintenant (en C# 7):

switch (i)
{
    case var test when test <= 2:
        Console.WriteLine("Less than 2");
        break;

    case var test when test > 2 && test < 10:
        Console.WriteLine("Between 2 and 10");
        break;

    case var test when test >= 10:
        Console.WriteLine("10 or more");
        break;
}

Un billet de blog sur le sujet

OriginalL'auteur pm_2

-1

vous pouvez faire
```
case 2:
case 3:
case 4:
...
case 8:
 //code here
 break
```
[-] Cette réponse a déjà été fournie par Andy Shellam ci-dessus.

OriginalL'auteur munissor

-1

Vous pouvez utiliser cas de chute par:

switch (x)
{
   case 1:
     //do something
     break;
   case 2:
   case 3:
   case 4:
   case 5:
   case 6:
   case 7:
   case 8:
     //do something else
     break;
   default:
     break;
}

Mais j'avais juste l'utiliser pour cela.

[-] Cette réponse a déjà été fournie par Andy Shellam ci-dessus.

OriginalL'auteur reko_t

-1

Vous ne pouvez utiliser aucune des instructions conditionnelles dans un commutateur cas.

Si vous voulez exécuter les mêmes lignes de code pour les différentes options que vous pouvez faire qu'une chose:

switch (i)
            {
                case 0:
                case 1:
                case 2: 
                case 3:
                    //do something here.
                    break;
                default:
                    //do something here.
                    break;
            }

[-] La réponse ci-dessus est déjà prévue par Andy Shellam.

OriginalL'auteur Hiscal

Vous devez vous connecter pour publier un commentaire.