// 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