如何用类C Union结构实现EF中Event的单非空多类型属性？

针对你的需求——让Event类关联Campaign/County/State三者之一，且用一个非空属性替代当前三个可空属性，以下是EF Core语境下的可行方案：

方案1：基类继承+EF分层映射（推荐） #

通过让三个目标类继承同一个抽象基类，再用单个非空导航属性关联，结合EF的TPH（单表继承）或TPT（多表继承）实现类似Union的语义。

步骤1：定义基类与子类 #

// 抽象基类，作为三个类型的共同父类
public abstract class EventScope
{
    public int Id { get; set; }
    // 可添加三个类的公共属性（如果有）
}

// 现有类继承基类
public class Campaign : EventScope { /* 原有属性和逻辑 */ }
public class County : EventScope { /* 原有属性和逻辑 */ }
public class State : EventScope { /* 原有属性和逻辑 */ }

步骤2：修改Event类 #

用单个非空的EventScope属性替代原有的三个可空属性：

public class Event
{
    public int Id { get; set; }
    // required关键字确保属性非空
    public required EventScope Scope { get; set; }
    // 其他原有属性
}

步骤3：EF配置映射 #

单表继承（TPH）：三个子类数据存同一张表

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    // 配置鉴别器，区分不同子类类型
    modelBuilder.Entity<EventScope>()
        .HasDiscriminator<string>("ScopeType")
        .HasValue<Campaign>("Campaign")
        .HasValue<County>("County")
        .HasValue<State>("State");

    // 配置Event与EventScope的一对多关系（无反向导航）
    modelBuilder.Entity<Event>()
        .HasOne(e => e.Scope)
        .WithMany()
        .OnDelete(DeleteBehavior.Cascade);
}

多表继承（TPT）：每个子类单独存表

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    // 每个类映射到单独的表
    modelBuilder.Entity<EventScope>().ToTable("EventScopes");
    modelBuilder.Entity<Campaign>().ToTable("Campaigns");
    modelBuilder.Entity<County>().ToTable("Counties");
    modelBuilder.Entity<State>().ToTable("States");

    // 配置关联关系
    modelBuilder.Entity<Event>()
        .HasOne(e => e.Scope)
        .WithMany()
        .OnDelete(DeleteBehavior.Cascade);
}

这种方案的优势是完全符合Union的语义，EF支持完善，且能利用数据库外键约束保证数据完整性，查询时可直接通过Scope属性访问对应实体。

方案2：鉴别器+检查约束（不修改原有类结构） #

如果不想调整现有类的继承关系，可以通过添加鉴别器字段、三个外键，配合数据库检查约束，模拟Union行为。

步骤1：修改Event类 #

添加鉴别器字段、外键，以及一个非映射的Scope属性封装逻辑：

public class Event
{
    public int Id { get; set; }
    // 标记当前关联的类型："Campaign"/"County"/"State"
    public string ScopeType { get; set; } = string.Empty;
    
    // 三个外键字段，仅一个非空
    public int? CampaignId { get; set; }
    public int? CountyId { get; set; }
    public int? StateId { get; set; }

    // 非映射属性，模拟Union的访问逻辑
    [NotMapped]
    public object Scope
    {
        get => ScopeType switch
        {
            "Campaign" => Campaign!,
            "County" => County!,
            "State" => State!,
            _ => throw new InvalidOperationException("无效的关联类型")
        };
        set
        {
            // 设置时自动清空其他关联，更新鉴别器
            switch (value)
            {
                case Campaign c:
                    Campaign = c;
                    CampaignId = c.Id;
                    County = null;
                    CountyId = null;
                    State = null;
                    StateId = null;
                    ScopeType = "Campaign";
                    break;
                case County co:
                    County = co;
                    CountyId = co.Id;
                    Campaign = null;
                    CampaignId = null;
                    State = null;
                    StateId = null;
                    ScopeType = "County";
                    break;
                case State s:
                    State = s;
                    StateId = s.Id;
                    Campaign = null;
                    CampaignId = null;
                    County = null;
                    CountyId = null;
                    ScopeType = "State";
                    break;
                default:
                    throw new ArgumentException("不支持的关联类型");
            }
        }
    }

    // 原有三个导航属性
    public Campaign? Campaign { get; set; }
    public County? County { get; set; }
    public State? State { get; set; }

    // 其他原有属性
}

步骤2：EF配置约束与关联 #

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    // 添加数据库检查约束，确保仅一个外键非空
    modelBuilder.Entity<Event>()
        .HasCheckConstraint("CK_Event_SingleScope",
            "(CampaignId IS NOT NULL AND CountyId IS NULL AND StateId IS NULL) OR " +
            "(CountyId IS NOT NULL AND CampaignId IS NULL AND StateId IS NULL) OR " +
            "(StateId IS NOT NULL AND CampaignId IS NULL AND CountyId IS NULL)");

    // 配置三个一对多关联
    modelBuilder.Entity<Event>()
        .HasOne(e => e.Campaign)
        .WithMany()
        .HasForeignKey(e => e.CampaignId)
        .OnDelete(DeleteBehavior.Restrict);

    modelBuilder.Entity<Event>()
        .HasOne(e => e.County)
        .WithMany()
        .HasForeignKey(e => e.CountyId)
        .OnDelete(DeleteBehavior.Restrict);

    modelBuilder.Entity<Event>()
        .HasOne(e => e.State)
        .WithMany()
        .HasForeignKey(e => e.StateId)
        .OnDelete(DeleteBehavior.Restrict);
}

此方案无需修改现有类结构，但需要手动维护Scope属性的逻辑，数据库层面通过检查约束保证数据合法性。

方案3：C# Union Types + JSON列（EF Core 7+） #

C# 9+支持Union Types（如Campaign|County|State），EF Core 7开始提供有限支持，可将Union类型序列化为JSON存储，但无法建立外键关联，适合无需数据库层面关联查询的场景。

步骤1：修改Event类 #

public class Event
{
    public int Id { get; set; }
    public required Campaign|County|State Scope { get; set; }
    // 其他原有属性
}

步骤2：EF配置序列化 #

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Event>()
        .Property(e => e.Scope)
        .HasConversion(
            v => JsonSerializer.Serialize(v, null),
            v => JsonSerializer.Deserialize<Campaign|County|State>(v, null)!,
            // 自定义值比较器，确保EF能正确识别相等性
            new ValueComparer<Campaign|County|State>(
                (c1, c2) => JsonSerializer.Serialize(c1) == JsonSerializer.Serialize(c2),
                c => JsonSerializer.Serialize(c).GetHashCode(),
                c => JsonSerializer.Deserialize<Campaign|County|State>(JsonSerializer.Serialize(c), null)!
            )
        );
}

这种方案代码简洁，但数据存储为JSON，无法直接用SQL查询关联实体，仅适合简单存储场景。

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