Quelle est la meilleure alternative à une déclaration de commutateur hors de contrôle?

Pourquoi voulez-vous de les réécrire dans une autre structure? Si vous avez vraiment des 20 cas qui doivent être traitées individuellement, un switch/case est le chemin à parcourir. Une grande chaîne de si/alors, la logique serait horrible à gérer.

Polymorphisme est une autre option si vous utilisez un langage orienté objet. Chaque sous-classe serait de mettre en œuvre sa propre fonctionnalité dans la méthode.

Comme d'autres l'ont souligné, il dépend de l'instruction switch. Cependant, dans le passé, j'ai refait les instructions switch en procédant de la manière suivante. Supposons que nous avons une instruction switch comme ça, avec beaucoup de répétition du code

switch(x){
   case 1:
     makeitso("foo");
     globalLog += "foo";
   case 2:
     makeitso("bar");
     globalLog += "bar";
   case 3:
     makeitso("baz");
     globalLog += "baz";
   ...
   default:
      throw("input error");
}

la première chose à faire est de reconnaître les parties communes (dans le monde réel, ce sera probablement un peu plus importante)

makeitso([some string]);
globalLog += [some string];

et le transformer en une fonction

function transformInput(somestring) {
     makeitso(somestring);
     globalLog += somestring;
}

alors pour les pièces à changer, dans chaque cas, utiliser une table de hachage ou d'un tableau;

var transformvalues = ["foo", "bar", "baz"];

de là, nous pouvons le faire:

var tvals = ["foo", "bar", "baz" ... ];
function transformInput(somestring) {
     makeitso(somestring);
     globalLog += somestring;
}
var tval = tvals[x];
if(tval!==undefined) {
     transformInput(tval);
} else {
    throw ("invalid input");
} 

Et avec tvals pris en compte de l'instruction switch, il pourrait même être fourni à l'externe, afin d'élargir le nombre de cas que vous pouvez manipuler. Ou vous pourriez construire dynamiquement. Dans le monde réel, l'instruction switch ont souvent des cas particuliers, cependant. Je laisse ça comme un exercice pour le lecteur.

Vous pouvez toujours utiliser une table de recherche.

En fonction de ce que l'instruction switch est de l'évaluation, vous pouvez refactoriser le code en utilisant le Modèle de Stratégie. Jetez un oeil à ce post pour un exemple de remplacement d'un interrupteur sur les valeurs de l'enum avec des classes séparées pour chaque fonction.

Il peut être également que l'aide de l'interrupteur avec 20 cas est peut être le meilleur plan d'action. Tant que c'est lisible et chaque résultat indique clairement que l'action il n'y a pas vraiment besoin de refactoriser le code.

Cela dépend de ce que l'instruction switch est en train de faire.

Si c'est de la correspondance des caractères ou des chaînes, dire dans un analyseur syntaxique, et vous n'avez pas le même ensemble de motifs répétés partout dans le code, puis d'une instruction switch peut être ok.

Si c'est la congruence (dire) un entier dans une liste de valeurs autorisées, vous pouvez créer une classe de base et un ensemble de classes dérivées pour chaque valeur. Alors, ce que génère les données entières en premier lieu peut créer une instance de la classe dérivée avec l'ensemble de l'instruction switch "réponses" à la place.

Une troisième option est de créer une structure de données de cartes de motifs pour les actions (par exemple, des fonctions ou des objets avec des méthodes virtuelles). Vous pouvez consulter le commutateur de valeur dans cette structure de données, et d'exécuter l'action appropriée.

Visite https://github.com/Pedram-Ahmadpour/Switch-Case

Côté Client

Créer une instance de votre Conditionpuis de passer d'un état à Condition objet par Switch() fonction.

    int sense = 2;
    ConditionSense conditionSense = new ConditionSense();
    conditionSense.Switch(sense);

Côté serveur

1. Créer un action de condition. Cette interface définit la façon d'exécuter une Condition.

   public interface IAction
   {
       void Do();
   }

2. Créer une liste de dossiers que vous le souhaitez. Ces classes doivent implémenter action de condition et ICase; Garder la lumière.

       public class CaseCry : IAction, ICase<int?>
       {
           public int? Key { get { return 2; } }
   
           public void Do()
           {
               Sense.Cry cry = new Sense.Cry();
               cry.Act();
           }
       }

   • ICase tient juste un Clé qu'il est utilisé par Switch() fonction pour naviguer le cas.

     public interface ICase<TCase>
     {
         TCase Key { get; }
     }

3. Créer un Condition classe qu'il Inherites SwitchCase générique de la classe abstraite.

   • Ajouter tous les cas, la sorcière vous voulez Cas propriété.

   • Définir un Switch() de la fonction et de naviguer Cas bien de trouver des correspondances des cas, puis les exécuter comme un action de condition.

     public class ConditionSense : SwitchCase<int?>
     {
         public ConditionSense()
         {
             Cases = new List<ICase<int?>>
             {
                 new CaseSmile(),
                 new CaseCry()
             };
     
             DefaultCases = new List<ICase<int?>> {
                 new CaseNoSense()
             };
         }
     
         public void Switch(int? key)
         {
             IEnumerable<IAction> matches = Cases.Where(p => p.Key.Equals(key))
                 .Select(p => p as IAction);
             if (matches.Count() > 0)
                 foreach (IAction match in matches)
                     match.Do();
             else
                 foreach (IAction defaultCase in DefaultCases)
                     defaultCase.Do();
         }
     }

SourirePleurer..., peut être énorme, ne vous inquiétez pas au sujet de leur dimension; action de condition et ICase garder le lazy load.

        public class Sense
        {
            public class Smile
            {
                public void Act()
                {
                    Console.WriteLine("I'm smiling :-)");
                }
            }

            public class Cry
            {
                public void Act()
                {
                    Console.WriteLine("I'm crying :-(");
                }
            }

            public class NoSense
            {
                public void Act()
                {
                    Console.WriteLine("I've no sense :-|");
                }
            }
        }