EF Core – 继承 Inheritance

前言

继承是面向对象里的概念. 关系数据库只有一对一, 一对多这类关系, 并没有 "继承" 关系的概念. 所以 ORM (Object–relational mapping) 就需要搞一些规则来映射出它.

这篇就说说 EF Core 如果映射继承关系.

题外话: 继承不顺风水, 尽量少用, 我的从前的经验是 OData 配 Entity Framework 6.0 继承经常会出 Bug. 就不知道这么多年后的 EF Core 有没有改善.

参考

Docs – Inheritance

How to configure inheritance mappings in Entity Framework 7

TPH (Table-per-hierarchy)

映射不只有一种方式, 目前一共有 3 种. 第一种叫 TPH (Table-per-hierarchy)

它有几个特色

1. 数据库只用一个表

2. 派生类的属性映射的 column 一定要是 nullable

优点是 query 速度快, 缺点是数据库结构有点乱, 因为它把全部东西都塞进一个表, 又那么多 nullable.

Model

假设有 4 个类

Cat, Dog, Fish ≼ Animal

public abstract class Animal
{
    public int Id { get; set; }
    public string SharedField { get; set; } = "";
}

public class Cat : Animal
{
    public string CatField { get; set; } = "";
}
public class Dog : Animal
{
    public string DogField { get; set; } = "";
}
public class Fish : Animal
{
    public string FishField { get; set; } = "";
}

注: Animal 是 abstract 类

Fluent API

public class ApplicationDbContext : DbContext
{
    public DbSet<Animal> Animals => Set<Animal>();
    public DbSet<Cat> Cat => Set<Cat>();
    public DbSet<Dog> Dogs => Set<Dog>();
    public DbSet<Fish> Fishes => Set<Fish>();
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Animal>().UseTphMappingStrategy();
    }
}

在 base class 声明 UseTphMappingStrategy 就可以了.

Database

数据库长这样.

只有一个表, 派生类的属性 Cat, Dog, Fish Field 都强制 nullable

Discriminator column 用来记入它们 under 什么类型.

进了数据后长这样

Column Name 的规则

by default 属性名会直接映射 column name. EF 不会加任何 prefix. 但如果不巧, 有一些派生类有相同属性 (但又不是全部派生类都有)

那么 EF 会加入 prefix

public class Dog : Animal
{
    public string Name { get; set; } = "";
    public string LastName { get; set; } = "";
}
public class Fish : Animal
{
    public int Age { get; set; }
    public string LastName { get; set; } = "";
}

Name, Age 没有 prefix, Fish.LastName 则会加入 prefix

注: 它不是两个都加 prefix, 而是只加其中一个...如果我们统一的话就需要自己配置了 (比如 set column name)

Shared Column

如果碰巧 LastName 的类型是一样的. 那么我们可以搞一个 shared column, 让它们共享一个 LastName column. 具体做法是 set 相同的 column name.

modelBuilder.Entity<Animal>().UseTphMappingStrategy();
modelBuilder.Entity<Dog>().Property(e => e.LastName).HasColumnName("LastName");
modelBuilder.Entity<Fish>().Property(e => e.LastName).HasColumnName("LastName");

效果

一些 Configuration

上面我都用了 default 的命名. EF 允许我们做一些配置.

public abstract class Animal
{
    public int Id { get; set; }
    public string SharedField { get; set; } = "";
    public string Type { get; set; } = ""; // 加入一个 Type 替代默认的 Discriminator
}

配置

modelBuilder.Entity<Animal>().UseTphMappingStrategy()
    .HasDiscriminator(e => e.Type)
    .HasValue<Cat>("MyCat")
    .HasValue<Dog>("MyDog")
    .HasValue<Fish>("MyFish");

modelBuilder.Entity<Animal>().Property(e => e.Type).HasMaxLength(256);

这样我们就完全控制了 Discriminator.

TPT (Table-per-type)

第二种映射方式是 TPT (Table-per-type)

它的特色是表多.

不管是 base class 还是派生类, 统统建一个表.

优点是数据库结构好看, 不像 TPH 全部塞一个表, 又一堆 nullable. 缺点就是 query 慢. 因为每次 query 都需要 join.

就是因为有许多的 trade-off 所以 EF 才搞了 3 种 pattern 做映射. 你可以依据你的需求找出比较合适的 pattern. 死死用其中一个是不恰当的哦.

Fluen API

modelBuilder.Entity<Animal>().UseTptMappingStrategy();

Database

4 个类就 4 个表

每个表负责自己的 column

Id and relation 规则

join 表是靠相同 Id 完成的. 只有 base table 的 Id 是 auto increment. 其余的是 insert 时填进去的.

