【问题标题】:Complex LINQ sorting with groups使用组进行复杂的 LINQ 排序
【发布时间】:2011-09-12 18:35:22
【问题描述】:

我正在尝试根据以下(简化的)规则对项目列表进行排序:

我将每个项目都有以下属性:

 Id (int), 
 ParentId (int?), 
 Name (string)

ParentID 是 Id 的自加入 ForeignKey。如果一个项目有一个 ParentId,那么父项也将存在于列表中。

我需要对列表进行排序,以使所有具有父项的项目立即出现在其父项之后。然后所有项目将按名称排序。

如果我有以下情况:

 Id: 1, ParentId: null, Name: Pi
 Id: 2, ParentId: null, Name: Gamma
 Id: 11, ParentId: 1, Name: Charlie
 Id: 12, ParentId: 1, Name: Beta
 Id: 21, ParentId: 2, Name: Alpha
 Id: 22, ParentId: 2, Name: Omega

然后我希望它们按如下方式排序:

ID:2、21、22、1、12、11

目前我能想到的最好方法是先按名称排序,然后按 ParentId 分组,如下所示:

var sortedItems = itemsToSort.OrderBy(x=> x.Name).GroupBy(x=> x.ParentId);

我的开始计划如下:(在非功能代码中)

var finalCollection = new List<Item>

var parentGroup = sortedItems.Where(si => si.Key == null);

foreach(parent in parentGroup)
{
   finalCollection.Add(parent);
   foreach(child in sortedItems.Where(si => si.Key == parent.Id)
   {
      finalCollection.Add(child);
   }
}

但是,parentGroup 不是

 IEnumerable<Item> 

所以这不起作用。

我觉得有一种更简单、更简洁的方法来实现这一点,但目前我还没有想到 - 谁能帮忙?

【问题讨论】:

  • parentGroup 肯定会是IEnumerable&lt;&gt; - 是什么让您觉得它不是?
  • 只有顶级项和一级子项,还是更深层次?
  • @Jamiec:该死 - 我的尖括号被隐藏了 - 让我更正
  • 只有 2 个级别 - 父母和他们的孩子
  • @BonyT - 它应该是一个IGrouping&lt;int,Item&gt;,它本身会继承自IEnumerable&lt;Item&gt;,所以你可以把它当作IEnumerable&lt;Item&gt;来对待。

标签: c# linq-to-objects


【解决方案1】:

如果你只有两个级别,你可以这样做:

var lookup = itemsToSort.OrderBy(x => x.Name).ToLookup(x => x.ParentId, x => x);
var parents = lookup[null];
var sortedItems = parents.SelectMany(x => new[] { x }.Concat(lookup[x.Id]));

最初,项目按名称排序,以确保以后将它们分成组时保持排序。

然后创建一个查找表,允许ParentId 查找。然后使用SelectMany 将通过null ParentId 标识的父母与他们的孩子连接起来,并使用查找表来查找孩子。父级插入子级之前以获得所需的序列。

如果您想解决多于两个级别的一般情况,您需要使用递归。这是一种递归获取节点子树的方法:

IEnumerable<Item> GetSubtreeForParent(Item parent, ILookup<Int32?, Item> lookup) {
  yield return parent;
  foreach (var child in lookup[parent.Id])
    foreach (var descendant in GetSubtreeForParent(child, lookup))
      yield return descendant;
}

代码和上面更简单的情况几乎一样:

var lookup = itemsToSort.OrderBy(x => x.Name).ToLookup(x => x.ParentId, x => x);
var parents = lookup[null];
var sortedItems = parents.SelectMany(x => GetSubtreeForParent(x, lookup));

通过使用递归 lambda,您甚至可以“内联”完成所有操作:

var lookup = itemsToSort.OrderBy(x => x.Name).ToLookup(x => x.ParentId, x => x);
// Declare Func to allow recursion.
Func<Int32?, IEnumerable<Item>> getSubTreeForParent = null;
getSubTreeForParent =
  id => lookup[id].SelectMany(x => new[] { x }.Concat(getSubTreeForParent(x.Id)));
var sortedItems = getSubTreeForParent(null);

【讨论】:

  • 我喜欢这种方法的外观 - 谢谢 - 我会试试看。
【解决方案2】:

据我了解您的问题,您希望按父母姓名(如果是父母)和孩子姓名(如果是孩子)对结果进行排序,但您希望所有孩子都出现在列表中,排在各自父母之后。

这应该可以解决问题:

更新以解决@Martin Liversage 提到的问题。

var query = from item in itemsToSort
            let parent = itemsToSort.Where(i => i.Id == item.ParentId).FirstOrDefault()
            //get the name of the item's parent, or the item itself if it is a parent
            let parentName = (parent != null) ? parent.Name : item.Name
            //get the name of the child (use null if the item isn't a child)
            let childName = (parent != null) ? item.Name : null
            orderby parentName, childName
            select item;

var finalCollection = query.ToList();

这是输出:

【讨论】:

  • 好点,我现在更新了我的答案来解决这个问题。
【解决方案3】:

这可以通过以下方式实现:

list.Select(i => 
      new {Parent=list.Where(x => x.Id == i.ParentId).FirstOrDefault(), Item = i})
    .OrderBy(i => i.Parent == null ? i.Item.Name : i.Parent.Name + i.Item.Name)
    .Select(i => i.Item)

现场示例:http://rextester.com/rundotnet?code=WMEZ40628

输出是:

2
21
22
1
12
11

【讨论】:

  • 所有项目,包括父母,都按名称排序 - 因此,由于名称排序,父母 2 在父母 1 之前。
  • 但不用担心 - 我可以处理这种复杂情况 - 你的回答提供了我看不到的逻辑 - 天才 - 谢谢。
  • 啊错过了“然后按名称排序”的要求。我现在去看看
  • 如果任何父母的名字是另一个父母和它的一个孩子的串联,这将打破。尝试将Pi 重命名为GammaAlpha 并查看输出。
【解决方案4】:

我会选择 DoctaJonez 的 answer 2 级。

它可以像这样扩展到n级:

Func<int?,Item> lookup = id => list.Where(i => i.Id == id).FirstOrDefault();

Func<Item,string> makeSortString = null;
makeSortString = i => i.ParentId == null ? i.Name : makeSortString(lookup(i.ParentId)) + i.Name;

list.OrderBy(makeSortString).ToList();

【讨论】:

  • 如果任何父母的名字是另一个父母和它的一个孩子的串联,这将打破。尝试将Pi 重命名为GammaAlpha 并查看输出。
【解决方案5】:

这个

var parentGroup = sortedItems.Where(si => si.Key == null).ToList()

将使parentGroup IEnumerable&lt;Item&gt; 。

你会在顶层放松懒惰,但我认为这很好,因为上下文。

【讨论】:

    【解决方案6】:

    这个怎么样?

    var lookup = items.ToLookup(x => x.ParentId);
    
    Func<int?, IEnumerable<Item>> f =  null;
    f = ni =>
        from a in lookup[ni].OrderBy(x => x.Name)
        from b in (new [] { a }).Concat(f(a.Id))
        select b;
    

    然后要获得排序列表,请执行以下操作:

    var sorted = f(null);
    

    简单。 :-)

    【讨论】:

      猜你喜欢
      • 1970-01-01
      • 1970-01-01
      • 2021-06-30
      • 2016-02-28
      • 1970-01-01
      • 2019-05-03
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      相关资源
      最近更新 更多