Strategy Pattern – Damian Kaczmarzyk

The Strategy Pattern is a behavioral design pattern that enables you to define a family of algorithms, encapsulate each one as a class, and make them interchangeable. It allows the algorithm’s behavior to be selected at runtime without altering the client code that uses them.

This pattern promotes the Open/Closed Principle by allowing algorithms to be extended or modified without changing the code that depends on them.

When to Use the Strategy Pattern?

Use the Strategy Pattern when:

Multiple variations of an algorithm exist:
- If you notice several conditional branches (if, elif, else) or repeated code blocks where only the logic changes, the Strategy Pattern might be a good fit.
The algorithm can change at runtime:
- When you need the flexibility to swap algorithms dynamically without modifying the code’s structure.
Encapsulation is essential:
- It is useful when algorithms should be independent and isolated from the rest of the code.
Avoid code duplication:
- If similar algorithms are implemented across multiple classes or functions, Strategy can centralize these variations.

How to Identify the Need for the Strategy Pattern:

Frequent changes to a specific behavior.
Duplication of similar logic across different parts of the application.
Complex conditional statements that vary in functionality.

Example: Before and After Strategy Pattern

Let’s consider an example of a payment processing system for an e-commerce platform. Customers can pay using Credit Card, PayPal, or Cryptocurrency.

Before Implementing Strategy Pattern

class PaymentProcessor:
    def process_payment(self, method, amount):
        if method == “credit_card”:
            print(f”Processing credit card payment of ${amount}”)
            # Credit card processing logic here
        elif method == “paypal”:
            print(f”Processing PayPal payment of ${amount}”)
            # PayPal processing logic here
        elif method == “crypto”:
            print(f”Processing cryptocurrency payment of ${amount}”)
            # Cryptocurrency processing logic here
        else:
            raise ValueError(“Unsupported payment method”)

# Client code
processor = PaymentProcessor()
processor.process_payment(“credit_card”, 100)
processor.process_payment(“paypal”, 200)

class PaymentProcessor:

def process_payment(self, method, amount):

if method == “credit_card”:

print(f“Processing credit card payment of ${amount}”)

# Credit card processing logic here

elif method == “paypal”:

print(f“Processing PayPal payment of ${amount}”)

# PayPal processing logic here

elif method == “crypto”:

print(f“Processing cryptocurrency payment of ${amount}”)

# Cryptocurrency processing logic here

else:

raise ValueError(“Unsupported payment method”)

# Client code

processor = PaymentProcessor()

processor.process_payment(“credit_card”, 100)

processor.process_payment(“paypal”, 200)

Problems

Violation of the Open/Closed Principle:
- Adding a new payment method requires modifying the process_payment method.
Conditional Complexity:
- The if-elif chain grows as more methods are added.
Testing and Maintenance:
- Individual payment methods cannot be tested independently.

After Implementing Strategy Pattern

# Define the Strategy interface
from abc import ABC, abstractmethod

class PaymentStrategy(ABC):
    @abstractmethod
    def pay(self, amount):
        pass

# Implement concrete strategies
class CreditCardPayment(PaymentStrategy):
    def pay(self, amount):
        print(f”Processing credit card payment of ${amount}”)

class PayPalPayment(PaymentStrategy):
    def pay(self, amount):
        print(f”Processing PayPal payment of ${amount}”)

class CryptoPayment(PaymentStrategy):
    def pay(self, amount):
        print(f”Processing cryptocurrency payment of ${amount}”)

# Context class
class PaymentProcessor:
    def __init__(self, strategy: PaymentStrategy):
        self._strategy = strategy

    def set_strategy(self, strategy: PaymentStrategy):
        self._strategy = strategy

    def process_payment(self, amount):
        self._strategy.pay(amount)

# Client code
credit_card_payment = CreditCardPayment()
paypal_payment = PayPalPayment()
crypto_payment = CryptoPayment()

processor = PaymentProcessor(credit_card_payment)
processor.process_payment(100)

processor.set_strategy(paypal_payment)
processor.process_payment(200)

processor.set_strategy(crypto_payment)
processor.process_payment(300)

# Define the Strategy interface

from abc import ABC, abstractmethod

class PaymentStrategy(ABC):

@abstractmethod

def pay(self, amount):

pass

# Implement concrete strategies

class CreditCardPayment(PaymentStrategy):

def pay(self, amount):

print(f“Processing credit card payment of ${amount}”)

class PayPalPayment(PaymentStrategy):

def pay(self, amount):

print(f“Processing PayPal payment of ${amount}”)

class CryptoPayment(PaymentStrategy):

def pay(self, amount):

print(f“Processing cryptocurrency payment of ${amount}”)

# Context class

class PaymentProcessor:

def __init__(self, strategy: PaymentStrategy):

self._strategy = strategy

def set_strategy(self, strategy: PaymentStrategy):

self._strategy = strategy

def process_payment(self, amount):

self._strategy.pay(amount)

# Client code

credit_card_payment = CreditCardPayment()

paypal_payment = PayPalPayment()

crypto_payment = CryptoPayment()

processor = PaymentProcessor(credit_card_payment)

processor.process_payment(100)

processor.set_strategy(paypal_payment)

processor.process_payment(200)

processor.set_strategy(crypto_payment)

processor.process_payment(300)

Benefits of Using the Strategy Pattern

Open/Closed Principle:

Adding a new payment method, such as “Bank Transfer,” only requires creating a new strategy class without modifying the existing code.

Testability:

Each payment method can be tested independently.

Maintainability:

Conditional logic is eliminated, reducing complexity.

Flexibility:

The payment method can be changed dynamically at runtime.

Conclusion

The Strategy Pattern is a powerful way to handle varying behaviors in your application. By decoupling the behavior (algorithm) from the context, it not only makes the code more modular and testable but also prepares it for future changes. When identifying where to use it, look for redundant algorithms or conditional branches in your code. With the Strategy Pattern, you can streamline and future-proof your application!