合并两个集合，按属性递归组合重复项

Question

给定两个具有递归结构的对象集合：

Collection1 = [
    {
        Header: "H1",
        Items: [{
            Header: "H1.1"
        },{
            Header: "H1.2"
        }]
    },
    {
        Header: "H2",
        Items: [{
            Header: "H2.1"
        }]
    }
]

Collection2 = [
    {
        Header: "H1",
        Items: [{
            Header: "H1.1",
            Items: [{
                Header: "H1.1.1"
            }]
        }]
    }
]

我想创建某种函数来组合这两个集合，该集合具有我指出的比较属性，在本例中为Header，并且结合了它们的属性，因此结果有点如下：

Result = [
    {
        Header: "H1",
        Items: [{
            Header: "H1.1",
            Items: [{
                Header: "H1.1.1"
            }]
        },{
            Header: "H1.2"
        }]
    },
    {
        Header: "H2",
        Items: [{
            Header: "H2.1"
        }]
    }
]

如您所见，它递归地检查对象属性，如果存在类似的项目（在本例中，比较 Header 属性），它只会合并两个对象。

我尝试过Union()、Distinct() 等等，但我似乎找不到实现这一目标的方法。

编辑：合并应该在“相同级别”的基础上完成，因此只有在相同深度级别具有相同标题的项目才应该被视为相等。

Answer 1

您可以执行以下操作...

假设你有一个类似这样的类：

public class Node {
    public string Header { get; set; }
    public IEnumerable<Node> Items { get; set; }

    public Node() {
        /* Note that I like to start the collections within the object's construction, 
         * to avoid issues inside operations that manipulate these collections. */
        Items = new Collection<Node>();
    }
}

您可以使用 IEqualityComparer 的递归实现来使用 Linq Union 的优点。类似的东西：

public class NodeComparer : IEqualityComparer<Node>
{
    public bool Equals(Node me, Node another) 
    {
        if (me.Header == another.Header) 
        {
            me.Items = me.Items.Union(another.Items, new NodeComparer()).ToList();

            return true;
        }

        return false;
    }

    public int GetHashCode(Node node) 
    {
        return node.Header.GetHashCode();
    }
}

这个的主要调用是：

var result = collection1.Union(collection2, new NodeComparer()).ToList();

这基本上是使用Union方法的比较，考虑节点的头部（通过方法GetHashCode），对于每个具有相同头部值的节点，进行相同的处理为您的孩子（通过 Equals 方法），这将依次发生在所有级别。

我已经用几个场景测试了这个解决方案，似乎效果很好，但是如果仍然有一些情况没有解决，也许这是一个很好的开始。

Answer 2

这是一个为您的项目建模的类：

class Item
{
    public string Header { get; set; }
    public IEnumerable<Item> Items { get; set; }
}

这个递归函数以你描述的方式合并项目：

IEnumerable<Item> Merge(IEnumerable<Item> items)
{
    var lookup = items.ToLookup(item => item.Header);
    foreach (var grouping in lookup)
    {
        var childItems = grouping.Aggregate(
            new List<Item>(),
            (list, item) =>
            {
                if (item.Items != null)
                    list.AddRange(item.Items);
                return list;
            });
        yield return new Item
        {
            Header = grouping.Key,
            Items = Merge(childItems)
        };
    }
}

让我解释一下：

• 查找类似于字典，只是每个键的值不是单个 Item，而是共享同一键 (Header) 的 Item 实例的集合。

• 查找中的每个项目都不是KeyValuePair，而是IGrouping，通过迭代所有分组，您可以获得该级别的所有标题。

• Aggregate 用于创建一个列表，其中包含分组中所有项目的所有子项目。此列表可以包含具有相同标题的多个项目，但这是 Merge 旨在处理的数据类型。

• 使用递归来合并子项。

要合并两个集合，您需要像这样调用函数：

var mergedCollection = Merge(collection1.Concat(collection2));