//
If you're using C# 2, this is probably about as good as it gets IMO,
unless you use a custom comparer which applies a simpler predicate to
each element each time... that involves more work, but would make it
simpler to implement the next time you had to do something similar.
//

(To the OP)
Follow the below link...read a little bit, and it'll show the Predicate and
simple comparer.

You would be very well served to read:
http://ludwig-stuyck.spaces.live.com/Blog/cns!E36D9BA98FC913B3!398.entry

the article on Generics.

It is in english.

..

Find the Sort section.

almurph@altavista.com <almurph@altavista.com> wrote:

If you're using C# 2, this is probably about as good as it gets IMO,
unless you use a custom comparer which applies a simpler predicate to
each element each time... that involves more work, but would make it
simpler to implement the next time you had to do something similar.

Unfortunately I don't have the time right now to explain myself more -
if no-one else has done it later, I'll do it myself :)

Okay, this is the kind of thing I meant. I've trimmed some of the XML
comments just because they ended up wrapping. The non-generic classes
are used to help with type inference. The only use for
MiscUtil.Extensions is for projection.ThrowIfNull - you can convert
that into
if (projection==null)
{
   throw new ArgumentNullException("projection");
}

if you want.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using MiscUtil.Extensions;
using System.Collections;

namespace MiscUtil.Collections
{
   /// <summary>
   /// Non-generic class to produce instances of the generic class,
   /// optionally using type inference.
   /// </summary>
   public static class ProjectionComparer
   {
       public static ProjectionComparer<TSource, TKey>
           Create<TSource,TKey>(Func<TSource, TKey> projection)
       {
           return new ProjectionComparer<TSource, TKey>(projection);
       }

       public static ProjectionComparer<TSource, TKey>
           Create<TSource,TKey>
           (TSource ignored,
            Func<TSource, TKey> projection)
       {
           return new ProjectionComparer<TSource, TKey>(projection);
       }

   }

   /// <summary>
   /// Class generic in the source only to produce instances of the
   /// doubly generic class, optionally using type inference.
   /// </summary>
   public static class ProjectionComparer<TSource>
   {
 
       public static ProjectionComparer<TSource, TKey>
           Create<TKey>(Func<TSource, TKey> projection)
       {
           return new ProjectionComparer<TSource, TKey>(projection);
       }
   }

   public class ProjectionComparer<TSource,TKey> : IComparer<TSource>
   {
       readonly Func<TSource, TKey> projection;

       public ProjectionComparer(Func<TSource, TKey> projection)
       {
           projection.ThrowIfNull("projection");
           this.projection = projection;
       }

       public int Compare(TSource x, TSource y)
       {
           // Don't want to project from nullity
           if (x==null && y==null)
           {
               return 0;
           }
           if (x==null)
           {
               return -1;
           }
           if (y==null)
           {
               return 1;
           }
           return Comparer<TKey>.Default.Compare(projection(x),
                                                 projection(y));
       }
   }
}