ASP.NET Core Web API-EF Core7多对多查询：单结果需集合返回类型问题

我有两个表存在多对多关系，希望在过滤其中一方后，获取另一方的单个条目。以Person和PersonRole表为例，其中角色为客户负责人，我想根据指定客户ID获取单个负责人。

实体类代码 #

public class Person
{
    [Key]
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public int Id { get; set; }
    public string FirstName { get; set; } = string.Empty;
    public string MiddleName { get; set; } = string.Empty;
    public string LastName { get; set; } = string.Empty;
    public ICollection<PersonRole> PersonRole { get; set; } = new List<PersonRole>();
}

public class PersonRole
{
    [Key]
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public int PersonRoleId { get; set; }
    public int PersonRoleLUId { get; set; }
    public string RoleTargetType { get; set; }
    public int RoleTargetId { get; set; }
    public ICollection<Person> Person { get; set; } = new List<Person>();
}

可运行但返回集合的仓储类 #

// 获取指定客户的单个负责人。
// 唯一能编译通过的方式是使用集合作为返回类型。
// 这感觉不太合理，我正在寻找更合适的实现方式。  
public async Task<IEnumerable<Person>> GetChampionForCustomerAsync(int customerId,
         int championId)
{
    const int CustomerChampionRoleId = 1;

    return await _context.PersonRoles
                         .Where(personRole => personRole.PersonRoleLUId == CustomerChampionRoleId)
                         .Where(personRole => personRole.RoleTargetType == "Customer")
                         .Where(personRole => personRole.RoleTargetId == customerId)
                         .Include(personRole => personRole.Person)
                         .Select(person => person.Person
                                                 .Where(person => person.Id == championId))
                         .FirstOrDefaultAsync();
}

无法运行的仓储类 #

public async Task<Person> GetChampionForCustomerAsync(int customerId, int championId)
{
    const int CustomerChampionRoleId = 1;

    return (Person) await _context.PersonRoles
                                  .Where(personRole => personRole.PersonRoleLUId == CustomerChampionRoleId)
                                  .Where(personRole => personRole.RoleTargetType == "Customer")
                                  .Where(personRole => personRole.RoleTargetId == customerId)
                                  .Include(personRole => personRole.Person)
                                  .Select(person => person.Person
                                                          .Where(person => person.Id == championId))
                                  .SingleOrDefaultAsync();
}

错误信息 #

CS0266 无法将类型“System.Collections.Generic.IEnumerable<MaelstromPlatform.API.Entities.Person>”隐式转换为“MaelstromPlatform.API.Entities.Person”。存在显式转换(是否缺少强制转换?) MaelstromPlatform.API

System.InvalidCastException: 无法将类型为“System.Collections.Generic.List`1[MaelstromPlatform.API.Entities.Person]”的对象强制转换为类型“MaelstromPlatform.API.Entities.Person”。

不添加提示的强制转换时，编译会出现第一个错误；添加强制转换后可编译，但运行API调用时会在日志和Swagger中出现第二个错误。

疑问解答 #

1. 为何使用集合作为返回类型就能正常运行？ #

你的Select操作返回的是person.Person.Where(...)，Where方法的返回值始终是IEnumerable<Person>，哪怕结果只有一条数据，它依然是集合类型。当返回类型定义为IEnumerable<Person>时，类型完全匹配，因此能正常编译和运行。

2. 为何使用.SingleOrDefault仍返回集合？ #

.SingleOrDefault是作用在PersonRoles集合上的，它只会确保你从PersonRoles中拿到单个匹配的角色条目，但你在Select里对该条目关联的Person集合做了Where过滤，最终得到的还是IEnumerable<Person>类型。.SingleOrDefault并没有改变Select的返回类型，所以整体结果依然是集合。

3. 为何添加强制转换后编译通过但运行时失败？ #

编译阶段仅做静态类型检查，显式强制转换会让编译器暂时允许类型不匹配的情况。但运行时实际返回的是List<Person>（EF Core会将IEnumerable转为具体的List实现），List<Person>和Person是完全不同的类型，无法直接强制转换，因此抛出InvalidCastException。

4. 是否有其他表结构或查询方式可实现需求？ #

优化查询方式

可以调整LINQ查询，直接返回单个Person对象：

public async Task<Person> GetChampionForCustomerAsync(int customerId, int championId)
{
    const int CustomerChampionRoleId = 1;

    // 方式一：从Person表出发查询
    return await _context.Person
                         .Where(p => p.Id == championId)
                         .Include(p => p.PersonRole)
                         .Where(p => p.PersonRole.Any(pr => 
                             pr.PersonRoleLUId == CustomerChampionRoleId &&
                             pr.RoleTargetType == "Customer" &&
                             pr.RoleTargetId == customerId))
                         .SingleOrDefaultAsync();
}

或者从PersonRole出发，直接筛选出目标Person：

public async Task<Person> GetChampionForCustomerAsync(int customerId, int championId)
{
    const int CustomerChampionRoleId = 1;

    // 方式二：从PersonRole表出发查询
    return await _context.PersonRoles
                         .Where(pr => pr.PersonRoleLUId == CustomerChampionRoleId &&
                                      pr.RoleTargetType == "Customer" &&
                                      pr.RoleTargetId == customerId)
                         .SelectMany(pr => pr.Person)
                         .Where(p => p.Id == championId)
                         .SingleOrDefaultAsync();
}

表结构优化（可选）

当前的PersonRole作为带额外字段的连接实体，设计是合理的，无需修改表结构。如果后续需要关联更多类型的实体（如项目、部门），可以考虑用显式外键或继承优化，但当前需求下调整查询方式即可解决问题。

内容的提问来源于stack exchange，提问作者Jason Alan Smith