What's the best alternative to an out of control switch statement?

Question

I have inherited a project that has some huge switch statement blocks, with some containing up to 20 cases. What is a good way to rewrite these?

Answer 1

Polymorphism. But it may not be a trivial refactoring.

Some examples and refs:

Refactoring (Googe books)

Switch Statement code smell and Polymorphism

Refactoring switch-statements

Answer 2

Depending on what the switch statement is evaluating, you may want to refactor it using the Strategy Pattern. Take a look at this post for an example of replacing a switch on enum values with separate classes to handle each function.

It also may be that using the switch with 20 cases may actually be the best course of action for it. As long as it's readable and each result clearly conveys what the action is there's no need to really refactor it.

Answer 3

In general, I think you should refactor only when you need to, such as when you want to add more features, but the current design isn't up for the task. You should then refactor without adding the new functionality, and only then add the new feature.

In other circumstances, don't bother with refactoring. Do it when you need to, otherwise there are probably more important things to do.

If you really really need to, then the Visitor Design Pattern is a common switch-case replacement, though you should note it does have drawbacks. (i.e., check out www.objectmentor.com/resources/articles/acv.pdf)

Answer 4

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

Client side

Create an instance of your Condition, then pass a condition to Condition object by Switch() function.

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

Server side

1. Create a condition action. This interface defines how to execute a Condition.

   public interface IAction
   {
       void Do();
   }
   

2. Create list of cases you want. These classes must implement condition action and ICase; Keep them light.

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

   • ICase just holds a Key that it is used by Switch() function to navigate the cases.

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

3. Create a Condition class that it Inherites SwitchCase generic abstract class.

   • Add all cases witch you want to Cases property.

   • Define a Switch() function and navigate Cases property to find matches cases, then execute them as a condition action.

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

Smile, Cry..., can be huge, don't worry about size of them; condition action and ICase keep them 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 :-|");
                }
            }
        }

Answer 5

Three suggestions (echoing some already given):

1. Maybe a switch isn't as bad as you think. It can be ugly if the case blocks are large. Shorten them by extracting the logic into methods.

2. In an OO language, polymorphism might be the answer, as many have pointed out.

3. In a functional language, like Javascript, write a function that returns the function you need to run for whatever input. That might use a switch statement itself, or it might use a lookup table.