TComparer - Sort a List

Download source code - 16.4 KB

Introduction

If you're still stuck in the ancient world of .NET 2.0 where LINQ and all its conveniences are not born, sorting a strongly typed list can be quite inconvenient. It will require you to:

perform a messy delegate(object a, object b){... Comparer<T>.Default.Compare() ...} every time you want to sort, or
write a specific comparer for each property of your custom objects

which can be very time-consuming and inefficient.

Using this TComparer class, you can move all those delegate methods into one reusable method, which allows you to sort all your objects by whatever property you want in a single line of code.

Using the code

Before we start, we need System.Collections.Generic to allow us to use List<T> and System.Reflection to provide us with our custom objects' PropertyInfo:

using System;
using System.Collections.Generic;   // provides List<T> and Comparer<T>
using System.Globalization;         // provides method to capitalize first char of a word
using System.Reflection;            // provides PropertyInfo
using System.Runtime.Serialization; // provides SerializationInfo for our custom Exception

To make things more convenient, we create our own enum for sorting order, so we don't rely on a specific ASP control's sort direction enum like System.Web.UI.WebControls.SortDirection etc:

public class SortTDirection
{
    public enum Direction
    {
        Ascending = 0,
        Descending = 1
    }
}

And for better error-handling, we can create our own custom Exception handler (this is optional):

public class PropertyNotFoundException : Exception
{
    public PropertyNotFoundException()
        : base() { }
    public PropertyNotFoundException(string message)
        : base(message) { }
    public PropertyNotFoundException(string message, Exception innerException)
        : base(message, innerException) { }
    public PropertyNotFoundException(SerializationInfo info, StreamingContext context)
        : base(info, context) { }
}

Now this is the interesting bit; TComparer:

public class TComparer<T> : Comparer<T>
{
    ...
}

The reason why we inherit Comparer<T> is because we want to still be able to use Comparer<T>.Default.

Now, to allow our TComparer to perform its sorting, we need to specify three things:

the type of T
the property we want to sort by
the sort direction

public class TComparer<T> : Comparer<T>
{
    private Type _obj;
    private PropertyInfo _property;
    private SortTDirection.Direction _direction;
    ...
}

Let's start with initializing these three variables:

public class TComparer<T> : Comparer<T>
{
    private Type _obj;
    private PropertyInfo _property;
    private SortTDirection.Direction _direction;

    /* new block */
    public TComparer()
    {
        _obj = typeof(T); // we don't care what T is

        // get T's properties
        PropertyInfo[] properties = _obj.GetProperties();
        if (properties.Length > 0)
            _property = properties[0];
        else
            throw new InvalidOperationException(
                String.Format("{0} does not have any property", _obj.Name));

        _direction = SortTDirection.Direction.Ascending;
    }
    /* end of new block */
    ...
}

An assumption we can make: the object to be sorted using TComparer will always have a property; otherwise, you don't have to worry about sorting by property.

You can just specify Comparer<T>.Default as a parameter, or simply leave it blank:

List<T>.Sort(Comparer<T>.Default)
// Or if you want to TComparer to handle the job:
List<T>.Sort(TComparer<T>.Default)
// remember that TComparer inherits Comparer<T>

or:

List<T>.Sort()

Then we need another default constructor which accepts two parameters and sets the property and sort direction:

public class TComparer<T> : Comparer<T>
{
    private Type _obj;
    private PropertyInfo _property;
    private SortTDirection.Direction _direction;

    public TComparer()
    {
        _obj = typeof(T); // we don't care what T is

        // get T's properties
        PropertyInfo[] properties = _obj.GetProperties();
        if (properties.Length > 0)
            _property = properties[0];
        else
            throw new Exception(String.Format(
              "{0} does not have any property", _obj.Name));

        _direction = SortTDirection.Direction.Ascending;
    }
    /* new block */
    public TComparer(string strPropertyName, 
                     SortTDirection.Direction direction)
        : this()
    {
        PropertyInfo p = _obj.GetProperty(strPropertyName);
        if (p != null)
            _property = p;
        else
            throw new PropertyNotFoundException(String.Format(
                "Property {0} does not belong to {1}", 
                strPropertyName, _obj.Name));

        _direction = direction;
    }
    // or if you like to pass a PropertyInfo instead:
    public TComparer(PropertyInfo prop, SortTDirection.Direction direction)
        : this()
    {
        // Set property
        if (prop != null)
            _property = prop;
        else
            throw new PropertyNotFoundException(
                String.Format("The specified PropertyInfo " + 
                              "does not belong to {0}", _obj.Name));
        // Set direction
        _direction = direction;
    }
    /* end of new block */
    ...
}

