先补充一下前一篇中的 TPH 策略的内容------非完整性类型鉴别器。这个东西官方文档写了等于没写，许多大伙伴可能不知道是啥玩意儿。不用慌，老周给你整个示例，你就懂了。
这种特例多见于先有数据库（DB First）的方案。好，那咱们就先建库，脚本如下，很简单。
use master;
go
-- 创建数据库
create database schoolDB;
go
use schoolDB;
go
-- 创建表
create table [tb_students]
(
-- 基类字段
id int identity not null,
[name] nvarchar(20) not null,
[age] int not null,
-- "转校生"字段
src_school nvarchar(40) null,
-- "留级生"字段
repeat_grade int null,
-- 鉴别器字段
_type char(1) not null,
-- 主键
constraint [PK_Student] primary key ([id] asc)
);
go
-- 添加点数据
insert into tb_students
([name], age, src_school, repeat_grade, _type)
values
(N'王番薯', 19, NULL, NULL, 'S'),
(N'吴正经', 20, N'华中聊汉大学', NULL, 'T'),
(N'余小琳', 17, NULL, 3, 'R'),
(N'欧皮革', 20, NULL, NULL, 'Z');
go上述脚本做了三件事：
1、创建数据库，命名为 schoolDB；
2、在库中建表，名为 tb_students；
3、往表中写入新数据，用于示例。
tb_students 表其实包含了三个实体：
A、正常学生（id、name、age）；
B、转校生，在正常学生基础上增加了 src_school 列，表示从哪个学校转过来的；
C、留级生，在正常学生基础上增加 repeat_grade 列，重读的年级。
用作类型鉴别器的是 _type 列，S 指代正常学生，T 指代转校生，R 指代留级生，Z 无意义。
好了，数据库搞好了，下面弄 EF Core。
先定义三个实体类。
/// <summary>
/// 正常学生
/// </summary>
public class Student
{
public int Id { get; set; }
public required string Name { get; set; }
public int Age { get; set; }
}
/// <summary>
/// 转校生
/// </summary>
public class TransferStudent : Student
{
public string SourceSchool { get; set; } = null!;
}
/// <summary>
/// 留级生
/// </summary>
public class RepeatStudent:Student
{
public int RepeatGrade { get; set; }
}在数据库上下文的 OnModelCreating 方法中配置模型。
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
// 映射策略和主键都要在基类上配置
modelBuilder.Entity<Student>(ent =>
{
ent.UseTphMappingStrategy();
ent.HasKey(x => x.Id);
// 表映射
ent.ToTable("tb_students");
// 列映射
ent.Property(x => x.Id).HasColumnName("id");
ent.Property(x => x.Name).HasColumnName("name").HasMaxLength(20);
ent.Property(x => x.Age).HasColumnName("age");
// 鉴别器
ent.HasDiscriminator<string>("StuType")
.HasValue<Student>("S")
.HasValue<TransferStudent>("T")
.HasValue<RepeatStudent>("R");
ent.Property<string>("StuType").HasColumnName("_type").HasMaxLength(1);
});
// 派生类的映射
modelBuilder.Entity<TransferStudent>(ent =>
{
ent.Property(x => x.SourceSchool).HasMaxLength(40).HasColumnName("src_school");
});
modelBuilder.Entity<RepeatStudent>(ent =>
{
ent.Property(u => u.RepeatGrade).HasColumnName("repeat_grade");
});
}现在咱们尝试把所有数据查询出来。
// 配置连接字符串
DbContextOptionsBuilder<MyContext> opbuilder = new();
opbuilder.UseSqlServer("Data Source=.\\TEST;Initial Catalog=schoolDB;Integrated Security=True;Persist Security Info=False;Encrypt=True;TrustServerCertificate=True");
using var context = new MyContext(opbuilder.Options);
// 获取数据集合
DbSet<Student> stus = context.Set<Student>();
// 打印
foreach(var s in stus)
{
Console.WriteLine("id: {0}", s.Id);
Console.WriteLine("name: {0}", s.Name);
Console.WriteLine("age: {0}", s.Age);
if(s is TransferStudent tfstu)
{
Console.WriteLine("source school: {0}", tfstu.SourceSchool);
}
if(s is RepeatStudent rpstu)
{
Console.WriteLine("repeat grade: {0}", rpstu.RepeatGrade);
}
Console.WriteLine();
}这个代码在运行后，你会看到该错误：
现在回过头看看鉴别器配置。
ent.HasDiscriminator<string>("StuType")
.HasValue<Student>("S")
.HasValue<TransferStudent>("T")
.HasValue<RepeatStudent>("R");再看看数据库中的数据。
select _type from tb_students
根据咱们的配置，Student 类由 S 表示，TransferStudent 类由 T 表示，RepeatStudent 类由 R 表示。Z 是没有类型映射的，这个异常的意思就是类型的鉴别值不完整------就是多了个Z出来，EF Core 不知道 Z 跟哪个实体类有关。
这种情况，我们要明确告诉 EF Core，咱们这个数据库中的鉴别器的值与实际的实体类型没有完全匹配的，我们所配置的类型鉴别的值是不完整的。
ent.HasDiscriminator<string>("StuType")
.HasValue<Student>("S")
.HasValue<TransferStudent>("T")
.HasValue<RepeatStudent>("R")
.IsComplete(false);true 表示类型列表是完整的，false 是不完整的。这样配置后就不会抛异常了。
现在进入主题，今天咱们聊 TPT 策略。TPT 会为每个实体类型独立映射一个数据表，但表中的列仅限于当前类所定义的成员，不包含从基类继承的成员。
咱们依旧使用上面那三个【学生】实体，不过，这次配置为 TPT 映射策略。
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
// 映射策略和主键都要在基类上配置
modelBuilder.Entity<Student>(ent =>
{
ent.UseTptMappingStrategy();
ent.HasKey(x => x.Id);
// 表映射
ent.ToTable("tb_students", tb =>
{
tb.Property(u => u.Id).HasColumnName("id");
tb.Property(u => u.Name).HasColumnName("name");
tb.Property(u => u.Age).HasColumnName("age");
});
ent.Property(x => x.Name).HasMaxLength(20);
});
// 派生类的映射
modelBuilder.Entity<TransferStudent>(ent =>
{
ent.Property(x => x.SourceSchool).HasMaxLength(40);
// 表映射
ent.ToTable("tb_trf_students", tb =>
{
tb.Property(i => i.Id).HasColumnName("mid");
tb.Property(i => i.SourceSchool).HasColumnName("src_school");
});
});
modelBuilder.Entity<RepeatStudent>(ent =>
{
// 表映射
ent.ToTable("tb_rpt_students", tb =>
{
tb.Property(w => w.Id).HasColumnName("mid");
tb.Property(w => w.RepeatGrade).HasColumnName("repeat_grade");
});
});
}不管你用哪种映射策略，UseXXXMappingStrategy 方法必须在配置基类实体时调用，不能在派生类的配置中调用，那样会报错。
由于 TPT 是每个类型一个表，所以你可以用 ToTable 方法为各个表自定义名称。
这里各位要注意：列映射的自定义名称最好在 ToTable 方法中通过 TableBuilder 对象来配置，不要在实体属性上直接配置（ent.Property(...).HasColumnName(...)）。这是因为在 PropertyBuilder 上配置的列名是通过 Annotations 字典（Key = Relational:ColumnName）来存储的，这表明这个列名你能存储一个值。如果这个属性被多次列映射，那么，后面设置的列名会覆盖掉前面设置的列名，而不管你映射的是否为同一个表。
对 TPT 策略而言，只有主键列会被多次映射，其他属性不会有覆盖的问题（派生类的表不包含基类成员，自然就不会重复映射了）。比如，基类 Student，在 tb_students 表中映射了 Id、Name、Age 属性；到了 TransferStudent 类，它只定义了 SourceSchool 属性，所以表 tb_trf_students 中只映射 SourceSchool 成员。RepeatStudent 实体同理。
从上面的配置代码看到，只有 Id 属性被做了多次列映射。所以，除了 Id 属性以外，其他属性是可以在 PropertyBuilder 上用 HasColumnName 方法配置列映射的，但为了代码更好看，统一用 TableBuilder 来配置最好。尤其在 TPC 策略下各个属性都会多次映射（本文先不提）。
那么，为什么 TPT 策略要把基类的主键映射多次呢？看看它生成的 SQL 语句，你或许就明白了。
CREATE TABLE [tb_students] (
[id] int NOT NULL IDENTITY,
[name] nvarchar(20) NOT NULL,
[age] int NOT NULL,
CONSTRAINT [PK_tb_students] PRIMARY KEY ([id])
);
GO
CREATE TABLE [tb_rpt_students] (
[mid] int NOT NULL,
[repeat_grade] int NOT NULL,
CONSTRAINT [PK_tb_rpt_students] PRIMARY KEY ([mid]),
CONSTRAINT [FK_tb_rpt_students_tb_students_mid] FOREIGN KEY ([mid]) REFERENCES [tb_students] ([id]) ON DELETE CASCADE
);
GO
CREATE TABLE [tb_trf_students] (
[mid] int NOT NULL,
[src_school] nvarchar(40) NOT NULL,
CONSTRAINT [PK_tb_trf_students] PRIMARY KEY ([mid]),
CONSTRAINT [FK_tb_trf_students_tb_students_mid] FOREIGN KEY ([mid]) REFERENCES [tb_students] ([id]) ON DELETE CASCADE
);
GO不知道大伙伴们看出啥门道了没有。在 TPT 映射策略中，只有基类的主键列会生成/插入新值，其他派生类表都是通过外键来引用基类表的主键的。正因为这样，所以在查询数据时，就等于做联表查询，这使得 TPT 策略的性能会比其他策略低。
啥意思呢，咱们试着插入几条记录就知道了。
using var context = new MyContext(opbuilder.Options);
context.Database.EnsureCreated(); // 运行时创建数据库
// 获取数据集合
DbSet<Student> students = context.Set<Student>();
// 添加新记录
students.AddRange([
new Student{Name = "吴珍珠", Age = 18},
new TransferStudent{Name = "王大山", Age = 18, SourceSchool = "飓风中学"},
new RepeatStudent{Name = "陆大锤", Age = 17, RepeatGrade = 2}
]);
// 保存数据
context.SaveChanges();咱们每个类型各添加一条记录，看看数据库怎么存储它们。
select * from tb_students;
select * from tb_trf_students;
select * from tb_rpt_students;
【吴珍珠】同学的 Id 为2，因为它是 Student 类，作为基类，只用到 tb_students 表；
【王大山】同学的 Id 为 3，它是 TransferStudent 类。从基类继承的 Name 和 Age 属性存放到 tb_students 表中，而 SourceSchool 属性的值则存放在 tb_trf_students 表的 src_school 列中；
【陆大锤】同学的 Id 为1，它是 RepeatStudent 类，其中 Name、Age 属性存入 tb_students 列，而它所定义的 RepeatGrade 属性的值就存入 tb_rpt_students 表的 repeat_grade 列。
最后，咱们把注意力放在主键列上。所有记录的主键值都在基类表中生成（tb_students.id 列），然后
对于【吴珍珠】同学，它就在基类表中，不需要外键引用；
对于【王大山】同学，tb_trf_students.mid 列通过外键，引用了主键值 3；
对于【陆大锤】同学，tb_rpt_students.mid 列通过外键引用了主键值 1；
目前 EF Core 在配置主键的约束名称是有限制的，所以不要去自定义主键的约束。
// 不要调用 HasName 方法
ent.HasKey(x => x.Id).HasName("PK_what_the_fk");下面老周解释一下为什么会有这个局限。
1、派生类中不允许配置主键。看看 EntityType.SetPrimaryKey 方法的源代码。
public virtual Key? SetPrimaryKey(
IReadOnlyList<Property>? properties,
ConfigurationSource configurationSource)
{
EnsureMutable();
Check.DebugAssert(IsInModel, "The entity type has been removed from the model");
if (BaseType != null)
throw newInvalidOperationException(CoreStrings.DerivedEntityTypeKey(DisplayName(), GetRootType().DisplayName())); }
......
}意思就是如果你正在配置的实体存在基类，那就抛出异常。所以，你只能在基类上配置主键。
2、对于 EF Core 的数据库模型，如果实体存在继承关系，那么，派生类实体所继承的成员，与基类实体所定义的同一个成员，它们之间使用相同的元数据。这后果是，如果你在 Student 类中配置了主键的约束名为 PK_XXX，那么，TransferStudent 类和 RepeatStudent 类的 Id 属性都从 Student 害继承，即它们的元数据相同，导致所有数据表的主键的约束名都变成 PK_XXX。多个表使用相同的约束名，在数据库中会报错。
所以，你不能改变约束名，一改就全部一起改掉了。但保留 EF Core 的默认配置就没有问题，因为 EF Core 在生成 SQL 语句时，主键默认的名字是 PK_<表名>，外键是 FK_<表名>，这样就不会出现重复约束名了。
public static string? GetDefaultName(
this IReadOnlyKey key,
in StoreObjectIdentifier storeObject,
IDiagnosticsLogger<DbLoggerCategory.Model.Validation>? logger)
{
if (storeObject.StoreObjectType != StoreObjectType.Table
|| key.DeclaringEntityType.IsMappedToJson())
{
return null;
}
if (key.DeclaringEntityType.IsMappedToJson())
{
return null;
}
string? name;
if (key.IsPrimaryKey())
{
var rootKey = key;
// Limit traversal to avoid getting stuck in a cycle (validation will throw for these later)
// Using a hashset is detrimental to the perf when there are no cycles
for (var i = 0; i < RelationalEntityTypeExtensions.MaxEntityTypesSharingTable; i++)
{
var linkingFk = rootKey!.DeclaringEntityType.FindRowInternalForeignKeys(storeObject)
.FirstOrDefault();
if (linkingFk == null)
{
break;
}
rootKey = linkingFk.PrincipalEntityType.FindPrimaryKey();
}
if (rootKey != null
&& rootKey != key)
{
return rootKey.GetName(storeObject);
}
name= "PK_" +storeObject.Name;
}
else
{
var columnNames = key.Properties.GetColumnNames(storeObject);
if (columnNames == null)
{
if (logger != null)
{
var table = storeObject;
if (key.DeclaringEntityType.GetMappingFragments(StoreObjectType.Table)
.Any(t => t.StoreObject != table && key.Properties.GetColumnNames(t.StoreObject) != null))
{
return null;
}
if (key.DeclaringEntityType.GetMappingStrategy() != RelationalAnnotationNames.TphMappingStrategy
&& key.DeclaringEntityType.GetDerivedTypes()
.Select(e => StoreObjectIdentifier.Create(e, StoreObjectType.Table))
.Any(t => t != null && key.Properties.GetColumnNames(t.Value) != null))
{
return null;
}
logger.KeyPropertiesNotMappedToTable((IKey)key);
}
return null;
}
var rootKey = key;
// Limit traversal to avoid getting stuck in a cycle (validation will throw for these later)
// Using a hashset is detrimental to the perf when there are no cycles
for (var i = 0; i < RelationalEntityTypeExtensions.MaxEntityTypesSharingTable; i++)
{
IReadOnlyKey? linkedKey = null;
foreach (var otherKey in rootKey.DeclaringEntityType
.FindRowInternalForeignKeys(storeObject)
.SelectMany(fk => fk.PrincipalEntityType.GetKeys()))
{
var otherColumnNames = otherKey.Properties.GetColumnNames(storeObject);
if ((otherColumnNames != null)
&& otherColumnNames.SequenceEqual(columnNames))
{
linkedKey = otherKey;
break;
}
}
if (linkedKey == null)
{
break;
}
rootKey = linkedKey;
}
if (rootKey != key)
{
return rootKey.GetName(storeObject);
}
name = new StringBuilder()
.Append("AK_")
.Append(storeObject.Name)
.Append('_')
.AppendJoin(columnNames, "_")
.ToString();
}
return Uniquifier.Truncate(name, key.DeclaringEntityType.Model.GetMaxIdentifierLength());
}这时候有大伙伴可能想到了使用约定来修改主键的约束名称。
public class MyConvention : IModelFinalizingConvention
{
public void ProcessModelFinalizing(IConventionModelBuilder modelBuilder, IConventionContext<IConventionModelBuilder> context)
{
var entStudent = modelBuilder.Metadata.FindEntityType(typeof(Student));
if(entStudent != null)
{
var key = entStudent.FindPrimaryKey() asIMutableKey;
if(key != null)
{
key.SetName("PK_Stu_base");
}
}
var entTrfStudent = modelBuilder.Metadata.FindEntityType(typeof(TransferStudent));
if(entTrfStudent != null)
{
var key = entTrfStudent.FindPrimaryKey() as IMutableKey;
if(key != null)
{
key.SetName("PK_Transf_stu");
}
}
var entRptStudent = modelBuilder.Metadata.FindEntityType(typeof(RepeatStudent));
if (entRptStudent != null)
{
var key = entRptStudent.FindPrimaryKey() as IMutableKey;
if (key != null)
{
key.SetName("PK_Rpt_stu");
}
}
}
}数据库模型一旦 Finalized 阶段就变成只读了，无法修改元数据。所以你不能在实例化 DbContext 之后修改，那时候已经改不了。故，咱们要用约定的话，只能在 Finalizing 阶段。这时候模型的配置已经完成，但还未被固化（只读），即实现 IModelFinalizingConvention 接口，这样做可以避免被其他约定干扰。
约定类写好后，重写 DbContext.ConfigureConventions 方法，将其注册到约定集合中。
protected override void ConfigureConventions(ModelConfigurationBuilder configurationBuilder)
{
configurationBuilder.Conventions.Add(_=> newMyConvention());
}然而，结果会让你失望的。
CREATE TABLE [tb_students] (
[id] int NOT NULL IDENTITY,
[name] nvarchar(20) NOT NULL,
[age] int NOT NULL,
CONSTRAINT [PK_Rpt_stu] PRIMARY KEY ([id])
);
GO
CREATE TABLE [tb_rpt_students] (
[mid] int NOT NULL,
[repeat_grade] int NOT NULL,
CONSTRAINT [PK_Rpt_stu] PRIMARY KEY ([mid]),
CONSTRAINT [FK_tb_rpt_students_tb_students_mid] FOREIGN KEY ([mid]) REFERENCES [tb_students] ([id]) ON DELETE CASCADE
);
GO
CREATE TABLE [tb_trf_students] (
[mid] int NOT NULL,
[src_school] nvarchar(40) NOT NULL,
CONSTRAINT [PK_Rpt_stu] PRIMARY KEY ([mid]),
CONSTRAINT [FK_tb_trf_students_tb_students_mid] FOREIGN KEY ([mid]) REFERENCES [tb_students] ([id]) ON DELETE CASCADE
);
GO只要改其中一个，等于全部主键都改了。这时可以初步推断，由于主键是从基类继承的，所以，派生类实体的元数据中，使用的主键对象是同一个实例。
要证明这个推测也很容易，我们打印出三个实体的 Key 对象的内存地址。
public class MyConvention : IModelFinalizingConvention
{
private void PrintObjectAddress(string tag, object obj)
{
GCHandle handle = GCHandle.Alloc(obj, GCHandleType.WeakTrackResurrection);
IntPtr addr = GCHandle.ToIntPtr(handle);
handle.Free();
Console.WriteLine("{0}: 0x{1:X}", tag, addr);
}
public void ProcessModelFinalizing(IConventionModelBuilder modelBuilder, IConventionContext<IConventionModelBuilder> context)
{
var entStudent = modelBuilder.Metadata.FindEntityType(typeof(Student));
if(entStudent != null)
{
var key = entStudent.FindPrimaryKey() as IMutableKey;
if(key != null)
{
key.SetName("PK_Stu_base");
PrintObjectAddress("Student Key", key);
}
}
var entTrfStudent = modelBuilder.Metadata.FindEntityType(typeof(TransferStudent));
if(entTrfStudent != null)
{
var key = entTrfStudent.FindPrimaryKey() as IMutableKey;
if(key != null)
{
key.SetName("PK_Transf_stu");
PrintObjectAddress("TransferStudent Key", key);
}
}
var entRptStudent = modelBuilder.Metadata.FindEntityType(typeof(RepeatStudent));
if (entRptStudent != null)
{
var key = entRptStudent.FindPrimaryKey() as IMutableKey;
if (key != null)
{
key.SetName("PK_Rpt_stu");
PrintObjectAddress("RepeatStudent Key", key);
}
}
}
}然后得到以下结果：
Student Key: 0x245CD862820
TransferStudent Key: 0x245CD862820
RepeatStudent Key: 0x245CD862820 看吧，它们的地址一样。
所以，现阶段，在 TPT 策略下你不能自定义主键的约束名称，但微软说以后的版本会支持。