不使用Owned Types，如何用EF Core实现值对象的表示与存储？

针对你的需求，完全可以实现领域模型中值对象无ID，但数据库独立存储并支持直接操作的方案。EF Core的Owned Type确实不适合这种需要独立管理的场景（因为它依赖主实体，无法单独操作），下面提供两种实用方案：

方案一：使用EF Core阴影属性（Shadow Property） #

这种方式无需修改领域模型的结构，直接通过EF配置添加数据库所需的主键和外键，领域层完全感知不到这些数据库相关的属性。

1. 定义领域层的RaceType值对象 #

用record实现值对象的结构相等特性，只保留业务属性：

// 领域层值对象，无ID属性
public record RaceType(string Name)
{
    // 可选：添加业务验证逻辑
    public static RaceType Create(string name)
    {
        if (string.IsNullOrWhiteSpace(name))
            throw new ArgumentException("赛事类型名称不能为空", nameof(name));
        return new RaceType(name);
    }
}

// 领域层实体Race
public class Race
{
    public Guid Id { get; set; }
    public Athlete AthleteA { get; set; }
    public Athlete AthleteB { get; set; }
    public RaceType RaceType { get; set; } // 关联值对象
}

2. EF Core上下文配置 #

添加DbSet以便直接操作RaceType，同时在模型配置中添加阴影主键和外键：

public class AppDbContext : DbContext
{
    public DbSet<Race> Races { get; set; }
    public DbSet<RaceType> RaceTypes { get; set; } // 允许直接操作RaceType

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // 为RaceType配置阴影主键Id，自动生成Guid
        modelBuilder.Entity<RaceType>()
            .Property<Guid>("Id")
            .ValueGeneratedOnAdd();
        
        // 设置阴影属性Id为主键
        modelBuilder.Entity<RaceType>()
            .HasKey("Id");

        // 配置Name属性的唯一性（值对象通常应该唯一）
        modelBuilder.Entity<RaceType>()
            .IndexerProperty<string>(nameof(RaceType.Name))
            .IsRequired()
            .HasMaxLength(50)
            .IsUnique();

        // 配置Race与RaceType的关联，使用阴影外键
        modelBuilder.Entity<Race>()
            .HasOne(r => r.RaceType)
            .WithMany() // 无需反向导航
            .HasForeignKey("RaceTypeId") // 阴影外键，领域层不可见
            .OnDelete(DeleteBehavior.Restrict);
    }
}

3. 操作示例 #

直接增删改查RaceType，领域模型完全不用关心ID：

// 新增赛事类型
var sprint = RaceType.Create("sprint");
context.RaceTypes.Add(sprint);
await context.SaveChangesAsync();

// 查询所有赛事类型
var allRaceTypes = await context.RaceTypes.ToListAsync();

// 更新赛事类型（值对象通常是不可变的，这里可以先删除旧的再新增，或者修改Name）
var marathon = await context.RaceTypes.FirstAsync(t => t.Name == "marathon");
context.RaceTypes.Remove(marathon);
context.RaceTypes.Add(RaceType.Create("full-marathon"));
await context.SaveChangesAsync();

方案二：分层实体映射（DDD架构推荐） #

如果你的项目采用严格的DDD分层架构，可以在基础设施层创建EF专用的实体，与领域层的RaceType值对象做转换，彻底分离领域模型和数据库实现。

1. 领域层保持纯值对象 #

和方案一的RaceType、Race定义一致，无任何数据库相关属性。

2. 基础设施层创建EF专用实体 #

// 仅用于EF映射的实体，包含数据库所需的ID
public class EfRaceType
{
    public Guid Id { get; set; }
    public string Name { get; set; }
}

3. 上下文与模型配置 #

public class AppDbContext : DbContext
{
    public DbSet<Race> Races { get; set; }
    public DbSet<EfRaceType> EfRaceTypes { get; set; } // 操作EF专用实体

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // 配置EfRaceType的主键和约束
        modelBuilder.Entity<EfRaceType>()
            .HasKey(e => e.Id);
        modelBuilder.Entity<EfRaceType>()
            .Property(e => e.Name)
            .IsRequired()
            .HasMaxLength(50)
            .IsUnique();

        // 配置Race与EfRaceType的关联
        modelBuilder.Entity<Race>()
            .HasOne<EfRaceType>()
            .WithMany()
            .HasForeignKey("RaceTypeId")
            .OnDelete(DeleteBehavior.Restrict);
    }
}

4. 仓储层做实体转换 #

实现领域层的仓储接口，在内部完成EfRaceType和RaceType的转换：

public interface IRaceTypeRepository
{
    Task AddAsync(RaceType raceType);
    Task<IEnumerable<RaceType>> GetAllAsync();
    Task DeleteAsync(RaceType raceType);
}

public class RaceTypeRepository : IRaceTypeRepository
{
    private readonly AppDbContext _context;

    public RaceTypeRepository(AppDbContext context)
    {
        _context = context;
    }

    public async Task AddAsync(RaceType raceType)
    {
        var efRaceType = new EfRaceType { Name = raceType.Name };
        _context.EfRaceTypes.Add(efRaceType);
        await _context.SaveChangesAsync();
    }

    public async Task<IEnumerable<RaceType>> GetAllAsync()
    {
        var efTypes = await _context.EfRaceTypes.ToListAsync();
        return efTypes.Select(e => RaceType.Create(e.Name));
    }

    public async Task DeleteAsync(RaceType raceType)
    {
        var efType = await _context.EfRaceTypes.FirstAsync(e => e.Name == raceType.Name);
        _context.EfRaceTypes.Remove(efType);
        await _context.SaveChangesAsync();
    }
}

关键说明 #

• 你对Owned Type的理解是正确的：它是依赖于主实体的附属类型，无法单独创建DbSet或直接操作，只适合嵌入主实体的场景（比如Address这种属于某个User的属性）。
• 上述两种方案都能满足你的需求：领域模型无ID，数据库独立存储，支持直接维护RaceType列表。方案一更简洁，方案二更符合DDD分层原则，可根据项目规模选择。

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