Here, I prefer having a string as the property parameter (hence, the second default constructor) because it is more convenient to use on the front-end. Of course, passing a string is more insecure, and will require us to perform validation to make sure it is a property of T.

Now, as a mandatory rule of inheriting Comparer<T>, we are required to override the Compare() method. This is where we compare two objects based on which property and in what sort direction we set earlier:

public class TComparer<T> : Comparer<T>
{
    private Type _obj;
    private PropertyInfo _property;
    private SortTDirection.Direction _direction;

    public TComparer()
    {
        _obj = typeof(T); // we don't care what T is

        // get T's properties
        PropertyInfo[] properties = _obj.GetProperties();
        if (properties.Length > 0)
            _property = properties[0];
        else
            throw new Exception(String.Format(
              "{0} does not have any property", _obj.Name));

        _direction = SortTDirection.Direction.Ascending;
    }
    public TComparer(string strPropertyName, 
                     SortTDirection.Direction direction)
    : this()
    {
        PropertyInfo p = _obj.GetProperty(strPropertyName);
        if (p != null)
            _property = p;
        else
            throw new PropertyNotFoundException(String.Format(
                "Property {0} does not belong to {1}", strPropertyName, _obj.Name));

        _direction = direction;
    }
    public TComparer(PropertyInfo prop, SortTDirection.Direction direction)
        : this()
    {
        // Set property
        if (prop != null)
            _property = prop;
        else
            throw new PropertyNotFoundException(
                String.Format("The specified PropertyInfo " + 
                              "does not belong to {0}", _obj.Name));
        // Set direction
        _direction = direction;
    }

    /* new block */
    #region Comparer<T> implementations
    public override int Compare(T a, T b)
    {
        int compareValue = 0;

        // Get the value of property _property in 'a'
        object valA = _property.GetValue(a, null);
        // Get the value of property _property in 'b'
        object valB = _property.GetValue(b, null);

        if (_property.PropertyType.Equals(typeof(DateTime)))
            // DateTime objects must be compared using DateTime.Compare
            compareValue = DateTime.Compare((DateTime)valA, (DateTime)valB);
        else
            // The rest using String.Compare
            compareValue = String.Compare(valA.ToString(), valB.ToString());

        // Reverse order if sort direction is Descending
        if (this._direction == SortTDirection.Direction.Descending)
            compareValue *= -1;

        return compareValue;
    }
    #endregion
    /* end of new block */
    ...
}

Now our TComparer() is ready for use.

To make it more convenient, we can add a static helper method to allow us to use TComparer without having to call new TComparer<T>(...) all the time:

public class TComparer<T> : Comparer<T>
{
    private Type _obj;
    private PropertyInfo _property;
    private SortTDirection.Direction _direction;

    public TComparer()
    {
        _obj = typeof(T); // we don't care what T is

        // get T's properties
        PropertyInfo[] properties = _obj.GetProperties();
        if (properties.Length > 0)
            _property = properties[0];
        else
            throw new Exception(String.Format(
              "{0} does not have any property", _obj.Name));

        _direction = SortTDirection.Direction.Ascending;
    }
    public TComparer(string strPropertyName, 
                     SortTDirection.Direction direction)
        : this()
    {
        PropertyInfo p = _obj.GetProperty(strPropertyName);
        if (p != null)
            _property = p;
        else
            throw new PropertyNotFoundException(String.Format(
                "Property {0} does not belong to {1}", 
                strPropertyName, _obj.Name));

        _direction = direction;
    }
    public TComparer(PropertyInfo prop, 
                     SortTDirection.Direction direction)
        : this()
    {
        // Set property
        if (prop != null)
            _property = prop;
        else
            throw new PropertyNotFoundException(
                String.Format("The specified PropertyInfo " + 
                              "does not belong to {0}", _obj.Name));
        // Set direction
        _direction = direction;
    }

