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:
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).
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
return A - B;
// MULTILPY -----------------------------------------------
class MultiplyOperation: IMathOperation
return A * B;
// DIVIDE -----------------------------------------------
class DivideOperation: IMathOperation
return A/B;
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.
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();
case "Multiply":
m_context.Operation = new MultiplyOperation();
case "Divide":
m_context.Operation = new DivideOperation();
default:
throw new ArgumentException("Unexpected value in drop down");
this.lblResult.Text = m_context.ExecuteOperation().ToString();
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
Exploring Design Pattern for Dummies