Here you go - a C# 3 version amenable to binary-search on a sub-
property; actually it should work in C# 2 given a few minor changes,
but anonymous methods aren't as appealing as lambdas, and the
extension methods and improved type inference really help us here...

using System;
using System.Collections.Generic;

class Racer
{
   public string Car { get; set; }
}
static class Program
{
   static void Main(string[] args)
   {
       List<Racer> racers = new List<Racer>();
       Random rand = new Random(123456);
       for (int i = 0; i < 10000; i++)
       { // invent some random data
           racers.Add(new Racer { Car = rand.Next().ToString() });
       }
       // add some known data to look for and sort
       racers.Add(new Racer { Car = "12345" });
       racers.Sort(r => r.Car);

       int index = racers.BinarySearch(r => r.Car, "12345");
   }
}
public static class ListExt
{
   public static void Sort<TSource, TValue>(this List<TSource> list,
Func<TSource, TValue> selector)
   {
       list.Sort(new SelectorComparer<TSource, TValue>(selector,
null, false));
   }
   public static int BinarySearch<TSource, TValue>(this
IList<TSource> list,
       Func<TSource, TValue> selector, TValue value)
   {
       return BinarySearch(list, 0, list.Count, selector, value,
null);
   }
   public static int BinarySearch<TSource, TValue>(this
IList<TSource> list,
       Func<TSource, TValue> selector, TValue value,
IComparer<TValue> comparer)
   {
       return BinarySearch(list, 0, list.Count, selector, value,
comparer);
   }
   public static int BinarySearch<TSource, TValue>(this
IList<TSource> list, int index, int length,
       Func<TSource, TValue> selector, TValue value)
   {
       return BinarySearch(list, index, length, selector, value,
null);
   }
   public static int BinarySearch<TSource, TValue>(this
IList<TSource> list, int index, int length,
       Func<TSource, TValue> selector, TValue value,
IComparer<TValue> comparer)
   {
       if (comparer == null)
       {
           comparer = Comparer<TValue>.Default;
       }
       int lowerBound = index;
       int upperBound = (index + length) - 1;
       while (lowerBound <= upperBound)
       {
           int compareResult;
           int testIndex = lowerBound + ((upperBound - lowerBound) >>
1);
           try
           {
               compareResult =
comparer.Compare(selector(list[testIndex]), value);
           }
           catch (Exception exception)
           {
               throw new InvalidOperationException("Comparer failed",
exception);
           }
           if (compareResult == 0)
           {
               return testIndex;
           }
           if (compareResult < 0)
           {
               lowerBound = testIndex + 1;
           }
           else
           {
               upperBound = testIndex - 1;
           }
       }
       return int.MinValue;
   }
}

/// <summary>
/// Comparer to sort elements of T based on a projection
/// </summary>
/// <typeparam name="T">Element type</typeparam>
/// <typeparam name="TKey">The projected type (usually a property)</
typeparam>
internal class SelectorComparer<T, TKey> : IComparer<T>
{
   private readonly Func<T, TKey> selector;
   private readonly IComparer<TKey> comparer;
   private readonly bool descending;

   /// <summary>
   /// Create a new comparer based on a projection
   /// </summary>
   /// <param name="selector">The projection function to apply to
obtain the key to compare</param>
   /// <param name="comparer">The comparer used to compare keys
(defaults if null)</param>
   /// <param name="descending">Should the order be considered
ascending or descending?</param>
   public SelectorComparer(
       Func<T, TKey> selector,
       IComparer<TKey> comparer,
       bool descending)
   {
       if (selector == null) throw new
ArgumentNullException("selector");
       this.selector = selector;
       this.comparer = comparer ?? Comparer<TKey>.Default;
       this.descending = descending;
   }

   int IComparer<T>.Compare(T x, T y)
   {
       return descending
           ? comparer.Compare(selector(y), selector(x))
           : comparer.Compare(selector(x), selector(y));
   }
}

I already have a list of about 200-300 items that I am doing about 100
searches on.  I am already doing a .Find on it - which works fine.  If I
were only doing 3 or 4 search, I might leave it as the time it took to sort
the list would more than nullify the advantage of the BinarySearch.

But with this many, a BinarySearch seems a pretty good way to go.  In my
list, I have a string which I am sorting and searching on with a couple of
other pieces of information that I use when I find the correct row.  I could
use a dataset (and maybe that is the better way to go) but I decided to use
a List instead.

Thanks,

Tom

Did you mean that to be a Customer variable declaration rather than
string? Note that it will still blow up in the next line if x and y are
both null.

Any IComparer<T> can represent the logic of a Comparison<T> and vice
versa. In this case you'd just need a captured variable to represent
the name.

Now, what would be nicer would be to have a Func<T,U> which could be
applied for both ordering and binary searches, using the default
comparer of U. The first part is basically what OrderBy does in LINQ
(although an IComparer<U> can also be specified).

So, there'd be (on List<T>):

public void Sort<TKey>(Func<T,TKey> keySelector)

public int BinarySearch<TKey>(TKey key,
                             Func<T,TKey keySelector)

Neither of these would be hugely hard to write, and both can reasonably
be added as extension methods. Heck, you could even make your Sort
stable if you wanted to, which would be nice in some situations.

I see no reason whatsoever to think that politics is involved here.
"API isn't quite as nice as it could be" isn't exactly a news story.

I guess "inconvenient" is a matter of opinion.  Sure, it'd be nice if  
BinarySearch took a Comparison<T> delegate rather than requiring an  
IComparer<T>.  And I'm not really sure why it doesn't (could be some  
legacy thing, or it could be that the designers didn't want people writing  
"brittle" implementations, as Ben describes it).

But Marc already posted one work-around that you should feel free to use,  
and which would avoid you ever having to write another "inconvenient  
class" again.  Just use his class where you need an IComparer<T> for  
specific properties.

While I understand your disappointment that the BinarySearch() method  
doesn't work with a Comparison<T>, I'm confused by your other comments:

What is "it" here?  Are you talking about the IComparer<T> class you  
posted?  Couldn't you just do something like this:

    class ComparisonComparer<T> : Comparer<T>
    {
        private Comparison<T> _comparison;

        public Comparer(Comparison<T> comparison)
        {
            _comparison = comparison;
        }

        public int Compare(T x, T y)
        {
            return _comparison(x, y);
        }
    }

Then you could just write your code like this:

    ComparisonComparer<Customer> comparerName =
        new ComparisonComparer<Customer>(delegate(Customer x, Customer y)
            {
                string rhs = x == null ? y : x;
                return Comparer<string>.Default.Compare(name, rhs.Name);
            });

Then just use that comparer instance for sorting and search as necessary.

(Note that I've just copied and pasted the comparison you posted...at the  
very least I'd just use String.CompareTo() instead of all that business  
with Comparer<string>, etc. and you've got at least two syntax errors and  
what looks to me to be a logic error.  But hopefully the general idea is  
clear, even if the comparison itself is not :) )

Again, as with Marc's code, you write the generic class once and you never  
have to write another Comparer implementation again if you don't want to.  
Maybe I'm missing something, but I really don't think things are as bad as  
your post makes them out to be.

Pete