Scroll To Top
Reader Level:
Article
Design Patterns & Practices

Introduction to the GOF Strategy Pattern in C#

By Matthew Cochran on Aug 08, 2006
For this article, we’ll be building an exciting calculation engine that does remarkable things like adding, subtracting, multiplying and dividing through implementation of the strategy pattern.

Part I. Strategy Pattern Overview

The Strategy Pattern is a GOF (Gang of Four) behavioral pattern where the intent is to "...define a family of algorithms, encapsulate each one, and make them interchangeable". ("Design Patterns" -- Gamma, Help, Johnson, Vlissides)

There are three  main parts to any strategy:

  1. Strategy: the interface that defines how the algorithm will be called.
  2. Concrete Strategy: the implementation of the strategy.
  3. Context: the object holding the Concrete Strategy.

The strategy pattern is an alternative for using subclasses to implement different functionality and actually allows us to plug in new strategies on-the-fly (which is a VERY powerful capability).

Part II. Implementation: an Abstract Math Operator.

For this article, we'll be building an exciting calculation engine that does remarkable things like adding, subtracting, multiplying and dividing through implementation of the strategy pattern. (Are you salivating yet?)

First, we'll define the strategy for performing an operation on two doubles.

public interface IMathOperation

{

    double PerformOperation(double A, double B);

} 

Next, we'll make four concrete implementations of our interface to add, subtract, multiply and divide.

// ADD -----------------------------------------------

class AddOperation: IMathOperation

{

    #region IMathOperation Members

 

    public double PerformOperation(double A, double B)

    {

        return A + B;

    }

 

    #endregion

}

 

// Subtract -----------------------------------------------

class SubtractOperation: IMathOperation

{

    #region IMathOperation Members

 

    public double PerformOperation(double A, double B)

    {

        return A - B;

    }

 

    #endregion

}

 

// MULTILPY -----------------------------------------------

class MultiplyOperation: IMathOperation

{

    #region IMathOperation Members

 

    public double PerformOperation(double A, double B)

    {

        return A * B;

    }

 

    #endregion

}

 

// DIVIDE -----------------------------------------------

class DivideOperation: IMathOperation

{

    #region IMathOperation Members

 

    public double PerformOperation(double A, double B)

    {

        return A/B;

    }

 

    #endregion

} 

And finally, we'll define our context, or the object utilizing the strategy. This object will contain two doubles and a reference to our strategy.  The strategy will be utilized through a method called "ExecuteOperation()" which will pass the request to the algorithm implemented in the IMathOperation interface.

class MathOperationContext

{

    public MathOperationContext()

    {

        m_a = m_b = 0;

        m_operation = new AddOperation();

    }

 

    private double m_a, m_b;

    private IMathOperation m_operation;

 

    public double A

    {

        get { return m_a; }

        set { m_a = value; }

    }

 

    public double B

    {

        get { return m_b; }

        set { m_b = value; }

    }

 

    public IMathOperation Operation

    {

        get { return m_operation; }

        set { m_operation = value; }

    }

 

    public double ExecuteOperation()

    {

        return m_operation.PerformOperation(m_a, m_b);

    } 

} 

And that is pretty much it. The strategy pattern one of the simpler patterns to understand and packs a tremendous amount of punch.

Part III. Implementation.

Implementation is fairly straight forward. We'll declare a MathOperationContext object for our application:

private MathOperationContext m_context = new MathOperationContext();

 

Next, when a button is clicked, we'll set the context values and set the strategy, call the method that utilizes the strategy and return the results. Notice that we are changing the strategy "on-the-fly" and we don't have to instantiate a new MathOperationContext for each type of operation we want to perform.  We could streamline our code by making each strategy object a singleton, but to keep things simple for this article, we'll just instantiate new ones each time.

 

private void btnExecute_Click(object sender, EventArgs e)

{

    m_context.A = Convert.ToDouble(txtA.Text);

    m_context.B = Convert.ToDouble(txtB.Text);

 

    switch (this.cbOperation.SelectedItem as string)

    {

        case "Add":

            m_context.Operation = new AddOperation();

            break;

        case "Subtract":

            m_context.Operation = new SubtractOperation();

            break;

        case "Multiply":

            m_context.Operation = new MultiplyOperation();

            break;

        case "Divide":

            m_context.Operation = new DivideOperation();

            break;

        default:

            throw new ArgumentException("Unexpected value in drop down");

    }

 

    this.lblResult.Text = m_context.ExecuteOperation().ToString();

}

Part VI. (There is no Part VI -- We are done already).

Well, it's a short article, but I hope it clarifies the strategy pattern and you can see what a powerful tool it is to have in your arsenal.

Until next time,

Happy coding