Всегда ли перегружен метод Equals или оператор ==?

Перегрузка Equals и оператора == в C#

Нет, перегрузка методов Equals и операторов == не является обязательной в C#, но её отсутствие может привести к неожиданному поведению при сравнении объектов. По умолчанию, для ссылочных типов оба способа проверяют ссылочную эквивалентность (т.е., указывают ли две переменные на один и тот же объект в памяти), а для значимых типов (структур) Equals выполняет поэлементное сравнение, а оператор == не определён.

Ключевые различия поведения по умолчанию

1. Для ссылочных типов (классы):
   • == и Equals по умолчанию сравнивают ссылки.
   • Пример без перегрузки:

class Person { public string Name { get; set; } }

var person1 = new Person { Name = "Alex" };
var person2 = new Person { Name = "Alex" };
var person3 = person1;

Console.WriteLine(person1 == person2); // False (разные объекты в памяти)
Console.WriteLine(person1.Equals(person2)); // False (разные объекты в памяти)
Console.WriteLine(person1 == person3); // True (одна ссылка)

1. Для значимых типов (структуры):
   • Equals по умолчанию сравнивает значения всех полей через рефлексию (медленно).
   • Оператор == не доступен без перегрузки (ошибка компиляции).

struct Point { public int X, Y; }

var point1 = new Point { X = 1, Y = 2 };
var point2 = new Point { X = 1, Y = 2 };

Console.WriteLine(point1.Equals(point2)); // True (значения полей совпадают)
// Console.WriteLine(point1 == point2); // Ошибка компиляции!

Когда перегрузка необходима?

1. Логическое сравнение объектов по значению (например, для сущностей DDD, где две сущности равны при совпадении идентификатора).
2. Работа с коллекциями, использующими Equals и GetHashCode (например, Dictionary<TKey, TValue>, HashSet<T>).
3. Структуры: для оператора == и оптимизации Equals (рефлексия по умолчанию медленная).
4. Сценарии, где семантика сравнения должна отличаться от ссылочной (например, сравнение строк по содержимому, а не по ссылкам).

Рекомендации по перегрузке

1. Всегда переопределяйте Equals и GetHashCode вместе (нарушение контракта приведёт к ошибкам в хэш-коллекциях).
2. Используйте интерфейс IEquatable<T> для типобезопасного сравнения и избежания боксинга для структур.
3. Оператор == лучше перегружать только для неизменяемых типов (изменение объекта после помещения в коллекцию сломает хэш).
4. Согласованность: если перегружаете ==, перегружайте !=, и наоборот.

Пример корректной перегрузки для класса:

class Person : IEquatable<Person>
{
    public string Name { get; set; }
    public int Age { get; set; }

    public override bool Equals(object obj)
        => obj is Person other && Equals(other);

    public bool Equals(Person other)
        => other != null && Name == other.Name && Age == other.Age;

    public override int GetHashCode()
        => HashCode.Combine(Name, Age);

    public static bool operator ==(Person left, Person right)
        => Equals(left, right);

    public static bool operator !=(Person left, Person right)
        => !Equals(left, right);
}

Исключения и важные замечания

• record типы (C# 9.0+) автоматически генерируют Equals, GetHashCode и == на основе значений свойств.
• Строки (string) уже имеют перегруженные Equals и ==, сравнивающие содержимое.
• Делегаты и массивы используют ссылочное сравнение по умолчанию.
• Наследование: при переопределении Equals в иерархии классов требуется осторожность с проверкой типов.

Вывод

Перегрузка не обязательна, но критически важна для реализации логики сравнения по значению. Игнорирование перегрузки может привести к тонким ошибкам, особенно при использовании коллекций или сравнении структур. Для ссылочных типов, где важна идентичность, оставьте поведение по умолчанию. Для неизменяемых value-like объектов (как Money, DateTime) всегда реализуйте полный набор сравнений.