如何使用EF/Linq实现类似MultiMap的一对多结果映射？

针对你遇到的大数据量下，将扁平化重复的SQL查询结果映射到带集合属性的Person模型的问题，以下是几个高效可行的方案：

方案一：客户端字典合并（高性能首选） #

先通过EF投影出最小化的扁平化数据，再用Dictionary做O(1)复杂度的合并，比GroupBy性能更优，避免内存爆炸：

// 1. 仅查询需要的字段，减少数据传输量
var flatRecords = await _context.PersonMeals
    .Select(pm => new 
    {
        pm.PersonId,
        pm.Person.Name,
        pm.BreakfastItem,
        pm.LunchItem,
        pm.DinnerItem
    })
    .AsNoTracking() // 禁用实体跟踪，提升查询速度
    .ToListAsync();

// 2. 用Dictionary快速合并重复Person记录
var personMap = new Dictionary<decimal, Person>();
foreach (var record in flatRecords)
{
    if (!personMap.TryGetValue(record.PersonId, out var person))
    {
        person = new Person
        {
            Id = record.PersonId,
            Name = record.Name,
            AteForBreakfast = new List<string>(),
            AteForLunch = new List<string>(),
            AteForDinner = new List<string>()
        };
        personMap.Add(record.PersonId, person);
    }

    // 填充对应餐食集合，跳过空值
    if (!string.IsNullOrWhiteSpace(record.BreakfastItem))
        ((List<string>)person.AteForBreakfast).Add(record.BreakfastItem);
    if (!string.IsNullOrWhiteSpace(record.LunchItem))
        ((List<string>)person.AteForLunch).Add(record.LunchItem);
    if (!string.IsNullOrWhiteSpace(record.DinnerItem))
        ((List<string>)person.AteForDinner).Add(record.DinnerItem);
}

// 最终结果
var result = personMap.Values.ToList();

优势：投影减少了数据传输体积，Dictionary的查找合并比Linq GroupBy更高效，适合10万+级别的数据量。

方案二：原生SQL+手动映射（接近Dapper MultiMap逻辑） #

如果需要完全控制SQL语句（比如利用索引、复杂过滤），可以用EF执行原生SQL，再进行字典合并：

// 定义接收原生SQL结果的DTO
public class FlatPersonMealDto
{
    public decimal Id { get; set; }
    public string Name { get; set; }
    public string BreakfastItem { get; set; }
    public string LunchItem { get; set; }
    public string DinnerItem { get; set; }
}

// 执行原生SQL
var sql = @"
SELECT p.Id, p.Name, m.BreakfastItem, m.LunchItem, m.DinnerItem
FROM Persons p
INNER JOIN Meals m ON p.Id = m.PersonId
-- 这里添加你的过滤条件
";

var flatRecords = await _context.Database
    .SqlQuery<FlatPersonMealDto>(sql)
    .ToListAsync();

// 重复方案一的字典合并逻辑
var personMap = new Dictionary<decimal, Person>();
foreach (var record in flatRecords)
{
    // 合并逻辑同方案一
}

var result = personMap.Values.ToList();

优势：完全掌控SQL性能，避免EF生成低效查询，同时复用EF的数据库连接管理。

方案三：EF Core SplitQuery（适用于有导航属性的场景） #

如果你的实体模型中已经定义了Person和Meals的导航关系，可以用AsSplitQuery拆分查询，避免扁平化重复数据：

var persons = await _context.Persons
    .Include(p => p.Meals) // 关联餐食表
    .AsSplitQuery() // 将查询拆分为两个SQL：查Person、查对应的Meals
    .AsNoTracking()
    .Select(p => new Person
    {
        Id = p.Id,
        Name = p.Name,
        AteForBreakfast = p.Meals.Where(m => !string.IsNullOrWhiteSpace(m.BreakfastItem))
                                 .Select(m => m.BreakfastItem),
        AteForLunch = p.Meals.Where(m => !string.IsNullOrWhiteSpace(m.LunchItem))
                               .Select(m => m.LunchItem),
        AteForDinner = p.Meals.Where(m => !string.IsNullOrWhiteSpace(m.DinnerItem))
                                .Select(m => m.DinnerItem)
    })
    .ToListAsync();

优势：EF自动处理关联，无需手动合并，SplitQuery避免了返回大量重复的Person基础数据，减少数据传输量。

为什么之前的GroupBy性能差？ #

Linq的GroupBy如果无法被EF转换为SQL（比如分组后需要复杂投影），会触发客户端分组，此时EF会把所有数据加载到内存再分组，大数据量下内存占用极高、性能差。而上面的方案要么先缩小数据体积，要么用更高效的Dictionary替代GroupBy，要么避免扁平化数据，从根源解决性能问题。

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