Strategy Pattern VS Static Class

Question

5.00/5 (1 vote)

See more:

need someone professional help me get the difference beteen

first :

C#

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;
   }
 }

second : Implementing the strategy pattern

C#

public interface IMathOperation
{
    double PerformOperation(double A, double B);
}
// 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
}

I quoted strategy pattern from this website
http://www.c-sharpcorner.com/UploadFile/rmcochran/strategyPattern08072006095804AM/strategyPattern.aspx[^]

Posted 7-Oct-11 4:54am

EgyptianRobot

Add a Solution

Comments

[no name] 7-Oct-11 11:05am

And what questions do you have?

EgyptianRobot 7-Oct-11 12:00pm

want to know why I need to Implement Strategy Pattern in this case ?
Is the static class better ? and why ?

1 solution

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Sander Rossel · Accepted Answer · 2011-10-07T07:24:00

With the strategy pattern it is possible to change or extend the behaviour of a Class.
This sounds a bit abstract, but let's look at an example.

C#

public interface IMathOperation
{
    double PerformOperation(double A, double B);
}

class DoMath
{
    private double _A;
    private double _B;

    public DoMath(double A, double B)
    {
        _A = A;
        _B = B;
    }

    public double DoMathOperation(IMathOperation operation)
    {
        return operation.PerformOperation(_A, _B);
    }
}

The DoMath Class, simple as it may be, makes use of the IMathOperation. Now just assume that DoMath does a lot more than what it does now, but somewhere it needs to do that math operation. By passing an IMathOperation you can tell the DoMath Class that it should perform an Add or Substraction. If you would have used the statis Class this would not have been possible. Your DoMathOperation would have looked something like:

C#

public double DoMathOperation()
{
    return SimpleMathOperations.Add(_A, _B);
}

Now all this Class will ever do is Add. If the behaviour needs to change you need to break open and change your Class, which is not what you want.
Another gain you will get from the Strategy Pattern is that when, should the need arise, you can easily create new MathOperations. You now have Add, Subtract, Divide and Multiply, but maybe you'll get a NthRoot operation one day. You could easily create a new Class, Implement IMathOperation and write code for A^B (or however that looks in code...). If you now pass your new Class to the DoMathOperation Function you have changed the behaviour of the DoMath Class without having to change it.

The idea that a Class is closed for modification (you'll never have to change anything in the DoMath Class), but open for extension (you can write new IMathOperations and pass it as parameter to DoMathOperation) is called the Open-Closed Principle or OCP, one of the SOLID principles of Object Oriented Programming. More on SOLID principles here[^] and more on OCP in specific here[^].

Of course you do not need the Strategy Pattern if adding, subtracting, multiplying or dividing is the only thing that makes sense in a certain scenario. If, for example, you need to calculate the total sum of money on an order with 5 items which each cost $10 you would always use 5 * 10 or:

C#

double total = SimpleMathOperation.Multiply(orderedAmount, price);

I hope that was a bit understandable :)