Wie vergleiche ich Werte generischer Typen?

Wie vergleiche ich Werte generischer Typen?

Ich habe es auf ein Minimum reduziert:

public class Foo<T> where T : IComparable
{
    private T _minimumValue = default(T);

    public bool IsInRange(T value) 
    {
        return (value >= _minimumValue); // <-- Error here
    }
}

Der Fehler ist:

Der Operator '> =' kann nicht auf Operanden vom Typ 'T' und 'T' angewendet werden.

Was in aller Welt!? Tist bereits eingeschränkt auf IComparable, und selbst , wenn es um Wertetypen (Zwang where T: struct), können wir immer noch nicht des Betreibers gelten <, >, <=, >=, ==oder !=. (Ich weiß, dass es Problemumgehungen Equals()für ==und gibt !=, aber es hilft den relationalen Operatoren nicht).

Also zwei Fragen:

1. Warum beobachten wir dieses seltsame Verhalten? Was hält uns davon ab , die Werte von generischen Typen zu vergleichen , die sind bekannt sein IComparable? Besiegt es nicht irgendwie den gesamten Zweck generischer Einschränkungen?
2. Wie löse ich das oder arbeite ich zumindest daran?

(Mir ist klar, dass es bereits eine Handvoll Fragen zu diesem scheinbar einfachen Problem gibt - aber keiner der Threads gibt eine erschöpfende oder praktikable Antwort, also hier.)

IComparableüberlastet den >=Bediener nicht. Du solltest benutzen

value.CompareTo(_minimumValue) >= 0

Problem mit Überlastung des Bedieners

Leider können Schnittstellen keine überladenen Operatoren enthalten. Versuchen Sie dies in Ihren Compiler einzugeben:

public interface IInequalityComaparable<T>
{
    bool operator >(T lhs, T rhs);
    bool operator >=(T lhs, T rhs);
    bool operator <(T lhs, T rhs);
    bool operator <=(T lhs, T rhs);
}

Ich weiß nicht, warum sie dies nicht zugelassen haben, aber ich vermute, dass dies die Sprachdefinition kompliziert und für Benutzer schwierig zu implementieren wäre.

Entweder das, oder die Designer mochten das Missbrauchspotential nicht. Stellen Sie sich zum Beispiel vor, Sie >=vergleichen a class MagicMrMeow. Oder sogar auf einem class Matrix<T>. Was bedeutet das Ergebnis für die beiden Werte?; Besonders wenn es eine Mehrdeutigkeit geben könnte?

Die offizielle Abhilfe

Da die obige Schnittstelle nicht legal ist, haben wir die IComparable<T>Schnittstelle, um das Problem zu umgehen. Es implementiert keine Operatoren und macht nur eine Methode verfügbar.int CompareTo(T other);

Siehe http://msdn.microsoft.com/en-us/library/4d7sx9hd.aspx

Das intErgebnis ist tatsächlich ein Tri-Bit oder ein Tri-Nary (ähnlich wie a Boolean, jedoch mit drei Zuständen). Diese Tabelle erklärt die Bedeutung der Ergebnisse:

Value              Meaning

Less than zero     This object is less than
                   the object specified by the CompareTo method.

Zero               This object is equal to the method parameter.

Greater than zero  This object is greater than the method parameter.

Workaround verwenden

Um das Äquivalent zu tun value >= _minimumValue, müssen Sie stattdessen schreiben:

value.CompareTo(_minimumValue) >= 0

Wenn valuenull sein kann, kann die aktuelle Antwort fehlschlagen. Verwenden Sie stattdessen so etwas:

Comparer<T>.Default.Compare(value, _minimumValue) >= 0

public bool IsInRange(T value) 
{
    return (value.CompareTo(_minimumValue) >= 0);
}

Bei der Arbeit mit IComparable-Generika müssen alle Operatoren, die kleiner oder größer als sind, in Aufrufe von CompareTo konvertiert werden. Welchen Operator Sie auch verwenden würden, halten Sie die verglichenen Werte in derselben Reihenfolge und vergleichen Sie sie mit Null. ( x <op> yWird x.CompareTo(y) <op> 0, in denen <op>ist >, >=usw.)

