Commutateur de cas: puis-je utiliser une plage au lieu d'un numéro de

Je veux le switch, mais j'ai beaucoup de cas, est-il un raccourci? Jusqu'à présent, la seule solution que je connaisse et essayé est:

switch (number)
{
case 1: something; break;
case 2: other thing; break;
...
case 9: .........; break;
}

Ce que j'espère, je suis capable de faire est quelque chose comme:

switch (number)
{
case (1 to 4): do the same for all of them; break;
case (5 to 9): again, same thing for these numbers; break;
}

dans quelle langue? (bien que généralement votre réponse est NON)
Vous pouvez utiliser des if-else pour un tel scénario

InformationsquelleAutor user3022162 | 2013-11-22

c#switch-statement

167

Un peu en retard pour le jeu, pour cette question, mais au cours des dernières modifications introduit en C# 7 (Disponible par défaut dans Visual Studio 2017/.NET Framework 4.6.2), basées sur une plage de commutation est désormais possible avec l' switch déclaration.

Exemple:
```
int i = 63;

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

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

    case int n when (n < 50):
        Console.WriteLine($"I am less than 50: {n}");
        break;
}
```
Notes:
- Les parenthèses ( et ) ne sont pas nécessaires dans le when condition, mais sont utilisés dans cet exemple pour mettre en évidence la comparaison(s).
- var peut également être utilisé en lieu et place de int. Par exemple: case var n when n >= 100:.
- Vous, monsieur, êtes mon héros. J'ai voulu souligner cette avec quelques gros mot, mais plutôt de ne pas. 🙂
- Le ( et ) autour de la when condition sont inutiles. I. e. case int n when n >= 100: fonctionne également.
- Même var fonctionne: I. e. case var n when n >= 100:.
- Belle réponse. Mais honnêtement, comment est-ce mieux qu'un bouquet de si les déclarations?
- Je pense que c'est propre et améliore la lisibilité par rapport à un tas de si les déclarations, en particulier si vous avez plus de 3-4 conditions.
- De loin supérieur à tout un tas d'if, c'est beaucoup plus propre.
InformationsquelleAutor Steve Gomez
45

Ici est une meilleure et solution élégante pour votre énoncé du problème.
```
int mynumbercheck = 1000;
//Your number to be checked
var myswitch = new Dictionary <Func<int,bool>, Action>
            { 
             { x => x < 10 ,    () => //Do this!...  },  
             { x => x < 100 ,    () => //Do this!...  },
             { x => x < 1000 ,    () => //Do this!...  },
             { x => x < 10000 ,   () => //Do this!... } ,
             { x => x < 100000 ,  () => //Do this!... },
             { x => x < 1000000 ,  () => //Do this!... } 
            };
```
Maintenant appeler notre conditionnelle switch
```
   myswitch.First(sw => sw.Key(mynumbercheck)).Value();
```
Suppléant de Commutateur/ifElse
- Je pense toujours que l'interrupteur doit être étendu en C#, mais ça a l'air fantastique et semble fonctionner très bien. Vraiment vous remercie de partager cet exemple. Merci
- Ce n'est pas de réponse claire à la gamme de commutateur/cas de question.
- Le dictionnaire n'est pas de stocker et de renvoyer les valeurs dans l'ordre dans lequel ils sont ajoutés. Ce qui se passe à travailler avec le compilateur de Microsoft, mais on pourrait facilement écrire un complient compilateur où il ne fonctionne pas. Au lieu d'utiliser une Liste<KeyValuePair<Func<int, bool>, Action>>. Sachez également qu'il est un coût pour la génération de la structure de données et donc il devrait probablement être un static readonly membre.
- veuillez ref le blog pour les besoin du code écrit dans les commentaires pour référence future
- merci pour aborder cette question. hargneux, IList collection aurait aussi être une alternative. c'était juste un exemple que j'ai mis en œuvre avec des paramètres complexes en utilisant la Liste des<t>.
InformationsquelleAutor Akxaya

If-else doit être utilisé dans ce cas, Mais si il ya encore un besoin d'interrupteur pour une raison quelconque, vous pouvez le faire ci-dessous, les premiers cas sans pause va se propager jusqu'à la première pause est rencontré. Comme les réponses précédentes ont suggéré que je recommande si-sinon-dessus de l'interrupteur.

