《ASP.NET Core技术内幕与项目实战》精简集-EFCore2.3：导航关系配置（一对多、一对一、多对多）

本节内容，涉及4.6（P100-P114）。主要NuGet包：

• Microsoft.EntityFrameworkCore.SqlServer
• Microsoft.EntityFrameworkCore.Tools

 

一、一对多关系-双向导航（主从表）

//实体类Article和Comment，在数据库上是主子表或主从表关系，在EFCore中称之为一对多
//Article.cs和Comment.cs
public class Article
{
    public long Id { get; set; }
    public string? Title { get; set; }
    public string? Content { get; set; }
    public List<Comment> Comments { get; set; } = new List<Comment>(); //导航属性，指向多端

}

public class Comment
{
    public long ID { get; set; }
    public Article? Article { get; set; } //导航属性，指向一端
    public long ArticleId { get; set; } //显式设置外键属性
    public string? Message { get; set; }
}



//创建DbContext类，并配置实体和数据表的映射关系
//MyDbContext.cs
public class MyDbContext: DbContext
{
    public DbSet<Article> Articles { get; set; }
    public DbSet<Comment> Comments { get; set; }
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        base.OnConfiguring(optionsBuilder);
        string connStr = "Data Source=(localdb)\\MSSQLLocalDB;Initial Catalog=TryRelation;Integrated Security=True;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False";
        optionsBuilder.UseSqlServer(connStr);
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);

        //配置Article的映射关系
        modelBuilder.Entity<Article>(b =>
        {
            b.ToTable("T_Articles");
            b.Property(a => a.Title).HasMaxLength(50).IsRequired().IsUnicode();
            b.Property(a => a.Content).HasMaxLength(500).IsRequired().IsUnicode();
        });

        //配置Comment的映射关系及导航关系
        modelBuilder.Entity<Comment>(b =>
        {
            b.ToTable("T_Comments");
            b.Property(c=>c.Message).HasMaxLength(500).IsRequired().IsUnicode();
            //配置导航关系，并显式配置外键
            b.HasOne<Article>(c => c.Article).WithMany(a => a.Comments).HasForeignKey(c => c.ArticleId);
        });
    }
}



//数据库迁移，在工具-Nuget包管理器-程序包管理控制台中，先后执行：
Add-Migration init
Update-database



//在Program中创建DbContext对象，并进行新增和查询操作
//创建DbContext对象
using var ctx = new MyDbContext();

//一对多的数据新增方式1
var a1 = new Article { Title = "文章标题1", Content = "文章内容1" };

var c1 = new Comment { Message = "评论内容1" };
var c2 = new Comment { Message = "评论内容2" };
var c3 = new Comment { Message = "评论内容3" };

a1.Comments.Add(c1);
a1.Comments.Add(c2);
a1.Comments.Add(c3);

ctx.Articles.Add(a1);
await ctx.SaveChangesAsync();


//一对多的数据新增方式2
var a2 = new Article { Title = "文章标题2", Content = "文章内容2" };

var c1 = new Comment { Message = "评论内容1", Article = a2 };
var c2 = new Comment { Message = "评论内容2", Article = a2 };
var c3 = new Comment { Message = "评论内容3", Article = a2 };

ctx.Comments.Add(c1);
ctx.Comments.Add(c2);
ctx.Comments.Add(c3);
await ctx.SaveChangesAsync();


//一对多的关联数据一起获取
var article1 = ctx.Articles.Include(a => a.Comments).Single(a=>a.Id == 1);
Console.WriteLine(article1.Title);
foreach (var item in article1.Comments)
{
    Console.WriteLine($"{item.ID}:{item.Message}");
}


//如果未设置外键属性ArticleId，获取Comment的ArticleId，需要使用Include
foreach (var item in ctx.Comments.Include(c=>c.Article))
{
    Console.WriteLine($"{item.ID}:{item.Message};{item.Article!.Id}");
}
//因本案例配置了外键属性，所以可以不使用Include
foreach (var item in ctx.Comments)
{
    Console.WriteLine($"{item.ID}:{item.Message};{item.ArticleId}");
}

代码解读：

8行：在一端，设置指向多端的导航属性

15行：在多端，设置指向一端的导航属性

16行：显式的创建了外键属性。可以省略，如省略，数据库T_Comments表中，一样会创建外键字段ArticleId，只是实体Comment没有ArticleId属性。如果要获得，需要使用Include查询，见下例。建议显式添加。

