Как сравнить значения универсальных типов?

Как сравнить значения универсальных типов?

Я сократил его до минимального образца:

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

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

Ошибка:

Оператор '> =' нельзя применять к операндам типа 'T' и 'T'.

Что, черт возьми !? Tуже вынужден IComparable, и даже тогда , когда ограничивает его к типам значений ( where T: struct), мы можем не применять какие - либо из операторов <, >, <=, >=, ==или !=. (Я знаю, что Equals()для ==и существуют обходные пути !=, но это не помогает для операторов отношения).

Итак, два вопроса:

1. Почему мы наблюдаем это странное поведение? Что удерживает нас от сравнения значений общих типов , которые известны как IComparable? Разве это каким-то образом не уничтожает всю цель общих ограничений?
2. Как мне решить эту проблему или, по крайней мере, обойти это?

(Я понимаю, что уже есть несколько вопросов, связанных с этой, казалось бы, простой проблемой, но ни один из потоков не дает исчерпывающий или работоспособный ответ, поэтому вот.)

IComparableне перегружает >=оператора. Вы должны использовать

value.CompareTo(_minimumValue) >= 0

Проблема с перегрузкой оператора

К сожалению, интерфейсы не могут содержать перегруженных операторов. Попробуйте ввести это в свой компилятор:

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

Я не знаю, почему они не разрешили это, но я предполагаю, что это усложняет определение языка, и пользователям будет сложно реализовать его правильно.

Либо так, либо дизайнерам не понравилась возможность злоупотреблений. Например, представьте, что вы >=сравниваете файл class MagicMrMeow. Или даже на class Matrix<T>. Что означает результат для двух значений ?; Особенно когда может быть двусмысленность?

Официальное решение

Поскольку указанный выше интерфейс не является законным, у нас есть IComparable<T>интерфейс для решения проблемы. Он не реализует операторов и предоставляет только один метод,int CompareTo(T other);

См. Http://msdn.microsoft.com/en-us/library/4d7sx9hd.aspx

В intрезультате получается трехбитовый или трехзначный (аналогично a Boolean, но с тремя состояниями). Эта таблица объясняет значение результатов:

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.

Использование обходного пути

Чтобы сделать эквивалент value >= _minimumValue, вы должны вместо этого написать:

value.CompareTo(_minimumValue) >= 0

Если valueможет быть нулевым, текущий ответ может быть неудачным. Вместо этого используйте что-то вроде этого:

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

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

При работе с универсальными шаблонами IComparable все операторы «меньше / больше» необходимо преобразовать в вызовы метода CompareTo. Какой бы оператор вы ни использовали, сохраняйте сравниваемые значения в том же порядке и сравнивайте с нулем. ( x <op> yстановится x.CompareTo(y) <op> 0, где <op>находится >, >=и т. д.)

Кроме того, я бы порекомендовал использовать общее ограничение where T : IComparable<T>. IComparable сам по себе означает, что объект можно сравнивать с чем угодно, сравнение объекта с другими объектами того же типа, вероятно, более уместно.

Вместо value >= _minimValueиспользования Comparerкласса:

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

Как заявляли другие, необходимо явно использовать метод CompareTo. Причина, по которой нельзя использовать интерфейсы с операторами, заключается в том, что класс может реализовать произвольное количество интерфейсов без четкого ранжирования между ними. Предположим, что кто-то пытался вычислить выражение «a = foo + 5;» когда foo реализовал шесть интерфейсов, каждый из которых определяет оператор "+" с целым вторым аргументом; какой интерфейс использовать для оператора?

Тот факт, что классы могут выводить несколько интерфейсов, делает интерфейсы очень мощными. К сожалению, это часто заставляет более четко указывать, что на самом деле нужно делать.

IComparableтолько принудительно вызывает функцию CompareTo(). Таким образом, вы не можете применять ни один из упомянутых вами операторов.

Я смог использовать ответ Питера Хедбурга для создания некоторых перегруженных методов расширения для дженериков. Обратите внимание, что CompareToметод здесь не работает, так как тип Tнеизвестен и не предоставляет этот интерфейс. Тем не менее, мне интересно увидеть любые альтернативы.

Я хотел бы опубликовать на C #, но конвертер Telerik не работает с этим кодом. Я недостаточно знаком с C #, чтобы надежно преобразовать его вручную. Если кто-то захочет оказать честь, я был бы рад увидеть это отредактированным соответствующим образом.

<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

--РЕДАКТИРОВАТЬ--

Я был в состоянии очистить это путем ограничения Tдля IComparable(Of T)всех методов, как указано ОП. Обратите внимание, что это ограничение также требует Tреализации типа IComparable(Of <type>).

<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