switch (number){
            case 1:
            case 2:
            case 3:
            case 4: //do something;
                    break;
            case 5:
            case 6:
            case 7:
            case 8:
            case 9: //Do some other-thing;
                   break;
        }

InformationsquelleAutor Gayathri

Intervalle est constante:

 int range = 5
 int newNumber = number / range;
 switch (newNumber)
 {
      case (0): //number 0 to 4
                break;
      case (1): //number 5 to 9
                break;
      case (2): //number 10 to 14
                break;
      default:  break;
 }

Autrement:

  if else

InformationsquelleAutor benba

Vous pourriez avoir switch construire la "poignée" va en l'utilisant conjointement avec un List de vos limites.

List<int> bounds = new List<int>() {int.MinValue, 0, 4, 9, 17, 20, int.MaxValue };

switch (bounds.IndexOf(bounds.Last(x => x < j)))
{
    case 0: //<=0
        break;

    case 1: //>= 1 and <=4
        break;
    case 2: //>= 5 and <=9
        break;
    case 3: //>= 10 and <=17
        break;
    case 4: //>= 18 and <=20
        break;

    case 5: //>20
        break;
}

Avec cette approche, les plages peuvent avoir différentes travées.

InformationsquelleAutor user3598756

Comme mentionné if-else serait mieux dans ce cas, où vous aurez la gestion d'une gamme:

if(number >= 1 && number <= 4)
{
   //do something;
}
else if(number >= 5 && number <= 9)
{
   //do something else;
}

InformationsquelleAutor henrik

Je voudrais utiliser ternaire opérateurs pour classer votre commutateur conditions.

Donc...

switch( number > 9 ? "High" :
        number > 5 ? "Mid" :
        number > 1 ? "Low" : "Floor")
        {
              case "High":
                    do the thing;
                    break;
               case "Mid":
                    do the other thing;
                    break;
               case "Low":
                    do something else;
                    break;
               case "Floor":
                    do whatever;
                    break;
         }

InformationsquelleAutor graphicdivine

Dans .Net Visual Basic permet de plages dans les instructions de commutation, mais en C# il n'y a pas de syntaxe valide pour cette.

S'attaquer à votre problème spécifique en C#, je voudrais résoudre ainsi:

if(number >= 1 && number <= 9) //Guard statement
{
    if(number < 5)
    {
        //Case (1 to 4):

        //break;

    }
    else
    {
        //Case (5 to 9):

        //break;

    }

}
else
{
    //Default code goes here

    //break;

}

Pour illustrer cela, imaginez que vous avez un pourcentage de la valeur.

À l'aide de votre problème en tant que modèle, vous pourriez voulez que cela ressemble à:

switch (percentage)
{
    case (0 to 19):
        break;

    case (20 to 39):
        break;

    case (40 to 69):
        break;

    case (70 to 79):
        break;

    case (80 to 100):
        break;

    default:
        break;

}

Cependant, depuis C# ne permet pas que de la syntaxe, voici une solution qui C# permet:

if (percentage >= 0 && percentage <= 100) //Guard statement
{
    if (percentage >= 40)
    {
        if (percentage >= 80)
        {
            //Case (80% to 100%)

            //break;

        }
        else
        {
            if (percentage >= 70)
            {
                //Case (70% to 79%)

                //break;

            }
            else
            {
                //Case (40% to 69%)

                //break;

            }

        }

    }
    else
    {
        if (percentage >= 20)
        {
            //Case (20% to 39%)

            //break;

        }
        else
        {
            //Case (0% to 19%)

            //break;

        }

    }

}
else
{
    //Default code goes here

    //break;

}

Il peut prendre un peu de s'habituer, mais c'est bien une fois que vous l'obtenez.

Personnellement, je serais heureux de les instructions switch pour permettre des plages.

L'avenir de C# les instructions switch

Ici sont quelques idées que j'ai eu de la façon dont les instructions switch pourrait être amélioré:

Version Un

switch(value)
{
    case (x => x >= 1 && x <= 4):
    break;

    case (x => x >= 5 && x <= 9):
    break;

    default:
    break;

}

Version B

switch(param1, param2, ...)
{
    case (param1 >= 1 && param1 <= 4):
    break;

    case (param1 >= 5 && param1 <= 9 || param2 != param1):
    break;

    default:
    break;

}

