EF Core 3.1多关系加载遇笛卡尔积爆炸，如何实现拆分查询？

问题背景 #

生产环境遭遇扩展性瓶颈：小数据量下处理正常，但数据规模扩大时，查询性能呈指数级下降。相关实体定义及查询代码如下：

public class Party 
{
    public DateTime When { get; set; }
    public ICollection<Attendee> Attendees { get; set; }
}

public class Attendee 
{
    public ICollection<Gift> Gifts { get; set; }
    public ICollection<Allergy> Allergies { get; set; }
}

public IEnumerable<Party> GetAllPartiesByDate(DateTime date) 
{
    var parties = Context.Parties             
                    .Include(p => p.Attendees).ThenInclude(a => a.Gifts)
                    .Include(p => p.Attendees).ThenInclude(a => a.Allergies)
                    .Where(p => p.When == date)
                    .ToList();
    return parties;
}

笛卡尔积爆炸分析 #

• 小数据量场景（4个Party，每个7个Attendee，每个Attendee含3个Gift、2个Allergy）：
  数据库总数据行仅 4 + (4*7) + (4*7*3) + (4*7*2) = 172 行，但EF生成的单查询会返回 4*7*3*2 = 168 行笛卡尔积结果，性能影响可忽略。
• 数据量放大10倍后（40个Party，每个70个Attendee，每个Attendee含30个Gift、20个Allergy）：
  数据库总数据行是 40 + (40*70) + (40*70*30) + (40*70*20) = 142840 行，但EF单查询会生成 40*70*30*20 = 1680000 行的笛卡尔积结果，导致查询耗时剧增。

新版本EF Core可通过AsSplitQuery拆分查询解决此问题，但因技术限制无法升级到3.1以上版本，需在EF Core 3.1中实现等效优化。

解决方案 #

方法1：手动拆分查询，批量加载关联数据 #

通过多次独立查询获取主实体及各层级关联数据，利用EF的实体跟踪机制自动关联数据：

public IEnumerable<Party> GetAllPartiesByDate(DateTime date) 
{
    // 1. 查询主实体Party，不加载关联数据
    var parties = Context.Parties
                        .Where(p => p.When == date)
                        .ToList();

    if (!parties.Any()) return parties;

    // 提取所有Party的ID（假设Party包含Id主键属性）
    var partyIds = parties.Select(p => p.Id).ToList();

    // 2. 查询所有关联的Attendee及其Gifts
    var attendees = Context.Attendees
                          .Include(a => a.Gifts)
                          .Where(a => partyIds.Contains(a.PartyId))
                          .ToList();

    if (!attendees.Any()) return parties;

    // 提取所有Attendee的ID
    var attendeeIds = attendees.Select(a => a.Id).ToList();

    // 3. 查询所有关联的Allergies
    var allergies = Context.Allergies
                          .Where(al => attendeeIds.Contains(al.AttendeeId))
                          .ToList();

    // EF会自动通过导航属性关联所有实体，无需手动赋值
    return parties;
}

注意：需确保实体类包含对应的外键属性（如Attendee.PartyId、Allergy.AttendeeId），且DbContext已正确配置实体间的一对多关系。

方法2：使用显式加载（Explicit Loading） #

先查询主实体，再通过Entry方法显式加载各层级关联数据，适合按需加载的场景：

public IEnumerable<Party> GetAllPartiesByDate(DateTime date) 
{
    var parties = Context.Parties
                        .Where(p => p.When == date)
                        .ToList();

    // 批量加载所有Party的Attendees及关联的Gifts
    Context.Entry(parties)
           .Collection(p => p.Attendees)
           .Query()
           .Include(a => a.Gifts)
           .Load();

    // 加载所有Attendees的Allergies
    foreach (var party in parties)
    {
        foreach (var attendee in party.Attendees)
        {
            Context.Entry(attendee)
                   .Collection(a => a.Allergies)
                   .Load();
        }
    }

    return parties;
}

方法3：禁用延迟加载（可选） #

若DbContext开启了延迟加载，建议禁用以避免隐式生成额外查询，确保所有关联数据通过显式查询加载：

在DbContext构造函数中添加：

this.ChangeTracker.LazyLoadingEnabled = false;

核心原理 #

上述方案均通过将单一大查询拆分为多个目标明确的小查询，彻底避免笛卡尔积生成，减少数据库返回的数据量；同时利用EF的实体跟踪机制，自动维护实体间的导航属性关联，达到与AsSplitQuery一致的性能优化效果。

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