C#中如何实现复杂对象的子相等性检查？重写Equals方法方案

刚好之前处理过类似的需求，给你整理一个可行的实现方案，核心是通过反射遍历类的属性，只检查目标对象（a2）的非空属性是否和当前对象（a1）匹配，完美契合你说的“子相等性”逻辑。

实现思路 #

1. 类型校验：首先判断传入的对象是否为A类型，不是直接返回false。
2. 反射获取属性：通过反射拿到A类的所有公共实例属性，这样后续新增属性时不用修改Equals逻辑，扩展性拉满。
3. 遍历检查非空属性：对每个属性，先获取a2的属性值，如果是null就跳过；否则取出a1的对应值，分情况比较：
   • 集合类型（比如List<B>）：用SequenceEqual比较元素，注意自定义类型B必须重写Equals，否则会比较引用地址。
   • 普通类型：直接用Equals方法比较值（字符串、值类型都适用）。
4. 重写GetHashCode：C#规范要求，只要重写Equals就必须重写GetHashCode，保证两个“相等”的对象哈希码一致。

完整代码实现 #

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;

public class A
{
    public string Prop1 { get; set; }
    public List<B> Prop2 { get; set; }
    // 可添加其他属性示例
    public int? Prop3 { get; set; }
    public B Prop4 { get; set; }

    public override bool Equals(object obj)
    {
        // 先判断是否为A类型
        if (obj is not A targetA)
            return false;

        // 获取当前类所有公共实例属性
        var properties = typeof(A).GetProperties(BindingFlags.Public | BindingFlags.Instance);

        foreach (var prop in properties)
        {
            // 拿到a2（targetA）的属性值
            var targetValue = prop.GetValue(targetA);
            
            // 如果a2的这个属性是null，跳过检查
            if (targetValue == null)
                continue;

            // 拿到a1（当前实例this）的属性值
            var currentValue = prop.GetValue(this);

            // 处理集合类型（比如List<B>）
            if (typeof(IEnumerable<>).IsAssignableFrom(prop.PropertyType))
            {
                var targetEnumerable = targetValue as IEnumerable<object>;
                var currentEnumerable = currentValue as IEnumerable<object>;

                // 如果a1的这个属性是null，但a2的不是，直接不相等
                if (currentEnumerable == null)
                    return false;

                // 比较集合元素，依赖B类的Equals实现
                if (!currentEnumerable.SequenceEqual(targetEnumerable))
                    return false;
            }
            else
            {
                // 普通类型直接比较值
                if (!Equals(currentValue, targetValue))
                    return false;
            }
        }

        // 所有a2的非空属性都匹配，返回true
        return true;
    }

    // 重写GetHashCode，保证和Equals逻辑一致
    public override int GetHashCode()
    {
        int hashCode = 17;
        var properties = typeof(A).GetProperties(BindingFlags.Public | BindingFlags.Instance);
        
        foreach (var prop in properties)
        {
            var value = prop.GetValue(this);
            // 组合所有属性的哈希码，null值哈希码取0
            hashCode = hashCode * 31 + (value?.GetHashCode() ?? 0);
        }
        
        return hashCode;
    }
}

// 自定义类型B必须重写Equals和GetHashCode，否则集合比较会失效
public class B
{
    public string Name { get; set; }
    public int Age { get; set; }

    public override bool Equals(object obj)
    {
        if (obj is not B otherB)
            return false;
        
        return Name == otherB.Name && Age == otherB.Age;
    }

    public override int GetHashCode()
    {
        return HashCode.Combine(Name, Age);
    }
}

测试示例 #

// 准备测试数据
var b1 = new B { Name = "Alice", Age = 30 };
var b2 = new B { Name = "Bob", Age = 25 };

// 目标对象a2，有三个非空属性
var a2 = new A 
{ 
    Prop1 = "Hello", 
    Prop2 = new List<B> { b1 },
    Prop3 = 42
};

// 测试1：a1的非空属性和a2完全匹配 → 返回true
var a1 = new A 
{ 
    Prop1 = "Hello", 
    Prop2 = new List<B> { b1 },
    Prop3 = 42,
    Prop4 = null // a2的Prop4是null，不检查
};
Console.WriteLine(a1.Equals(a2)); // 输出: True

// 测试2：a1的Prop1和a2不同 → 返回false
var a3 = new A 
{ 
    Prop1 = "World", 
    Prop2 = new List<B> { b1 },
    Prop3 = 42
};
Console.WriteLine(a3.Equals(a2)); // 输出: False

// 测试3：a1的集合元素和a2不同 → 返回false
var a4 = new A 
{ 
    Prop1 = "Hello", 
    Prop2 = new List<B> { b2 },
    Prop3 = 42
};
Console.WriteLine(a4.Equals(a2)); // 输出: False

注意事项 #

• 边界情况：如果a2是null，当前实现会返回false；如果你需要处理“a2为null时默认子相等”的场景，可以在开头添加if (obj == null) return true;（根据实际需求调整）。
• 性能考虑：反射会有一定性能开销，如果你的类属性很多或者调用非常频繁，可以考虑手动写属性比较逻辑，替代反射。
• B类的Equals：一定要确保自定义类型B正确重写Equals和GetHashCode，否则集合比较（SequenceEqual）会用引用地址判断，导致结果不符合预期。

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