如何在单元测试中检查可变类的“值相等性”？

针对可变类不能重写Equals和GetHashCode（避免哈希集合异常）的情况，以下几种方案可以在单元测试中安全地验证对象的值相等性：

1. 手动逐个断言字段/属性 #

这是最直接的方式，完全不修改生产代码，仅在测试中对需要验证的成员逐一断言：

// 示例测试代码
var actual = GetTargetMutableObject();
var expected = new MutableClass 
{ 
    Name = "Test", 
    Age = 30, 
    Status = ObjectStatus.Active 
};

// 对需要验证的属性逐一断言
Assert.AreEqual(expected.Name, actual.Name);
Assert.AreEqual(expected.Age, actual.Age);
Assert.AreEqual(expected.Status, actual.Status);

优点：简单直观，无额外依赖；缺点：字段/属性较多时代码繁琐。

2. 使用FluentAssertions灵活比较 #

通过第三方库FluentAssertions（可通过NuGet安装），无需修改原类即可灵活指定比较规则，支持包含/排除成员、嵌套对象比较等：

// 示例测试代码
var actual = GetTargetMutableObject();
var expected = new MutableClass { Name = "Test", Age = 30 };

// 指定仅比较Name和Age属性
actual.Should().BeEquivalentTo(expected, options =>
    options.Including(m => m.Name)
           .Including(m => m.Age)
           .Excluding(m => m.Status)); // 排除不需要验证的属性

优点：语法简洁，功能强大，可复用比较规则；缺点：需要引入第三方库。

3. 编写测试专用的相等比较器 #

实现IEqualityComparer<T>接口，仅在测试代码中使用该比较器，完全隔离生产代码的相等逻辑：

// 测试专用的比较器
public class MutableClassEqualityComparer : IEqualityComparer<MutableClass>
{
    public bool Equals(MutableClass x, MutableClass y)
    {
        if (ReferenceEquals(x, y)) return true;
        if (x is null || y is null) return false;
        
        // 定义需要比较的字段/属性
        return x.Name == y.Name 
               && x.Age == y.Age 
               && x.Status == y.Status;
    }

    public int GetHashCode(MutableClass obj)
    {
        // 仅在测试中使用，无需担心对象变更导致的哈希集合问题
        return HashCode.Combine(obj.Name, obj.Age, obj.Status);
    }
}

// 测试中使用比较器
var expectedList = new List<MutableClass> { /* 预期对象 */ };
var actualList = GetTargetMutableList();

// 验证集合相等
CollectionAssert.AreEqual(expectedList, actualList, new MutableClassEqualityComparer());

// 验证单个对象相等
Assert.IsTrue(new MutableClassEqualityComparer().Equals(expected, actual));

优点：比较逻辑可复用，完全不影响生产代码；缺点：需要为每个可变类编写对应的比较器。

4. 反射自动比较成员 #

通过反射遍历对象的公共成员，自动完成断言，适合字段/属性较多的场景：

// 测试工具方法
public static void AssertObjectValueEquals<T>(T expected, T actual, params string[] excludedMembers)
{
    if (ReferenceEquals(expected, actual)) return;
    if (expected is null || actual is null)
    {
        Assert.Fail("预期对象和实际对象不能有一个为null");
    }

    var type = typeof(T);
    // 获取需要比较的公共属性和字段
    var members = type.GetProperties(BindingFlags.Public | BindingFlags.Instance)
        .Where(p => !excludedMembers.Contains(p.Name))
        .Cast<MemberInfo>()
        .Concat(type.GetFields(BindingFlags.Public | BindingFlags.Instance)
                    .Where(f => !excludedMembers.Contains(f.Name)));

    foreach (var member in members)
    {
        var expectedValue = member switch
        {
            PropertyInfo prop => prop.GetValue(expected),
            FieldInfo field => field.GetValue(expected),
            _ => null
        };
        var actualValue = member switch
        {
            PropertyInfo prop => prop.GetValue(actual),
            FieldInfo field => field.GetValue(actual),
            _ => null
        };

        Assert.AreEqual(expectedValue, actualValue, $"成员 {member.Name} 值不匹配");
    }
}

// 测试中调用工具方法
var expected = new MutableClass { Name = "Test", Age = 30, Status = ObjectStatus.Active };
var actual = GetTargetMutableObject();

// 排除Status属性，仅比较Name和Age
AssertObjectValueEquals(expected, actual, "Status");

优点：减少重复代码，适配多字段场景；缺点：需要处理嵌套对象、复杂类型等特殊情况，性能略低于手动断言。

内容的提问来源于stack exchange，提问作者Martin