Außerdem würde ich empfehlen, dass die von Ihnen verwendete generische Einschränkung lautet where T : IComparable<T>. IComparable für sich bedeutet, dass das Objekt mit allem verglichen werden kann. Ein Vergleich eines Objekts mit anderen Objekten des gleichen Typs ist wahrscheinlich besser geeignet.

Statt value >= _minimValueVerwendung ComparerKlasse:

public bool IsInRange(T value ) {
    var result = Comparer<T>.Default.Compare(value, _minimumValue);
    if ( result >= 0 ) { return true; }
    else { return false; }
}

Wie andere angegeben haben, muss die CompareTo-Methode explizit verwendet werden. Der Grund, warum man keine Schnittstellen mit Operatoren verwenden kann, ist, dass es einer Klasse möglich ist, eine beliebige Anzahl von Schnittstellen zu implementieren, ohne dass eine eindeutige Rangfolge zwischen ihnen besteht. Angenommen, man hat versucht, den Ausdruck "a = foo + 5;" zu berechnen. wenn foo sechs Schnittstellen implementiert hat, die alle einen Operator "+" mit einem ganzzahligen zweiten Argument definieren; Welche Schnittstelle soll für den Bediener verwendet werden?

Die Tatsache, dass Klassen mehrere Schnittstellen ableiten können, macht Schnittstellen sehr leistungsfähig. Leider zwingt es einen oft dazu, genauer zu sagen, was man eigentlich tun möchte.

IComparableerzwingt nur eine aufgerufene Funktion CompareTo(). Sie können also keinen der von Ihnen genannten Operatoren anwenden

Ich konnte die Antwort von Peter Hedburg verwenden, um einige überladene Erweiterungsmethoden für Generika zu erstellen. Beachten Sie, dass die CompareToMethode hier nicht funktioniert, da der Typ Tunbekannt ist und diese Schnittstelle nicht darstellt. Trotzdem bin ich daran interessiert, Alternativen zu sehen.

Ich hätte gerne in C # gepostet, aber der Konverter von Telerik schlägt bei diesem Code fehl. Ich bin mit C # nicht vertraut genug, um es zuverlässig manuell zu konvertieren. Wenn jemand die Ehre erweisen möchte, würde ich mich freuen, wenn dies entsprechend bearbeitet wird.

<Extension>
<DebuggerStepThrough>
Public Sub RemoveDuplicates(Of T)(Instance As List(Of T))
  Instance.RemoveDuplicates(Function(X, Y) Comparer(Of T).Default.Compare(X, Y))
End Sub



<Extension>
<DebuggerStepThrough>
Public Sub RemoveDuplicates(Of T)(Instance As List(Of T), Comparison As Comparison(Of T))
  Instance.RemoveDuplicates(New List(Of Comparison(Of T)) From {Comparison})
End Sub



<Extension>
<DebuggerStepThrough>
Public Sub RemoveDuplicates(Of T)(Instance As List(Of T), Comparisons As List(Of Comparison(Of T)))
  Dim oResults As New List(Of Boolean)

  For i As Integer = 0 To Instance.Count - 1
    For j As Integer = Instance.Count - 1 To i + 1 Step -1
      oResults.Clear()

      For Each oComparison As Comparison(Of T) In Comparisons
        oResults.Add(oComparison(Instance(i), Instance(j)) = 0)
      Next oComparison

      If oResults.Any(Function(R) R) Then
        Instance.RemoveAt(j)
      End If
    Next j
  Next i
End Sub

--BEARBEITEN--

Ich konnte diese bis reinigen , indem Zwang Tzu IComparable(Of T)auf allen Methoden, wie OP angezeigt. Beachten Sie, dass diese Einschränkung erfordert Typ Tzu implementieren IComparable(Of <type>)als auch.

<Extension>
<DebuggerStepThrough>
Public Sub RemoveDuplicates(Of T As IComparable(Of T))(Instance As List(Of T))
  Instance.RemoveDuplicates(Function(X, Y) X.CompareTo(Y))
End Sub