Linq中如何筛选含特定年龄子女的家长并仅保留符合条件的子女

模型定义 #

public class Parent
{
    public int ID { get; set; }
    public string Name{ get; set; }

    public virtual ICollection<Child> Children { get; set; }
}

public class Child
{
    public int ID { get; set; }
    public int ParentID { get; set; }
    public string Name{ get; set; }
    public int Age{get; set;}

    [ForeignKey("ParentID")]
    public virtual Parent Parent { get; set; }
}

示例数据 #

Parent            Child  

ID      Name     ID    Name    Age  ParentID
1       a        1       a1     10     1
2       b        2       a2     20     1
3       c        3       a3     25     1
4       d        4       b1     30     2
5       e        5       b2     35     2
                 6       c1     27     3
                 7       d1     10     4
                 8       d2     18     4
                 9       d3     26     4
                 10      e1     15     5

需求 #

获取所有拥有至少一位年龄≥25岁子女的家长列表，且每个家长的Children子集仅保留符合该年龄条件的子女，期望输出：

parents
ID      Name  Children.ID Children.Name   Age  
1       a        3            a3          25     
2       b        4            b1          30     
3       c        5            b2          35     
4       d        6            c1          27     
                 9            d3          26     

尝试的代码及问题 #

以下代码会返回符合条件的家长，但家长的Children集合包含所有子女，而非仅过滤后的：

var parents = context.Parents.Include(p => p.Children).ToList();

// 一些对parents的处理...

parents = parents.Where(p => p.Children.Any(c => c.Age >= 25)).ToList();

解决方案 #

方法1：使用投影构造结果（适用于所有EF版本） #

通过Select投影出包含过滤后子集合的对象，直接在数据库层面完成过滤，避免加载冗余数据：

var minAge = 25;
var parents = context.Parents
    .Where(p => p.Children.Any(c => c.Age >= minAge))
    .Select(p => new Parent 
    {
        ID = p.ID,
        Name = p.Name,
        Children = p.Children.Where(c => c.Age >= minAge).ToList()
    })
    .AsNoTracking() // 不需要实体跟踪时添加，避免潜在问题
    .ToList();

如果担心直接投影到EF实体的跟踪问题，可以创建一个DTO类接收结果，比如ParentDto，结构与Parent一致但不属于实体类。

方法2：EF Core 5+ 过滤Include（推荐） #

从EF Core 5开始支持直接在Include中过滤关联集合，写法简洁且性能最优：

var minAge = 25;
var parents = context.Parents
    .Include(p => p.Children.Where(c => c.Age >= minAge))
    .Where(p => p.Children.Any(c => c.Age >= minAge))
    .ToList();

该方式会生成带过滤条件的SQL，仅加载符合要求的家长和对应子项。

方法3：内存中过滤（仅适用于小数据量） #

如果已将所有数据加载到内存，可遍历家长并重新赋值Children集合：

var minAge = 25;
var parents = context.Parents.Include(p => p.Children).ToList();

// 筛选符合条件的家长
parents = parents.Where(p => p.Children.Any(c => c.Age >= minAge)).ToList();

// 逐个过滤子集合
foreach (var parent in parents)
{
    parent.Children = parent.Children.Where(c => c.Age >= minAge).ToList();
}

此方式会先加载所有家长和子女，数据量大时性能较差，优先推荐前两种方法。

内容的提问来源于stack exchange，提问作者NedaM