有没有办法减少 Equals 和 GetHashCode 中的样板代码量？

Question

出于单元测试的目的，我经常不得不重写 Equals 和 GetHashCode 方法。在此之后，我的课程开始看起来像这样：

public class TestItem
{
    public bool BoolValue { get; set; }

    public DateTime DateTimeValue { get; set; }

    public double DoubleValue { get; set; }

    public long LongValue { get; set; }

    public string StringValue { get; set; }

    public SomeEnumType EnumValue { get; set; }

    public decimal? NullableDecimal { get; set; }

    public override bool Equals(object obj)
    {
        var other = obj as TestItem;

        if (other == null)
        {
            return false;
        }

        if (object.ReferenceEquals(this, other))
        {
            return true;
        }

        return this.BoolValue == other.BoolValue
            && this.DateTimeValue == other.DateTimeValue
            && this.DoubleValue == other.DoubleValue // that's not a good way, but it's ok for demo
            && this.EnumValue == other.EnumValue
            && this.LongValue == other.LongValue
            && this.StringValue == other.StringValue
            && this.EnumValue == other.EnumValue
            && this.NullableDecimal == other.NullableDecimal;
    }

    public override int GetHashCode()
    {
        return this.BoolValue.GetHashCode()
            ^ this.DateTimeValue.GetHashCode()
            ^ this.DoubleValue.GetHashCode()
            ^ this.EnumValue.GetHashCode()
            ^ this.LongValue.GetHashCode()
            ^ this.NullableDecimal.GetHashCode()
            ^ (this.StringValue != null ? this.StringValue.GetHashCode() : 0);
    }
}

虽然做起来并不难，但在Equals 和GetHashCode 中维护相同字段的列表时会变得无聊且容易出错。有没有办法只列出一次用于相等检查和哈希码功能的文件？ Equals 和 GetHashCode 应该按照这个设置列表来实现。

在我的想象中，此类设置列表的配置和使用可能看起来像

public class TestItem
{
    // same properties as before

    private static readonly EqualityFieldsSetup Setup = new EqualityFieldsSetup<TestItem>()
        .Add(o => o.BoolValue)
        .Add(o => o.DateTimeValue)
        // ... and so on
        // or even .Add(o => o.SomeFunction())

    public override bool Equals(object obj)
    {
        return Setup.Equals(this, obj);
    }

    public override int GetHashCode()
    {
        return Setup.GetHashCode(this);
    }
}

有一种方法可以在 java 中自动实现 hashCode 和 equals，例如 project lombok。我想知道是否有任何东西可以减少 C# 的样板代码。

Answer 1

我做了一些研究，发现几个组件不是我想要的：

• EqualityComparer (nuget) - 默认情况下似乎没有提供有意义的GetHashCode()，而且对我来说太重了。
• AnonymousComparer (nuget) - 不支持 GetHashCode() 合成。
• MemberwiseEqualityComparer - 需要添加自定义属性以从比较中排除成员，这种方式无法灵活配置现有类型的比较。亲自为这个任务做Emit 有点矫枉过正。
• System.DataStructures.FuncComparer (nuget) - 不支持合成。

还有一些相关的讨论：

• Hows to quick check if data transfer two objects have equal properties in C#?
• Is there a better way to implment Equals for object with lots of fields?

到目前为止，明确配置成员列表的想法似乎是独一无二的。我实现了我自己的库https://github.com/alabax/YetAnotherEqualityComparer。它比 TylerOhlsen 建议的代码更好，因为它不会对提取的成员进行装箱，而是使用 EqualityComparer<T> 来比较成员。

现在代码如下：

public class TestItem
{
    private static readonly MemberEqualityComparer<TestItem> Comparer = new MemberEqualityComparer<TestItem>()
        .Add(o => o.BoolValue)
        .Add(o => o.DateTimeValue)
        .Add(o => o.DoubleValue) // IEqualityComparer<double> can (and should) be specified here
        .Add(o => o.EnumValue)
        .Add(o => o.LongValue)
        .Add(o => o.StringValue)
        .Add(o => o.NullableDecimal);

    // property list is the same

    public override bool Equals(object obj)
    {
        return Comparer.Equals(this, obj);
    }

    public override int GetHashCode()
    {
        return Comparer.GetHashCode(this);
    }
}

MemberEqualityComparer 还实现了IEqualityComparer<T> 并遵循其语义：它可以成功地比较default(T) 这可能是null 的引用类型和Nullables。

更新：有工具可以解决基于IEqualityComparer<T>创建成员的相同问题，但这些工具也可以提供复合IComparer<T>！

• Comparers (by Stephen Cleary) (nuget)。
• ComparerExtensions (nuget)。

Answer 2

我认为在 C# 中实现与 Lombok 几乎相同的东西是可能的，但我目前并没有那么雄心勃勃。

我相信这就是您所追求的（与您所描述的几乎完全一样）。此实现确实将所有值类型装箱到对象中，因此它不是最有效的实现，但它应该足以满足您的单元测试目的。

public class EqualityFieldsSetup<T>
    where T : class
{
    private List<Func<T, object>> _propertySelectors;

    public EqualityFieldsSetup()
    {
        _propertySelectors = new List<Func<T, object>>();
    }

    public EqualityFieldsSetup<T> Add(Func<T, object> propertySelector)
    {
        _propertySelectors.Add(propertySelector);
        return this;
    }

    public bool Equals(T objA, object other)
    {
        //If both are null, then they are equal 
        //    (a condition I think you missed)
        if (objA == null && other == null)
            return true;

        T objB = other as T;

        if (objB == null)
            return false;

        if (object.ReferenceEquals(objA, objB))
            return true;

        foreach (Func<T, object> propertySelector in _propertySelectors)
        {
            object objAProperty = propertySelector.Invoke(objA);
            object objBProperty = propertySelector.Invoke(objB);

            //If both are null, then they are equal
            //   move on to the next property
            if (objAProperty == null && objBProperty == null)
                continue;

            //Boxing requires the use of Equals() instead of '=='
            if (objAProperty == null && objBProperty != null ||
                !objAProperty.Equals(objBProperty))
                return false;
        }

        return true;
    }

    public int GetHashCode(T obj)
    {
        int hashCode = 0;

        foreach (Func<T, object> propertySelector in _propertySelectors)
        {
            object objProperty = propertySelector.Invoke(obj);

            if (objProperty != null)
                hashCode ^= objProperty.GetHashCode();
        }

        return hashCode;
    }
}