Overriding the Equals Method

The nonstatic version of the Object class's Equals method is declared to be virtual, allowing us to override its behavior in a derived class. We often override the Equals method to define a different interpretation of what it means for two objects to be equal: for example, in the Student class, we may wish to deem two physically distinct Student objects as nonetheless being "equal" if they have the same value for their respective student ID numbers.

Because the code involved in doing so is a bit complex, we'll present it in its entirety first, and will then explain it step by step:

using System;

public class Student
{
  // Field.
  private string studentId;

  // Property.
  public string StudentId {
    // Accessor details omitted.
  }

  // Overriding the Equals method.
  public override bool Equals(object obj) {
    // Initialize a flag.
    bool isEqual = false;

    try {
      // Start by attempting to cast the generic object reference,
      // "obj", as a Student; if an InvalidCastException arises
      // at run time, we KNOW that the object in question is NOT
      // a Student, and so by definition cannot be equal to THIS
      // Student!
      Student s = (Student) obj;

      // If we make it this far in the Equals method without
      // throwing an InvalidCastException, we know that we are
      // indeed dealing with two Student instances. Next,
      // we'll compare their ID numbers.
      if (this.StudentID == s.StudentID) {
        // Eureka! They're equal, according to our new
        // definition of Student equality.
        isEqual = true;
      }
      else {
        isEqual = false;
      }
    }
    catch (InvalidCastException e) {
      // As mentioned above, if "obj" cannot be cast as a Student,
      // we know it doesn't equal THIS Student!
      isEqual = false;
    }
    return isEqual;
  }
}

Let's now discuss key aspects of this code.

First, note that the Object class's version of the Equals method:

public virtual bool Equals(object obj)

takes a generic object reference as an argument. In our overridden Equals method for the Student class, however, we're interested in establishing the equality/inequality of two Student objects, so we first attempt to cast the obj argument into a Student object reference.

      Student s = (Student) obj;

Two possible outcomes can arise:

• If the object reference being passed in is indeed a Student reference, the cast proceeds without exception at run time, and we then proceed to compare the two students' ID numbers. If they are found to be identical, we set the isEqual flag to true to indicate that they are "equal" according to our business rules for Student equality; otherwise, we set the flag to false.

              if (this.StudentID == s.StudentID) {
                isEqual = true;
              }
              else {
                isEqual = false;
              }
  

• On the other hand, if the object being passed in is not a Student, an InvalidCastException is thrown, transferring control to the catch block of our example. Here, we automatically set the isEqual flag to false: if the object being compared to this Student isn't even a Student, then they are obviously unequal!

            catch (InvalidCastException e) {
              // If obj cannot be cast to a Student, we know it doesn't equal
              // THIS Student!
              isEqual = false;
            }
  

Let's put our new overridden method to work in our client code:

      public class Example
      {
        static void Main() {
          Professor p = new Professor();

          Student s1 = new Student(); // first object ...
          s1.StudentID = "123-45-6789";

          Student s2 = new Student(); // second object ...
          s2.StudentID = "123-45-6789"; // same ID as s1

          Student s3 = new Student(); // third object!
          s3.StudentID = "987-65-4321"; // different ID as s1 and s2

          Console.WriteLine("Is s1 equal to s2? " + s1.Equals(s2));
          Console.WriteLine("Is s1 equal to s3? " + s1.Equals(s3));
          Console.WriteLine("Is s1 equal to p? " + s1.Equals(p));
        }
      }

The preceding code would generate the following output:

Is s1 equal to s2? true
Is s1 equal to s3? false
Is s1 equal to p? false

      if (x == y) { ... }

Overriding the ToString Method

In the preceding example, we'd prefer that the ToString method for a Student return a more informative result, such as perhaps the label "Student:" followed by a given student's name and student ID number, formatted as shown here:

Student: Dianne Bolden [999999]

To achieve this result, we'd simply need to override the ToString method in the Student class as follows:

public class Student {
  // Fields.
  private string name;
  private string studentId;
  // Other details omitted ...
  public override string ToString() {
    return "Student: " + Name + " [" + StudentId + "]";
  }

Now, the snippet shown earlier:

Student s = new Student();
s.Name = "Dianne Bolden";
s.StudentId = "999999";
Console.WriteLine(s.ToString());

would output the desired result when executed:

Student: Dianne Bolden [999999]

by virtue of our overridden ToString method.

"Behind the Scenes" Use of ToString

As it turns out, the ToString method is often called "behind the scenes"—for example, by the Console.WriteLine method. The Console.WriteLine method, which we normally think of as accepting string arguments, is overloaded such that an arbitrary object reference can be passed as an argument to the method. It's therefore perfectly acceptable to write code as follows:

Student s = new Student();
s.Name = "Cheryl Richter";
s.StudentId = "123456";
Console.WriteLine(s);

When an arbitrary object reference is passed to the WriteLine method, the WriteLine method automatically calls the object's ToString method to obtain its class-specific string representation, which is then printed to the console. Given the way in which we'd overridden the ToString method for the Student class earlier, the result of running the preceding code snippet would produce the following output:

Student: Cheryl Richter [123456]

Many of the predefined classes in the .NET Framework libraries have overridden the ToString method. What's more, it's a good idea to get into the habit of overriding the ToString method for all user-defined classes, to ensure that whenever ToString is called "behind the scenes" on an instance of such a class, a meaningful result is returned.