    #region Comparer<T> implementations
    public override int Compare(T a, T b)
    {
        int compareValue = 0;

        // Get the value of property _property in 'a' 
        object valA = _property.GetValue(a, null);
        // Get the value of property _property in 'b'
        object valB = _property.GetValue(b, null);

        if (_property.PropertyType.Equals(typeof(DateTime)))
            // DateTime objects must be compared using DateTime.Compare
            compareValue = DateTime.Compare((DateTime)valA, (DateTime)valB);
        else
            // The rest using String.Compare
            compareValue = String.Compare(valA.ToString(), valB.ToString());

        // Reverse order if sort direction is Descending
        if (this._direction == SortTDirection.Direction.Descending)
            compareValue *= -1;

        return compareValue;
    }
    #endregion
    
    /* new block */
    #region Static helpers
    // pass string as parameter
    public static TComparer<T> SortBy(string strPropertyName, 
                  SortTDirection.Direction direction)
    {
        return new TComparer<T>(strPropertyName, direction);
    }
    // pass PropertyInfo as parameter
    public static TComparer<T> SortBy(PropertyInfo prop, 
                  SortTDirection.Direction direction)
    {
        return new TComparer<T>(prop, direction);
    }
    #endregion
    /* end of new block */
}

Now, let's use our TComparer in an example.

Say we have a sortable object User:

public class User : IComparable
{
    #region Properties
    private int _userID;
    public int UserID
    {
        get { return _userID; }
        set { _userID = value; }
    }

    private string _firstName;
    public string FirstName
    {
        get { return _firstName; }
        set { _firstName = value; }
    }

    private string _lastName;
    public string LastName
    {
        get { return _lastName; }
        set { _lastName = value; }
    }

    private DateTime _DateOfBirth;
    public DateTime DateOfBirth
    {
        get { return _DateOfBirth; }
        set { _DateOfBirth = value; }
    }
    #endregion

    public User()
    {
    }
    public User(object[] values)
        : this()
    {
        UserID = Convert.ToInt32(values[0]);
        FirstName = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(
                    values[1].ToString().Trim());
        LastName = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(
                   values[2].ToString().Trim());
        DateOfBirth = Convert.ToDateTime(values[3]);
    }

    // Default sort
    #region IComparable implementations
    public int CompareTo(object obj)
    {
        return CompareTo((User)obj);
    }
    public int CompareTo(User userObj)
    {
        return TComparer<User>.SortBy("UserID", 
           SortTDirection.Direction.Ascending).Compare(this, userObj);
    }
    #endregion

    ...
}

We use our TComparer to perform the default sort method for User, and here we use "UserID" as the default sort property.

To enable us to test our default constructor which accepts PropertyInfo, we can add a static Find() method to search for a particular property of User:

public class User : IComparable
{
    #region Properties
    public int UserID { get { ; } set { ; } }
    public string FirstName { get { ; } set { ; } }
    public string LastName { get { ; } set { ; } }
    public DateTime DateOfBirth { get { ; } set { ; } }
    #endregion

    public User()
    {
    }
    public User(object[] values)
        : this()
    {
        UserID = Convert.ToInt32(values[0]);
        FirstName = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(
                    values[1].ToString().Trim());
        LastName = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(
                   values[2].ToString().Trim());
        DateOfBirth = Convert.ToDateTime(values[3]);
    }

    // Default sort
    #region IComparable implementations
    public int CompareTo(object obj)
    {
        return CompareTo((User)obj);
    }
    public int CompareTo(User userObj)
    {
        return TComparer<User>.SortBy("UserID", 
          SortTDirection.Direction.Ascending).Compare(this, userObj);
    }
    #endregion

    /* new block */
    #region Static Finder
    public static PropertyInfo Find(string propertyName)
    {
        // We don't care whether the property is found or not,
        // the TComparer<T> default constructor can handle it
        return Array.Find(typeof(User).GetProperties(),
                delegate(PropertyInfo userProp)
                { return userProp.Name == propertyName; })
               as PropertyInfo;
    }
    #endregion
    /* end of new block */
}

