All About Sorting in C#

Introduction

This article explains all the comparison options available in C#. We will go through IComparable<> and IComparer<> first. Then we will move to other options provided by C#.

Problem

The first question is when to use what option. Well there is lots of scope. But why do we need those? Suppose we have an Employee class as follows:  

public class Employee
{
     public string Name { get; set; }
     public double Salary { get; set; }
     public override string ToString()
     {
         return this.Name;
     }
}

If we have a collection of Employee classes and want to sort it based on Name then if we try:

var empList = new List<Employee> { new Employee() { Name = "Bubu", Salary = 5000 }, new Employee() { Name = "Arunava", Salary = 10000 } };
 empList.Sort();
 empList.ForEach(e => Console.WriteLine(e));

We will get a run-time exception. The runtime doesn't read your mind and is unable to determine what logic to use to sort the list. So, the solution provided by C# is to implement IComparable<> or IComparer<>.

Differences between IComparable<> and IComparer<>

If the requirement is to sort the employees always by one property then in this case say by Name, then we can use IComparable<>. That means:

public class Employee : IComparable<Employee>
{
     public string Name { get; set; }
     public int Salary { get; set; }
     public int CompareTo(Employee other)
     {
         return this.Name.CompareTo(other.Name);
     }

     public override string ToString()
     {
         return this.Name;
     }
}

And the main program will be:

var empList = new List<Employee> { new Employee() { Name = "Bubu", Salary = 5000 }, new Employee() { Name = "Arunava", Salary = 10000 } };
 empList.Sort();
 empList.ForEach(e => Console.WriteLine(e));

Now you will not get any exception and get your desired result. But sometimes we need to sort the collection differently, such as sort by Name and sort by Salary. Then we need to implement IComparer<>. But we need to have two different implementations as follows:

public class EmployeeSortByName : IComparer<Employee>
{
     public int Compare(Employee x, Employee y)
     {
         return x.Name.CompareTo(y.Name);
     }
}

public class EmployeeSortBySal : IComparer<Employee>
{
     public int Compare(Employee x, Employee y)
     {
         return x.Salary.CompareTo(y.Salary);
     }
}

And use it as:

var empList = new List<Employee> { new Employee() { Name = "Bubu", Salary = 10000 }, new Employee() { Name = "Arunava", Salary = 5000 } };
 empList.Sort(new EmployeeSortBySal()); or empList.Sort(new EmployeeSortByName());
 empList.ForEach(e => Console.WriteLine(e));

This is another problem since we need to create multiple compare classes for different sorting.

Easier way

There is a better solution provided by C#, that is to use a Comparison<T> delegate. It is simple to use and see the power of it. It just removes all the code and reduces it to this:

empList.Sort((x,y)=>x.Name.CompareTo(y.Name));

Or:

empList.Sort((x,y)=>x.Salary.CompareTo(y.Salary));

If you want to order it by ascending or descending, you can use the OrderBy() extension as follows: 

var eres=empList.OrderBy(x=>x.Name).ToList();
 eres.ForEach(e => Console.WriteLine(e));

Or:

var eres=empList.OrderBy(x=>x.Salary).ToList();
 eres.ForEach(e => Console.WriteLine(e));

Happy coding.