53行：配置一对多的导航关系，在一端和多端均可以设置，建议在多端设置，如上例所示。HasOne<T>().WithMany()，Has的主语为当前实体（即Comment），泛型T可以省略。With的主语为导航过去实体。

53行：显式配置实体的外键属性，除了在多端添加外键属性外，还需要在导航关系配置中，显示的设置外键

99行，108行：查询主表时，要关系从表；或查询从表时，要关系主表，使用Include

 

 

二、一对多关系-单向导航

//实体类，一端为User-用户，多端为Leave-离职申请
//User.cs和Leave.cs
public class User
{
    public long Id { get; set; }
    public string? Name { get; set; }
}

public class Leave
{
    public long Id { get; set; }
    public User Requester { get; set; } //申请人
    public User? Approver { get; set; } //审批人
    public DateTime From { get; set; }
    public DateTime To { get; set; }
}


//DbContext类，配置映射和一对多的单向导航关系
public class MyDbContext: DbContext
{
    public DbSet<User> Users { get; set; }
    public DbSet<Leave> Leaves { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        //配置User的映射关系
        modelBuilder.Entity<User>(b =>
        {
            b.ToTable("T_Users");
            b.Property(u => u.Name).IsRequired().HasMaxLength(100).IsUnicode();
        });

        //配置Leave的映射关系及一对多单向导航
        modelBuilder.Entity<Leave>(b =>
        {
            b.ToTable("T_Leaves");
            b.HasOne<User>(l => l.Requester).WithMany(); //设置申请人的单向导航
            b.HasOne<User>(l => l.Approver).WithMany(); //设置审批人的单向导航
        });
     }
}


//新增数据和查询
//Program.cs
var u1 = new User { Name = "张三" };
var l1 = new Leave { Requester = u1, From = new DateTime(2022, 10, 28), To = new DateTime(2022, 10, 30) };

ctx.Users.Add(u1);
ctx.Leaves.Add(l1);
await ctx.SaveChangesAsync();

var u = await ctx.Users.SingleAsync(u => u.Name == "张三");
foreach (var item in ctx.Leaves.Where(l => l.Requester == u))
{
    Console.WriteLine(item.From.ToString());
}

代码解读：

38-39行：一对多关系配置，建议都在多端设置。单向导航与双向的差异，主要在WithMany端，因为一端不会指向多端，所以WithMany端留空

50-51行：一对多单向导航新增数据时，一端和多端，均需要Add，而双向导航，只要在一端或多端Add即可

54-55行：单向导航时，一端和多端的关联查询，不能使用Include

 

三、一对一关系，双向导航

//实体类，订单和快递单，一对一关系，在业务流上有上下前后关系
//Order.cs和Delivery.cs
public class Order
{
    public long Id { get; set; }
    public string? Name { get; set; } //品名
    public string? Address { get; set; } //收货地址
    public Delivery? Delivery { get; set; } //快递单
}

public class Delivery
{
    public long Id { get; set; }
    public string? Company { get; set; } //快递公司
    public string? Number { get; set; } //快递单号
    public Order Order { get; set; } //订单
    public long OrderId { get; set; } //指向订单的外键
}


//DbContext类设置映射关系和一对一导航关系
public class MyDbContext: DbContext
{
    public DbSet<Order> Orders { get; set; }
    public DbSet<Delivery> Deliverys { get; set; }

    ......

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        //配置Leave的映射关系及一对多单向导航
        modelBuilder.Entity<Leave>(b =>
        {
            b.ToTable("T_Leaves");
            b.HasOne<User>(l => l.Requester).WithMany(); //设置申请人的单向导航
            b.HasOne<User>(l => l.Approver).WithMany(); //设置审批人的单向导航
        });

        //配置Order的映射关系
        modelBuilder.Entity<Order>(b =>
        {
            b.ToTable("T_Orders");
            b.Property(o => o.Name).IsUnicode();
            b.Property(o => o.Address).IsUnicode();
        });

        //配置Delivery的映射关系和一对一（双向）导航
        modelBuilder.Entity<Delivery>(b =>
        {
            b.ToTable("T_Delivery");
            b.Property(d => d.Company).HasMaxLength(10).IsUnicode();
            b.Property(d => d.Number).HasMaxLength(50);
            b.HasOne<Order>(d => d.Order).WithOne(l => l.Delivery).HasForeignKey<Delivery>(d=>d.OrderId);
        });
    }
}    


//一对一导航关系，新增和查询
//Program.cs
var o1 = new Order { Name = "笔记本电脑", Address = "某某市" };
var d1 = new Delivery { Company = "蜗牛快递", Number = "SN847534", Order = o1};

