Plusieurs cas dans l'instruction switch

Existe-t-il un moyen de passer à travers plusieurs déclarations de cas sans préciser case value: répéter à plusieurs reprises?

Je sais que cela fonctionne:

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;
}

mais je voudrais faire quelque chose comme ça:

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

Cette syntaxe à laquelle je pense provient-elle d'un autre langage ou manque-t-il quelque chose?

Il n'y a pas de syntaxe en C ++ ni en C # pour la deuxième méthode que vous avez mentionnée.

Il n'y a rien de mal avec votre première méthode. Si toutefois vous avez de très grandes plages, utilisez simplement une série d'instructions if.

Je suppose que cela a déjà été répondu. Cependant, je pense que vous pouvez toujours mélanger les deux options d'une manière syntaxiquement meilleure en faisant:

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

Cette syntaxe provient de l' instruction Visual Basic Select ... Case :

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

Vous ne pouvez pas utiliser cette syntaxe en C #. Au lieu de cela, vous devez utiliser la syntaxe de votre premier exemple.

En C # 7 (disponible par défaut dans Visual Studio 2017 / .NET Framework 4.6.2), la commutation basée sur la plage est désormais possible avec l' instruction switch et aiderait à résoudre le problème de l'OP.

Exemple:

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

Remarques:

• Les parenthèses (et )ne sont pas obligatoires dans la whencondition, mais sont utilisées dans cet exemple pour mettre en évidence la ou les comparaisons.
• varpeut également être utilisé à la place de int. Par exemple: case var n when n >= 7:.

Vous pouvez laisser de côté la nouvelle ligne qui vous donne:

case 1: case 2: case 3:
   break;

mais je considère ce mauvais style.

.NET Framework 3.5 a des plages:

Enumerable.Range de MSDN

vous pouvez l'utiliser avec "contains" et l'instruction IF, car comme quelqu'un l'a dit, l'instruction SWITCH utilise l'opérateur "==".

Voici un exemple:

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

Mais je pense que nous pouvons avoir plus de plaisir: puisque vous n'aurez pas besoin des valeurs de retour et que cette action ne prend pas de paramètres, vous pouvez facilement utiliser des actions!

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

Le vieil exemple avec cette nouvelle méthode:

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

Puisque vous passez des actions, pas des valeurs, vous devez omettre les parenthèses, c'est très important. Si vous avez besoin d'une fonction avec des arguments, changez simplement le type de Actionen Action<ParameterType>. Si vous avez besoin de valeurs de retour, utilisez Func<ParameterType, ReturnType>.

En C # 3.0, il n'y a pas d' application partielle facile pour encapsuler le fait que le paramètre case est le même, mais vous créez une petite méthode d'aide (un peu verbeuse, mais).

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

Voici un exemple de la façon dont la nouvelle déclaration fonctionnelle importée est à mon humble avis plus puissante et élégante que l'ancienne impérative.

Voici la solution complète 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;
}

Cela fonctionne aussi avec les cordes ...

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

Le code ci - dessous ne fonctionnera pas :

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

La seule façon de procéder est:

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

Le code que vous recherchez fonctionne en Visual Basic où vous pouvez facilement mettre des plages ... dans l' noneoption de l' switchinstruction ouif else blocs pratiques, je suggère, à un point très extrême, de créer .dll avec Visual Basic et de l'importer à votre projet C #.

Remarque: l'équivalent de commutateur dans Visual Basic est Select Case.

Une autre option serait d'utiliser une routine. Si les cas 1 à 3 exécutent tous la même logique, encapsulez cette logique dans une routine et appelez-la pour chaque cas. Je sais que cela ne supprime pas réellement les déclarations de cas, mais cela met en œuvre un bon style et maintient la maintenance au minimum .....

[Modifier] Ajout d'une implémentation alternative pour correspondre à la question d'origine ... [/ Modifier]

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()
{
   ...
}

Une facette moins connue du commutateur en C # est qu'il repose sur l' opérateur = et comme il peut être remplacé, vous pourriez avoir quelque chose comme ceci:

string s = foo();

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

gcc implémente une extension du langage C pour prendre en charge les plages séquentielles:

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

Edit : Je viens de remarquer la balise C # sur la question, donc probablement une réponse gcc n'aide pas.

En C # 7, nous avons maintenant la correspondance de motifs afin que vous puissiez faire quelque chose comme:

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;
}

