动态按嵌套对象多属性分组的C#技术实现问询

嘿，我来帮你搞定这个运行时动态按嵌套属性分组的需求！针对你给出的类结构，我会用C#的LINQ结合反射来实现这个功能，这样不管是多少层嵌套的属性，都能灵活分组。

首先先补全你给出的类定义（把NestedClassThree也完善一下）：

public class ParentClass 
{ 
    public int ID { get; set; } 
    public string Name { get; set; } 
    public NestedClassOne NestedOne { get; set; } 
    public NestedClassThree NestedThree { get; set; } 
}

public class NestedClassOne 
{ 
    public string Make { get; set; } 
    public string Model { get; set; } 
    public NestedClassTwo NestedTwo { get; set; } 
}

public class NestedClassTwo 
{ 
    public string Data { get; set; } 
}

public class NestedClassThree
{
    public string Category { get; set; }
    // 可根据需求添加其他属性
}

核心思路 #

因为要运行时动态指定分组属性，硬编码LINQ的GroupBy肯定不行，所以我们用反射来动态解析嵌套属性路径（比如NestedOne.Make、NestedOne.NestedTwo.Data这种格式），然后把每个对象的这些属性值组合成分组键，再进行分组。

实现代码 #

首先写一个辅助方法，用来根据属性路径获取嵌套对象的属性值：

private static object GetNestedPropertyValue(object obj, string propertyPath)
{
    if (obj == null || string.IsNullOrEmpty(propertyPath))
        return null;

    // 把属性路径按.分割，逐层遍历嵌套对象
    var properties = propertyPath.Split('.');
    var currentObj = obj;

    foreach (var propName in properties)
    {
        if (currentObj == null)
            return null;

        var prop = currentObj.GetType().GetProperty(propName);
        if (prop == null)
            throw new ArgumentException($"属性 '{propName}' 在类型 '{currentObj.GetType().Name}' 中不存在");

        currentObj = prop.GetValue(currentObj);
    }

    return currentObj;
}

然后是分组的核心方法，接收ParentClass列表和要分组的属性路径列表：

public static IEnumerable<IGrouping<object[], ParentClass>> GroupByNestedProperties(List<ParentClass> items, List<string> groupByPropertyPaths)
{
    if (items == null || !items.Any())
        return Enumerable.Empty<IGrouping<object[], ParentClass>>();

    // 按属性路径的取值数组来分组
    return items.GroupBy(item => 
        groupByPropertyPaths.Select(path => GetNestedPropertyValue(item, path)).ToArray());
}

使用示例 #

我们构造一些测试数据，然后按NestedOne.Make和NestedOne.NestedTwo.Data来分组：

// 构造测试数据
var testData = new List<ParentClass>
{
    new ParentClass
    {
        ID = 1,
        Name = "Item1",
        NestedOne = new NestedClassOne { Make = "Toyota", Model = "Camry", NestedTwo = new NestedClassTwo { Data = "Sedan" } },
        NestedThree = new NestedClassThree { Category = "Vehicle" }
    },
    new ParentClass
    {
        ID = 2,
        Name = "Item2",
        NestedOne = new NestedClassOne { Make = "Toyota", Model = "Corolla", NestedTwo = new NestedClassTwo { Data = "Sedan" } },
        NestedThree = new NestedClassThree { Category = "Vehicle" }
    },
    new ParentClass
    {
        ID = 3,
        Name = "Item3",
        NestedOne = new NestedClassOne { Make = "Ford", Model = "F-150", NestedTwo = new NestedClassTwo { Data = "Truck" } },
        NestedThree = new NestedClassThree { Category = "Vehicle" }
    }
};

// 指定要分组的嵌套属性路径
var groupPaths = new List<string> { "NestedOne.Make", "NestedOne.NestedTwo.Data" };
var groupedResult = GroupByNestedProperties(testData, groupPaths);

// 遍历输出分组结果
foreach (var group in groupedResult)
{
    Console.WriteLine($"分组键: 品牌={group.Key[0]}, 类型={group.Key[1]}");
    foreach (var item in group)
    {
        Console.WriteLine($"  - {item.Name} (ID: {item.ID})");
    }
}

额外注意事项 #

• 如果嵌套对象中有null值，GetNestedPropertyValue会返回null，这时候这些对象会被归为同一组（因为null是相等的），如果需要特殊处理，可以在辅助方法里添加自定义逻辑。
• 分组键是object[]类型，如果需要更友好的键（比如可自定义比较逻辑），可以封装一个类来存储这些属性值，并重写Equals和GetHashCode方法。
• 反射的性能比硬编码稍弱，如果是高性能场景，可以用表达式树动态生成属性访问逻辑，替代反射来提升效率。

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