After reading this post from Steven Smith I thought I should write something about it.
Sorting a generic List<T> is pretty straightforward if you know how to do it. With C# 2.0, anonymous methods come at hand, as well as the little known Comparison<T> delegate (check out this post for more information about this class as well as other useful classes new to C# 2.0).
Ok, let's suppose we have a product class (let me save some space by using C# 3.0 syntax).
class Product
{
public int ProductID { get; set; }
public string ProductName { get; set; }
public decimal UnitPrice { get; set; }
}
When we have a list of products we may want to sort it on the ProductName property before displaying it to the user. This can be accomplished with the Sort method of the List<T> class, which defines several overloads. The most handy in this case is the Sort(Comparison<Product>) method and the result is easily achieved with a couple lines of code.
List<Product> products = new List<Product>();
products.Sort(delegate(Product p1, Product p2)
{
return p1.ProductName.CompareTo(p2.ProductName);
});
So far so good, but what if we need to sort our list in several places during the execution of our program? Do we have to write that code each time? Actually no, since we can use the parameterless Sort() method of our list class. What this method does is use the "default comparer" to sort the list. So what's this default comparer? It's the comparer that's automatically created if we implement the IComparable<T> interface. This way we can centralize the sorting logic into our class, and just call the parameterless Sort() method on it whenever we need it sorted on the ProductName property.
public class Product : IComparable<Product>
{
[...]
public int CompareTo(Product other)
{
return ProductName.CompareTo(other.ProductName);
}
}
Ok, now what if we want to be able to sort it on the other two properties, ProductID and UnitPrice? Do we have to write an anonymous method each time as we did in the beginning? Of course no, since there's a useful trick which prevents us from needing to do that. We can define two static Comparer<Product> properties in our product class, and supply them as parameters to the Sort(Comparer<T>) method of our list whenever we need it sorted on something which is not the default sorting logic.
public class Product : IComparable<Product>
{
[...]
public static Comparison<Product> PriceComparison =
delegate(Product p1, Product p2)
{
return p1.Price.CompareTo(p2.Price);
};
public static Comparison<Product> IDComparison =
delegate(Product p1, Product p2)
{
return p1.ProductID.CompareTo(p2.ProductID);
};
[...]
}
Since they are static they can be used simply like so: products.Sort(Product.PriceComparison) or products.Sort(Product.IDComparison), which will respectively sort the list by price and id.
Below is the full code of the Product class.
public class Product : IComparable<Product>
{
private int id;
private string prodName;
private decimal price;
public static Comparison<Product> PriceComparison = delegate(Product p1, Product p2)
{
return p1.price.CompareTo(p2.price);
};
public static Comparison<Product> IDComparison = delegate(Product p1, Product p2)
{
return p1.id.CompareTo(p2.id);
};
public int ProductID
{
get { return id; }
set { id = value; }
}
public string ProductName
{
get { return prodName; }
set { prodName = value; }
}
public decimal UnitPrice
{
get { return price; }
set { price = value; }
}
public Product(int id, string prodName, decimal price)
{
this.id = id;
this.prodName = prodName;
this.price = price;
}
#region IComparable<Product> Members
public int CompareTo(Product other)
{
return ProductName.CompareTo(other.ProductName);
}
#endregion
public override string ToString()
{
return string.Format("Id: {0} Name: {1} Price: {2}", id, prodName, price);
}
}
