Actually *using* them shouldn't be allowed, but the design is all
there - you need some way to compare two objects, without knowing
their type beforehand. In other words, you need something to ask to
compare things: IComparer<T> and Comparison<T> spring to mind.

Jon

Why not? Is this purely academic?

OK; what version of .NET do you have available? In .NET 3.5/C# 3, I
would be very tempted to look at using a lambda/delegate to specify
the property/properties - something similar to Jon's post here:
http://msmvps.com/blogs/jon.skeet/archive/2008/01/08/extension-methods-on-lamdba
-expressions-don-t-work-unfortunately.aspx

Re the fundamental ordering of values - look at IComparer<T>; as a
default, Comparer<TValue>.Default is a good bet, but it would be nice
to offer custom as an argument (see my reply to Jon's blog for an
illustration).

If you don't have .NET 3.5, then consider the approach that
IBindingListView adopts for ApplySort:
http://msdn2.microsoft.com/en-us/library/e6t44cba.aspx

It isn't quite as elegant to use, but suffices. I've posted examples
on writing sorted lists several times (to this forum), but always re-
using the standard sort functionality under the bonnet... so just add
your own "sort" implementation...

Marc

http://ludwig-stuyck.spaces.live.com/Blog/cns!E36D9BA98FC913B3!398.entry

Great C#/Generics article....in english.

And look at the ~~comments~~ of this blog entry:
http://sholliday.spaces.live.com/blog/cns!A68482B9628A842A!141.entry

http://www.dotnet2themax.com/ShowContent.aspx?ID=05c3d0c3-ac44-4a20-92d9-16cdae040bc3

A universal comparer class
by Francesco Balena

The definitive comparer enables you to sort arrays and collections of
objects of any kind.

/// <summary>
       /// A generic bubblesort method implementation
       /// Bubblesort Explanation:  http://en.wikipedia.org/wiki/Bubblesort
       /// </summary>
       /// <typeparam name="T">The object type populating the
list</typeparam>
       /// <param name="sourceList">A list of objects</param>
       /// <param name="customComparer">A custom comparer object used to
compare the list items</param>
       public static void BubbleSort<T>(IList<T> sourceList, IComparer<T>
customComparer)
       {
           try
           {
               // Ensure that no null values have been provided
               if (sourceList == null)
               {
                   throw new ArgumentNullException("sourceList",
Properties.Resources.NullParam);
               }
               else if (customComparer == null)
               {
                   throw new ArgumentNullException("customComparer",
Properties.Resources.NullParam);
               }

               for (int counter = sourceList.Count - 1; counter >= 0;
counter--)
               {
                   // The inner loop ensures that all values are
re-compared and swapped, if necessary
                   for (int index = 1; index <= counter; index++)
                   {
                       if (customComparer.Compare(sourceList[index - 1],
sourceList[index]) > 0)
                       {
                           // Create a temporary holding object and swap
the order of the items
                           T tempListItem = sourceList[index - 1];
                           sourceList[index - 1] = sourceList[index];
                           sourceList[index] = tempListItem;
                       }
                   }
               }
           }
           catch (System.Exception exception)
           {
               ExceptionHandler.HandleException(exception);
           }
       }

       /// <summary>
       /// A generic quicksort method implementation
       /// </summary>
       /// <typeparam name="T">The object type populating the
list</typeparam>
       /// <param name="sourceList">A list of objects</param>
       /// <param name="customComparer">A custom comparer object used to
compare the list items</param>
       public static void QuickSort<T>(IList<T> sourceList, IComparer<T>
customComparer)
       {
           try
           {
               // Ensure that no null values have been provided
               if (sourceList == null)
               {
                   throw new ArgumentNullException("sourceList",
Properties.Resources.NullParam);
               }
               else if (customComparer == null)
               {
                   throw new ArgumentNullException("customComparer",
Properties.Resources.NullParam);
               }

               // Call the actual quicksort algorithm
               CustomObjectListSort.PrivateQuickSort(sourceList,
customComparer, 0, sourceList.Count - 1);
           }
           catch (System.Exception exception)
           {
               ExceptionHandler.HandleException(exception);
           }
       }
       #endregion

       #region Private Methods
       /// <summary>
       /// A generic quicksort algorithm implementation
       /// Quicksort Explanation:  http://en.wikipedia.org/wiki/Quicksort
       /// </summary>
       /// <typeparam name="T">The object type populating the
list</typeparam>
       /// <param name="sourceList">A list of objects</param>
       /// <param name="customComparer">A custom comparer object used to
compare the list items</param>
       /// <param name="lowIndex">Lower index in the list</param>
       /// <param name="highIndex">Upper index in the list</param>
       private static void PrivateQuickSort<T>(IList<T> sourceList,
IComparer<T> customComparer,int lowIndex, int highIndex)
       {
           try
           {
               // Ensure that no null values have been provided
               if (sourceList == null)
               {
                   throw new ArgumentNullException("sourceList",
Properties.Resources.NullParam);
               }
               else if (customComparer == null)
               {
                   throw new ArgumentNullException("customComparer",
Properties.Resources.NullParam);
               }

               int tempLowIndex = lowIndex + 1;
               int tempHighIndex = highIndex;

               // If the lowIndex is not less than the highIndex, the sort
is complete
               if (lowIndex < highIndex)
               {
                   // Create a temporary holding object for swapping the
order of the items
                   T tempListItem = sourceList[lowIndex];

                   // Loop through list until all items
                   // between indices have been compared
                   while (tempLowIndex < tempHighIndex)
                   {
                       // Keep incrementing temp indices until appropriate
discrepancy for swap is found
                       if (customComparer.Compare(sourceList[tempLowIndex],
tempListItem) <= 0)
                       {
                           tempLowIndex++;
                       }
                       else if
(customComparer.Compare(sourceList[tempHighIndex], tempListItem) >= 0)
                       {
                           tempHighIndex--;
                       }
                       else
                       {
                           tempListItem = sourceList[tempLowIndex];
                           sourceList[tempLowIndex] =
sourceList[tempHighIndex];
                           sourceList[tempHighIndex] = tempListItem;
                       }
                   }

                   if (customComparer.Compare(sourceList[tempLowIndex],
tempListItem) < 0)
                   {
                       // If tempLow is less than lowIndex, swap the items
                       tempListItem = sourceList[tempLowIndex];
                       sourceList[tempLowIndex] = sourceList[lowIndex];
                       sourceList[lowIndex] = tempListItem;
                       tempLowIndex--;
                   }
                   else
                   {
                       // Otherwise, swap item just below tempLow with the
lowIndex
                       tempLowIndex--;
                       tempListItem = sourceList[tempLowIndex];
                       sourceList[tempLowIndex] = sourceList[lowIndex];
                       sourceList[lowIndex] = tempListItem;
                   }

                   // Recursively call the quicksort function until both
partitions
                   // (i.e. 'lowIndex' and 'highIndex' pieces of list) are
complete
                   PrivateQuickSort(sourceList, customComparer, lowIndex,
tempLowIndex);
                   PrivateQuickSort(sourceList, customComparer,
tempHighIndex, highIndex);
               }
           }
           catch (System.Exception exception)
           {
               ExceptionHandler.HandleException(exception);
           }
       }