我目前正在尝试找出一种使用 LINQ 和 C# 对元素进行排序的好方法，但我有点失败了。

对于这个问题，假设您有下表

---TempTable
ID (int)
ParentID (int)
Name (varchar)
SortOrder (int)

ID 和 ParentID 相互关联，给了我一个 self 分层的数据结构。 根元素在 ID 字段中为空。 SortOrder 只是整个表的一部分，并且基于 ParentID，因此共享相同 ParentID 的元素确实有 1、2、3。

让我们进一步假设以下数据:

ID = 1
ParentID = null
Name = Test 1
SortOrder = 1

ID = 2
ParentID = 1
Name = Test 2
SortOrder = 1

ID = 3
ParentID = 1
Name = Test 3
SortOrder = 2

ID = 4
ParentID = 2
Name = Test 4
SortOrder = 1

我想要的平面列表应具有以下顺序:

Test 1 //root element with sort order 1 = very top
Test 2 //child element of root with sort order 1
Test 4 //child element of test 2 with sort order 1
Test 3 //child element of root with sort order 2

我也喜欢获取对象本身而不是只获取一部分信息抛出使用 select new ...

这是我失败的尝试之一:

from x in EntityModel.TempTables //DbSet<TempTable> by EntityFramework - which already holds all elements
   orderby x.SortOrder
   from y in x.TempTableChildren //Navigation Property by EntityFramework
   orderby y.SortOrder
   select y

预先感谢您的帮助。

编辑:

ParentID 的顺序可能有帮助，由于 ID 给定的 TestData，ParentIDs 是完美的顺序，但在真实的应用程序中情况并非如此，因为它的数据驱动，有人可以删除一个条目创建一个新的并放置它在父项下按一定顺序排列，你会得到类似的东西:

ID = 193475037
ParentID = 2
Name = Test 192375937
SortOrder = 25

现在在应用程序中可以移动这个并且 ParentID 和 SortOrder 将随机更改为如下内容:

ID = 193475037
ParentID = 456798424
Name = Test 192375937
SortOrder = 4

为了进一步解释这里的问题是一些代码——如果没有 1 个漂亮的 Linq 查询但有 2 个和一些 yield 返回，我将如何做到这一点:

public class LinqTestDemo
{
    Random rand = new Random();
    List<TempTable> list = new List<TempTable>();

    public List<TempTable> GetFlatData()
    {
        list = GetTestData();

        var rootElement = (from x in list
                            where x.ParentID == null
                            orderby x.SortOrder
                            select x).ToList();

        var flatList = OrderChilds(rootElement).ToList();

        foreach (var tempTable in flatList)
        {
            Console.WriteLine(string.Format("ID = {0} - ParentID = {1} - Name = {2} - SortOrder = {3}", tempTable.ID, tempTable.ParentID, tempTable.Name, tempTable.SortOrder));
        }

        return flatList;
    }

    private IEnumerable<TempTable> OrderChilds(List<TempTable> enumerable)
    {
        foreach (var tempTable in enumerable)
        {
            yield return tempTable;

            TempTable table = tempTable;
            var childs = OrderChilds((from x in list
                                        where x.ParentID == table.ID
                                        orderby x.SortOrder
                                        select x).ToList());

            foreach (var child in childs)
            {
                yield return child;
            }
        }
    }

    public List<TempTable> GetTestData()
    {
        var returnValue = new List<TempTable>();
        for (int i = 0; i < 50; i++)
        {
            var tempTable = new TempTable();
            tempTable.ID = i;
            if (i == 0)
                tempTable.ParentID = null;
            else
                tempTable.ParentID = rand.Next(0, i);

            var maxSortOrder = (from x in returnValue
                                where x.ParentID == tempTable.ParentID
                                select (int?)x.SortOrder).Max();

            if (maxSortOrder.HasValue)
                tempTable.SortOrder = maxSortOrder.Value + 1;
            else
                tempTable.SortOrder = 1;

            tempTable.Name = string.Format("Test {0:00}", i);
            returnValue.Add(tempTable);
        }

        return returnValue;
    }

    public class TempTable
    {
        public int ID { get; set; }
        public int? ParentID { get; set; }
        public string Name { get; set; }
        public int SortOrder { get; set; }
    }
}

@广度优先与深度优先遍历: 阅读一些内容后，我会说我想要的结果是深度优先遍历，其中同一级别深度的元素应按属性 SortOrder 排序。

最佳答案

  public lEnumerable<TempTable> GetList( int? parentID = null){

     foreach ( var item in Context.TempTables
        .Where( x => x.ParentID == parentID )
        .OrderBy( x=> x.SortOrder)
        .ToList() {

        yield return item;

        foreach( var child in GetList( item.ID))
        {
            yield return child;
        }

     }
  }


  var sortedList = GetList();

它与您的方法类似，但更小且递归。并适用于许多深度级别。我更喜欢调用 ToList，因为它会在查询下一个查询之前关闭结果集。

目前还没有办法在单个查询中执行此操作。

根据要求进行单一查询

Entity Framework 将自动填充所有子项。

 public IEnumerable<TempTable> PrepareList(IEnumerable<TempTable> list){
     list = list.OrderBy( x=> x.SortOrder);
     foreach(var item in list){
         yield return item;
         foreach(var child in PrepareList(item.ChildTempTables)){
             yield return child;
         }
     }
 }

 // since EF will automatically fill each children on fetch
 // all we need is just a top level nodes
 // which we will pass to PrepareList method
 var list = Context.TempTables.ToList().Where(x=> x.ParentID == null);
 var sortedList = PrepareList(list).ToList();

 // it is good to create list at the end if you are going to 
 // iterate it many times and logic will not change.

关于c# - LINQ 根据子顺序对平面列表进行排序，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/17968069/