C # o que faz o operador == fazer em detalhes?

Question

em c # o que exatamente acontece em segundo plano quando você faz uma comparação com o operador "==" em dois objetos? isso basta comparar os endereços? ou faz algo como Equals () ou CompareTo ()?

PS: o que acontece com o operador "==" em java? ele se comporta o mesmo?

Answer 1

Tanto quanto eu sei:

• compara tipos de valor por valor (igualdade)
• compara tipos de referência por referência (identidade)
• salvo se o operador == é sobrecarregado, em seguida, ele chama esse.

Equals é implementada no objeto e pode ser substituído também. A implementação padrão em Object executa uma comparação de referência para tipos de referência. Então, por padrão, iguais e == fazer o mesmo.

Eu acho que em java você não pode sobrecarregar o operador ==. Mas meu conhecimento Java é muito desatualizado.

Editar: Note-se que o operador == é um método estático. Ele é obrigado em tempo de compilação, base sobre os tipos de suas variáveis ??ou campos. Equals é um método virtual que é encontrada em tempo de execução, com base nos tipos de tempo de execução reais.

Answer 2

Como uma extensão excelente resposta de Stefan - outra exceção é se os operandos envolvem Nullable<T> - caso em que "levantou" operadores aplicar (14.2.7 na ECMA 334v4):

Para os operadores de igualdade ==! =

numa forma levantado de um operador no caso dos tipos de operandos são ambos tipos e se o valor não anuláveis Tipo de resultado é bool. A forma levantado é calculado adicionando um único? modificador para cada tipo de operando. o operador levantada considera dois nulo valores iguais, e um valor nulo desigual para qualquer valor não nulo. Se ambos operandos são não nulo, o levantado operador desenrola os operandos e aplica-se o operador subjacente a produzir o resultado bool.

O que isto significa é: porque não há um operador de igualdade entre (digamos):

int i = ..., j = ...;
bool eq = i == j;

Assim, existe um operador implícita da forma (embora feito de maneira diferente):

int? i = ..., j = ...;
bool eq;
if(i.HasValue) {
    if(j.HasValue) { // both have values; compare
       eq = i.GetValueOrDefault() == j.GetValueOrDefault();
    } else { // one null; always false
       eq = false;
    }
} else { // true if both null, else false
    eq = !j.HasValue;
}

Answer 3

De MSDN :

Para tipos de valores pré-definidos, a operador de igualdade (==) retorna true se os valores dos seus operandos são iguais, false caso contrário. Para os tipos de referência diferente de corda ==, retorna true se seus dois operandos se referir à mesma objeto. Para o tipo de corda, == compara os valores das strings.

Answer 4

Não ... o operador == nem sempre se comportam da mesma em Java e em C #.

Por exemplo, com cordas; Java == se compara as referências dos objetos string ... (se você usa tipos primitve, == em Java compara os valores). É por isso que

// returns FALSE in JAVA
(new String("test") == "test") 

não retornará verdadeiro em java ...

Em C #, em contraste, o operador == se comporta diferente em cordas. Por exemplo, ele irá retornar verdadeiro no caso seguinte:

// returns TRUE in C#
(new String("test".ToCharArray()) == "test") 

Answer 5

O que ele faz depende do contexto.

http://en.csharp-online.net/ECMA -334: _14.9_Relational_and_type-testing_operators

Answer 6

O comportamento do operador == depende de como a variável que você está aplicando-a foi declarado (e não na classe do objeto, vou acrescentar um exemplo).

Para tipos de valores que vai comparar seus valores.

Para tipos de referência a == b retornos verdadeiros se um é o mesmo objecto que b, a não ser que o operador foi == sobrecarregado. Não substituído como outros disseram, você não pode substituir operadores em c # porque eles não são virtual.

object obj_a, obj_b; string str_a, str_b;

        str_a = "ABC";
        str_b = new string("ABC".ToCharArray());
        obj_a = str_a;
        obj_b = str_b;

        Console.WriteLine("str_a == str_b = {0}", str_a == str_b); // in string == operator is overloaded
        Console.WriteLine("str_a.Equals(str_b) = {0}", str_a.Equals(str_b)); // string overrides Object.Euqals
        Console.WriteLine("obj_a == obj_b = {0}", obj_a == obj_b); // in object == operator is not overloaded
        Console.WriteLine("obj_a.Equals(obj_b) = {0}", obj_a.Equals(obj_b)); // Object.Equesl is virtual and overridden method from string will be executed.
        Console.ReadKey();

A saída desse programa é

str_a == str_b = True
str_a.Equals(str_b) = True
obj_a == obj_b = False
obj_a.Equals(obj_b) = True