How to Refactor a Switch Statement to Polymorphism

Transform your code from rigid switch statements to flexible, maintainable polymorphic designs. Follow this step-by-step guide with practical C# examples to improve your object-oriented programming skills.

Why Switch Statements Become a Maintenance Nightmare in C#

Large switch statements in C# applications often start simple enough. They’re straightforward to implement and easy to understand initially. However, as your application grows, these switch statements can quickly become code smells that violate core object-oriented principles.

The Common Code Smell: Real-World C# Example

Consider this typical scenario in a payment processing system:

public decimal CalculateFee(PaymentMethod paymentMethod, decimal amount)
{
    switch (paymentMethod)
    {
        case PaymentMethod.CreditCard:
            return amount * 0.03m; // 3% fee
        case PaymentMethod.DebitCard:
            return amount * 0.01m; // 1% fee
        case PaymentMethod.BankTransfer:
            return amount * 0.005m + 1.0m; // 0.5% + $1 fee
        case PaymentMethod.PayPal:
            return amount * 0.035m; // 3.5% fee
        case PaymentMethod.Crypto:
            return amount * 0.02m; // 2% fee
        default:
            throw new ArgumentException("Unsupported payment method", nameof(paymentMethod));
    }
}

public enum PaymentMethod
{
    CreditCard,
    DebitCard,
    BankTransfer,
    PayPal,
    Crypto
}

This implementation creates several significant problems:

❌ Violates the Open/Closed Principle: Adding a new payment method requires modifying existing code
❌ Creates scattered logic: When payment method behavior appears in multiple switch statements, you must update each one
❌ Leads to maintenance challenges: As conditions grow, the switch statement becomes harder to read and maintain
❌ Results in duplicate code: Similar switch structures often appear throughout the codebase

“Switch statements are one of the most common code smells in object-oriented programming. They’re a clear indicator that your code might benefit from polymorphism.” – Robert C. Martin, Clean Code

The Step-by-Step Guide to Replacing Switch Statements with Polymorphism in C#

Polymorphism is a core principle of object-oriented programming that allows us to treat different types through a common interface. By refactoring switch statements to polymorphic designs, we create more flexible, maintainable code that follows SOLID principles.

Step 1: Create an Interface or Abstract Base Class in C#

First, define an interface or abstract class that represents the behavior:

public interface IPaymentMethod
{
    string Name { get; }
    decimal CalculateFee(decimal amount);
}

This interface establishes the contract that all payment methods must follow, providing a foundation for our polymorphic design.

Step 2: Implement Concrete C# Classes for Each Case

Next, create concrete implementations for each case in your original switch statement:

public class CreditCardPayment : IPaymentMethod
{
    public string Name => "Credit Card";
    
    public decimal CalculateFee(decimal amount)
    {
        return amount * 0.03m; // 3% fee
    }
}

public class DebitCardPayment : IPaymentMethod
{
    public string Name => "Debit Card";
    
    public decimal CalculateFee(decimal amount)
    {
        return amount * 0.01m; // 1% fee
    }
}

public class BankTransferPayment : IPaymentMethod
{
    public string Name => "Bank Transfer";
    
    public decimal CalculateFee(decimal amount)
    {
        return amount * 0.005m + 1.0m; // 0.5% + $1 fee
    }
}

public class PayPalPayment : IPaymentMethod
{
    public string Name => "PayPal";
    
    public decimal CalculateFee(decimal amount)
    {
        return amount * 0.035m; // 3.5% fee
    }
}

public class CryptoPayment : IPaymentMethod
{
    public string Name => "Cryptocurrency";
    
    public decimal CalculateFee(decimal amount)
    {
        return amount * 0.02m; // 2% fee
    }
}

Each class encapsulates the behavior for a specific payment method, making the code more modular and easier to maintain.

Step 3: Implement a Factory Method or Registry in C#

To manage the creation of appropriate payment method instances, implement a factory pattern:

public static class PaymentMethodFactory
{
    private static readonly Dictionary<string, IPaymentMethod> _paymentMethods = new Dictionary<string, IPaymentMethod>
    {
        { "CREDIT", new CreditCardPayment() },
        { "DEBIT", new DebitCardPayment() },
        { "BANK", new BankTransferPayment() },
        { "PAYPAL", new PayPalPayment() },
        { "CRYPTO", new CryptoPayment() }
    };

    public static IPaymentMethod GetPaymentMethod(string code)
    {
        if (_paymentMethods.TryGetValue(code.ToUpper(), out var paymentMethod))
        {
            return paymentMethod;
        }
        
        throw new ArgumentException($"Payment method '{code}' not supported", nameof(code));
    }
    
    public static IEnumerable<IPaymentMethod> GetAllPaymentMethods()
    {
        return _paymentMethods.Values;
    }
}

The factory provides a centralized mechanism for getting the right payment method implementation based on a code or identifier.

Step 4: Use the Polymorphic Design in Your C# Application

Now we can rewrite our original code to use the polymorphic design:

public decimal CalculateFee(string paymentMethodCode, decimal amount)
{
    IPaymentMethod paymentMethod = PaymentMethodFactory.GetPaymentMethod(paymentMethodCode);
    return paymentMethod.CalculateFee(amount);
}

That’s it! With just a few lines of code, we’ve transformed a complex switch statement into a clean, extensible design that respects the Open/Closed Principle.