O operador == não pode ser aplicado a tipos genéricos em C #?

De acordo com a documentação do ==operador no MSDN ,

Para tipos de valor predefinidos, o operador de igualdade (==) retornará true se os valores de seus operandos forem iguais, caso contrário, false. Para tipos de referência diferentes de string, == retorna true se seus dois operandos se referem ao mesmo objeto. Para o tipo de string, == compara os valores das strings. Os tipos de valores definidos pelo usuário podem sobrecarregar o operador == (consulte o operador). Os tipos de referência definidos pelo usuário também podem, embora por padrão == se comporte como descrito acima para os tipos de referência predefinidos e definidos pelo usuário.

Então, por que esse snippet de código falha na compilação?

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

Eu recebo o erro Operador '==' não pode ser aplicado a operandos do tipo 'T' e 'T' . Eu me pergunto por que, desde que eu entenda, o ==operador é predefinido para todos os tipos?

Edit: Obrigado a todos. Inicialmente, não percebi que a declaração se referia apenas a tipos de referência. Eu também pensei que a comparação bit a bit é fornecida para todos os tipos de valor, que agora sei que não estão corretos.

Mas, no caso de eu estar usando um tipo de referência, o ==operador usaria a comparação de referência predefinida ou a versão sobrecarregada do operador se um tipo o definisse?

Edit 2: Por tentativa e erro, aprendemos que o ==operador usará a comparação de referência predefinida ao usar um tipo genérico irrestrito. Na verdade, o compilador usará o melhor método possível para o argumento de tipo restrito, mas não procurará mais. Por exemplo, o código abaixo sempre será impresso true, mesmo quando Test.test<B>(new B(), new B())for chamado:

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 padrão == se comporta como descrito acima para os tipos de referência predefinidos e definidos pelo usuário."

O tipo T não é necessariamente um tipo de referência; portanto, o compilador não pode fazer essa suposição.

No entanto, isso será compilado porque é mais explícito:

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

Continue com a pergunta adicional: "Mas, caso eu esteja usando um tipo de referência, o operador == usaria a comparação de referência predefinida ou a versão sobrecarregada do operador se um tipo o definisse?"

Eu pensaria que o == no Generics usaria a versão sobrecarregada, mas o teste a seguir demonstra o contrário. Interessante ... eu adoraria saber o porquê! Se alguém souber, por favor, compartilhe.

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

Resultado

Inline: Sobrecarregado == chamado

Genérico:

Pressione qualquer tecla para continuar . . .

Acompanhamento 2

Quero ressaltar que alterar meu método de comparação para

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

faz com que o operador == sobrecarregado seja chamado. Eu acho que sem especificar o tipo (como um local ), o compilador não pode inferir que ele deve usar o operador sobrecarregado ... embora eu ache que teria informações suficientes para tomar essa decisão, mesmo sem especificar o tipo.

Como outros já disseram, ele só funcionará quando T for restrito a ser um tipo de referência. Sem restrições, você pode comparar com nulo, mas apenas nulo - e essa comparação sempre será falsa para os tipos de valores não nulos.

Em vez de chamar Igual, é melhor usar uma IComparer<T>- e se você não tiver mais informações, EqualityComparer<T>.Defaulté uma boa opção:

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

Além de qualquer outra coisa, isso evita boxe / fundição.

Em geral, EqualityComparer<T>.Default.Equalsdeve fazer o trabalho com qualquer coisa que implemente IEquatable<T>, ou que tenha uma Equalsimplementação sensata .

Se, no entanto, ==e Equalsforem implementados de maneira diferente por algum motivo, meu trabalho com operadores genéricos deve ser útil; suporta as versões do operador de (entre outros):

• Igual (valor T1, valor T2)
• NotEqual (valor T1, valor T2)
• GreaterThan (valor T1, valor T2)
• LessThan (valor T1, valor T2)
• GreaterThanOrEqual (valor T1, valor T2)
• LessThanOrEqual (valor T1, valor T2)

Tantas respostas, e nenhuma explica o PORQUÊ? (que Giovanni perguntou explicitamente) ...

Os genéricos do .NET não agem como modelos C ++. Nos modelos C ++, a resolução de sobrecarga ocorre depois que os parâmetros reais do modelo são conhecidos.

Nos genéricos do .NET (incluindo C #), a resolução de sobrecarga ocorre sem conhecer os parâmetros genéricos reais. As únicas informações que o compilador pode usar para escolher a função a chamar são provenientes de restrições de tipo nos parâmetros genéricos.

A compilação não pode saber que T não pode ser uma estrutura (tipo de valor). Então você tem que dizer que só pode ser do tipo de referência, eu acho:

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

É porque se T poderia ser um tipo de valor, poderia haver casos em x == yque seria mal formado - nos casos em que um tipo não tem um operador == definido. O mesmo acontecerá com isso, que é mais óbvio:

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

Isso também falha, porque você poderia passar um tipo T que não teria uma função foo. O C # obriga a garantir que todos os tipos possíveis sempre tenham uma função foo. Isso é feito pela cláusula where.

Parece que sem a restrição de classe:

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

Deve-se perceber que, enquanto classrestrito Equalsno ==operador herda Object.Equals, enquanto o de uma estrutura substitui ValueType.Equals.

Observe que:

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

também fornece o mesmo erro do compilador.

Até agora não entendo por que a comparação de operadores de igualdade de tipo de valor é rejeitada pelo compilador. Eu realmente sei que isso funciona:

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

Bem, no meu caso, eu queria testar o operador de igualdade. Eu precisava chamar o código sob os operadores de igualdade sem definir explicitamente o tipo genérico. As recomendações EqualityComparernão foram úteis como método EqualityComparerchamado Equals, mas não o operador de igualdade.

Aqui está como eu consegui isso trabalhando com tipos genéricos criando um LINQ. Ele chama o código certo para operadores ==e !=:

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

Há uma entrada do MSDN Connect para isso aqui

A resposta de Alex Turner começa com:

Infelizmente, esse comportamento ocorre por design e não há uma solução fácil para habilitar o uso de == com parâmetros de tipo que podem conter tipos de valor.

Se você quiser garantir que os operadores do seu tipo personalizado sejam chamados, faça isso por meio de reflexão. Basta obter o tipo usando seu parâmetro genérico e recuperar o MethodInfo para o operador desejado (por exemplo, op_Equality, op_Inequality, op_LessThan ...).

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

Em seguida, execute o operador usando o método Invoke do MethodInfo e passe os objetos como parâmetros.

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

Isso chamará seu operador sobrecarregado e não aquele definido pelas restrições aplicadas no parâmetro genérico. Pode não ser prático, mas pode ser útil para testar a unidade de seus operadores ao usar uma classe base genérica que contém alguns testes.

Eu escrevi a seguinte função olhando o último msdn. Pode facilmente comparar dois objetos xe 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; }

O acima funcionará porque == é resolvido no caso de tipos de referência definidos pelo usuário.
No caso de tipos de valor, == pode ser substituído. Nesse caso, "! =" Também deve ser definido.

Eu acho que esse poderia ser o motivo, ele não permite a comparação genérica usando "==".

O .Equals()trabalho para mim TKeyé um tipo genérico.

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


    // ...
}