Der beste Weg, um zwei generische Werte zu vergleichen?

Question

Ich schreibe eine kleine Klasse, in der ich mich bewegen werde, wenn sie benötigt wird wie eine DLL, und sie wird verschiedene Sortieralgorithmen haben. Ich möchte, dass die Funktionen mit beliebigen Listen beliebiger Typen, einschließlich Objekten, arbeiten. So ist es im Grunde wie folgt:

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) 
    } 
} 

Nun ist die Frage, die ich Probleme habe dabei ist - was ist die beste Art und Weise zwei generische Werte zu vergleichen: Überlastung Vergleichsoperatoren oder mit der Klasse IComparable-Schnittstelle erben? Was ist besser und warum?

Answer 1

Wenn Sie möchten, dass es mit einem beliebigen Typ funktioniert, sollten Sie T wahrscheinlich nicht auf Typen beschränken, die IComparable implementieren, weil nicht alle Typen dies tun.

Eine einfache Möglichkeit, um dies zu umgehen, ist es, den Anrufer entscheiden zu lassen, wie die Objekte zu vergleichen. Sie müssen nur einen zusätzlichen Parameter:

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

Sie comparator mit 2 Argumenten aufrufen kann und es wird Ihnen einen negativen Wert geben, 0 oder einen positiven Wert, der angibt, dass der erste Parameter kleiner als, gleich oder größer als der zweite Parameter.

Als Beispiel können Sie SortBubble mit int s wie folgt aufrufen:

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

EDIT:

Wenn Sie nicht über einen zusätzlichen Parameter wollen und die Art innerhalb der Methode zu überprüfen, Sie können etwas tun:

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

Sie Ihren Code verallgemeinern kann, so dass es mit jeder potentiell gültigen Typ arbeiten können T: Jetzt

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

, können Sie auch immer jede T sortieren, wenn:

1. T implementiert IComparable<T>
2. T implementiert Vermächtnis IComparable
3. Sie eine Comparator vererben, die weiß, wie T vergleichen s

Es wird in keinem anderen Szenario in dem Moment fehlschlagen, in dem Sie versuchen, den ersten Vergleich durchzuführen.