Strategy Design Pattern Using C#

This pattern falls under the category of behavioral pattern and as the name suggests, it allows clients to choose an algorithm from a set of algorithms at run time.

Strategy pattern defines a family of algorithms, encapsulates each one of them and makes them interchangeable at run time within that family.

Now let’s understand what each one of them actually means.

1. Family of Algorithms: This means this pattern provides a set of algorithms using one of which at run time you can achieve the desired output.
2. Encapsulate each one of the: This pattern allows you to place your algorithms in different classes (encapsulate them).
3. Makes the algorithm interchangeable: The beauty with strategy pattern is that we can select at run time which algorithm we want to apply to our object and can also replace them with one another.

These are the three main points of Strategy pattern. I hope we are clear with the above- discussed points. So, let’s understand one real -world scenario where it can be really helpful to use.

Example

Suppose you want to go from one place to another and you want to see how much time it will take you to reach your destinations if you use different modes of transport. In this case you can implement the Strategy Pattern.

Let’s now see the UML diagram and then we will go deep into the code to see how actually it works.

Image source: Wikipedia

Clearly here we see the below things,

• An Interface called Strategy which has a method called execute () .
• Concrete Strategy classes A and B which implement that Interface.
• Lastly one Context class using which we can use different concrete strategies at run time.

As per our example, IStrategy is the interface which looks something like,

public interface IStrategy {
    string GetTravelTime(string source, string destination);
}

We have 3 Concrete Strategy classes which implement IStrategy interface and these classes can have their own logic to calculate the time.

public class CarStrategy: IStrategy {
    public string GetTravelTime(string source, string destination) {
        return "It takes 40 minutes to reach from " + source + " to " + destination + " using Car.";
    }
}
public class BikeStrategy: IStrategy {
    public string GetTravelTime(string source, string destination) {
        return "It takes 25 minutes to reach from " + source + " to " + destination + " using Bike.";
    }
}
public class BusStrategy: IStrategy {
    public string GetTravelTime(string source, string destination) {
        return "It takes 60 minutes to reach from " + source + " to " + destination + " using Bus.";
    }
}

Lastly, we have one Context class called TravelStrategy using which a client can select any strategy at run-time.

public class TravelStrategy {
    private IStrategy _strategy;
    public TravelStrategy(IStrategy chosenStrategy) {
        _strategy = chosenStrategy;
    }
    public void GetTravelTime(string source, string destination) {
        var result = _strategy.GetTravelTime(source, destination);
        Console.WriteLine(result);
    }
}

Our main program looks like:

void Main() {
    Console.WriteLine("Hello!, Please select the mode of transport to get the travel time between source and destination: \nCar \nBike \nBus");
    var userStrategy = Console.ReadLine().ToLower();
    Console.WriteLine("\nUser has selected *" + userStrategy + "* as mode of transport\n");
    Console.WriteLine("\n*****************************************************************************************************\n");
    switch (userStrategy) {
        case "car":
            new TravelStrategy(new CarStrategy()).GetTravelTime("Point A", "Point B");
            break;
        case "bike":
            new TravelStrategy(new BikeStrategy()).GetTravelTime("Point A", "Point B");
            break;
        case "bus":
            new TravelStrategy(new BusStrategy()).GetTravelTime("Point A", "Point B");
            break;
        default:
            Console.WriteLine("You have chosen an invalid mode of transport.");
            break;
    }
}

OUTPUTS

1. When user selects car as the preferred mode of transport
   
   
   
   Output
   
   
   
   
2. When user selects bike as the preferred mode of transport
   
   
   
   Output
   
   
   
   
3. When user selects bus as the preferred mode of transport
   
   
   
   Output
   
   
4. When user selects anything else as the preferred mode of transport
   
   
   
   Output
   
   

When to use this pattern?

Use this pattern when there are multiple similar classes that only differ in terms of how they execute the behavior.

Some common use cases

• Giving different permissions depending on role and department.
• Giving discount depending on different conditions/coupons/happy hours etc.
• It can be used in games, considering the surrounding conditions player can either swim (In water), trek (on mountain), jump (hurdles) or walk (on road).

Further readings:

 

Learn more about other design patterns here: Design Pattern in .NET. 

 

 

I hope you find this article helpful. Stay tuned for more … Cheers!!