Now let's write down a test case:

public static void Main(string[] args)
{
    List<User> users = new List<User>();
    users.Add(new User(new object[] { 4, "DavId", "teNG", new DateTime(1988, 10, 10) }));
    users.Add(new User(new object[] { 0, "teddy", "segoro", new DateTime(1986, 11, 26) }));
    users.Add(new User(new object[] { 3, "NDi", "saPUtrA", new DateTime(1999, 1, 2) }));
    users.Add(new User(new object[] { 2, "leO", "SurYAna", new DateTime(1990, 11, 7) }));
    users.Add(new User(new object[] { 5, "sTevEN", "TjipTo", new DateTime(1977, 9, 8) }));
    users.Add(new User(new object[] { 1, "bEq", "AriF", new DateTime(1984, 9, 3) }));

    // Sort by Default
    Console.WriteLine("Sort by Default:");
    users.Sort(TComparer<User>.Default);
    //users.Sort();
    foreach (User user in users)
    {
        Console.WriteLine(String.Format("{0}, {1}, {2}, {3}", 
                          user.UserID, user.FirstName, user.LastName, 
                          user.DateOfBirth.ToString("dd-MMM-yyyy")));
    }
    Console.WriteLine();

    // Sort by FirstName DESC
    Console.WriteLine("Sort by First Name DESCENDING:");
    PropertyInfo fname = User.Find("FirstName"); // sort by PropertyInfo
    users.Sort(TComparer<User>.SortBy(fname, SortTDirection.Direction.Descending));
    foreach (User user in users)
    {
        Console.WriteLine(String.Format("{0}, {1}, {2}, {3}", 
           user.UserID, user.FirstName, user.LastName, 
           user.DateOfBirth.ToString("dd-MMM-yyyy")));
    }
    Console.WriteLine();

    // Sort by LastName ASC
    Console.WriteLine("Sort by Last Name ASCENDING:");
    PropertyInfo lname = User.Find("LastName"); // sort by PropertyInfo
    users.Sort(TComparer<User>.SortBy(lname, SortTDirection.Direction.Ascending));
    foreach (User user in users)
    {
        Console.WriteLine(String.Format("{0}, {1}, {2}, {3}", 
           user.UserID, user.FirstName, user.LastName, 
           user.DateOfBirth.ToString("dd-MMM-yyyy")));
    }
    Console.WriteLine();

    // Sort by DateOfBirth DESC
    Console.WriteLine("Sort by Date of Birth DESCENDING:");
    //     sort by property name
    users.Sort(TComparer<User>.SortBy("DateOfBirth", 
               SortTDirection.Direction.Descending));
    foreach (User user in users)
    {
        Console.WriteLine(String.Format("{0}, {1}, {2}, {3}", 
           user.UserID, user.FirstName, user.LastName, 
           user.DateOfBirth.ToString("dd-MMM-yyyy")));
    }
    Console.WriteLine();

    Console.ReadLine(); // keep the window open
}

You can see our TComparer is used by passing either string or PropertyInfo :)

And here's the result:

Unable to load image

Version 1.0 (2010-11-22)

1.0: First release.

Version 1.1 (2010-11-23)

1.1: Minor update - Reduced typo and improved unclear descriptions.

Version 2.0 (2010-12-03)

Separated SortDirection to another class SortTDirection and renamed into Direction.
Added PropertyNotFoundException.
Removed redundant code and added better error handling (as suggested by Richard Deeming, *thx Richard*).
Added default constructor and static helper that accepts PropertyInfo.
Added Find() method in User class to enable us to sort by PropertyInfo instead of string for more precision (as suggested by Member 1537433 *thx..*).

License

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

About the Author

Teddy Segoro

Web Developer
TPP Bell Direct

Australia

Member

Follow on Twitter

He is a very passionate ASP.NET developer with almost 4 year experience who just found his true joy in programming recently. He is doing both web and software development during work hours and full web development after hours as his freelance work.

