C# 对表上具有多对多关系的查询进行排序

我有一个问题，我有一个表

Book

，它与

BookByEditor

表有多对多关系，而这个表与

Editor

表有相同的关系，其思想是一本书可能有多个编辑器，而一个编辑器可能有多本书

以下是我的桌子的简要介绍：

public partial class Book
{
    public int BookID { get; set; }
    public string BookName { get; set; }
    (...)

    public virtual ICollection<BookByEditor> BookByEditor { get; set; }
}


public partial class BookByEditor
{
    public int BookByEditorId { get; set; }
    public int BookID { get; set; }
    public int EditorID { get; set; }

    public virtual Book Book { get; set; }
    public virtual Editor Editor { get; set; }
}


public partial class Editor
{
    public int EditorID { get; set; }
    public string EditorName { get; set; }
    (...)

    public virtual ICollection<BookByEditor> BookByEditor { get; set; }
}

公共部分类书
{
public int BookID{get；set；}
公共字符串BookName{get；set；}
(...)
公共虚拟ICollection BookByEditor{get；set；}
}
公共部分类BookByEditor
{
public int BookByEditorId{get；set；}
public int BookID{get；set；}
public int EditorID{get；set；}
公共虚拟图书{get；set；}
公共虚拟编辑器{get；set；}
}
公共部分类编辑器
{
public int EditorID{get；set；}
公共字符串EditorName{get；set；}
(...)
公共虚拟ICollection BookByEditor{get；set；}
}

因此，我希望能够，例如，进行一个查询，以按编辑器的字母顺序对所有书籍进行排序；意思是编辑A，编辑B，编辑C，等等。我真的希望我对我所追求的东西足够清楚

我正在使用LINQtoSQL和linqkit，所以任何这样做的方法都是受欢迎的

通常我会这样做：

IQueryable<Editor> editors = from e in context.Editor.OrderBy(x => x.EditorName)
                                                         select e;

                            List<Editor> listEditors = new List<Editor>
                                {
                                    editors.First()
                                };

                            count = 0;

                            Editor editorModel = listEditors.Last();

                            while (listBook.Count < 20)
                            {
                                IQueryable<Book> bookByEditor =
                                    from e in context.Book.Where(
                                        item => item.BookByEditor.Any(x => x.EditorID == editorModel.EditorID))
                                    select e;

                                switch (secondOption)
                                {
                                    default:
                                        fetch = bookByEditor.OrderBy(x => x.BookID).Skip(pageCount * 20).Take(20).ToList();
                                        break;
                                    case "New":
                                        fetch = bookByEditor.OrderByDescending(x => x.DateAdded).Skip(pageCount * 20).Take(20).ToList();
                                        break;
                                    case "Old":
                                        fetch = bookByEditor.OrderBy(x => x.DateAdded).Skip(pageCount * 20).Take(20).ToList();
                                        break;
                                }

                                listBook.AddRange(fetch);

                                count++;

                                listEditors.AddRange(editors.Skip(count).Take(1));

                                editorModel = listEditors.Last();
                            }

IQueryable editors=来自context.Editor.OrderBy（x=>x.EditorName）中的e
选择e；
列表编辑器=新列表
{
编辑：第一（）
};
计数=0；
Editor editorModel=listEditors.Last（）；
而（listBook.Count<20）
{
IQueryable bookByEditor=
来自context.Book.Where中的e(
item=>item.BookByEditor.Any（x=>x.EditorID==editorModel.EditorID））
选择e；
开关（第二选项）
{
违约：
fetch=bookByEditor.OrderBy（x=>x.BookID）.Skip（pageCount*20）.Take（20）.ToList（）；
打破
案例“新”：
fetch=bookByEditor.OrderByDescending（x=>x.DateAdded）.Skip（pageCount*20）.Take（20）.ToList（）；
打破
案例“旧”：
fetch=bookByEditor.OrderBy（x=>x.DateAdded）.Skip（pageCount*20）.Take（20）.ToList（）；
打破
}
AddRange（fetch）；
计数++；
AddRange（editors.Skip（count.Take）（1））；
editorModel=listEditors.Last（）；
}

---

但是我对这种方法不满意，而且我也不确定结果…

由编辑对书籍进行分组，排序，然后选择Many以取回书籍怎么样

我不确定。也许它会起作用，我需要测试一下，我从来没有和SelectMany打过电话。所以测试一下吧！：）类似于

var books=context.books.GroupBy（g=>g.Editor）.OrderBy（o=>o.Key.EditorName）.SelectMany（s=>s.Key.books.ToList（）