Overriding Equals in C# Records

C# records, introduced in C# 9.0, are primarily designed to simplify the creation of immutable types with value-based equality. By default, records automatically provide implementations for methods like Equals(), GetHashCode(), and ToString(), based on all their properties. However, there may be scenarios where the default implementation of Equals() does not fit your needs, and you might want to override it to customize equality logic. This article will guide you through the process of overriding the Equals() method in records and explain when such overrides are necessary.

Default Behavior of Equals in Records

The default Equals() implementation in records checks for value-based equality. That is, two record instances are considered equal if all their properties are equal. This is different from classes, which, by default, use reference equality.

public record Person(string Name, int Age);

var person1 = new Person("John", 30);
var person2 = new Person("John", 30);
Console.WriteLine(person1 == person2); // Outputs: True

When to Override Equals

You might need to override the Equals() method in a record for several reasons:

Selective Property Comparison: If equality should be determined based on a subset of properties rather than all properties.
Complex Property Types: If some properties require custom logic for equality comparison.
Performance Considerations: If the default equality check is inefficient for large or complex types.

How to Override Equals in a Record

Overriding Equals() in a record is straightforward but requires careful consideration to maintain consistency with GetHashCode() and the record's immutability principles.

Example: Overriding Equals for Selective Comparison

Consider a Book record where equality should only consider the ISBN and ignore other properties like Title and Author.

public record Book(string ISBN, string Title, string Author)
{
    public override bool Equals(object? obj)
    {
        if (obj is Book book)
        {
            return this.ISBN == book.ISBN;
        }
        return false;
    }

    public override int GetHashCode()
    {
        return ISBN.GetHashCode();
    }
}

In this example, Equals() and GetHashCode() are overridden to only consider the ISBN property. This ensures that two books are considered the same if they have the same ISBN, regardless of other differences.

Best Practices for Overriding Equals in Records

Consistency Between Equals and GetHashCode: Always ensure that GetHashCode() is consistent with Equals(). If two objects are equal according to Equals(), they must return the same hash code.
Use the is Type Check: Use the is keyword for type checking in the overridden Equals() method to safely cast and compare.
Call Base Equals When Needed: If you're extending another record and adding properties, and you still want to consider base record properties in your equality check, call the base class's Equals() method within your override.

Conclusion

Overriding the Equals() method in C# records can provide more control over how instances are compared, which can be crucial for domain models or data entities where specific attributes define identity. While the default implementation suits most scenarios with its simplicity and correctness, understanding how to customize it allows developers to fine-tune how their data types behave in collections, lookups, and logical comparisons, ensuring optimal performance and correctness in their applications.

c# record override equals