I recently read the MSDN article by Jan Gray at:

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dndotnet/html/f
astmanagedcode.asp

... and was impressed by the analysis of the types of CLR statements,
but I've run into an interesting problem.  I have a scenario where I
could use a switch statement or abstract an interface to compare a
bunch of items by type.  This method will be call a *huge* number of
times, so I'm a bit sensitive to the relative performance (ie I'm only
going to use C#, not C++).  Basically, the options I have are similar
to the following:

//
// NOTE: This is pseudo-code and wasn't compiled
//
int   doThisByType( object compareA, object compareB ) {

  switch( typeof( compareA ) ) {
    case Int32:
       return compareInt32( compareA, compareB ) ;
       break ;
    case Int64:
       return compareInt64( compareA, compareB ) ;
       break ;
    case string:
       return compareString( compareA, compareB ) ;
       break ;
  }
}

// The only problem is that if I'm calling this method often
// for the same known type, then I'm constantly evaluating the
// switch statement. (ie paying the time for the comparison)

//
// Or, I could abstract the method like this:
//

public interface ITypeComparer
{
 int   Compare( object valueA, object valueB ) ;
}

public class Int32Comparer : ITypeComparer
{
 int   Compare( object valueA, object valueB )
 {
    Int32  valueAInt32 = (Int32)valueA ;
    Int32  valueBInt32 = (Int32)valueB ;

    if ( valueA < valueB )
      return -1 ;
    else if ( valueA == valueB )
      return 0 ;
    else
      return +1 ;
 }
}

public class Int64Comparer : ITypeComparer
{
 int   Compare( object valueA, object valueB )
 {
    Int64  valueAInt32 = (Int64)valueA ;
    Int64  valueBInt32 = (Int64)valueB ;

    if ( valueA < valueB )
      return -1 ;
    else if ( valueA == valueB )
      return 0 ;
    else
      return +1 ;
 }
}

public class StringComparer : ITypeComparer
{
 int   Compare( object valueA, object valueB )
 {
    string valueAInt32 = (string)valueA ;
    string valueBInt32 = (string)valueB ;

    return string.Compare( valueA, valueB, true ) ;
 }
}

public class Comparer {
 public static int   doThisByType( ITypeComparer comparer, object
compareA, object compareB ) {

    return comparer.Compare( compareA, compareB );
 }
}

//
// END CODE
//

But basically, I was concerned about the penalty for the interface
method invokation.  In the article mentioned above, an interface method
call is ~10x slower than a class method call.  I was wondering if the
switch statement evaluation has less than a ~10x performance hit for
under 10 conditions?  Any ideas?

Thanks,

Jim