Mastering the Strategy Pattern in C#: A Complete Guide

Design Flexible, Extensible, and Maintainable Applications Using Strategy Pattern Techniques

Design patterns are essential tools for building maintainable, flexible, and scalable software. One of the most powerful behavioral patterns in object-oriented programming is the Strategy Pattern. In this article, we’ll explore the Strategy Pattern in C#, understand when and how to use it, and provide practical examples that you can implement in your projects.

What is the Strategy Pattern?

The Strategy Pattern is a behavioral design pattern that allows you to define a family of algorithms, encapsulate each one, and make them interchangeable. Instead of hardcoding multiple conditional statements or behaviors, you can dynamically change the behavior of a class at runtime.

In simpler terms:

“Encapsulate algorithms in separate classes and let the client choose which one to use.”

When to Use the Strategy Pattern

The Strategy Pattern is particularly useful when:

• You have multiple ways to perform a specific task.

• You want to avoid complex if-else or switch statements.

• You want to make your code open for extension but closed for modification (following the Open/Closed Principle).

Examples in real-world scenarios:

• Payment processing (Credit Card, PayPal, Cryptocurrency)

• Sorting algorithms (QuickSort, MergeSort, BubbleSort)

• Logging strategies (File, Database, Console)

Anatomy of the Strategy Pattern

The Strategy Pattern consists of three main components:

1. Strategy Interface: Declares a common interface for all supported algorithms.

2. Concrete Strategies: Implement the Strategy interface with specific algorithms.

3. Context: Maintains a reference to a Strategy object and delegates behavior execution to it.

mplementing Strategy Pattern in C#

Let’s walk through a real-world example: a Payment Processor.

Step 1: Define the Strategy Interface

public interface IPaymentStrategy
{
    void Pay(decimal amount);
}

Step 2: Create Concrete Strategies

public class CreditCardPayment : IPaymentStrategy
{
    private string _cardNumber;

    public CreditCardPayment(string cardNumber)
    {
        _cardNumber = cardNumber;
    }

    public void Pay(decimal amount)
    {
        Console.WriteLine($”Paid {amount:C} using Credit Card {_cardNumber}”);
    }
}

public class PayPalPayment : IPaymentStrategy
{
    private string _email;

    public PayPalPayment(string email)
    {
        _email = email;
    }

    public void Pay(decimal amount)
    {
        Console.WriteLine($”Paid {amount:C} using PayPal account {_email}”);
    }
}

Step 3: Implement the Context

public class PaymentProcessor
{
    private IPaymentStrategy _paymentStrategy;

    public PaymentProcessor(IPaymentStrategy paymentStrategy)
    {
        _paymentStrategy = paymentStrategy;
    }

    public void SetPaymentStrategy(IPaymentStrategy paymentStrategy)
    {
        _paymentStrategy = paymentStrategy;
    }

    public void ProcessPayment(decimal amount)
    {
        _paymentStrategy.Pay(amount);
    }
}

Step 4: Use the Strategy Pattern

class Program
{
    static void Main(string[] args)
    {
        var creditCardPayment = new CreditCardPayment("1234-5678-9876-5432");
        var paypalPayment = new PayPalPayment("user@example.com");

        var processor = new PaymentProcessor(creditCardPayment);
        processor.ProcessPayment(100); // Paid 100 using Credit Card 1234-5678-9876-5432

        processor.SetPaymentStrategy(paypalPayment);
        processor.ProcessPayment(200); // Paid 200 using PayPal account user@example.com
    }
}

Advantages of the Strategy Pattern

• Flexibility: Easily swap algorithms without modifying the client.

• Single Responsibility: Each algorithm is encapsulated in its own class.

• Open/Closed Principle: Adding a new algorithm does not require changing existing code.

Disadvantages

• Increased number of classes: Each algorithm requires a separate class.

• Complexity: Can add complexity if overused for simple tasks.

Real-World Example

Imagine an e-commerce platform where you need to implement different shipping methods: Standard Shipping, Express Shipping, and Overnight Shipping. Using the Strategy Pattern, you can create a flexible system where new shipping strategies can be added without modifying the core checkout logic.

Conclusion

The Strategy Pattern is a powerful design pattern for situations where multiple algorithms exist, and you want to dynamically select the best one at runtime. By encapsulating algorithms into separate classes and using a common interface, your code becomes cleaner, more maintainable, and easily extendable.

Using the Strategy Pattern in C# can drastically reduce your conditional logic, improve code readability, and enhance scalability in large applications.

A class in C# is a reference type, meaning it is stored on the heap, and assignments create references to the same object. Classes support inheritance, encapsulation, and polymorphism.

🔹 Ready to refactor your code with Strategy Pattern?

Which part of your current project could benefit from dynamically swapping behaviors?

👉 Full working code available at:

🔗https://sourcecode.kanaiyakatarmal.com/StrategyPattern

---

I hope you found this guide helpful and informative.

Thanks for reading!

If you enjoyed this article, feel free to share it and follow me for more practical, developer-friendly content like this.

---