EF Core中使用强类型ID投影模型时查询失败问题排查

使用EF Core对带有强类型ID的模型进行查询并投影时，抛出如下异常：

Unhandled exception. System.InvalidOperationException:
Translation of 'EF.Property(u3.Id, "ClientId")' failed.
Either the query source is not an entity type, or the specified property does not exist on the entity type.

改用普通Guid类型代替强类型ID后，查询可正常执行并返回数据。相关代码如下：

public class Program
{
    public static void Main()
    {
        using var context = new EntityContext();

        var query = (from client in context.Clients
            let managers = from managerId in client.ManagerIds
                join user in context.Users on managerId equals user.Id
                select new { user.Id, user.Name }
            select new { client, managers }).ToList();
    }
}

public record UserId(Guid Value);
public record ClientId(Guid Value);

public class Client
{
    public ClientId Id { get; set; }
    public ICollection<UserId> ManagerIds { get; set; } = new List<UserId>();
}

public record User(UserId Id, string Name);

public class EntityContext : DbContext
{
    public DbSet<Client> Clients { get; set; }
    public DbSet<User> Users { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<User>().HasKey(x => x.Id);
        modelBuilder.Entity<User>()
            .Property(x => x.Id)
            .HasConversion(x => x.Value, x => new UserId(x));

        modelBuilder.Entity<Client>().HasKey(x => x.Id);
        modelBuilder.Entity<Client>()
            .Property(x => x.Id)
            .HasConversion(x => x.Value, x => new ClientId(x));
        modelBuilder.Entity<Client>()
            .OwnsMany(
                client => client.ManagerIds, 
                ownedNavigationBuilder =>
                {
                    ownedNavigationBuilder
                        .WithOwner()
                        .HasForeignKey("ClientId");
                    ownedNavigationBuilder
                        .Property(x => x.Value)
                        .HasColumnName("ManagerId");
                }
            );
    }
}

问题原因 #

问题出在OwnsMany配置的ManagerIds集合上：EF Core会把值类型的集合当作Owned Entity处理，生成查询时会尝试为这个Owned Entity添加外键属性ClientId，但UserId是仅包含Value属性的强类型记录，不存在ClientId属性，最终导致查询翻译失败。改用普通Guid时，EF Core直接处理原始值类型，不会触发Owned Entity的特殊逻辑，因此查询正常。

解决方案 #

方案1：改用关联实体代替值类型集合（推荐） #

创建中间关联实体ClientManager，通过标准多对多关联连接Client和User，避免EF Core将值类型集合识别为Owned Entity：

// 新增中间关联实体
public class ClientManager
{
    public ClientId ClientId { get; set; }
    public UserId ManagerId { get; set; }
    public Client Client { get; set; }
    public User Manager { get; set; }
}

// 修改Client类，替换ManagerIds为ClientManagers集合
public class Client
{
    public ClientId Id { get; set; }
    public ICollection<ClientManager> ClientManagers { get; set; } = new List<ClientManager>();
}

// 在EntityContext的OnModelCreating中配置关联
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    // 原有User和Client的强类型ID配置保持不变

    // 配置中间实体的复合主键
    modelBuilder.Entity<ClientManager>()
        .HasKey(c => new { c.ClientId, c.ManagerId });

    // 配置Client与ClientManager的一对多关联
    modelBuilder.Entity<ClientManager>()
        .HasOne(c => c.Client)
        .WithMany(c => c.ClientManagers)
        .HasForeignKey(c => c.ClientId);

    // 配置User与ClientManager的一对多关联
    modelBuilder.Entity<ClientManager>()
        .HasOne(c => c.Manager)
        .WithMany()
        .HasForeignKey(c => c.ManagerId);

    // 配置中间实体的强类型ID转换
    modelBuilder.Entity<ClientManager>()
        .Property(c => c.ClientId)
        .HasConversion(x => x.Value, x => new ClientId(x));

    modelBuilder.Entity<ClientManager>()
        .Property(c => c.ManagerId)
        .HasConversion(x => x.Value, x => new UserId(x));
}

修改查询语句，通过中间实体关联User：

var query = (from client in context.Clients
             let managers = from cm in client.ClientManagers
                            join user in context.Users on cm.ManagerId equals user.Id
                            select new { user.Id, user.Name }
             select new { client, managers }).ToList();

方案2：内存中处理关联（临时解决） #

如果不想修改模型结构，可以先将Client和ManagerIds加载到内存，再在内存中关联User，绕开EF Core的查询翻译问题：

using var context = new EntityContext();

// 先加载所有Client及其ManagerIds到内存
var clients = context.Clients
    .Include(c => c.ManagerIds)
    .ToList();

// 提取所有需要查询的UserId，批量获取User数据
var allManagerIds = clients.SelectMany(c => c.ManagerIds).ToList();
var managerUsers = context.Users
    .Where(u => allManagerIds.Contains(u.Id))
    .ToDictionary(u => u.Id);

// 在内存中关联数据
var result = clients.Select(c => new
{
    client = c,
    managers = c.ManagerIds
        .Where(id => managerUsers.ContainsKey(id))
        .Select(id => new { Id = id, Name = managerUsers[id].Name })
}).ToList();

方案对比 #

• 方案1是EF Core推荐的多对多关联实现方式，逻辑清晰，性能稳定，适合长期维护的项目。
• 方案2无需修改模型，适合快速临时解决问题，但需注意内存处理的数据量，避免内存溢出。

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