¿Cómo comparar valores de tipos genéricos?

¿Cómo comparo valores de tipos genéricos?

Lo he reducido a una muestra mínima:

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

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

El error es:

El operador '> =' no se puede aplicar a operandos de tipo 'T' y 'T'.

¿¡Que demonios!? TYa se ve limitado a IComparable, e incluso cuando constreñir a los tipos de valor ( where T: struct), todavía no podemos aplicar cualquiera de los operadores <, >, <=, >=, ==o !=. (Sé que Equals()existen soluciones alternativas para ==y !=, pero no ayuda para los operadores relacionales).

Entonces, dos preguntas:

1. ¿Por qué observamos este comportamiento extraño? ¿Qué nos impide comparar los valores de los tipos genéricos que se sabe que son IComparable? ¿No frustra de alguna manera todo el propósito de las restricciones genéricas?
2. ¿Cómo resuelvo esto, o al menos lo soluciono?

(Me doy cuenta de que ya hay un puñado de preguntas relacionadas con este problema aparentemente simple, pero ninguno de los hilos da una respuesta exhaustiva o viable, así que aquí).

IComparableno sobrecarga al >=operador. Deberías usar

value.CompareTo(_minimumValue) >= 0

Problema con la sobrecarga del operador

Desafortunadamente, las interfaces no pueden contener operadores sobrecargados. Intente escribir esto en su compilador:

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

No sé por qué no permitieron esto, pero supongo que complicó la definición del lenguaje y sería difícil para los usuarios implementarlo correctamente.

O eso, o a los diseñadores no les gustó el potencial de abuso. Por ejemplo, imagina hacer una >=comparación en a class MagicMrMeow. O incluso en un class Matrix<T>. ¿Qué significa el resultado sobre los dos valores ?; ¿Especialmente cuando podría haber una ambigüedad?

La solución temporal oficial

Dado que la interfaz anterior no es legal, tenemos la IComparable<T>interfaz para solucionar el problema. No implementa operadores y expone solo un método,int CompareTo(T other);

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

El intresultado es en realidad un tri-bit, o un tri-nary (similar a a Boolean, pero con tres estados). Esta tabla explica el significado de los resultados:

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.

Usando la solución alternativa

Para hacer el equivalente de value >= _minimumValue, debes escribir:

value.CompareTo(_minimumValue) >= 0

Si valuepuede ser nulo, la respuesta actual podría fallar. Use algo como esto en su lugar:

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

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

Cuando se trabaja con genéricos IComparable, todos los operadores menores / mayores que deben convertirse en llamadas a CompareTo. Independientemente del operador que utilice, mantenga los valores que se comparan en el mismo orden y compárelos con cero. ( x <op> ySe convierte x.CompareTo(y) <op> 0, en donde <op>es >, >=, etc.)

Además, recomendaría que la restricción genérica que use sea where T : IComparable<T>. IComparable por sí mismo significa que el objeto se puede comparar con cualquier cosa, comparar un objeto con otros del mismo tipo probablemente sea más apropiado.

En lugar de value >= _minimValueusar la Comparerclase:

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

Como han dicho otros, es necesario utilizar explícitamente el método CompareTo. La razón por la que no se pueden usar interfaces con operadores es que es posible que una clase implemente un número arbitrario de interfaces, sin una clasificación clara entre ellas. Suponga que uno intenta calcular la expresión "a = foo + 5;" cuando foo implementó seis interfaces, todas las cuales definen un operador "+" con un segundo argumento entero; ¿Qué interfaz se debe utilizar para el operador?

El hecho de que las clases puedan derivar múltiples interfaces hace que las interfaces sean muy poderosas. Desafortunadamente, a menudo obliga a uno a ser más explícito sobre lo que realmente quiere hacer.

IComparablesolo fuerza una función llamada CompareTo(). Entonces no puede aplicar ninguno de los operadores que ha mencionado

Pude usar la respuesta de Peter Hedburg para crear algunos métodos de extensión sobrecargados para genéricos. Tenga en cuenta que el CompareTométodo no funciona aquí, ya que el tipo Tes desconocido y no presenta esa interfaz. Dicho esto, me interesa ver alternativas.

Me gustaría haber publicado en C #, pero el convertidor de Telerik falla en este código. No estoy lo suficientemente familiarizado con C # para convertirlo manualmente de manera confiable. Si alguien quisiera hacer los honores, me complacería ver esto editado en consecuencia.

<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

--EDITAR--

Yo era capaz de limpiar esto al limitar Ta IComparable(Of T)sobre todos los métodos, según lo indicado por la OP. Tenga en cuenta que esta restricción también requiere Tque se implemente un tipo 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