Linq 将父列表和子列表合并到单个嵌套父列表中

我有两个列表，一个是父列表（parents），一个是子列表（children），子列表有parentId

List<Parent> parents
List<Child> children

---

有什么建议吗？

您可以使用

Join

，并结合

GroupBy

：

var parentChildrenQry =
    from parent in parents
    join child in children on parent.Id equals child.ParentId
    group child by parent;

foreach(var grp in parentChildrenQry) {
    grp.Key.Children = grp.ToList();
}

或在带有

GroupJoin

的一条语句中同时使用这两个语句：

var parentChildrenQry =
    parents.GroupJoin(children, parent.Id, child.ParentId, new { (parent, childGrp) => new { Parent = parent, Children = childGrp.ToList() } );

foreach(var grp in parentChildrenQry) {
    grp.Parent.Children = grp.Children;
}

---

您可以使用

加入

，并结合

分组方式

：

var parentChildrenQry =
    from parent in parents
    join child in children on parent.Id equals child.ParentId
    group child by parent;

foreach(var grp in parentChildrenQry) {
    grp.Key.Children = grp.ToList();
}

或在带有

GroupJoin

的一条语句中同时使用这两个语句：

var parentChildrenQry =
    parents.GroupJoin(children, parent.Id, child.ParentId, new { (parent, childGrp) => new { Parent = parent, Children = childGrp.ToList() } );

foreach(var grp in parentChildrenQry) {
    grp.Parent.Children = grp.Children;
}

---

从性能的角度来看，您的foreach没有任何问题

如果您的代码可读性足够好，那么就没有必要让您的代码变得灵巧

---

如果您的集合非常大，从性能的角度来看，如果您首先按父id对子集合进行分组，并按父id对组进行排序，然后将它们附加到已排序的父集合中，则可能最有效。

从性能的角度看，您的foreach没有任何问题

如果您的代码可读性足够好，那么就没有必要让您的代码变得灵巧

---

如果您的集合非常大，从性能角度来看，如果您首先按父id对您的孩子进行分组，并按父id对组进行排序，然后将它们附加到已排序的父组中，可能会最有效。

我知道这是一个老问题，但我想分享我的经验

对我来说，我在数据库中有很多记录，所以性能很重要，我用另一种方式包装它，得到的结果大约快了3倍。我在一次选择中获得所有数据，然后将结果放入我的模型中

我有餐厅数据库，有菜单和菜谱

首先，这些是处理所选数据的类模型，与数据库模型不同

public class Menu
{
    public Menu()
    {
        Dishes = new List<Dish>();
    }

    public long ID { get; set; }
    public string Name { get; set; }
    public string ImagePath { get; set; }
    public List<Dish> Dishes { get; set; }
}

public class Dish
{
    public long ID { get; set; }
    public string Name { get; set; }
    public string PicturePath { get; set; }
    public double Price { get; set; }
}

和foreach循环来排列数据

List<Menu> menus = new List<Menu>();
foreach (var r in all)
{
    Menu m = menus.Find(x => x == r.Menu);
    if (m == null)
    {
        menus.Add(r.Menu);
        m = r.Menu;
    }
    m.Dishes.Add(r.Dish);
}

列表菜单=新建列表（）；
foreach（总风险值r）
{
menum m=menus.Find（x=>x==r.Menu）；
如果（m==null）
{
菜单。添加（r.Menu）；
m=r.菜单；
}
m、 添加（r.盘）；
}

我知道这是一个老问题，但我想分享我的经验

对我来说，我在数据库中有很多记录，所以性能很重要，我用另一种方式包装它，得到的结果大约快了3倍。我在一次选择中获得所有数据，然后将结果放入我的模型中

我有餐厅数据库，有菜单和菜谱

首先，这些是处理所选数据的类模型，与数据库模型不同

public class Menu
{
    public Menu()
    {
        Dishes = new List<Dish>();
    }

    public long ID { get; set; }
    public string Name { get; set; }
    public string ImagePath { get; set; }
    public List<Dish> Dishes { get; set; }
}

public class Dish
{
    public long ID { get; set; }
    public string Name { get; set; }
    public string PicturePath { get; set; }
    public double Price { get; set; }
}

和foreach循环来排列数据

List<Menu> menus = new List<Menu>();
foreach (var r in all)
{
    Menu m = menus.Find(x => x == r.Menu);
    if (m == null)
    {
        menus.Add(r.Menu);
        m = r.Menu;
    }
    m.Dishes.Add(r.Dish);
}

列表菜单=新建列表（）；
foreach（总风险值r）
{
menum m=menus.Find（x=>x==r.Menu）；
如果（m==null）
{
菜单。添加（r.Menu）；
m=r.菜单；
}
m、 添加（r.盘）；
}