Used to be a hardcore online gamer - CS, WC3, DoTA, WoW, Team Fortress 2 - but has changed interest a while ago, and now he is truly enjoying web development more than anything else.

When not in front of his computer, he usually plays guitar and drum and get involved in various Catholic youth group ministry.

Article Top

Poor

Excellent

Add a reason or comment to your vote: x
Votes of 3 or less require a comment

Comments and Discussions

You must Sign In to use this message board. (secure sign-in)

Search this forum
	Profile popups Noise Layout Per page

My vote of 5

Dilip Baboo

13:01 9 Mar '11

Nice !
Sign In·View Thread·Permalink

nice - have 5

Pranay Rana

22:01 12 Jan '11

good one My blog:http://pranayamr.blogspot.com/ Programming practice Do vote my articles December 2010 Best C# article of Best ASP.NET article of Best overall artic
Sign In·View Thread·Permalink

My vote of 5

Avi Farah

1:45 27 Dec '10

Excellent
Sign In·View Thread·Permalink	5.00/5 (1 vote)

My vote of 5

prasad02

4:10 22 Dec '10

Nice 5/5
Sign In·View Thread·Permalink

My vote of 5

nodar

18:01 21 Dec '10

Nice job. Like it. Thanks.
Sign In·View Thread·Permalink

My vote of 4

Perry Bruins

2:50 15 Dec '10

Nicely done! I had the same idea some time ago, and also implemented it in a similar fashion. The only thing I did extra was add the possibility to drill down in nested classes (e.g. sort on Employee.Address.Street property). Nice article, maybe I'll consider putting my own stuff up here too. Regards, Perry
Sign In·View Thread·Permalink

Re: My vote of 4

Teddy Segoro

17:16 18 Jan '11

Thanks Perry. It would be great if you can share your code with everyone, Your idea did pop up in my head but just couldn't work it out.
Sign In·View Thread·Permalink

Re: My vote of 4

Perry Bruins

21:17 18 Jan '11

Hi, Yep, you are right. at the end of this week i'll have some time on my hands to write an article. Cheers, Perry
Sign In·View Thread·Permalink

My vote of 5

dpflovely

20:27 8 Dec '10

so,nice!
Sign In·View Thread·Permalink

My vote of 2

Member 1537433

8:43 29 Nov '10

Hardcoded strings should be avoided like the plague.
Sign In·View Thread·Permalink

Re: My vote of 2

Teddy Segoro

15:16 29 Nov '10

Which section are you referring to and do you have a better alternative? I can update the code as you suggest if it makes it better. Thanks.
Sign In·View Thread·Permalink

Re: My vote of 2

Member 1537433

8:53 30 Nov '10

Dear Teddy,

Please forgive me for not reading your introduction properly.
I missed the fact that you were aiming at 2.0 code.

My only cent would be to declare public constants for property names (especially if the classes are generated from a database model).

I.e. in the User class something like:
public const string PropertyName_DateOfBirth = "DateOfBirth";

and then
users.Sort(TComparer.SortBy(User.PropertyName_DateOfBirth, SortDirection.Descending));

Not a huge improvement but would make maintenance a wee bit easier.

/Tobs

Re: My vote of 2

Teddy Segoro

20:19 2 Dec '10

Not a problem, thanks for your input.
Sign In·View Thread·Permalink

_obj

kornman00

5:57 23 Nov '10

Since you only need to reference the Type information inside the ctor, perhaps only a local variable can be used instead of using an object member (ie, _obj)? Just my 2c . Nice article
Sign In·View Thread·Permalink

Re: _obj

Teddy Segoro

17:52 23 Nov '10

Yeah that would also do it, kornman00. I just thought there is no harm in having it global so we don't have to retype typeof(T) more than once. (maybe I'm just a lazy bum) Thanks for your input!
Sign In·View Thread·Permalink	5.00/5 (1 vote)

Re: _obj

Richard Deeming

6:26 29 Nov '10

Teddy Segoro wrote:
... so we don't have to retype typeof(T) more than once.

In that case, you could make it static and readonly:

private static readonly Type _obj = typeof(T);

Having said that, there's not much cost associated with a typeof(T) call. You'd probably be better off inlining this statement.

