Refactoring and removing switch statements in C#

Switch statements are a common way to handle different cases in a program, but they can quickly become unwieldy and difficult to maintain as the number of cases increases. In this blog post, we’ll take a look at how to refactor and remove switch statements in C# to make your code more readable and maintainable.

First, let’s take a look at a simple example of a switch statement:

switch (shapeType)
{
    case "circle":
        DrawCircle();
        break;
    case "square":
        DrawSquare();
        break;
    case "triangle":
        DrawTriangle();
        break;
    default:
        throw new ArgumentException("Invalid shape type");
}

In this example, we have a switch statement that takes a string shapeType and calls the appropriate method based on its value. As the number of cases increases, this switch statement can become difficult to read and maintain.

One way to refactor this switch statement is to use polymorphism. We can create a base class Shape and then create subclasses for each shape type (Circle, Square, Triangle) that implement a Draw method.

abstract class Shape
{
    public abstract void Draw();
}

class Circle : Shape
{
    public override void Draw()
    {
        // code to draw a circle
    }
}

class Square : Shape
{
    public override void Draw()
    {
        // code to draw a square
    }
}

class Triangle : Shape
{
    public override void Draw()
    {
        // code to draw a triangle
    }
}

Now we can use a factory pattern to create the appropriate shape object based on the shapeType string and call the Draw method.

class ShapeFactory
{
    public static Shape GetShape(string shapeType)
    {
        switch (shapeType)
        {
            case "circle":
                return new Circle();
            case "square":
                return new Square();
            case "triangle":
                return new Triangle();
            default:
                throw new ArgumentException("Invalid shape type");
        }
    }
}

Shape shape = ShapeFactory.GetShape(shapeType);
shape.Draw();

This approach makes the code more readable, as the logic for handling different cases is separated from the logic for drawing the shapes. Additionally, it makes it easy to add new shape types without having to modify the existing switch statement.

Another way to remove switch statements is to use a Dictionary<string, Action> or Dictionary<string, Func<T>> where T is the return type of the function.

Dictionary<string, Action> shapes = new Dictionary<string, Action>
{
    { "circle", DrawCircle },
    { "square", DrawSquare },
    { "triangle", DrawTriangle }
};
shapes[shapeType]();

This way, you can remove the switch statement, which is much more readable and maintainable.

In conclusion, switch statements can quickly become unwieldy and difficult to maintain as the number of cases increases. By using polymorphism and the factory pattern, or using a Dictionary