проверка на равенство С#

Вы правы, это много шаблонного кода, и вам нужно реализовать все отдельно.

Я бы порекомендовал:

• Если вы вообще собираетесь реализовать равенство значений, переопределите GetHashCode и Equals(object) — создание перегрузок для == и реализация IEquatable<T> без этого могут привести к очень неожиданному поведению.
• Я бы всегда реализовывал IEquatable<T>, если вы переопределяете Equals(object) и GetHashCode
• Я только реже перегружаю оператор ==
• Правильная реализация равенства для незапечатанных классов сложна и может привести к неожиданным/нежелательным результатам. Если вам нужно равенство типов в иерархии, реализуйте IEqualityComparer<T>, выражающее интересующее вас сравнение.
• Равенство для изменяемых типов, как правило, плохая идея, так как два объекта могут быть равными, а затем неравными позже... если объект мутирует (влияющим на равенство) после того, как он использовался в качестве ключа в хеш-таблице, вы выиграли не найти его снова.
• Некоторые шаблоны для структур немного отличаются... но, как и Марк, я очень редко пишу свои собственные структуры.

Вот пример реализации:

using System;

public sealed class Foo : IEquatable<Foo>
{
    private readonly string name;
    public string Name { get { return name; } }

    private readonly int value;
    public int Value { get { return value; } }

    public Foo(string name, int value)
    {
        this.name = name;
        this.value = value;
    }

    public override bool Equals(object other)
    {
        return Equals(other as Foo);
    }

    public override int GetHashCode()
    {
        int hash = 17;
        hash = hash * 31 + (name == null ? 0 : name.GetHashCode());
        hash = hash * 31 + value;
        return hash;
    }

    public bool Equals(Foo other)
    {
        if ((object) other == null)
        {
            return false;
        }
        return name == other.name && value == other.value;
    }

    public static bool operator ==(Foo left, Foo right)
    {
        return object.Equals(left, right);
    }

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

И да, это чертовски много шаблонов, очень мало из которых меняется между реализациями :(

Реализация == немного менее эффективна, чем могла бы быть, так как она будет вызывать Equals(object), которая должна выполнять проверку динамического типа... но альтернатива еще более стандартна, как эта :

public static bool operator ==(Foo left, Foo right)
{
    if ((object) left == (object) right)
    {
        return true;
    }

    // "right" being null is covered in left.Equals(right)
    if ((object) left == null)
    {
        return false;
    }
    return left.Equals(right);
}

Я редко делаю что-то особенное для занятий; для большинства обычных объектов ссылочное равенство работает нормально.

Я еще реже пишу struct; но поскольку структуры представляют значения, обычно уместно обеспечить равенство и т. д. Обычно это касается всего; Равно, ==, != и IEquatable<T> (поскольку это позволяет избежать упаковки в сценариях, использующих EqualityComparer<T>.Default.

Шаблон обычно не слишком проблематичен, но здесь могут помочь инструменты IIRC, такие как resharper.

Да, рекомендуется синхронизировать Equals и ==, и это нужно делать явно.

Вам просто нужно реализовать operator== для a==b .
Поскольку мне нравятся мои данные в словарях, иногда я переопределяю GetHashCode.
Затем я реализую Equals (как не упомянутый стандарт... это потому, что нет ограничений на равенство при использовании дженериков) и определяю реализацию IEquatable. Поскольку я собираюсь это сделать, я мог бы указать свои реализации == и != на Equals. :)

См. Что лучше всего подходит для сравнения двух Экземпляры ссылочного типа?

Вы можете избежать шаблонного кода (надеемся, что команда C#/VS предложит что-то простое для разработчиков в своей следующей итерации) с помощью фрагмента, здесь один из таких..