web-dev-qa-db-fra.com

Instruction switch dans une instruction switch?

Je dois évaluer de nombreuses conditions. Dans mon cas, je dois faire quelque chose comme ceci:

switch(id)
{
    case 5:
         // switch some other cases here
    case 6:
         // set some value
    ...
 }

Est-ce une bonne pratique d'avoir un autre commutateur dans le cas 5? Sinon, quoi de mieux? Y a-t-il des instructions if?

c#switch-statement
20
grady

J'appellerais une fonction spécifique au cas 5, puis j'aurais le cas du commutateur dans cette fonction. Par exemple :

switch(id)
{
    case 5:
         functionFiveSpecific(id);
    case 6:
         // set some value
    ...
 }

La fonction spécifique au cas 5:

private void functionFiveSpecific(id)
{
   // other switch in here
}

Bien que

Il est fortement recommandé d'éviter l'utilisation des instructions switch si possible. Lisez ici .

19
Lloyd Powell

La seule chose qui pourrait être erronée est que cela pourrait nuire à la lisibilité:

switch(id)
{
    case 5:
    {
        switch (somethingElse)
        {
            case 1:
                // blah...
        }
    }
    case 6:
         // set some value
    ...
}

Vous pouvez améliorer cela en déplaçant la section imbriquée dans une méthode:

switch(id)
{
    case 5:
        Foo();
        break;
    case 6:
         // set some value
    ...
}
7
Andrew Hare

Éviter !

Essayez de refactoriser votre code pour éliminer les boîtiers de commutation. Les instructions de changement de comportement peuvent être refactorisées en modèle de stratégie.

Strategy Pattern](![Strategy Pattern

7
abhilash

Les instructions Switch ne sont pas une mauvaise pratique. Les instructions de commutateur imbriquées peuvent être compliquées à regarder.

Pensez peut-être à incorporer l'instruction switch imbriquée dans une autre méthode pour améliorer la clarté.

6
Adam Houldsworth

Dès que vous commencez à imbriquer votre complexité cyclomatique commence à augmenter. Selon la complexité de vos commutateurs imbriqués, cela peut être amusant à maintenir. Vous voudrez peut-être réfléchir au déplacement du deuxième commutateur imbriqué vers une fonction qui lui est propre. Par exemple

switch (order.Status)
{
    case OrderStatus.New: 
        // Do something to a new order;
        break;

    ...

    case OrderStatus.ReadyToShip
        // Process Shipping Instructions
        ShipOrder(order);
        break;
}

puis si vous aviez un commutateur basé sur le type d'expédition payé

void ShipOrder(Order order)
{
    switch (order.ShippingMethod)
    {
    }
}

En déplaçant la deuxième instruction switch de la première, elle est plus facile à gérer et peut également être testée isolément

6
blowdart

La meilleure pratique consiste à encapsuler les différents comportements de manière polymorphe à l'intérieur de différentes classes et à essayer d'éviter les instructions switch si possible.

Ce n'est pas toujours possible, et si vous devez utiliser des instructions switch, je ne mettrais pas d'autre instruction switch imbriquée (ou une collection d'instructions if) mais aurais probablement un appel de méthode qui contiendrait cette logique.

Si vous postez un peu plus de détails sur ce que vous essayez de faire, nous pourrons peut-être vous proposer de meilleures suggestions.

5
Sam Holder

Utilisez le polymorphisme si possible. Cela rendrait votre code beaucoup plus propre.

2
Daniel Hilgarth

J'appellerais une fonction et passerais dans les cas supplémentaires et dans la fonction ferais un cas de commutation sur eux. Rend le code plus propre. Une autre méthode que j'utilise souvent est en effet imbriquée si

1
SynerCoder