En fait, je n'aime pas non plus la commande GOTO, mais elle est dans les documents officiels de Microsoft, et voici toutes les syntaxes autorisées.

Si le point final de la liste d'instructions d'une section de commutateur est accessible, une erreur de compilation se produit. C'est ce que l'on appelle la règle de «non-répercussion». L'exemple

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

est valide car aucune section de commutateur n'a de point de fin accessible. Contrairement à C et C ++, l'exécution d'une section de commutateur n'est pas autorisée à "passer" à la section de commutateur suivante, et l'exemple

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

entraîne une erreur de compilation. Lorsque l'exécution d'une section de commutateur doit être suivie par l'exécution d'une autre section de commutateur, un cas goto explicite ou une instruction par défaut goto doit être utilisé:

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

Plusieurs étiquettes sont autorisées dans une section de commutation. L'exemple

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

Je crois que dans ce cas particulier, le GOTO peut être utilisé, et c'est en fait le seul moyen de passer à travers.

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

Beaucoup de travail semble avoir été fait pour trouver des moyens d'obtenir une des syntaxes C # les moins utilisées pour mieux paraître ou mieux fonctionner. Personnellement, je trouve que l'instruction switch vaut rarement la peine d'être utilisée. Je suggère fortement d'analyser les données que vous testez et les résultats finaux que vous recherchez.

Disons par exemple que vous souhaitez tester rapidement des valeurs dans une plage connue pour voir s'il s'agit de nombres premiers. Vous voulez éviter que votre code fasse les calculs inutiles et vous pouvez trouver une liste de nombres premiers dans la plage que vous souhaitez en ligne. Vous pouvez utiliser une instruction switch massive pour comparer chaque valeur à des nombres premiers connus.

Ou vous pouvez simplement créer une carte matricielle de nombres premiers et obtenir des résultats immédiats:

    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();
        }
    }

Vous voulez peut-être voir si un caractère dans une chaîne est hexadécimal. Vous pouvez utiliser une instruction switch ungly et quelque peu volumineuse.

Ou vous pouvez utiliser des expressions régulières pour tester le caractère ou utiliser la fonction IndexOf pour rechercher le caractère dans une chaîne de lettres hexadécimales connues:

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

Supposons que vous souhaitiez effectuer l'une des 3 actions différentes en fonction d'une valeur comprise entre 1 et 24. Je suggère d'utiliser un ensemble d'instructions IF. Et si cela devenait trop complexe (ou si les nombres étaient plus grands, comme 5 actions différentes selon une valeur comprise entre 1 et 90), utilisez une énumération pour définir les actions et créer une carte de tableau des énumérations. La valeur serait ensuite utilisée pour indexer dans la carte du tableau et obtenir l'énumération de l'action souhaitée. Utilisez ensuite un petit ensemble d'instructions IF ou une instruction switch très simple pour traiter la valeur d'énumération résultante.

En outre, la bonne chose à propos d'une carte de tableau qui convertit une plage de valeurs en actions est qu'elle peut être facilement modifiée par le code. Avec du code câblé, vous ne pouvez pas facilement changer de comportement lors de l'exécution, mais avec une carte de tableau, c'est facile.

Juste pour ajouter à la conversation, en utilisant .NET 4.6.2, j'ai également pu faire ce qui suit. J'ai testé le code et cela a fonctionné pour moi.

Vous pouvez également faire plusieurs instructions "OU", comme ci-dessous:

            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;
            }

Vous pouvez également vérifier s'il correspond à une valeur dans un tableau:

            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;
            }

Si vous avez un très grand nombre de chaînes (ou tout autre type) faisant toutes la même chose, je recommande l'utilisation d'une liste de chaînes combinée avec la propriété string.Contains.

Donc, si vous avez une grosse instruction switch comme ceci:

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;
    .
    .
    .
}

Vous voudrez peut-être le remplacer par une ifdéclaration comme celle-ci:

// 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
}

Cette échelle convient bien à n'importe quel nombre de cas de chaîne.

Je pense que celui-ci est meilleur en C # 7 ou supérieur.

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

    default:
    // Do the default
    break;
 }

Vous pouvez également vérifier la plage dans le boîtier de commutateur C #: Boîtier de commutateur: puis-je utiliser une plage au lieu d'un seul chiffre Ou si vous voulez comprendre les bases du boîtier de commutateur C #

Pour cela, vous utiliseriez une instruction goto. Tel que:

    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();
    }