ctx.Deliverys.Add(d1);
await ctx.SaveChangesAsync();

var o = await ctx.Orders.Include(o=>o.Delivery).FirstAsync(o=>o.Name.Contains("电脑"));
Console.WriteLine($"品名：{o.Name}，单号：{o.Delivery.Number}");

代码解读：

52行：设置一对一导航关系，可以设置在任何一端，建议设置在下游端。HasForeignKey和外键属性必须设置，注意HasForeignKey的泛型和参数类型。

64行：新增时，在任何一端Add均可，建议在下游端Add。

67行：关联查询，需要使用Include。

 

四、多对多关系，双向导航

//实体类，老师和学生，多对多关系
//Teacher.cs和Student.cs
public class Teacher
{
    public long Id { get; set; }
    public string? Name { get; set; }
    public List<Student> Students { get; set; } = new List<Student>(); //导航属性，多对多端
}

public class Student
{
    public long Id { get; set; }
    public string? Name { get; set; }
    public List<Teacher> Teachers { get; set; } = new List<Teacher>(); //导航属性，多对多端
}


//DbContext配置映射和多对多导航关系
//MyDbContext.cs
public class MyDbContext: DbContext
{
    public DbSet<Student> Students { get; set; }
    public DbSet<Teacher> Teachers { get; set; }
    ......
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);

        //配置Teacher的映射关系
        modelBuilder.Entity<Teacher>(b =>
        {
            b.ToTable("T_Teachers");
            b.Property(t => t.Name).HasMaxLength(20).IsUnicode();
        });

        //配置Teacher的映射关系和多对多导航关系
        modelBuilder.Entity<Student>(b =>
        {
            b.ToTable("T_Students");
            b.Property(s => s.Name).HasMaxLength(20).IsUnicode();
            b.HasMany<Teacher>(s=>s.Teachers).WithMany(t=>t.Students)
             .UsingEntity(j=>j.ToTable("T_Teachers_Students"));
        });
    }
}


//多对多关系进行关联新增
var t1 = new Teacher { Name = "MissFan" };
var t2 = new Teacher { Name = "MissLiu" };
var s1 = new Student { Name = "ZS" };
var s2 = new Student { Name = "LS" };

t1.Students.Add(s1);
t1.Students.Add(s2);
t2.Students.Add(s1);
t2.Students.Add(s2);

ctx.Students.AddRange(s1, s2);
ctx.Teachers.AddRange(t1, t2);
await ctx.SaveChangesAsync();


//多对多关系进行关联查询
foreach (var item in ctx.Teachers.Include(t=>t.Students))
{
    Console.WriteLine($"老师：{item.Name}");
    foreach (var student in item.Students)
    {
        Console.WriteLine($"------学生：{student.Name}");
    }
}

代码解读：

7，14行：两个多端，均配置List<T>导航属性

41-42行：在任何一个多端均可以配置多对多导航关系。多对多，需要一张中间表建立两端关系，UsingEntity方法设置中间表的表名，如果不使用UsingEntity方法，则会自动创建一个中间表

59-60行：在两端均Add，使用了AddRange方法，仅是Add的语法糖，更容易写代码而已，编译为SQL时，还是一条条新增。

65行：查询使用Include，可见无论是一对多、一对一、或多对多，只要是双向导航，关联查询时均使用Include。

 

五、最后总结：

1、一对多，有双向导航和单向导航；一对一和多对多，均是双向导航

2、一对多、一对一和多对多的双向导航，两端的实体均要配置导航属性；一对多的单向导航，仅在多端设置导航属性

3、一对多配置导航映射关系时，在多端设置，HasOne<>(...).WithMany(...)。其中单向导航的WithMany方法参数为空

4、一对一配置导航映射关系，任何一端均可，建议在下游端

5、多对多配置导航映射关系，任何一端均可

6、关联新增时，有双向导航关系的，会顺竿爬，Add一端即可；单向导航关系的，两端都要Add。当然，无论单向或双向，两端都Add，均可以

7、关联查询时，有双向导航关系的，使用Include；单向导航关系的，不能使用Include

 

特别说明：
1、本系列内容主要基于杨中科老师的书籍《ASP.NET Core技术内幕与项目实战》及配套的B站视频视频教程，同时会增加极少部分的小知识点
2、本系列教程主要目的是提炼知识点，追求快准狠，以求快速复习，如果说书籍学习的效率是视频的2倍，那么“简读系列”应该做到再快3-5倍