优化复杂对象比较：提升多层嵌套类结构相等性校验性能

看起来你的嵌套对象相等性比较遇到了性能瓶颈——3500个Class4实例的情况下单次比较要12秒，核心问题出在每次Equals调用时都重复对集合做排序操作，这带来了O(n log n)的时间复杂度，而且嵌套层级会把这个开销放大好几倍。结合你提到的「两个对象对应集合数量始终一致」这个前提，我们可以通过以下几种方式大幅提升性能：

方案1：缓存集合哈希值，快速排除不相等情况 #

每次排序计算哈希是巨大的浪费，我们可以在集合初始化/修改时预先计算并缓存集合的哈希值，这样在比较时先通过哈希快速筛选，只有哈希相等时再做精确比较（避免哈希冲突）。

以Class3为例，修改后的代码如下：

public class Class3 : IEquatable<Class3>
{
    public int Id { get; set; }
    public string Name { get; set; }
    
    private IList<Class4> _class4s;
    public IList<Class4> Class4s 
    { 
        get => _class4s; 
        set 
        {
            _class4s = value;
            // 预先计算排序后的集合哈希，缓存起来
            _cachedClass4sHash = CalculateOrderedCollectionHash(_class4s);
        }
    }
    
    private int _cachedClass4sHash;

    // 计算排序后集合的哈希值
    private int CalculateOrderedCollectionHash<T>(IEnumerable<T> items) where T : IEquatable<T>
    {
        unchecked
        {
            int hash = 13;
            foreach (var item in items.OrderBy(c => c.Id))
            {
                hash = (hash * 7) + item.GetHashCode();
            }
            return hash;
        }
    }

    public bool Equals(Class3 other)
    {
        if (other == null) return false;
        
        // 先快速对比基础字段和缓存的集合哈希，不相等直接返回
        if (Id != other.Id || !Name.Equals(other.Name) || _cachedClass4sHash != other._cachedClass4sHash)
            return false;
        
        // 哈希相等时，用HashSet做精确比较（数量一致时SetEquals效率远高于排序+SequenceEqual）
        return new HashSet<Class4>(Class4s).SetEquals(other.Class4s);
    }

    public override bool Equals(object obj)
    {
        return obj is Class3 other && Equals(other);
    }

    public override int GetHashCode()
    {
        unchecked
        {
            int hash = 13;
            hash = (hash * 7) + Id.GetHashCode();
            hash = (hash * 7) + Name.GetHashCode();
            hash = (hash * 7) + _cachedClass4sHash; // 直接用缓存的哈希，不用重复计算
            return hash;
        }
    }
}

按照同样的逻辑修改Class2和Class1，把每个集合的哈希值缓存起来，这样每次比较时可以先快速排除99%以上的不相等情况，只有少数哈希碰撞的情况才需要做精确比较，能大幅减少耗时。

方案2：用HashSet替代IList存储集合（业务允许的话最优） #

如果你的业务场景中不需要集合保持顺序，也不会有重复元素，直接把IList<Class2>/IList<Class3>/IList<Class4>替换成HashSet<T>类型，这样比较相等性时直接调用SetEquals方法，时间复杂度是O(n)，比排序的O(n log n)快很多。

示例修改Class1：

public class Class1 : IEquatable<Class1>
{
    public string Id { get; set; }
    public string Name { get; set; }
    public HashSet<Class2> Class2s { get; set; }

    public bool Equals(Class1 other)
    {
        if (other == null) return false;
        // SetEquals直接检查元素是否完全一致，顺序无关
        return Name.Equals(other.Name) && Class2s.SetEquals(other.Class2s);
    }

    public override bool Equals(object obj)
    {
        return obj is Class1 other && Equals(other);
    }

    public override int GetHashCode()
    {
        unchecked
        {
            int hash = 13;
            hash = (hash * 7) + Name.GetHashCode();
            foreach (var c2 in Class2s)
            {
                hash = (hash * 7) + c2.GetHashCode();
            }
            return hash;
        }
    }
}

这种方案不需要任何排序操作，性能提升最明显，是优先考虑的选项。

方案3：预先排序并缓存集合（必须保留IList时的次优选择） #

如果业务上必须用IList存储集合，那可以在集合赋值时就完成排序并缓存，避免每次比较都重复排序：

public class Class1 : IEquatable<Class1>
{
    public string Id { get; set; }
    public string Name { get; set; }
    
    private IList<Class2> _class2s;
    public IList<Class2> Class2s 
    { 
        get => _class2s; 
        set 
        {
            // 赋值时直接排序并缓存，后续比较无需再排序
            _class2s = value.OrderBy(c => c.Id).ToList();
        }
    }

    public bool Equals(Class1 other)
    {
        if (other == null) return false;
        // 直接用SequenceEqual，因为集合已经预先排好序
        return Name.Equals(other.Name) && Class2s.SequenceEqual(other.Class2s);
    }

    public override bool Equals(object obj)
    {
        return obj is Class1 other && Equals(other);
    }

    public override int GetHashCode()
    {
        unchecked
        {
            int hash = 13;
            hash = (hash * 7) + Name.GetHashCode();
            foreach (var c2 in Class2s)
            {
                hash = (hash * 7) + c2.GetHashCode();
            }
            return hash;
        }
    }
}

这样排序操作只执行一次，后续比较的开销就只剩O(n)的SequenceEqual，比原来每次都排序的情况快很多。

测试建议 #

• 先尝试方案2，如果业务允许，这是性能最优的选择
• 必须用IList的话，结合方案1和方案3，既缓存哈希快速筛选，又预先排序减少比较开销

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