InformationsquelleAutor Knickerless-Noggins

1

Si vous utilisez C/C++, il n'y a pas de "plage" de la syntaxe. Vous pouvez seulement de la liste de toutes les valeurs après chaque "case" du segment.
Le langage Ada ou Pascal gamme de support de la syntaxe.

InformationsquelleAutor SliceSort
0

Tout d'abord, vous devez spécifier le langage de programmation que vous faites référence.
Deuxièmement, switch déclarations sont correctement utilisés pour les jeux fermés d'options concernant la commutation variable, par exemple, des énumérations ou des chaînes prédéfinies. Pour ce cas, je vous recommande d'utiliser le bon vieux if-else structure.

InformationsquelleAutor Andrei Nicusan
0

En C# commutateur cas sont essentiellement des dictionnaires sur ce qu'il faut faire ensuite. Puisque vous ne pouvez pas regarder une série dans un dictionnaire, le meilleur que vous pouvez faire est le cas ... lors de la déclaration de Steve Gomez mentionné.

InformationsquelleAutor user3406087

Pour terminer le thread, voici la syntaxe du C# 8 :

  var percent = price switch
  {
    var n when n >= 1000000 => 7f,
    var n when n >= 900000 => 7.1f,
    var n when n >= 800000 => 7.2f,
    _ => 0f //default value
  };

Si vous souhaitez spécifier les plages :

  var percent2 = price switch
  {
    var n when n >= 1000000 => 7f,
    var n when n < 1000000 && n >= 900000 => 7.1f,
    var n when n < 900000 && n >= 800000 => 7.2f,
    _ => 0f //default value
  };

InformationsquelleAutor A.Baudouin

-1

Si la question était sur C (vous n'avez pas dit), alors la réponse est non, mais: GCC et Clang (peut-être d'autres) prennent en charge un syntaxe, mais c'est pas valide ISO C:
```
switch (number) {
    case 1 ... 4:
        //Do something.
        break;

    case 5 ... 9:
        //Do something else.
        break;
}
```
Assurez-vous d'avoir un espace avant et après le ..., sinon vous aurez une erreur de syntaxe.
- Pascal/delphi n'est ce trop. numéro d'affaire de 1..4 : faire quelque chose; etc.
- La question est sur C#
- Je sais. J'ai ajouté le C# tag à cette question après l'OP, enfin, nous a dit langue dans laquelle la question est à propos. Mais la réponse peut être très utile pour les personnes qui viennent ici via un moteur de recherche qui est pourquoi je n'ai pas supprimé.
InformationsquelleAutor DarkDust
-1

Par switch cas, c'est impossible.Vous pouvez aller avec des instructions if imbriquées.
```
if(number>=1 && number<=4){
//Do something
}else if(number>=5 && number<=9){
//Do something
}
```
- Le bon vieux (number >= 1 && number <= 4) au lieu de vérifier chaque numéro? Comment écririez-vous entre 1 et 120? 😉
- Oh, et faites attention à = vs ==.
InformationsquelleAutor Joke_Sense10
-3

Vous pouvez utiliser des if-else avec || les opérateurs (ou opérateur) comme:
```
if(case1 == true || case2 == true || case3 == true)
   {
    Do this!... 
   }
else if(case4 == true || case5 == true || case6 == true)
   {
    Do this!... 
   }
else if(case7 == true || case8 == true || case9 == true)
   {
    Do this!... 
   }
```
- Wow, c'est un peu compliqué pour quelque chose comme if (number >= 1 && number <= 4) { … } else if (number >= 5 && number <= 9) { … }, vous ne pensez pas?
- Oh bien oui... Euh, mais si les cas qui sont censés faire la même chose arent commandé, vous devez utiliser le "| | opérateur"...
- Mais son but était de vérifier si un nombre est au sein d'une gamme, de sorte que l'ordre n'a pas d'importance (sauf pour le plages coché).
- Ce n'est pas un défaut, votre solution n'est pas mal, juste compliqué 😉
- == true :face_palm: c'est le comportement par défaut et pour == false, vous pouvez utiliser l'opérateur not
InformationsquelleAutor Lukas Warsitz

Vous devez vous connecter pour publier un commentaire.