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

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

Para los tipos de valores predefinidos, el operador de igualdad (==) devuelve verdadero si los valores de sus operandos son iguales, de lo contrario, falso. 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). También pueden los tipos de referencia definidos por el usuario, aunque por defecto == se comporta como se describe anteriormente para los tipos de referencia predefinidos y definidos por el usuario.

Entonces, ¿por qué este fragmento de código no se compila?

bool 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 entiendo que el ==operador está predefinido para todos los tipos.

Editar: Gracias a todos. Al principio no me di cuenta de que la declaración se refería solo a los tipos de referencia. También pensé que se proporciona una comparación bit a bit para todos los tipos de valores, lo que ahora sé que no es correcto.

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

Edición 2: a través de prueba y error, aprendimos que el ==operador usará la comparación de referencia predefinida cuando use un tipo genérico sin restricciones. En realidad, el compilador utilizará el mejor método que pueda encontrar para el argumento de tipo restringido, pero no buscará más. Por ejemplo, el siguiente código siempre se 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); } }

"... por defecto == se comporta como se describe 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;
    }

Siga a la pregunta adicional: "Pero, en caso de que esté usando un tipo de referencia, ¿el operador == usaría la comparación de referencia predefinida, o usaría la versión sobrecargada del operador si un tipo definiera uno?"

Pensé 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 por favor 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 == llamado

Genérico:

Pulse cualquier tecla para continuar . . .

Seguimiento 2

Quiero señalar que cambiar mi método de comparación a

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

hace que se llame al operador == sobrecargado. Supongo que sin especificar el tipo (como un lugar ), 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.

Como han dicho otros, solo funcionará cuando T esté limitado 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 no anulables.

En lugar de llamar a Equals, es mejor usar un IComparer<T>, y si no tiene más información, EqualityComparer<T>.Defaultes 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 / lanzamiento.

En general, EqualityComparer<T>.Default.Equalsdebe hacer el trabajo con cualquier cosa que implemente IEquatable<T>, o que tenga una Equalsimplementación sensata .

Si, sin embargo, ==y Equalsse implementan de forma diferente por alguna razón, entonces mi trabajo sobre operadores genéricos debe ser útil; admite las versiones de operador de (entre otros):

• Igual (valor T1, valor T2)
• NotEqual (T valor1, T valor2)
• GreaterThan (valor T1, valor T2)
• Menos de (valor T1, valor T2)
• GreaterThanOrEqual (valor T1, valor T2)
• LessThanOrEqual (valor T1, valor T2)

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

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

En los genéricos .NET (incluido C #), la resolución de sobrecarga ocurre 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.

La compilación no puede saber que T no podría ser una estructura (tipo de valor). Entonces, debes decir que solo puede ser del tipo de referencia, creo:

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

Esto se debe a que si T podría ser un tipo de valor, podría haber casos en los x == yque estaría mal formado, en los casos en que un tipo no tiene un operador == definido. Lo mismo sucederá para esto, que es más obvio:

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

Eso también falla, porque podrías 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 se hace con la cláusula where.

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 está classrestringido Equalsen el ==operador hereda Object.Equals, mientras que el 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 de compilación.

Hasta ahora no entiendo por qué el compilador rechaza tener una comparación de operador de igualdad de tipo de valor. Sin embargo, sí sé que esto funciona:

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

Bueno, en mi caso, quería probar unitariamente el operador de igualdad. Necesitaba llamar al código bajo los operadores de igualdad sin establecer explícitamente el tipo genérico. Los consejos para EqualityComparerno fueron útiles como método EqualityComparerllamado Equals, pero no el operador de igualdad.

Así es como he conseguido que esto funcione con tipos genéricos mediante la construcción de un LINQ. Llama al 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);
}

Hay una entrada de MSDN Connect para esto aquí

La respuesta de Alex Turner comienza con:

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

Si desea asegurarse de que se llame a los operadores de su tipo personalizado, puede hacerlo mediante reflexión. Simplemente obtenga el tipo usando 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 de invocación MethodInfo y pase los objetos como parámetros.

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

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

Escribí la siguiente función mirando el último msdn. Puede comparar fácilmente dos objetos xy y:

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

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

Lo anterior funcionará porque == se atiende en caso de tipos de referencia definidos por el usuario.
En el caso de los tipos de valor, == se puede anular. En cuyo caso, "! =" También debe definirse.

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

los .Equals() funciona para mí mientras que TKeyes un tipo genérico.

public virtual TOutputDto GetOne(TKey id)
{
    var entity =
        _unitOfWork.BaseRepository
            .FindByCondition(x => 
                !x.IsDelete && 
                x.Id.Equals(id))
            .SingleOrDefault();


    // ...
}