Menu
Article Design Patterns

Crafting Strategies: A Comprehensive Guide to the Strategy Pattern in C#

Casper

Casper

• 3 min read

The Strategy Pattern is a behavioral design pattern that defines a family of algorithms, encapsulates each algorithm, and makes them interchangeable. It allows a client to choose an algorithm from a family of algorithms dynamically, without altering the client's code. This pattern promotes the use of composition over inheritance and enhances flexibility by enabling runtime algorithm changes. In this article, we will explore the Strategy Pattern in-depth, examining its structure, advantages, and providing practical examples in C#.

Understanding the Strategy Pattern

The Strategy Pattern involves the following key components:

  1. Context: The class that contains a reference to the strategy interface and maintains a reference to a concrete strategy. The context delegates the algorithm-specific behavior to the strategy.
  2. Strategy: The interface or abstract class that declares the algorithm interface. Concrete strategy classes implement this interface, providing specific algorithm implementations.
  3. ConcreteStrategy: The class that implements the Strategy interface and contains the algorithm-specific behavior. Multiple concrete strategy classes can be defined, each representing a different algorithm.

Implementation in C#

Let's delve into a simple example of the Strategy Pattern in C#. Suppose we want to implement a payment system where different payment methods (e.g., credit card, PayPal) can be used interchangeably. The Strategy Pattern can be applied to represent these payment methods and allow clients to choose a payment method dynamically.

// Step 1: Define Strategy interface
public interface IPaymentStrategy
{
    void ProcessPayment(decimal amount);
}

// Step 2: Implement ConcreteStrategy classes
public class CreditCardPayment : IPaymentStrategy
{
    private readonly string cardNumber;
    private readonly string expiryDate;
    private readonly string cvv;

    public CreditCardPayment(string cardNumber, string expiryDate, string cvv)
    {
        this.cardNumber = cardNumber;
        this.expiryDate = expiryDate;
        this.cvv = cvv;
    }

    public void ProcessPayment(decimal amount)
    {
        Console.WriteLine($"Processing credit card payment of {amount:C} with card ending in {cardNumber.Substring(cardNumber.Length - 4)}");
        // Actual payment processing logic here...
    }
}

public class PayPalPayment : IPaymentStrategy
{
    private readonly string email;

    public PayPalPayment(string email)
    {
        this.email = email;
    }

    public void ProcessPayment(decimal amount)
    {
        Console.WriteLine($"Processing PayPal payment of {amount:C} with email {email}");
        // Actual payment processing logic here...
    }
}

// Step 3: Define Context class
public class ShoppingCart
{
    private readonly IPaymentStrategy paymentStrategy;

    public ShoppingCart(IPaymentStrategy paymentStrategy)
    {
        this.paymentStrategy = paymentStrategy;
    }

    public void Checkout(decimal totalAmount)
    {
        Console.WriteLine($"Items in the cart have a total value of {totalAmount:C}");
        paymentStrategy.ProcessPayment(totalAmount);
    }
}

// Step 4: Client code
public class Client
{
    public void Run()
    {
        // Using Credit Card payment strategy
        var creditCardPayment = new CreditCardPayment("1234567890123456", "12/23", "123");
        var shoppingCartCreditCard = new ShoppingCart(creditCardPayment);
        shoppingCartCreditCard.Checkout(150.0m);

        // Using PayPal payment strategy
        var payPalPayment = new PayPalPayment("[email protected]");
        var shoppingCartPayPal = new ShoppingCart(payPalPayment);
        shoppingCartPayPal.Checkout(100.0m);
    }
}

In this example, IPaymentStrategy is the Strategy interface that declares the ProcessPayment method. CreditCardPayment and PayPalPayment are ConcreteStrategy classes that implement the IPaymentStrategy interface, providing specific payment method implementations. ShoppingCart is the Context class that contains a reference to the payment strategy and delegates the payment processing to the strategy.

Advantages of the Strategy Pattern

1. Flexibility: The Strategy Pattern allows clients to choose from a family of algorithms dynamically. Strategies can be added, removed, or replaced at runtime without modifying the client's code.

2. Encapsulation: Each strategy encapsulates its algorithm, promoting clean separation of concerns and enhancing maintainability.

3. Reuse: Strategies can be reused across different contexts, promoting code reuse and minimizing redundancy.

4. Open/Closed Principle: The pattern supports the Open/Closed Principle by allowing the addition of new strategies without modifying existing code.

Real-world Examples

1. Sorting Algorithms

In sorting algorithms, the Strategy Pattern can be applied to represent different sorting strategies, such as quicksort, mergesort, or bubblesort. The context (sorting algorithm) can dynamically switch between these strategies based on user preferences or data characteristics.

2. Compression Algorithms

In compression utilities, different compression strategies (e.g., gzip, zlib, lzma) can be implemented using the Strategy Pattern. The user can choose the desired compression strategy, and the context (compression utility) applies the selected strategy.

Conclusion

The Strategy Pattern is a powerful design pattern that promotes flexibility and enhances code maintainability by allowing the dynamic selection of algorithms. Through practical examples in C#, we have demonstrated how the Strategy Pattern can be applied to real-world scenarios, providing a blueprint for creating systems that involve interchangeable algorithms. Understanding and incorporating this pattern into your design practices can contribute to building modular, extensible, and maintainable software architectures, ensuring efficient algorithm management in your applications.

Share