EF Core LINQ查询分组结果异常问题排查与修复

实体定义 #

public class Vehicle
{
    public long Id { get; set; }

    public string RegistrationNumber { get; set; }

    public string Model { get; set; }

    public string Code { get; set; }

    //其他属性
}

该实体在{ RegistrationNumber, Model, Code, /*另外两个属性*/ }上有唯一约束。

期望输出结构 #

需要查询生成如下层级结构的结果：

[
  {
    "name": "Model1",
    "codes": [
      {
        "name": "AAA",
        "registrationNumbers": ["2", "3"]
      },
      {
        "name":"BBB",
        "registrationNumbers": ["3", "4"]
      }
    ]
  },
  { 
    "name": "Model2",
    "codes": [
      {
        "name": "BBB",
        "registrationNumbers": ["4", "5"]
      }
    ]
  }
]

逻辑为按Model分组，每个Model下包含关联的Code列表，每个Code下对应Model+Code组合的RegistrationNumber列表。

当前LINQ查询及异常 #

编写的LINQ查询如下：

var vehicles = _context.Vehicles.Where(/*一些额外过滤条件*/)
return await vehicles.Select(v => v.Model).Distinct().Select(m => new ModelFilterDTO()
      {
          Name = m,
          Codes = vehicles.Where(v => v.Model== m).Select(v => v.Code).Distinct().Select(c => new CodeFilterDTO()
          {
              Name = c,
              RegistrationNumbers = vehicles.Where(v => v.Model == m && v.Code == c).Select(v => v.RegistrationNumber).Distinct()
          })
      }).ToListAsync();

该查询生成的SQL在SQL Server中执行结果正确，但通过LINQ返回的对象结构异常：

[
  {
    "name": "Model1",
    "codes": [
      {
        "name": "AAA",
        "registrationNumbers": [/*所有通过过滤的记录中的RegistrationNumber*/]
      }
    ]
  }
]

补充测试结果 #

1. 仅查询Model列表的LINQ可得到预期结果：

var vehicles = _context.Vehicles.Where(/*一些额外过滤条件*/)
return await vehicles.Select(v => v.Model).Distinct().Select(m => new ModelFilterDTO()
      {
          Name = m
      }).ToListAsync();

结果：

[
  {
    "name": "Model1"
  },
  { 
    "name": "Model2"
  },
  ...
]

2. 添加全量Code列表的LINQ返回结果异常：

var vehicles = _context.Vehicles.Where(/*一些额外过滤条件*/)
return await vehicles.Select(v => v.Model).Distinct().Select(m => new ModelFilterDTO()
      {
          Name = m,
          Codes = vehicles.Select(v=>v.Code).Distinct().Select(c => new CodeFilterDTO() 
          {
              Name = c
          })
      }).ToListAsync();

结果：

[
  {
    "name": "Model1",
    "codes": [
      {
        "name": "AAA"
      }
    ]
  }
]

问题源于EF Core对嵌套查询的客户端求值逻辑缺陷：

• 外层Select(m => ...)中多次引用外层定义的vehicles查询时，EF Core未正确关联内层查询的上下文参数（如m和c），导致客户端处理结果时错误复用第一个查询的结果集，未按分组条件过滤。
• 多层嵌套的Where查询生成了复杂的OUTER APPLY语句，客户端映射时容易出现分组逻辑错误。

改用一次性分组查询，通过GroupBy在数据库端完成分组，避免多层嵌套查询的上下文问题：

方案1：数据库端层级分组（推荐） #

var vehicles = _context.Vehicles.Where(/*额外过滤条件*/);

var result = await vehicles
    .GroupBy(v => new { v.Model, v.Code })
    .Select(g => new 
    {
        g.Key.Model,
        g.Key.Code,
        RegistrationNumbers = g.Select(v => v.RegistrationNumber).Distinct()
    })
    .GroupBy(x => x.Model)
    .Select(g => new ModelFilterDTO
    {
        Name = g.Key,
        Codes = g.Select(x => new CodeFilterDTO
        {
            Name = x.Code,
            RegistrationNumbers = x.RegistrationNumbers
        })
    })
    .ToListAsync();

return result;

方案2：内存端分组（小数据量适用） #

如果过滤后数据量不大，可先加载到内存再用LINQ to Objects处理分组，规避EF Core查询转换问题：

var vehicles = await _context.Vehicles.Where(/*额外过滤条件*/).ToListAsync();

var result = vehicles
    .GroupBy(v => v.Model)
    .Select(g => new ModelFilterDTO
    {
        Name = g.Key,
        Codes = g.GroupBy(v => v.Code)
            .Select(cg => new CodeFilterDTO
            {
                Name = cg.Key,
                RegistrationNumbers = cg.Select(v => v.RegistrationNumber).Distinct().ToList()
            })
            .ToList()
    })
    .ToList();

return result;

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