How does overloading the equality operator == really work?

Question

I have this piece of code in MyClass:

public static bool operator ==(MyClass lhs, MyClass rhs)
{
    if (lhs == null || rhs == null)
        return false;

    // Other operations to check for equality
}

Going by the first line in the code, I'm comparing lhs and rhs to null. I'm not sure but I suppose that comparison itself will invoke the overload function again. And then we het to that line again, it invokes itself and so on. Sort of an infinite recursion.
But we all know that does not take place. This implies, in my opinion, that comparing with null does not invoke the equality overload. So what really occurs? How does comparing with null work?

That's because with `lhs == null` not both are objects of `MyClass` — Hatted Rooster, Oct 21 '15 at 15:13
As a side note, here's an excellent example by @EricLippert about how to properly implement operator overloads: http://stackoverflow.com/a/19300732/870604 — ken2k, Oct 21 '15 at 15:18
@M.kazemAkhgary Is that valid code? Casting `null`? That's something. Can it ever be useful, though? — afaolek, Oct 21 '15 at 15:18

D Stanley · Accepted Answer · 2015-10-21T15:36:05.063

5

EDIT

I stand corrected. It does call the == operator recursively (at least in LinqPad 4.5) rather than binding to object.==. There are three ways to fix this:

Overload Equals instead if you really want value equality semantics.
Cast lhs and rhs to object
Use Object.ReferenceEquals as the MSDN guidelines recommend

I suppose that comparison itself will invoke the overload function again

No - null is not a MyClass so the call uses the default meaning of == which is reference equality.

Also note that the guidelines for overloading == state that it should only be overloaded for immutable types, since the expected behavior for == is reference equality which is what happens by default. Equals implies "value equality" semantics.

edited Oct 21 '15 at 15:36

answered Oct 21 '15 at 15:13

D Stanley

149,601
11
178
240

Right, that's true. As an aside, can we really call `null` an `object`? Technically, `null` means nothing. But, it has a representation, I believe. – afaolek Oct 21 '15 at 15:17
I just tested it. in VS 2015 also calls recursive. i was mistaken. thanks for mentioning it. – M.kazem Akhgary Oct 21 '15 at 15:40

score 2 · Answer 2 · answered Oct 21 '15 at 15:22

In addition to D Stanley answer. To avoid such kind of surprizes (Object operator == is called), use Object.ReferenceEquals when implementing ==:

public static bool operator ==(MyClass lhs, MyClass rhs)   
{
    // lhs and rhs are the same instance (both are null included)
    if (Object.ReferenceEquals(lhs, rhs))
      return true;
    else if (Object.ReferenceEquals(lhs, null) || Object.ReferenceEquals(rhs, null))
      return false;

    // From here we have different instances, none of them is null
    // Other operations to check for equality
}

How does overloading the equality operator == really work?

2 Answers2