You're also calling GetProperties twice instead of reusing the result of the first call:

PropertyInfo[] properties = _obj.GetProperties();
if (properties.Length > 0)
    _property = typeof(T).GetProperties()[0];

This can be simplified to:

PropertyInfo[] properties = _obj.GetProperties();
if (properties.Length > 0)
    _property = properties[0];

Since the properties of a type are unlikely to change during the lifetime of an AppDomain, you could store the properties in a static readonly field to avoid paying the reflection overhead every time you create an instance of your class:

public class TComparer<T> : Comparer<T>
{
    private static readonly PropertyInfo[] _properties = typeof(T).GetProperties();
    private PropertyInfo _property;
    private SortDirection _direction;
    
    public TComparer()
    {
        if (0 == _properties.Length)
            throw new InvalidOperationException(String.Format("Type {0} does not have any properties.", typeof(T).Name));
        
        _property = _properties[0];
        _direction = SortDirection.Ascending;
    }
    ...

Finally, you should never use throw new Exception; always use a more specific exception type. Personally, I think the framework designers should have made the Exception type abstract, but it's too late for that now.

"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer

Re: _obj

Teddy Segoro

15:14 29 Nov '10

Ah yes, this:

_property = typeof(T).GetProperties()[0];

should have been:

_property = _properties[0];

Thanks a bunch.

Oh and one more thing, I would like to know a better alternative to throw new Exception.
Just put it in there because I thought it was the best alternative I had Smile | :)

Re: _obj

Richard Deeming

2:19 30 Nov '10

Teddy Segoro wrote:
I would like to know a better alternative to throw new Exception.

Throw a more specific exception type - for example, an System.InvalidOperationException or a System.Reflection.TargetException.

If you throw new Exception(...), callers have no way to differentiate between fatal and boneheaded exceptions[^] without catching all exceptions and looking at the message, which is a very bad idea.

"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer

Re: _obj

Teddy Segoro

20:16 2 Dec '10

Thanks for your input, Richard. Had a brief look at the available exceptions and I think InvalidOperationException probably fits best in handling a T that has no property.
Sign In·View Thread·Permalink

just one question

Member 3643133

16:11 22 Nov '10

Why Am I born in 1977? I am surely not that old hehehehehhehe Anyway Good Post dude keep it up
Sign In·View Thread·Permalink

A simple approach

senguptaamlan

2:08 22 Nov '10

A simple approach is also given at the following URL http://www.c-sharpcorner.com/UploadFile/dipenlama22/SortingUsingGeneric07052006081035AM/SortingUsingGeneric.aspx
Sign In·View Thread·Permalink

Re: A simple approach

Teddy Segoro

17:48 23 Nov '10

Ah, thanks senguptaamlan. I wrote this article because I couldn't find any article discussing about this through Google (maybe I didn't try hard enough). Probably should give the author of that article a credit as the first one to bring up this topic.
Sign In·View Thread·Permalink

Re: A simple approach

Serverside

4:50 3 Dec '10

Here's a List extension you can use:

public enum SortDirection { ASC, DESC }
 
public static void Sort<T>(this List<T> list, string propertyName, SortDirection sortDirection)
{
    PropertyInfo propInfo = typeof(T).GetProperty(propertyName);
    list.Sort(delegate(T a, T b)
    {
        bool asc = (sortDirection == SortDirection.ASC);
        object vA = asc ? propInfo.GetValue(a, null) : propInfo.GetValue(b, null);
        object vB = asc ? propInfo.GetValue(b, null) : propInfo.GetValue(a, null);
        return vA is IComparable ? ((IComparable)vA).CompareTo(vB) : 0;
    });
}

Usage:

List<User> users = GetUsers();
users.Sort<User>("Username", SortDirection.ASC)

---------------
www.serverside.no

Re: A simple approach

Teddy Segoro

6:27 3 Dec '10

Hey, thanks for your code Just got a little confused here, can't seem to understand which code should be in which section. So does that Sort() method stands by itself or is it meant to be part of my existing code above? And the way you use it.. hmm, can you elaborate more please
Sign In·View Thread·Permalink