Reader Level:
ARTICLE

Introduction to the GOF Strategy Pattern in C#

Posted by Matthew Cochran Articles | Design & Architecture August 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.
  • 0
  • 0
  • 45123
Download Files:
 

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

Article Extensions
Contents added by Mohammed Mostafa on Oct 07, 2011
I'm new to design pattern and wonder what's the disadvantages of the following code

static class SimpleMathOperations
{
public static double add(double a, double b)
{
return a + b;
}

public static double subtract(double a, double b)
{
return a - b;
}

public static double multiply(double a, double b)
{
return a * b;
}

public static double divide(double a, double b)
{
return a / b;
}
}

what can I get more with strategy pattern ?!?!?!?!?!?!?!?!?!

thanks for your simple example 
and thanks for your reply in advance
Contents added by Balan Sinniah on May 07, 2011
Hi Mathew,
It's a great article. Thanks for the posting. However, I am wondering if this strategy pattern can be modified to get rid of the switch case statement.

Thanks

regards,
Balan Sinniah
COMMENT USING

Trending up