web-dev-qa-db-fra.com

Évaluer les expressions dans les instructions de commutateur en C #

Je dois implémenter les éléments suivants dans une instruction switch:

switch(num)
{
  case 4:
    // some code ;
    break;
  case 3:
    // some code ;
    break;
  case 0:
    // some code ;
    break;
  case < 0:
    // some code ;
    break;
}

Est-il possible que l'instruction switch évalue case < 0? Sinon, comment pourrais-je faire cela?

c#switch-statement
43
priyanka.sarkar

Vous ne pouvez pas - switch/case est uniquement pour les valeurs individuelles. Si vous souhaitez spécifier des conditions, vous avez besoin d'un "si":

if (num < 0)
{
    ...
}
else
{
    switch(num)
    {
        case 0: // Code
        case 1: // Code
        case 2: // Code
        ...
    }
}
70
Jon Skeet

Je sais que ce sujet est assez ancien mais si quelqu'un cherche toujours la réponse en C # 7, c'est possible. Voici un exemple:

switch (value)
{
     case var expression when value < 0:
         //some code
         break; 

     case var expression when (value >= 0 && value < 5):
         //some code
         break;

     default:
         //some code
         break;
}
38
Max

Vous pouvez faire quelque chose comme ceci à la fin de votre instruction switch:

default:
    if(num < 0)
    {
        ... // Code
    }
    break;
13
tbreffni

Si votre num ne peut pas être inférieur à zéro:

public int GetSwitch(int num) { return num < 0 ? -1 : num; }
switch(GetSwitch(num))
{
case 4: // some code ; break;
case 3:// some code ; break;
case 0: // some code ; break;
case -1 :// some code ; break;
}

Si c'est le cas, utilisez un autre nombre "inexistant" tel que int.MinValue.

8
queen3

Vous devrez utiliser si, que vous le vouliez ou non. Switch est uniquement capable de comparer votre valeur à des valeurs constantes.

5
Maximilian Mayerl

La seule façon de penser (et je ne le recommande vraiment pas) serait la suivante:

int someValue;

switch (Math.Max(someValue, -1))
{
    case -1:
        // will be executed for everything lower than zero.
        break;

    case 0:
       // will be executed for value 0.
       break;

    case 1:
       // will be executed for value 1.
       break;

    default:
       // will be executed for anything else.
       break;
}
5
Oliver Hanappi

tu peux le faire

switch (mark)
        {
            case int n when n >= 80:
                Console.WriteLine("Grade is A");
                break;

            case int n when n >= 60:
                Console.WriteLine("Grade is B");
                break;

            case int n when n >= 40:
                Console.WriteLine("Grade is C");
                break;

            default:
                Console.WriteLine("Grade is D");
                break;
        }
5
Cat_img.jpeg

L'inverse serait également possible (concernant la réponse de Jon Skeet):

switch(num)
{
  case a:
      break;
  default:
      if( num < 0 )
      {}
   break;
}
4
StampedeXV

Ce que vous pourriez faire, c'est d'utiliser un délégué comme celui-ci.

        var actionSwitch = new Dictionary<Func<int, bool>, Action>
        {
             { x => x < 0 ,     () => Log.Information("0")},
             { x => x == 1,     () => Log.Information("1")},
             { x => x == 2,     () => Log.Information("2")},
             { x => x == 3,     () => Log.Information("3")},
             { x => x == 4,     () => Log.Information("4")},
             { x => x == 5,     () => Log.Information("5")},
        };

        int numberToCheck = 1;

        //Used like this
        actionSwitch.FirstOrDefault(sw => sw.Key(numberToCheck)).Value();

Échangez simplement ce que vous ne voulez pas faire là où se trouve Log.Information ("x") et vous obtenez votre instruction "switch".

Vous aurez besoin d'une gestion des erreurs si vous recherchez une clé qui est "trouvée" par le Func.

Si vous aimez voir la version Func du commutateur, je viens d'écrire un article de blog avec un exemple de chapitre sur Switch .

3
Sturla

Vous ne pouvez pas utiliser des comparaisons dans les commutateurs comme vous le pourriez dans VB, vous avez 2 options ici, remplacez la valeur que vous allumez par une valeur connue et utilisez-la ou - si vous voulez dire tous les autres cas - vous pouvez utiliser la clause par défaut:

switch(num)
{
  case 4:
    // some code ;
    break;
  case 3:
    // some code ;
    break;
  case 0:
    // some code ;
    break;
  default:
    // some code ;
    break;
}

Notez que cela ne correspond pas exactement à ce que vous avez demandé: toute valeur autre que 0,3,4 se retrouvera dans la clause deafult :.

1
rsp

J'ai rencontré récemment le modèle suivant, et bien que je le déteste, je ne peux pas affirmer que ce n'est pas pratique:

switch(0)
{
  case 0 when x < 0:
    ...
    break;
  case 0 when a > 5 && x == 0:
    ...
    break;
}

L'utilisation d'expressions fictives ((0) dans le commutateur, et case 0) est absolument terrible, et je détesterais qu'il devienne un idiome, mais bon - c'est concis et très clair. Bien sûr, ce n'est pas un hack qui obscurcit complètement le sens et a besoin de connaissances arcaniques. Mais C # ferait bien d'éviter le besoin. Je voudrais que ce qui suit soit légal:

switch                   // maybe () here, if the grammar would demand
{
  case when x < 0:       // I like the case to stay
    ...
  case when a > 5 && x == 0:
    ...
}
0
Kuba Ober