What are the best practices for implementing the == operator for a class in C#?

Question

While implementing an == operator, I have the feeling that I am missing some essential points.
Hence, I am searching some best practices around that.
Here are some related questions I am thinking about:

• How to cleanly handle the reference comparison?
• Should it be implemented through a IEquatable<T>-like interface? Or overriding object.Equals?
• And what about the != operator?

(this list might not be exhaustive).

Answer 1

I would follow Microsoft's Guidelines for Overloading Equals() and Operator ==.

edit: Microsoft's guidelines contain this important remark, which seems to confirm Henk's answer:

Overriding operator == in non-immutable types is not recommended.

Answer 2

• If you implement ==, override .Equals and . GetHashCode
• implement != as well
• Check for null references using object.ReferenceEquals otherwise the operator will recurse

Answer 3

Each time you implement the == operator, be sure to also implement !=, IEquatable<T> and to override Object.Equals() and Object.GetHashCode() for consistency for the user of your class.

Considering a class, here's my usual implementation:

    public bool Equals(MyClass other) {
  if (ReferenceEquals(other, null))
   return false;
  if (ReferenceEquals(other, this))
   return true;
  return // your equality code here
 }

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

 public override int GetHashCode() {
  return // your hash function here
 }

 public static bool operator ==(MyClass left, MyClass right) {
  return Equals(left, right);
 }

 public static bool operator !=(MyClass left, MyClass right) {
  return !(left == right);
 }

Answer 4

The most common approach is not to handle it. The default is reference comparison which in general is right for class objects.

So first you want to be very sure you need value-type behaviour.

Answer 5

Use Resharper for such tasks. There is no point in reinventing the wheel.