如何比较两个对象的属性（忽略空属性）？支持复杂对象与数组

刚好之前做过类似的需求，这就给你梳理出一个实用的实现方案！

核心思路 #

要满足你的需求，关键要解决两个问题：嵌套复杂对象的递归比较和null属性的跳过逻辑，整体思路如下：

• 用反射遍历对象的所有公共实例属性
• 对每个属性值分情况处理：
  • 若任意一方属性值为null，直接跳过该属性的比较
  • 基本类型/字符串直接对比值
  • 复杂对象递归调用比较方法
  • 数组或集合类，遍历每个元素逐一比较

完整代码实现（C#） #

using System;
using System.Collections;
using System.Reflection;

public static class ObjectComparer
{
    public static bool Compare<T>(T obj1, T obj2) where T : class
    {
        // 两个对象都为null，视为相等
        if (obj1 == null && obj2 == null)
            return true;
        
        // 其中一个为null，另一个不为null（兜底处理非同一实例的极端情况）
        if (obj1 == null || obj2 == null)
            return false;
        
        // 获取对象的所有公共实例属性
        PropertyInfo[] properties = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance);
        
        foreach (PropertyInfo prop in properties)
        {
            object value1 = prop.GetValue(obj1);
            object value2 = prop.GetValue(obj2);
            
            // 只要任意一个属性值为null，跳过该属性的比较
            if (value1 == null || value2 == null)
                continue;
            
            // 判断是否为值类型或字符串（直接比较）
            if (prop.PropertyType.IsValueType || prop.PropertyType == typeof(string))
            {
                if (!value1.Equals(value2))
                    return false;
            }
            // 判断是否为数组或集合
            else if (typeof(IEnumerable).IsAssignableFrom(prop.PropertyType))
            {
                IEnumerable enumerable1 = (IEnumerable)value1;
                IEnumerable enumerable2 = (IEnumerable)value2;
                
                IEnumerator enumerator1 = enumerable1.GetEnumerator();
                IEnumerator enumerator2 = enumerable2.GetEnumerator();
                
                // 同时遍历两个集合，逐一比较元素
                while (enumerator1.MoveNext() && enumerator2.MoveNext())
                {
                    if (!CompareObjects(enumerator1.Current, enumerator2.Current))
                        return false;
                }
                
                // 检查两个集合的元素数量是否一致（可根据需求决定是否保留）
                if (enumerator1.MoveNext() || enumerator2.MoveNext())
                    return false;
            }
            // 复杂对象，递归比较
            else
            {
                if (!CompareObjects(value1, value2))
                    return false;
            }
        }
        
        // 所有需要比较的属性都匹配
        return true;
    }
    
    // 通用的对象比较辅助方法，处理不同类型的对象
    private static bool CompareObjects(object obj1, object obj2)
    {
        if (obj1 == null && obj2 == null)
            return true;
        if (obj1 == null || obj2 == null)
            return false;
        
        // 如果是同一类型，调用泛型Compare方法
        if (obj1.GetType() == obj2.GetType())
        {
            MethodInfo compareMethod = typeof(ObjectComparer).GetMethod("Compare")?.MakeGenericMethod(obj1.GetType());
            return (bool)(compareMethod?.Invoke(null, new[] { obj1, obj2 }) ?? false);
        }
        
        // 类型不同直接返回不相等
        return false;
    }
}

// 示例测试类
public class Car
{
    public string Make { get; set; }
    public string Model { get; set; }
    public Option[] Options { get; set; }
}

public class Option
{
    public string Name { get; set; }
    public decimal Price { get; set; }
}

// 使用示例
public class Program
{
    public static void Main()
    {
        var c1 = new Car
        {
            Make = "Ford",
            Model = "F-150",
            Options = null // 这个属性为null，会被跳过比较
        };
        
        var c2 = new Car
        {
            Make = "Ford",
            Model = "F-150",
            Options = new[] { new Option { Name = "GPS", Price = 1500 } }
        };
        
        // 结果为true，因为Options属性一个为null，跳过比较，其他属性匹配
        bool isEqual = ObjectComparer.Compare(c1, c2);
        Console.WriteLine(isEqual); // 输出 True
    }
}

关键点说明 #

1. 反射获取属性：用BindingFlags.Public | BindingFlags.Instance确保只获取实例的公共属性，避免静态属性或私有属性干扰。
2. null跳过逻辑：遍历属性时，只要value1或value2任意一个为null，就直接跳过该属性的比较，完全符合你的需求。
3. 递归处理复杂对象：通过CompareObjects辅助方法，自动识别复杂对象并递归调用比较逻辑，完美支持多层嵌套的对象结构。
4. 集合/数组处理：统一转换成IEnumerable遍历，不管是数组、List还是其他集合类型都能处理，同时检查元素数量是否一致（如果不需要严格数量一致，可以删除数量检查的代码）。
5. 类型安全：泛型方法Compare<T>确保只比较同一类型的对象，避免跨类型比较的错误。

可调整的细节 #

• 如果需要比较私有属性，可以修改BindingFlags添加BindingFlags.NonPublic。
• 如果集合只需要元素内容匹配不关心顺序，可以先把集合转换成排序后的列表再比较。
• 如果某些属性需要强制比较（即使其中一个为null），可以添加一个属性黑名单/白名单机制，指定哪些属性必须比较。

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