c# - Linq-to-objects:从平面源创建两级层次结构

Question

假设我有这个简单的结构

class FooDefinition
{
    public FooDefinition Parent { get; set; }
}

class Foo
{
    public FooDefinition Definition { get; set; }
}

class Bar
{
    public ICollection<Foo> Foos { get; set; }
}

A Bar有一个列表 Foos这可以是简单的(没有父/子关系)或仅嵌套一层(即父 Foo 有许多子 Foos )。从这里可以看出，关系在 FooDefinition 中指定。 , 而不是 Foo itself .

我需要做的是生成 Foos 的列表按此层次结构正确分组。考虑以下源数据:

var simpleDefinition = new FooDefinition();
var parentDefinition = new FooDefinition();
var childDefinition = new FooDefinition { Parent = parentDefinition };

var bar = new Bar { Foos = new[]
                           {
                               new Foo { Definition = simpleDefinition },
                               new Foo { Definition = parentDefinition },
                               new Foo { Definition = childDefinition }
                           }};

我想和他们的 child 一起收集顶级元素。一个合适的数据结构可能是 IEnumerable<IGrouping<Foo, Foo>> .

结果如下:

• 项目 1(简单)
• 项目 2(父级)
  • 项目 3( child )

当然，我想使用纯功能 Linq 查询来完成此操作。我做了很多这样的事情，但今天我的大脑似乎卡住了。

Answer 1

bar.Foos.Where(x => x.Definition.Parent == null)
        .Select(x => Tuple.Create(x, 
                                  bar.Foos.Where(c => c.Definition
                                                       .Parent == x.Definition
                                                ))); 

这将返回 IEnumerable<Tuple<Foo, IEnumerable<Foo>>> , 其中Item2的 Tuple包含 Item1 中父项的子项.对于您的示例，这将返回两个元组:

• Item1 = simpleDefinition和 Item2包含一个空的枚举
• Item1 = parentDefinition和 Item2包含一个包含 childDefinition 的枚举

可能有更优雅或更快的方法，但我想不出...

哦，好吧，我的评论与此有点矛盾，但是 GroupBy 是可能的- 至少接近:

bar.Foos.Where(x => x.Definition.Parent == null)
        .GroupBy(x => x,
                 x => bar.Foos.Where(c => c.Definition.Parent == x.Definition));

这将返回 IEnumerable<IGrouping<Foo, IEnumerable<Foo>>> .

更新:
我想知道，您想要的解决方案是否可行。
是的，它是:

bar.Foos.Where(x => x.Definition.Parent != null)
        .GroupBy(x => bar.Foos.Where(y => y.Definition == x.Definition.Parent)
                              .Single(),
                 x => x)
        .Union(bar.Foos.Where(x => x.Definition.Parent == null && 
                                   !bar.Foos.Any(c => c.Definition.Parent == 
                                                      x.Definition))
                       .GroupBy(x => x, x => (Foo)null));

但我真的不想知道它的大O而且它真的不应该被使用;-)