C# equality operators override (== and !=)

Question

Possible Duplicate:
How do I check for nulls in an ‘==’ operator overload without infinite recursion?

I have an object that looks like this:

public class Tags
{
   int mask;

   public static bool operator !=(Tags x, Tags y)
   {
      return !(x == y);
   }

   public static bool operator ==(Tags x, Tags y)
   {
      return x.mask == y.mask;
   }
}

This works fine for comparing instances to each other, but I also want to be able to handle an expression such as:

if(tags1 == null)

Doing this causes an exception on the following line:

return x.mask == y.mask;

Since y is null.

I've tried changing this function to:

public static bool operator ==(Tags x, Tags y)
{
   if (x == null && y == null) return true;
   if (x == null || y == null) return false;

   return x.mask == y.mask;
}

However, this creates a stack overflow since the implementation uses its own overridden comparison operator.

What's the trick to getting the == operator to handle comparisons to null? Thanks!

Answer 1

According to guideline:

public static bool operator ==(Tags a, Tags b)
{
    // If both are null, or both are same instance, return true.
    if (System.Object.ReferenceEquals(a, b))
    {
        return true;
    }

    // If one is null, but not both, return false.
    if (((object)a == null) || ((object)b == null))
    {
        return false;
    }

    // Return true if the fields match:
    return a.mask == b.mask;
}

Answer 2

Instead of x == null, you could use (object)x == null or Object.ReferenceEquals(x, null):

public static bool operator ==(Tags x, Tags y)
{
    if ((object)x == null && (object)y == null) return true;
    if ((object)x == null || (object)y == null) return false;

    return x.mask == y.mask;
}

But you should also implement Equals and GetHashCode:

public override bool Equals(object obj)
{
    return this.Equals(obj as Tags);
}

public bool Equals(Tags tags)
{
    return (object)tags != null && this.mask == tags.mask;
}

public override int GetHashCode()
{
    return this.mask.GetHashCode();
}

Now operator == can be written simply:

public static bool operator ==(Tags x, Tags y)
{
    return (object)x != null ? x.Equals(y) : (object)y == null;
}

Answer 3

Kirill gave already a good answer, but i use some kind of improved schema for implementation of the operators including a correct implementation of Equals() and GetHashCode() in the following way:

public static bool operator !=(MyType first, MyType second)
{
    return !(first == second);
}

public static bool operator ==(MyType first, MyType second)
{
    if (ReferenceEquals(first, null)
       || ReferenceEquals(second, null))
    {
        return ReferenceEquals(first, second);
    }

    return first.Equals(second);
}

public override bool Equals(object obj)
{
    return Equals(obj as MyType);
}

public bool Equals(MyType other)
{
    if (ReferenceEquals(other, null))
    {
        return false;
    }

    if (ReferenceEquals(this, other))
    {
        return true;
    }

    // Check all simple properties
    if (GetHashCode() != other.GetHashCode()
        || Name != other.Name
        || Age != other.Age
        || Phone != other.Phone)
    {
        return false;
    }

    return true;
}

public override int GetHashCode()
{
    unchecked
    {
        var hash = 34591;

        if (Name != null)
        {
            hash = hash * 29863 + Name.GetHashCode();
        }

        if (Phone != null)
        {
            hash = hash * 29863 + Phone.GetHashCode();
        }

        hash = hash * 29863 + Age;

        return hash;
    }
 }

Answer 4

See this question. Uses Object.ReferenceEquals.

Answer 5

If you can think of not using operators but methods instead, cant you define your own extension method. Like this.

public static bool IsEqual(this Tags a, Tags b) 
{
    if(a == null && b == null)
       return true;
    if((a != null && b == null) || (a == null && b != null))
       return false;
    return b.mask == this.mask
}