"多对多"关系不像"一对多"那么"单纯"，它内部涉及到"连接实体"（Join Entity）的概念。咱们先放下这个概念不表，来了解一下多对多数据表为什么需要一个"辅助表"来建立关系。
假设有两张表：一张表示学生，一张表示选修课。那么，这里头的关系是你可以选多门课，而一门课可以被多人选。这是多对多关系，没问题吧。
按照数据库存储的原则，学生表中每位学生的信息都不应重复，而课程表也是如此。这么一看，多对多的关系不能直接在这两个表中创建了。
那就只能引入第三个表，专门保存前两个表的信息了。
经过这样处理后，多对多的关系被拆解成两个一对多关系：
左边：学生（1）--- 中间表（N）；
右边：课程（1）--- 中间表（N）。
这个中间表负责"连接"两个数据表。转换为实体类开，这个中间表就是"连接实体"了。
接下来先弄个开胃菜，一个很简单的例子
1、定义实体。
public class Student
{
public int Id { get; set; }
public string Name { get; set; } = null!;
public string Code { get; set; } = null!;
public string? Email { get; set; }
// 注意这个属性
public IList\<Course\> SelectedCourses { get; set; } = new List\<Course\>();
}
public class Course
{
public Guid Id { get; set; }
public string Name { get; set; } = null!;
public string? Tags { get; set; }
// 注意这个属性
public IList\<Student\> Students { get; set; } = new List\<Student\>();
}实体类没什么，就是一个学生类，一个课程类。不过，请留意一下被标记的属性，后面会考。
2、定义数据库上下文。
public class TestContext : DbContext
{
protected override void OnConfiguring(DbContextOptionsBuilder ob)
{
ob.UseSqlServer("server=(localdb)\\mssqllocaldb;database=MySchool");
}
#region 数据集合
public DbSet<Student> StudentSet { get; set; }
public DbSet<Course> CourseSet { get; set; }
#endregion
}上下文这样就可以了，这里可以不写配置数据库模型的代码，因为 EF Core 内置的约定类会帮我们自动完成。
a、通过 DbContext 或子类定义的 DbSet 类型的属性，自动向模型添加 Student、Course 实体；
b、通过上面标记的特殊属性（你看，考点来了），自动识别出这是多对多的关系。
Student 类的 SelectedCourses 属性导航到 Course；
Course 类的 Students 属性导航到 Student。
两个导航属性都是集合类型，因此两者的关系是多对多。此处，SelectedCourses 和 Students 属性有个专用名字，叫"跳跃导航"（Skip Navigation）。这里不应该翻译为"跳过导航"，因为那样翻译意思就不太好理解，所以应取"跳跃"。
解释一下为什么会跳跃。还记得前文的分析吗？两个表如果是多对多关系，那么它们需要一个"连接"表来存储对应关系。也就是说，正常情况下，Student 类的导航属性应该指向中间实体（映射到连接表），Course 实体的导航属性也应该指向中间实体，再通过中间实体把二者连接起来。可是我们再回头看看示例，Student 的导航属性直接指向了 Course，而 Course 实体的导航属性也直接指向了 Student 实体。即它们都跨过（跳过）中间实体，两者直接连接起来了。
老周画了一个不专业的简图。
这里也产生了一个疑问：我们没创建中间实体啊，难道是 EF Core 帮我们创建了？还真是，不妨打印一下数据库模型。
static void Main(string[] args)
{
using var context = new TestContext();
// 获取数据库模型
IModel model = context.Model;
// 打印
Console.WriteLine(model.ToDebugString());
}然后，运行代码，看看输出什么。
Model:
EntityType: Course
Properties:
Id (Guid) Required PK AfterSave:Throw ValueGenerated.OnAdd
Name (string) Required
Tags (string)
Skip navigations:
Students (IList<Student>) CollectionStudent Inverse: SelectedCourses
Keys:
Id PK
EntityType: **CourseStudent (Dictionary****\<string, object\>) CLR Type: Dictionary\<string, object\>**
Properties:
SelectedCoursesId (no field, Guid) Indexer Required PK FK AfterSave:Throw
StudentsId (no field, int) Indexer Required PK FK Index AfterSave:Throw
Keys:
SelectedCoursesId, StudentsId PK
Foreign keys:
CourseStudent (Dictionary<string, object>) {'SelectedCoursesId'} -> Course {'Id'} Required Cascade
CourseStudent (Dictionary<string, object>) {'StudentsId'} -> Student {'Id'} Required Cascade
Indexes:
StudentsId
EntityType: Student
Properties:
Id (int) Required PK AfterSave:Throw ValueGenerated.OnAdd
Code (string) Required
Email (string)
Name (string) Required
Skip navigations:
SelectedCourses (IList<Course>) CollectionCourse Inverse: Students
Keys:
Id PK有没有发现多了一个实体，叫 CourseStudent。虽然我们在代码中没有定义这样的类，但 EF Core 的 ManyToManyJoinEntityTypeConvention 约定类会自动给数据库模型添加一个实体，类型是共享的 Dictionary<string, object>。这可是个万能实体类型，当你不想给项目定义一堆实体类时，你甚至可以把所有实体全注册为字典类型。当然，这样做对于面向对象，对阅读你代码的人来说就不友好了。
protected virtual void CreateJoinEntityType(
string joinEntityTypeName,
IConventionSkipNavigation skipNavigation)
{
var model = skipNavigation.DeclaringEntityType.Model;
// DefaultPropertyBagType 就是字典类型
var joinEntityTypeBuilder = model.Builder.SharedTypeEntity(joinEntityTypeName, Model.DefaultPropertyBagType)!;
var inverseSkipNavigation = skipNavigation.Inverse!;
CreateSkipNavigationForeignKey(skipNavigation, joinEntityTypeBuilder);
CreateSkipNavigationForeignKey(inverseSkipNavigation, joinEntityTypeBuilder);
}
可以看看 DefaultPropertyBagType 字段在 Model 类中的定义（Model 类从用途上不对外公开，但类本身是 public 的）。
public static readonly Type DefaultPropertyBagType = typeof(Dictionary<string, object>);那这个自动添加的中间实体怎么命名呢？继续看源代码。
protected virtual string GenerateJoinTypeName(IConventionSkipNavigation skipNavigation)
{
var inverseSkipNavigation = skipNavigation.Inverse;
Check.DebugAssert(
inverseSkipNavigation?.Inverse == skipNavigation,
"Inverse's inverse should be the original skip navigation");
var declaringEntityType = skipNavigation.DeclaringEntityType;
var inverseEntityType = inverseSkipNavigation.DeclaringEntityType;
var model = declaringEntityType.Model;
var joinEntityTypeName = !declaringEntityType.HasSharedClrType
? declaringEntityType.ClrType.ShortDisplayName()
: declaringEntityType.ShortName();
var inverseName = !inverseEntityType.HasSharedClrType
? inverseEntityType.ClrType.ShortDisplayName()
: inverseEntityType.ShortName();
joinEntityTypeName = StringComparer.Ordinal.Compare(joinEntityTypeName, inverseName) < 0
? joinEntityTypeName + inverseName
: inverseName + joinEntityTypeName;
if (model.FindEntityType(joinEntityTypeName) != null)
{
var otherIdentifiers = model.GetEntityTypes().ToDictionary(et => et.Name, _ => 0);
joinEntityTypeName = Uniquifier.Uniquify(
joinEntityTypeName,
otherIdentifiers,
int.MaxValue);
}
return joinEntityTypeName;
}乱七八糟一大段，总结起来就是：
1、分别获取跳跃导航两端的类型，即多对多关系中的两实体（Student 和 Course）；
2、将两实体的名称按字符排序，排在前面的作为前半段名字，排序在后面的作为后半段名字。比如，Student 与 Course 排序，字母 C 在 S 前面，所以，中间实体的名字就是 CourseStudent；
3、向中间实体添加两个属性，两个属性共同构成主键。同时，它们也是外键，一个指向 Student，一个指向 Course。即这两个属性同时是主键和外键。
从中间实体到 Student 的导航叫"左边"，从中间实体到 Course 实体的导航叫 "右边"。
如果咱们不想用 EF Core 约定的中间实体，也可以自己去定义。
public class StudentCourseJoin
{
public Student TheStudent { get; set; } = null!;
public Course TheCourse { get; set; } = null!;
}有大伙伴会说了，你这实体没有作为外键的属性啊。没事，外键属性可以作为影子属性（Shadow Property）来添加，反正有 TheStudent 等导航属性，不需要借助外键属性也可以引用其实体。
下面是非常复杂的配置代码，各位可以先让时间停止然后慢慢看。
public class TestContext : DbContext
{
......
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<Student>()
// 一个学生选多门课
.HasMany(s => s.SelectedCourses)
// 一门课多位学生选
.WithMany(c => c.Students)
// 中间实体
.UsingEntity<StudentCourseJoin>(
// 右边：StudentCourseJoin >>> Course
// 一个 StudentCourseJoin 只引用一个 Course
right => right.HasOne(e => e.TheCourse)
// 一个Course可引用多个StudentCourseJoin
// 但此处省略了
.WithMany()
// 外键
.HasForeignKey("Course_ID"),
// 左边：StudentCourseJoin >>> Student
// 一个StudentCourseJoin引用一个Student
left => left.HasOne(e => e.TheStudent)
// 一个Student可引用多个StudentCourseJoin
// 但这里省略了
.WithMany()
// 外键
.HasForeignKey("Student_ID"),
ent =>
{
// 因为这两个是影子属性，必须显式配置
// 否则找不到属性，会报错
ent.Property<int>("Student_ID");
ent.Property<Guid>("Course_ID");
// 两个属性都是主键
ent.HasKey("Student_ID", "Course_ID");
}
);
}
}最外层调用 modelBuilder.Entity<Student>() 的代码就是配置 Student 和 Course 的关系的，相信各位都懂的。复杂的部分是 UsingEntity 方法开始的，配置中间实体（连接实体）的。
首先，咱们把中间实体的关系拆开：
A、Student 对中间实体：一对多，左边；
B、Course 对中间实体：一对多，右边。
所以，UsingEntity 方法的第一个委托配置右边。
right => right.HasOne(e => e.TheCourse)
// 一个Course可引用多个StudentCourseJoin
// 但此处省略了
.WithMany()
// 外键
.HasForeignKey("Course_ID")不要问为什么，因为微软定义这个方法就是先右后左的。HasOne 就是从中间实体（StudentCourseJoin）出发，它引用了几个 Course？一个吧，嗯，所以是One嘛；然后 WithMany 反过来，Curse 可以引用几个中间实体？多个吧（不明白的可以想想，中间表里面是不是可以重复出现课程？）。因为 Course 类没有定义导航属性去引用中间实体，所以 WithMany 参数空白。最后是设置外键，谁引用谁？是中间实体引用 Course 吧，所以，需要一个叫 Course_ID 属性来保存课程ID。
好了，右边干完了，到左边了。
left => left.HasOne(e => e.TheStudent)
// 一个Student可引用多个StudentCourseJoin
// 但这里省略了
.WithMany()
// 外键
.HasForeignKey("Student_ID")左边是谁跟谁？从中间实体出发，它可以引用几个 Student？一个吧，所以是 HasOne；反过来，Student 可以引用几个中间实体？由于学生可以多次出现在中间实体中，所以是 WithMany，但 Student 类没有指向中间实体的导航属性，所以参数空。最后是外键，谁引用谁？是中间实体引用 Student 类吧？所以，中间实体要有一个 Student_ID 属性来保存学生ID。
可是，Student_ID 和 Course_ID 在中间实体中是没有定义的属性，如果不手动配置，EF Core 是找不到的。
ent =>
{
// 因为这两个是影子属性，必须显式配置
// 否则找不到属性，会报错
ent.Property<int>("Student_ID");
ent.Property<Guid>("Course_ID");
// 两个属性都是主键
ent.HasKey("Student_ID", "Course_ID");
}这两个属性因为实体类中没有定义，所以要作为影子属性用，然后是两个属性都是主键。完事了。
这个代码你要是看懂了，说明你学习 EF Core 的境界又提高了。