¿No se puede aplicar el operador == a los tipos genéricos en C#?

Question

De acuerdo con la documentación del operador == en MSDN,

Para los tipos de valor predefinido, el operador igualdad (==) devuelve verdadero si los valores de sus operandos son iguales, falso en caso contrario. Para los tipos de referencia que no sean cadenas, == devuelve verdadero si sus dos operandos se refieren al mismo objeto . Para el tipo de cadena, == compara los valores de las cadenas. Los tipos de valores definidos por el usuario pueden sobrecargar el operador == (ver operador). Entonces, ¿pueden los tipos de referencia definidos por el usuario , aunque por defecto == se comporta como se describe para ambos tipos de referencia predefinidos y definidos por el usuario.

¿Por qué no se compila este fragmento de código?

void Compare<T>(T x, T y) { return x == y; } 

me sale el error operador '==' no se puede aplicar a operandos de tipo 'T' y 'T'. Me pregunto por qué, ya que, según tengo entendido, el operador == está predefinido para todos los tipos?

Edit: Gracias a todos. Al principio no me di cuenta de que la declaración era solo acerca de los tipos de referencia. También pensé que la comparación bit por bit se proporciona para todos los tipos de valores, que ahora sé que es no correctos.

Pero, en caso de que esté usando un tipo de referencia, ¿utilizaría el operador == la comparación de referencia predefinida, o usaría la versión sobrecargada del operador si un tipo lo definiera?

Editar 2: Por prueba y error, nos enteramos de que el operador == utilizará la comparación de referencia predefinida cuando utilice un tipo genérico sin restricciones. En realidad, el compilador usará el mejor método que pueda encontrar para el argumento de tipo restringido, pero no buscará más. Por ejemplo, el código de abajo siempre imprimirá true, incluso cuando Test.test<B>(new B(), new B()) se llama:

class A { public static bool operator==(A x, A y) { return true; } } 
class B : A { public static bool operator==(B x, B y) { return false; } } 
class Test { void test<T>(T a, T b) where T : A { Console.WriteLine(a == b); } } 

Answer 1

"... de forma predeterminada == se comporta como se describió anteriormente para los tipos de referencia predefinidos y definidos por el usuario."

El tipo T no es necesariamente un tipo de referencia, por lo que el compilador no puede hacer esa suposición.

Sin embargo, esto se compilará porque es más explícito:

bool Compare<T>(T x, T y) where T : class 
    { 
     return x == y; 
    } 

Seguimiento a la pregunta adicional, "Pero, en caso de que estoy usando un tipo de referencia, sería el operador del == utilizar el comparación de referencia predefinida, ¿o usaría la versión sobrecargada del operador si un tipo definiera una? "

Hubiera pensado que == en los genéricos usaría la versión sobrecargada, pero la siguiente prueba demuestra lo contrario. Interesante ... ¡Me encantaría saber por qué! Si alguien sabe, comparte.

namespace TestProject 
{ 
class Program 
{ 
    static void Main(string[] args) 
    { 
     Test a = new Test(); 
     Test b = new Test(); 

     Console.WriteLine("Inline:"); 
     bool x = a == b; 
     Console.WriteLine("Generic:"); 
     Compare<Test>(a, b); 

    } 


    static bool Compare<T>(T x, T y) where T : class 
    { 
     return x == y; 
    } 
} 

class Test 
{ 
    public static bool operator ==(Test a, Test b) 
    { 
     Console.WriteLine("Overloaded == called"); 
     return a.Equals(b); 
    } 

    public static bool operator !=(Test a, Test b) 
    { 
     Console.WriteLine("Overloaded != called"); 
     return a.Equals(b); 
    } 
    } 
} 

salida

en línea: sobrecargado == llamados

genérico:

Pulse cualquier tecla para continuar. . .

Seguimiento 2

sí quiero señalar que el cambio de mi método de comparación a

static bool Compare<T>(T x, T y) where T : Test 
    { 
     return x == y; 
    } 

== hace que el operador sobrecargado para ser llamado. Supongo que sin especificar el tipo (como donde), el compilador no puede inferir que debería usar el operador sobrecargado ... aunque creo que tendría suficiente información para tomar esa decisión, incluso sin especificar el tipo .

Answer 2

La compilación no puede saber T no podría ser una estructura (tipo de valor). Así que hay que decir que sólo puede ser del tipo de referencia que pienso:

bool Compare<T>(T x, T y) where T : class { return x == y; } 

Es porque si T podría ser un tipo de valor, puede haber casos en los que x == y estaría mal formada - en los casos en que un tipo doesn no tiene un operador == definido. Lo mismo sucederá para este que es más obvio:

void CallFoo<T>(T x) { x.foo(); } 

esto también falla, ya que podría pasar un tipo T que no tendría una función foo. C# lo obliga a asegurarse de que todos los tipos posibles siempre tengan una función foo. Eso es hecho por la cláusula where.

Answer 3

 

bool Compare(T x, T y) where T : class { return x == y; } 
 

Lo anterior funcionará porque se tiene en cuenta == en caso de tipos de referencia definidos por el usuario.
En el caso de tipos de valores, == puede anularse. En cuyo caso, "! =" También debe definirse.

Creo que esa podría ser la razón, no permite la comparación genérica con "==".

Answer 4

Parece que sin la restricción de clase:

bool Compare<T> (T x, T y) where T: class 
{ 
    return x == y; 
} 