insert 过程是这样的.

无论 insert Dog, Fish, Cat. 首先 insert Animal 然后拿 Animal Id 去 insert 子表.

所以它不只是 query 慢, insert 也慢...这个映射 pattern 就是结构好. 但性能烂到家.

TPC (Table-per-concrete-type)

TPC 是 EF 7.0 才推出的. 它位于 TPH 和 TPT 的中间. 在性能和结构上又做了一些 balance.

它的特色是

抽象类不建表, 每一个子类各一个表.

抽象类的属性, 每一个子表都有相同的 column.

比快, 大部分情况下比不过 TPH, 但如果你单独 query 某一个类的数据, 它会比 TPH 还快.

比结构, 至少比 TPH 全部塞一表好, 而且也不需要 nullable. 比 TPT 差了一点点.

三表的速度比拼. 参考: Entity Framework 7 TPH, TPT and TPC inheritance mapping performance benchmarks

TPT 完全没有优势...哈哈

Fluent API

modelBuilder.Entity<Animal>().UseTpcMappingStrategy();

Id and relation 规则

TPT 利用 base table 来统一 Id, TPC 没了 base table 它怎么管理呢?

答案是 Sequence

Database

没有了 Animals 表, SharedField column 则每一个表都有.

总结

EF 一共给了 3 种方式来映射继承关系.

TPH

- 最 popular

- 绝大部分情况最快

- 全部属性塞一个表, 表臃肿

- 一堆 nullable 很烦人

TPT

- 结构最贴近 class, 每一个 class 都映射一个表

- 表干净, 没有 nullable, 也没有其它 class 的属性

- 速度慢, query 时要 join 表, insert 时要先 insert base table 拿到 id 后才 insert 子类的表

TPC

- 表干净, 没有 nullable, 也没有其它 class 的属性

- 速度还不错, query all 需要 join 表, 但 query one type 连 where 都不需要, 比 TPH 还快. insert 时不需要像 TPT insert 2 次, 所以比 TPT 快.

怎么选

首选 TPH. 除非 nullable 给了你很大的困扰, 或者 column 真的太多太臃肿了可以考虑换成 TPC

如果你确信业务需求通常都是指定 query 某个类, 那么可以优先考虑 TPC.

TPT 就等着被淘汰吧.

当 1-n 遇上 Inheritance

1-n relation 是这样的, 一个 Person 有 n 个 Animals

public class Person
{
    public int Id { get; set; }
    public List<Animal> Animals { get; set; } = new();
}

public abstract class Animal
{
    public int Id { get; set; }
    public Person Person { get; set; } = null!;
    public int PersonId { get; set; }
    public string SharedField { get; set; } = "";
}

public class Cat : Animal
{
    public string CatField { get; set; } = "";
}
public class Dog : Animal
{
    public string DogField { get; set; } = "";

}
public class Fish : Animal
{
    public string FishField { get; set; } = "";
}

Relation Config

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Animal>().HasOne(e => e.Person).WithMany(e => e.Animals).HasForeignKey(e => e.PersonId).OnDelete(DeleteBehavior.Cascade);
}

如果我希望拆分成个别具体类型可以吗? 行!

public class Person
{
    public int Id { get; set; }
    // public List<Animal> Animals { get; set; } = new();
    public List<Dog> Dogs { get; set; } = new();
    public List<Cat> Cats { get; set; } = new();
    public List<Fish> Fishes { get; set; } = new();
}

Relation Config

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Dog>().HasOne(e => e.Person).WithMany(e => e.Dogs).HasForeignKey(e => e.PersonId).OnDelete(DeleteBehavior.Cascade);
    modelBuilder.Entity<Cat>().HasOne(e => e.Person).WithMany(e => e.Cats).HasForeignKey(e => e.PersonId).OnDelete(DeleteBehavior.Cascade);
    modelBuilder.Entity<Fish>().HasOne(e => e.Person).WithMany(e => e.Fishes).HasForeignKey(e => e.PersonId).OnDelete(DeleteBehavior.Cascade);
    // modelBuilder.Entity<Animal>().HasOne(e => e.Person).WithMany(e => e.Animals).HasForeignKey(e => e.PersonId).OnDelete(DeleteBehavior.Cascade); // 一定要在下面
}

这样子是 ok 的, 但是不可以抽象具体一起 (把上面注释的打开, 就不行了)

一旦抽象具体一起, 数据库就会变成多个 PersonId column. 哪怕我们用 shared column 也无发让它们变成一个 column.

我觉得是它目前支持的不好, 以后或许是可以的.