4

我有一个对象层次结构（MasterNode -> ChildNodes），其中主节点和子节点属于同一类型，并且只有两个级别（顶级和子级）像这样（'A' 是 D、E 和 F 的父级，' B' 是 G 的父级，等等）

A--+
|  D
|  E
|  F
|
B--+
|  G
|
C--+
   H
   I

假设我有一个MasterNodes作为父对象（A，B，C）的 IEnumerable，并且给定一个父对象X，我可以通过X.children获得其子对象的 IEnumerable

我知道我可以使用SelectMany方法或使用枚举所有叶子（子节点）

from parent in Masternodes
from child in parent.children
select child

这会给我这个序列：

[D,E,F,G,H,I]

，但这不是我要的。

获取 MasterNodes 集合中对象的深度优先序列的 LINQ 查询是什么？（返回第一个父母，然后是它的所有孩子，然后是下一个父母，然后是它的所有孩子等等）

预期的结果应该是这样的序列：

[A,D,E,F,B,G,C,H,I]

更新：

我要求纯 .NET 就绪的 LINQ。我知道我可以定义自己的方法来做事，但我想要一些仅基于框架提供的方法的东西。

4

4 回答 4

4

如果你有像下面这样的课程

public class Node
{
    public string Name;
    public List<Node> Children = new List<Node>();
}

你的 linq 将是

 Func<IEnumerable<Node>, IEnumerable<Node>> Flatten = null;
 Flatten = coll => coll.SelectMany(n=>n.Concat(Flatten(n.Children)));

测试代码：

Node[] roots = new Node[]{ new Node(){Name="A"},new Node(){Name="B"},new Node(){Name="C"} };
roots[0].Children.Add(new Node(){Name="D"});
roots[0].Children.Add(new Node(){Name="E"});
roots[0].Children.Add(new Node(){Name="F"});

roots[1].Children.Add(new Node(){Name="G"});

roots[2].Children.Add(new Node(){Name="H"});
roots[2].Children.Add(new Node(){Name="I"});

Func<IEnumerable<Node>, IEnumerable<Node>> Flatten = null;
Flatten = coll => coll.SelectMany(n=>n.Concat(Flatten(n.Children)));

var result = String.Join(",",Flatten(roots).Select(x=>x.Name));

Console.WriteLine(result);
于 2012-09-03T07:51:01.817 回答
3

如果您需要两个以上的层次结构级别，您可以使用以下扩展方法递归地遍历您的对象图：

public static IEnumerable<T> Flat<T>(this IEnumerable<T> l, Func<T, IEnumerable<T>> f) =>
        l.SelectMany(i => new T[] { i }.Concat(f(i).Flat(f)));

IEnumerable<T>它使用将 a 映射T到IEnumerable<T>描述数据的父 -> 子关系的函数来扁平化给定值。

深度优先展平是通过将每个元素与其子树连接起来，然后将它们与SelectMany.

你可以像这样使用它：

var flattened = Masternodes.Flat(c => c.children);
于 2018-03-01T09:09:42.430 回答
2

由于您只有两个级别，因此以下方法应该有效：

var result = (from parent in masternodes
              select new Node[] { parent }.Concat(parent.children)).SelectMany(i => i);

首先，它创建了父级及其子级的枚举：

[A, D, E, F]
[B, G]
[C, H]

然后用SelectMany.

于 2012-09-03T07:55:27.260 回答
0

说，我们有以下类：

public class MasterNode : ChildNode
{
    public List<ChildNode> ChildNodes;
}

public class ChildNode
{
    public string Value;
}

然后

        List<MasterNode> list = new List<MasterNode>
        {
            new MasterNode
            {
                Value="A", 
                ChildNodes = new List<ChildNode>
                {
                    new ChildNode{Value = "D"},
                    new ChildNode{Value = "E"},
                    new ChildNode{Value = "F"}
                }
            },
            new MasterNode
            {
                Value="B", 
                ChildNodes = new List<ChildNode>
                {                        
                    new ChildNode{Value = "G"}
                }
            },
            new MasterNode
            {
                Value="C", 
                ChildNodes = new List<ChildNode>
                {
                    new ChildNode{Value = "H"},
                    new ChildNode{Value = "I"}
                }
            }
        };

        foreach (ChildNode c in list.SelectMany(l =>
                                {
                                   List<ChildNode> result = l.ChildNodes.ToList();
                                   result.Insert(0, l);
                                   return result;
                                }))
        {
            Console.WriteLine(c.Value);
        }
于 2012-09-03T07:41:22.487 回答