Uno debe darse cuenta de que mientras class constreñidos Equals en el operador == hereda de Object.Equals, mientras que la de una estructura anula ValueType.Equals.

Tenga en cuenta que:

bool Compare<T> (T x, T y) where T: struct 
{ 
    return x == y; 
} 

también da el mismo error del compilador.

Todavía no entiendo por qué el compilador rechaza tener una comparación de operador de igualdad de tipo de valor.Yo sé que es un hecho, sin embargo, que esto funciona:

bool Compare<T> (T x, T y) 
{ 
    return x.Equals(y); 
} 

Answer 5

Como han dicho otros, que sólo funcionará cuando T es obligado a ser un tipo de referencia. Sin restricciones, puede comparar con nulo, pero solo nulo, y esa comparación siempre será falsa para los tipos de valores que no admiten nulos.

En lugar de llamar a igual, es mejor utilizar un IComparer<T> - y si usted no tiene más información, EqualityComparer<T>.Default es una buena opción:

public bool Compare<T>(T x, T y) 
{ 
    return EqualityComparer<T>.Default.Equals(x, y); 
} 

Aparte de cualquier otra cosa, esto evita el boxeo/fundición.

Answer 6

En general, EqualityComparer<T>.Default.Equals debería hacer el trabajo con cualquier cosa que implemente IEquatable<T>, o que tenga una implementación sensata de Equals.

Si, sin embargo, == y Equals se implementan de manera diferente por algún motivo, entonces mi trabajo en generic operators debería ser útil; que soporta el operador versiones de (entre otros):

• Equal (T value1, T valor2)
• NotEqual (T valor1, T valor2)
• GreaterThan (T valor1, T valor2)
• lessThan (valor1 T, T valor2)
• GreaterThanOrEqual (T valor1, T valor2)
• LessThanOrEqual (T valor1, T valor2)

Answer 7

hay una entrada de MSDN Connect para responder esta here

Alex Turner comienza con:

Desafortunadamente, este comportamiento es por diseño y no hay una solución fácil para permitir el uso de == con tipo parámetros que pueden contener tipos de valor .

Answer 8

Tantas respuestas, y ni una sola explica el POR QUÉ? (que Giovanni preguntó explícitamente) ...

.NET genéricos no actúan como plantillas de C++. En las plantillas C++, la resolución de sobrecarga ocurre después de que se conocen los parámetros reales de la plantilla.

En genéricos .NET (incluido C#), la resolución de sobrecarga se produce sin conocer los parámetros genéricos reales. La única información que el compilador puede usar para elegir la función a llamar proviene de restricciones de tipo en los parámetros genéricos.

Answer 9

Si desea asegurarse de que se llaman los operadores de su tipo personalizado, puede hacerlo a través de la reflexión. Simplemente obtenga el tipo utilizando su parámetro genérico y recupere el MethodInfo para el operador deseado (por ejemplo, op_Equality, op_Inequality, op_LessThan ...).

var methodInfo = typeof (T).GetMethod("op_Equality", 
          BindingFlags.Static | BindingFlags.Public);  

Luego ejecute el operador utilizando el método Invoke de MethodInfo y pase los objetos como parámetros.

var result = (bool) methodInfo.Invoke(null, new object[] { object1, object2}); 

Este invocarán su operador sobrecargado y no el definido por las restricciones aplicadas en el parámetro genérico. Puede que no sea práctico, pero podría ser útil para probar las unidades de los operadores cuando se utiliza una clase base genérica que contiene un par de pruebas.

Answer 10

Escribí la siguiente función mirando el último msdn. Se puede comparar fácilmente los dos objetos x y y:

static bool IsLessThan(T x, T y) 
{ 
    return ((IComparable)(x)).CompareTo(y) <= 0; 
} 

Answer 11

Bueno, en mi caso yo quería unidad de prueba el operador de igualdad. Necesitaba llamar al código bajo los operadores de igualdad sin establecer explícitamente el tipo genérico. Los avisos para EqualityComparer no fueron útiles como EqualityComparer método llamado Equals, pero no el operador de igualdad.

He aquí cómo esto funciona con tipos genéricos construyendo un LINQ. Se llama el código correcto para == y != operadores:

/// <summary> 
/// Gets the result of "a == b" 
/// </summary> 
public bool GetEqualityOperatorResult<T>(T a, T b) 
{ 
    // declare the parameters 
    var paramA = Expression.Parameter(typeof(T), nameof(a)); 
    var paramB = Expression.Parameter(typeof(T), nameof(b)); 
    // get equality expression for the parameters 
    var body = Expression.Equal(paramA, paramB); 
    // compile it 
    var invokeEqualityOperator = Expression.Lambda<Func<T, T, bool>>(body, paramA, paramB).Compile(); 
    // call it 
    return invokeEqualityOperator(a, b); 
} 

/// <summary> 
/// Gets the result of "a =! b" 
/// </summary> 
public bool GetInequalityOperatorResult<T>(T a, T b) 
{ 
    // declare the parameters 
    var paramA = Expression.Parameter(typeof(T), nameof(a)); 
    var paramB = Expression.Parameter(typeof(T), nameof(b)); 
    // get equality expression for the parameters 
    var body = Expression.NotEqual(paramA, paramB); 
    // compile it 
    var invokeInequalityOperator = Expression.Lambda<Func<T, T, bool>>(body, paramA, paramB).Compile(); 
    // call it 
    return invokeInequalityOperator(a, b); 
}