比较两个通用值的最佳方法？

Question

I'm writing a small class which I'm gonna move around when needed like a dll, and it's gonna have different sorting algorithms in it. I want the functions to work with any lists, of any types, including objects. So it's basically like this:

class TemplateSortings<T>
{
    List<T> GNRList;

    static void SortBubble<T>()
    {
        //Do stuff with GNRList, which can be a list of any values (nums, strings, objects)
    }
}

Now the question I'm having troubles with is this - what is the best way to compare two generic values: overloading comparison operators or having the class inherit IComparable interface? What is better and why?

Answer 1

If you want it to work with any type, you probably shouldn't constrain T to types that implement IComparable , because not all types do.

A simple way to work around this is to let the caller decide how to compare the objects. You just need an extra parameter:

static void SortBubble(Func<T, T, int> comparator)
{
    ...
}

You can call comparator with 2 arguments and it will give you a negative value, 0, or a positive value indicating that the first parameter is less than, equal to, or greater than the second parameter.

As an example, you can call SortBubble with int s like this:

var sorting = new TemplateSortings<int>();
// populate the list...
sorting.SortBubble((x, y) => x.CompareTo(y)) // pass a lambda

EDIT:

If you don't want an extra parameter and want to check the type inside the method, you can do something like this:

if (typeof(IComparable<T>).IsAssignableFrom(typeof(T))) {
    // do your sorting
    // you need to cast values of type "T" to "Comparable<T>" like this
    // var castedValue = (IComparable<T>)tValue;
} else {
    throw ...
}

Answer 2

You could generalize your code so it can work with any potentially valid type T :

public static IEnumerable<T> BubbleSort(
    this IEnumerable<T> source,
    IComparer<T> comparer == null)
{
    var currentComparer = comparer ?? Comparer<T>.Default;
    //bubble sort with currentComparator 
}

Now, you can sort any T whatsoever, if:

1. T implements IComparable<T>
2. T implements legacy IComparable
3. You hand down a Comparator that knows how to compare T s

It will fail on any other scenario the moment you attempt to perform the first comparison.