Best way to handle null when writing equals operator

Question

When I overload the == operator for objects I typically write something like this:

 public static bool operator ==(MyObject uq1, MyObject uq2) {
  if (((object)uq1 == null) || ((object)uq2 == null)) return false;
  return uq1.Field1 == uq2.Field1 && uq1.Field2 == uq2.Field2;
 }

If you don't down-cast to object the function recurses into itself but I have to wonder if there isn't a better way?

Answer 1

ReferenceEquals(object obj1, object obj2)

Answer 2

This article seems to be exactly what you are looking for.

Answer 3

if ((object)uq1 == null) 
    return ((object)uq2 == null)
else if ((object)uq2 == null)
    return false;
else
    //return normal comparison

This compares them as equal when both are null.

Answer 4

Follow the DB treatment:

null == <anything> is always false

Answer 5

@neouser99: That's the right solution, however the part that is missed is that when overriding the equality operator (the operator ==) you should also override the Equals function and simply make the operator call the function. Not all .NET languages support operator overloading, hence the reason for overriding the Equals function.

Answer 6

As Microsoft says,

A common error in overloads of operator == is to use (a == b), (a == null), or (b == null) to check for reference equality. This instead results in a call to the overloaded operator ==, causing an infinite loop. Use ReferenceEquals or cast the type to Object, to avoid the loop.

So use ReferenceEquals(a, null) || ReferenceEquals(b, null) is one possibility, but casting to object is just as good (is actually equivalent, I believe).

So yes, it seems there should be a better way, but the method you use is the one recommended.

However, as has been pointed out, you really SHOULD override Equals as well when overriding ==. With LINQ providers being written in different languages and doing expression resolution at runtime, who knows when you'll be bit by not doing it even if you own all the code yourself.

Answer 7

This is a duplicate of the post found here.

Answer 8

But why don't you create an object member function? It can certainly not be called on a Null reference, so you're sure the first argument is not Null.

Indeed, you lose the symmetricity of a binary operator, but still...

(note on Purfideas' answer: Null might equal Null if needed as a sentinel value of an array)

Also think of the semantics of your == function: sometimes you really want to be able to choose whether you test for

• Identity (points to same object)
• Value Equality
• Equivalence ( e.g. 1.000001 is equivalent to .9999999 )

Answer 9

Just use Resharper to create you Equals & GetHashCode methods. It creates the most comprehensive code for this purpose.

Update I didn't post it on purpose - I prefer people to use Resharper's function instead of copy-pasting, because the code changes from class to class. As for developing C# without Resharper - I don't understand how you live, man.

Anyway, here is the code for a simple class (Generated by Resharper 3.0, the older version - I have 4.0 at work, I don't currently remember if it creates identical code)

public class Foo : IEquatable<Foo>
{
    public static bool operator !=(Foo foo1, Foo foo2)
    {
        return !Equals(foo1, foo2);
    }

    public static bool operator ==(Foo foo1, Foo foo2)
    {
        return Equals(foo1, foo2);
    }

    public bool Equals(Foo foo)
    {
        if (foo == null) return false;
        return y == foo.y && x == foo.x;
    }

    public override bool Equals(object obj)
    {
        if (ReferenceEquals(this, obj)) return true;
        return Equals(obj as Foo);
    }

    public override int GetHashCode()
    {
        return y + 29*x;
    }

    private int y;
    private int x;
}