11,581,852 members (74,664 online)

# Strategy Pattern-C#

, 23 May 2014 CPOL 21.2K 22
 Rate this:
Explaining the strategy pattern using C#

## Introduction

Strategy pattern can be categorized as behavioral design pattern and is one of my favorite patterns just because it is simple and powerful. It can be considered in a kind of scenario where your object would perform a common action and that too selecting from various options available.

## Background

Let’s understand the widely accepted definition of strategy pattern which you can find from various resources on net. “Strategy pattern defines a family of algorithms, encapsulates each one of them and makes them interchangeable.” Confused with the definition? let’s try to break it in three parts:-

1) Family of Algorithms- The definition says that the pattern defines the family of algorithms- it means we have functionality (in these algorithms) which will do the same common thing for our object, but in different ways.

2) Encapsulate each one of them- The pattern would force you to place your algorithms in different classes (encapsulate them). Doing so would help us in selecting the appropriate algorithm for our object.

3) Make them interchangeable- The beauty with strategy pattern is we can select at run time which algorithm we should apply to our object and can replace them with one another

## Using the code

Let’s go through an example which would use the strategy pattern and would make everything clear. Suppose you have to write an application which could sort different types of objects, that means it can sort the scholar numbers of students in the university, the ticket numbers of railway passengers or even more the names of all people residing in a county.

The problem seems to be very simple and involves just one thing for all of them i.e. sorting. Now let’s try to recollect from our school days when our professors were teaching us algorithm designs. We were taught that the complexity of different sorting algorithms is a relative term- meaning it is based on the number and type of elements to be sorted. Not going into anymore algorithm science, suppose we have formulated (be it correct or wrong) that quick sort would be good for sorting names of county residents, the merge sort would be suitable for scholar numbers (ints/doubles) and heap sort would be best for sorting the railway passengers. This is the optimum scenario where we can apply the strategy pattern. We will be encapsulating all our algorithms and would select at runtime that which one we would be using. Have a look at the code below(In C# and can be applied in similar way to any oops supporting language) which would tell you how we are implementing strategy.

```class Program
{
static void Main(string[] args)
{
ISortingStrategy sortingStrategy = null;

//Sorting the countyResidents
List<string> countyResidents = new List<string>{ "ad","ac", "ax", "zw" };
sortingStrategy = GetSortingOption(ObjectToSort.CountyResidents);
sortingStrategy.Sort(countyResidents);

//Sorting student numbers

List<int> studentNumbers = new List<int>{ 123,678,543,  189};
sortingStrategy = GetSortingOption(ObjectToSort.StudentNumber);
sortingStrategy.Sort(studentNumbers);

//Sorting railway passengers
List<string> railwayPassengers = new List<string> { "A21", "Z2", "F3", "G43" };
sortingStrategy = GetSortingOption(ObjectToSort.RailwayPassengers);
sortingStrategy.Sort(railwayPassengers);

}

private static ISortingStrategy GetSortingOption(ObjectToSort objectToSort)
{
ISortingStrategy sortingStrategy = null;

switch (objectToSort)
{
case ObjectToSort.StudentNumber:
sortingStrategy = new MergeSort();
break;
case ObjectToSort.RailwayPassengers:
sortingStrategy = new HeapSort();
break;
case ObjectToSort.CountyResidents:
sortingStrategy = new QuickSort();
break;
default:
break;
}
return sortingStrategy;
}
}
```

// Enum for different types of sortings.

```public enum ObjectToSort
{
StudentNumber,
RailwayPassengers,
CountyResidents
}
```

// Interface for the sorting strategy.

```public interface ISortingStrategy
{
void Sort<T>(List<T> dataToBeSorted);
}
```

// Algorithm-Quicksort.

```public class QuickSort : ISortingStrategy
{
#region ISortingStrategy Members
public void Sort<T>(List<T> dataToBeSorted)
{
//Logic for quick sort
}
#endregion
}
```

// Algorithm-Mergesort.

```public class MergeSort : ISortingStrategy
{
#region ISortingStrategy Members
public void Sort<T>(List<T> dataToBeSorted)
{
//Logic for Merge sort
}
#endregion
}
```

// Algorithm-Heapsort.

```public class HeapSort : ISortingStrategy
{
#region ISortingStrategy Members
public void Sort<T>(List<T> dataToBeSorted)
{
//Logic for Heap sort
}
#endregion
}
```

What a beauty! Our ISortingStrategy object would decide which algorithm to call. The great thing is suppose we realize that one of our algorithm is flawed we simply need to change the sorting algorithm reference in GetSortingOption method and in doing so we need not to change anything in the client code ( i.e the Program class). We can even decide the algorithm at runtime. Suppose during the peak hours when the number of railway passengers increase we can have another customized algorithm (say HugeDataSorting) in place. Based on the number of passengers the ISortingStrategy object would keep changing the reference to HeapSort or HugeDataSorting.

## Points of Interest

Having learned strategy pattern think of applying this at places where you feel your objects needs to perform a similar action but that action has difference in the way it is being performed. Closing this with another practical example. Think of applying this pattern for a discounting system, which calculates a discount for different customers. So this system would decide at run time which discounting method to call based on type of customer.

## History

Version 1- (23/05/2014)

## About the Author

 Team Leader United States
I am a software developer by profession presently working as an Lead Software Engineer in New York City. My passion is technology. I like to learn new things every day and improve my skills in terms of technology. I feel software development can be made very interesting if we inculcate the habit of "beautiful thinking".

## Comments and Discussions

 First Prev Next
 Very helpful article Member 110714289-Sep-14 21:49 Member 11071428 9-Sep-14 21:49
 Re: Very helpful article Rahul Dhammy10-Sep-14 18:55 Rahul Dhammy 10-Sep-14 18:55
 Strategy Pattern Vs Factory Pattern Member 1054417226-May-14 23:02 Member 10544172 26-May-14 23:02
 Re: Strategy Pattern Vs Factory Pattern Rahul Dhammy26-May-14 23:24 Rahul Dhammy 26-May-14 23:24
 Hi Rajkumar In this example you may see that strategy pattern is looking like like the factory pattern, because you are creating instances of algorithms in a switch case. But the purpose of both these patterns is different. Factory pattern is a creational pattern which deals with abstracting out the object creation in the system. Whereas strategy pattern is a behavioral pattern which deals with organizing objects according to their behavior. In the above example you should focus on how these algorithms are changeable at runtime and it has encapsulated family of algorithms. Although this is very much true that I have created a kind of factory to get the instance of these algorithms. Hope that explains! Please let me know.
 Re: Strategy Pattern Vs Factory Pattern Member 1054417227-May-14 21:45 Member 10544172 27-May-14 21:45
 very well explained on the strategy pattern. Well done... dotnetbuzzzzzzz25-May-14 20:51 dotnetbuzzzzzzz 25-May-14 20:51
 Re: very well explained on the strategy pattern. Well done... Rahul Dhammy26-May-14 23:25 Rahul Dhammy 26-May-14 23:25
 Not an article Rage23-May-14 1:12 Rage 23-May-14 1:12
 Last Visit: 31-Dec-99 18:00     Last Update: 6-Jul-15 16:16 Refresh 1

General    News    Suggestion    Question    Bug    Answer    Joke    Rant    Admin

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.