C# what does the == operator do in detail?

Question

in c# what does exactly happen in the background when you do a comparison with the "==" operator on two objects? does it just compare the addresses? or does it something like Equals() or CompareTo() ?

PS: what about the "==" operator in java? does it behave the same?

Answer 1

As I know:

• it compares value types by value (equality)
• it compares reference types by reference (identity)
• except if the == operator is overloaded, then it calls that one.

Equals is implemented in object and can be overridden as well. The default implementation in Object performs a reference comparison for reference types. So by default, Equals and == do the same.

I think in java you cannot overload the == operator. But my Java knowledge is pretty outdated.

Answer 2

What it does depends on the context.

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

Answer 3

From MSDN:

For predefined value types, the equality operator (==) returns true if the values of its operands are equal, false otherwise. For reference types other than string, == returns true if its two operands refer to the same object. For the string type, == compares the values of the strings.

Answer 4

No ... the == operator does not always behave the same in java and in c#.

For example with Strings; Java == does compare the references of the string objects... (if you use primitve types, == in java compares the values). That's why

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

will not return true in java...

In C# in contrast, the == operator does behave different on strings. For example, it will return true in the following case:

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

Answer 5

As an extension to Stefan's excellent answer - another exception is if the operands involve Nullable<T> - in which case "lifted" operators apply (14.2.7 in ECMA 334v4):

For the equality operators == !=

a lifted form of an operator exists if the operand types are both non-nullable value types and if the result type is bool. The lifted form is constructed by adding a single ? modifier to each operand type. The lifted operator considers two null values equal, and a null value unequal to any non-null value. If both operands are non-null, the lifted operator unwraps the operands and applies the underlying operator to produce the bool result.

What that means is: because there is an equality operator between (say):

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

Thus there is an implicit operator of the form (although done differently):

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