Post
Ask Question

Strategy Pattern in C# with Example

Introduction

In the world of software development, the quest for cleaner, more flexible code is ever-present. One common challenge developers face is managing conditional logic effectively, especially as applications grow in complexity. Traditional approaches often involve extensive if-else statements or switch-case blocks, leading to code that is hard to read, maintain, and extend.

Enter the Strategy Pattern – a powerful design pattern that offers a solution to this problem. By encapsulating algorithms into separate classes and making them interchangeable, the Strategy Pattern provides a more elegant way to handle conditional logic. In this article, we'll delve into how you can harness the Strategy Pattern in C# to pass parameters effectively, thereby enhancing your code's flexibility and maintainability.

Understanding 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. This pattern enables you to select a particular algorithm at runtime without coupling the client code to specific implementations.

Passing Parameters in Strategy Pattern

When passing parameters in the Strategy Pattern, you want to ensure that each strategy (algorithm) receives the necessary data it needs to perform its task. Here's how you can achieve this effectively:

Step 1. Define the Strategy Interface

public interface ICalculationStrategy
{
    double Calculate(double value);
}

Step 2. Implement Concrete Strategies

public class AddStrategy : ICalculationStrategy
{
    public double Calculate(double value)
    {
        // Add custom logic here
        return value + 10;
    }
}

public class MultiplyStrategy : ICalculationStrategy
{
    public double Calculate(double value)
    {
        // Add custom logic here
        return value * 2;
    }
}

Step 3. Context Class

public class CalculationContext
{
    private ICalculationStrategy _strategy;

    public CalculationContext(ICalculationStrategy strategy)
    {
        _strategy = strategy;
    }

    public double ExecuteStrategy(double value)
    {
        return _strategy.Calculate(value);
    }

    public void ChangeStrategy(ICalculationStrategy strategy)
    {
        _strategy = strategy;
    }
}

Step 4. Client Code

class Program
{
    static void Main(string[] args)
    {
        var context = new CalculationContext(new AddStrategy());
        double result = context.ExecuteStrategy(5);
        Console.WriteLine($"Result: {result}");

        context.ChangeStrategy(new MultiplyStrategy());
        result = context.ExecuteStrategy(5);
        Console.WriteLine($"Result: {result}");

        Console.ReadLine();
    }
}

Benefits of Passing Parameters with Strategy Pattern

  1. Flexibility: By passing parameters through the strategy interface, you can easily switch algorithms at runtime without modifying client code.
  2. Decoupling: Client code is decoupled from specific algorithm implementations, promoting code maintainability and extensibility.
  3. Testability: Each strategy can be unit-tested independently, facilitating easier testing and debugging.
  4. Scalability: Adding new strategies (algorithms) is straightforward, allowing for the seamless expansion of your application's functionality.

Conclusion

Passing parameters in the Strategy Pattern offers a clean and flexible approach to managing conditional logic in C#. By following the outlined steps, you can effectively utilize this pattern to improve the readability, maintainability, and extensibility of your codebase. Whether you're building a small application or a large-scale system, incorporating the Strategy Pattern can help you write cleaner, more modular code.


Similar Articles