C#中比较对象时忽略UUID属性的实现方案咨询

针对两个仅Employee的UUID不同、其余属性一致的Company对象，默认相等性判断因UUID返回false的问题，下面是几种实用的解决方法：

一、重写Employee类的Equals和GetHashCode #

直接在employee类中重写相等性逻辑，忽略UUID字段，只对比业务属性：

class employee
{
    public string uuid { get; set; }
    public string name { get; set; }
    public int age { get; set; }
    public string designation { get; set; }

    public override bool Equals(object obj)
    {
        if (obj is not employee other)
            return false;
        
        // 仅对比姓名、年龄、职位，忽略UUID
        return name == other.name 
            && age == other.age 
            && designation == other.designation;
    }

    public override int GetHashCode()
    {
        // 基于参与比较的属性生成哈希码，保证集合比较的正确性
        return HashCode.Combine(name, age, designation);
    }
}

二、自定义比较器处理嵌套集合 #

因为Company和EmployeeDetails是嵌套集合结构，需要自定义IEqualityComparer<T>逐层处理相等性判断：

1. EmployeeDetails比较器 #

public class EmployeeDetailsEqualityComparer : IEqualityComparer<EmployeeDetails>
{
    public bool Equals(EmployeeDetails x, EmployeeDetails y)
    {
        if (x == null || y == null)
            return x == y;
        
        // 利用Employee重写的Equals，对比两个集合的员工是否一致
        return x.employee != null && y.employee != null 
            && x.employee.SetEquals(y.employee);
    }

    public int GetHashCode(EmployeeDetails obj)
    {
        if (obj?.employee == null)
            return 0;
        
        // 排序后计算哈希，避免集合顺序影响结果
        int hash = 17;
        foreach (var emp in obj.employee.OrderBy(e => e.name))
        {
            hash = hash * 31 + emp.GetHashCode();
        }
        return hash;
    }
}

2. Company比较器 #

public class CompanyEqualityComparer : IEqualityComparer<Company>
{
    public bool Equals(Company x, Company y)
    {
        if (x == null || y == null)
            return x == y;
        
        // 对比两个Company的EmployeeDetails集合
        return x.EmployeeDetails != null && y.EmployeeDetails != null 
            && x.EmployeeDetails.SetEquals(y.EmployeeDetails, new EmployeeDetailsEqualityComparer());
    }

    public int GetHashCode(Company obj)
    {
        if (obj?.EmployeeDetails == null)
            return 0;
        
        int hash = 17;
        foreach (var details in obj.EmployeeDetails.OrderBy(d => d.employee?.FirstOrDefault()?.name))
        {
            hash = hash * 31 + new EmployeeDetailsEqualityComparer().GetHashCode(details);
        }
        return hash;
    }
}

使用方式：

bool companiesAreEqual = new CompanyEqualityComparer().Equals(oldCompany, currentCompany);

三、用LINQ直接逐层对比 #

如果不想修改实体类或写比较器，也可以用LINQ遍历嵌套集合，逐个对比属性：

bool AreCompaniesEqual(Company oldComp, Company currentComp)
{
    if (oldComp == null || currentComp == null)
        return oldComp == currentComp;
    
    // 先检查EmployeeDetails的数量是否一致
    if (oldComp.EmployeeDetails?.Count != currentComp.EmployeeDetails?.Count)
        return false;
    
    // 遍历每个EmployeeDetails
    for (int i = 0; i < oldComp.EmployeeDetails.Count; i++)
    {
        var oldDetails = oldComp.EmployeeDetails[i];
        var currentDetails = currentComp.EmployeeDetails[i];
        
        // 检查当前EmployeeDetails下的员工数量
        if (oldDetails?.employee?.Count != currentDetails?.employee?.Count)
            return false;
        
        // 按姓名排序后对比，避免顺序不同导致误判
        var sortedOldEmps = oldDetails.employee.OrderBy(e => e.name).ToList();
        var sortedCurrentEmps = currentDetails.employee.OrderBy(e => e.name).ToList();
        
        for (int j = 0; j < sortedOldEmps.Count; j++)
        {
            var oldEmp = sortedOldEmps[j];
            var currentEmp = sortedCurrentEmps[j];
            
            // 对比核心属性
            if (oldEmp.name != currentEmp.name 
                || oldEmp.age != currentEmp.age 
                || oldEmp.designation != currentEmp.designation)
            {
                return false;
            }
        }
    }
    
    return true;
}

使用方式：

bool areEqual = AreCompaniesEqual(oldCompany, currentCompany);

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