翼度科技»论坛 编程开发 .net 查看内容

【EF Core】主从实体关系与常见实体关系的区别

5

主题

5

帖子

15

积分

新手上路

Rank: 1

积分
15
上次老周扯了有关主、从实体的话题,本篇咱们再挖一下,主、从实体之间建立的关系,跟咱们常用的一对一、一对多这些关系之间有什么不同。
先看看咱们从学习数据库开始就特熟悉的常用关系——多对多、一对一、一对多说起。数据实体之间会建立什么样的关系,并不是规则性的,而是要看数据的功能。比如你家养的狗狗和水果(你家狗狗可能不吃水果,但老周养的动物基本是什么都吃的,因为从它们幼年起,老周就训练它们,对食物要来者不拒,就算哪天它们不想跟着老周混,出去流浪也不会饿死,适应性更强)。
假设:
1、你的数据是以狗狗为主,那么一条狗狗会吃多种水果。即狗狗对水果是一对多;
2、你的数据以水果为主,每种水果单独记录,然后在另一个表中记录水果被哪几条狗喜欢。例:雪梨,狗Y和狗B都喜欢吃。于是水果对狗狗也可以是一对多的关系。
再假设你有个幼儿园学生尿床登记表,表中记录每次尿床的时间、床号等。每一条尿床记录都有一个字段,引用自学生表,代表是哪们同学尿床了。多条尿床记录可能都是同一个人的,比如,小明一周有三次尿床。这样,尿床记录和学生之间可以是多对一关系了。
数据是为咱们人服务的,因此实体之间建立什么样的关系,得看咱们人类是怎么理解,以及这些实体的用途。
还是用上一篇水文中的学生 - 作业的例子。
  1. public class Student
  2. {
  3.     // 主键:学生ID
  4.     public int StuID { get; set; }
  5.     // 学生姓名
  6.     public string? Name { get; set; }
  7.     // 年级
  8.     public ushort Grade { get; set; }
  9.     // 作业(导航属性)
  10.     public IEnumerable<Homework> Homeworks { get; set; } = new List<Homework>();
  11. }
  12. public class Homework
  13. {
  14.     // 主键,ID
  15.     public int WorkID { get; set; }
  16.     // 作业描述
  17.     public string? Description { get; set; }
  18.     // 科目(导航属性)
  19.     public Subject? Subject { get; set; }
  20.     // 引用学生对象
  21.     public Student? Student { get; set; }
  22. }
  23. public class Subject
  24. {
  25.     // 主键:科目ID
  26.     public int SubID { get; set; }
  27.     // 科目名称
  28.     public string? Name { get; set; }
  29. }
复制代码
这次老周加了个实体——Subject,它表示作业的科目(数学、语文等)。
导航属性是用于建立实体关系的。
1、学生类中,Homeworks 属性建立与 Homework 对象的关系:一条学生信息可以对应多条作业信息,是一对多的关系;
2、作业类中,Subject 属性建立与 Subject 对象的关系。一对一的关系。
在 DbContext 的自定义类型中,三个实体间的关系配置如下:
  1. protected override void OnModelCreating(ModelBuilder modelBuilder)
  2. {
  3.     // 设置主键
  4.     modelBuilder.Entity<Student>().HasKey(s => s.StuID);
  5.     modelBuilder.Entity<Homework>().HasKey(w => w.WorkID);
  6.     modelBuilder.Entity<Subject>().HasKey(u => u.SubID);
  7.     // 建立模型关系
  8.     modelBuilder.Entity<Student>().HasMany(s => s.Homeworks).WithOne(w => w.Student);
  9.     modelBuilder.Entity<Homework>().HasOne(w => w.Subject);
  10. }
复制代码
这是咱们常规的关系配置方法,从当前实体到另一实体的关系描述为 HasXXX 方法;HasXXX 方法调用后,会顺带调用一个 WithXXX 方法。WithXXX 方法是反向描述,即描述另一个实体与当前实体的关系。这样调用可以建立比较完整的相对关系。
在上述代码中,Student -> Homework 是一对多,所以,Student 实体上调用 HasMany 方法;之后是反向关系,Homework -> Student 是一对一关系,也就是说,一条 Homework 记录通过外键只引用一条学生记录。因此调用了 WithOne 方法。
Homework -> Subject 是一对一,所以在 Homework 实体上调用 HasOne 方法。这里,Homework 与 Subject 两实体并没有建立相互引用的关系,仅仅是作业中引用了科目信息,而 Subject 实体自身可以独立,它不需要引用 Homework 的任何实例,因此没有调用 WithXXX 方法。
由于实体之间建立的关系是相对的,即参照当前对象。所以,上面代码也可以这样写:
  1. modelBuilder.Entity<Homework>().HasOne(h => h.Student).WithMany(s => s.Homeworks);
  2. modelBuilder.Entity<Homework>().HasOne(h => h.Subject);
复制代码
要注意的是,这两种关系配置其实是相同的,所以两者任选一即可,不要重复配置。
两种关系配置的差别就在选择谁来做“当前实体”,即以当前实体为参照而建立相对关系。第二种方法是以 Homework 实体为当前实体,一条作业信息只关联一位学生,所以是一对一,调用 HasOne 方法;反过来,一条学生信息可包含多条作业信息,所以是一对多,即调用 WithMany 方法。
定义几个静态方法,用于验证模型建得对不对。
首先,InitDatabase 方法负责运行阶段创建数据库,并插入一些测试数据。
  1. static void InitDatabase()
  2. {
  3.     using MyContext cxt = new();
  4.     // 确保数据已创建
  5.     bool v = cxt.Database.EnsureCreated();
  6.     // 如果数据库已存在,不用初始化数据
  7.     if (!v)
  8.         return;
  9.     /*  初始化数据  */
  10.     // 这是科目
  11.     Subject s1 = new(){ Name = "语文"};
  12.     Subject s2 = new(){ Name = "数学"};
  13.     Subject s3 = new(){ Name = "英语"};
  14.     Subject s4 = new(){ Name = "物理"};
  15.     Subject s5 = new(){ Name = "地理"};
  16.     cxt.Subjects.AddRange(new[]{
  17.         s1, s2, s3, s4, s5
  18.     });
  19.     // 学生和作业可以一起添加
  20.     cxt.Students.Add(
  21.         new Student{
  22.             Name = "小华",
  23.             Grade = 4,
  24.             Homeworks = new []
  25.             {
  26.                 new Homework
  27.                 {
  28.                     Description = "背单词3500个",
  29.                     Subject = s3
  30.                 },
  31.                 new Homework
  32.                 {
  33.                     Description = "作文《我是谁,我在哪里》",
  34.                     Subject = s1
  35.                 },
  36.                 new Homework
  37.                 {
  38.                    Description = "手绘广州地铁网络图",
  39.                    Subject = s5
  40.                 }
  41.             }
  42.         }
  43.     );
  44.     cxt.Students.Add(
  45.         new Student
  46.         {
  47.             Name = "王双喜",
  48.             Grade = 3,
  49.             Homeworks = new[] {
  50.                 new Homework
  51.                 {
  52.                     Description = "完型填空练习",
  53.                     Subject = s3
  54.                 }
  55.             }
  56.         }
  57.     );
  58.     cxt.Students.Add(
  59.         new Student
  60.         {
  61.             Name = "割麦小王子",
  62.             Grade = 5,
  63.             Homeworks = new[]{
  64.                 new Homework
  65.                 {
  66.                     Description = "实验:用激光给蟑螂美容",
  67.                     Subject = s4
  68.                 },
  69.                 new Homework{
  70.                     Description = "翻译文言文《醉驾通鉴》",
  71.                     Subject = s1
  72.                 }
  73.             }
  74.         }
  75.     );
  76.     // 保存到数据库
  77.     cxt.SaveChanges();
  78. }
复制代码
SaveChanges 方法记得调用,调用了才会保存数据。
ShowData 方法负责在控制台打印数据。
  1. static void ShowData()
  2. {
  3.     using MyContext ctx = new();
  4.     var students = ctx.Students.Include(s => s.Homeworks)
  5.                 .ThenInclude(hw => hw.Subject)
  6.                 .AsEnumerable();
  7.     // 打印学生信息
  8.     Console.WriteLine("{0,-5}{1,-10}{2,-6}", "学号", "姓名", "年级");
  9.     Console.WriteLine("----------------------------------------------------");
  10.     foreach(var stu in students)
  11.     {
  12.         Console.WriteLine($"{stu.StuID,-7}{stu.Name,-10}{stu.Grade,-4}");
  13.         // 打印作业信息
  14.         foreach(Homework wk in stu.Homeworks)
  15.         {
  16.             Console.Write(">> {0,-4}", wk.Subject!.Name);
  17.             Console.WriteLine(wk.Description);
  18.         }
  19.         Console.Write("\n\n");
  20.     }
  21. }
复制代码
在加载数据时得小心,因为如果你只访问 Students 集合,那么,Homeworks 和 Subjects 集合不会加载,这会使得 Student 实体的 Homeworks 属性变为空。为了让访问 Students 集合时同时加载关联的数据,要用 Include 方法。
第一个 Include 方法加载 Homeworks 属性引用的 Homework对象;第二个ThenInclude 方法是指在加载 Homework 后,Homework 实体的 Subject 属性引用了 Subject 对象,所以 ThenInclude 方法是通知模型顺便加载 Subjects 集合。
最后,要调用一下实际触发查询的方法,如 AsEnumerable 方法,这样才会让查询执行,你在内存中才能访问到数据。当然,像 ToArray、ToList 之类的方法也可以,这个和 LINQ 语句的情况类似。要调用到相应的方法才触发查询真正执行。
RemoveDatabase 方法是可选的,删除数据库。咱们这是演示,免得在数据库中存太多不必要的东西。测试完代码可以调用一下它,删除数据库。这里老周照例用 SQL Server LocalDB 来演示。
  1. static void RemoveDatabase()
  2. {
  3.     using MyContext c = new();
  4.     c.Database.EnsureDeleted();
  5. }
复制代码
-------------------------------------------------------------------------------------------
用的时候,按顺调用这些方法,就可以测试了。
  1.    Console.WriteLine("** 第一步:初始化数据库。【请按任意键继续】");
  2.    _ = Console.ReadKey(true);
  3.    InitDatabase();
  4.    Console.WriteLine("** 第二步:显示数据。【请按任意键继续】");
  5.    _ = Console.ReadKey(true);
  6.    ShowData();
  7.    //Console.WriteLine("** 第三步:删除数据库。【请按任意键继续】");
  8.    //_ = Console.ReadKey();
  9.    //RemoveDatabase();
复制代码

产生的数据表如下图所示:

 
我们上面的这个模型还是有点问题的,可以看一下,生成的数据表是没有删除约束的。
  1. CREATE TABLE [dbo].[Homeworks] (
  2.     [WorkID]       INT            IDENTITY (1, 1) NOT NULL,
  3.     [Description]  NVARCHAR (MAX) NULL,
  4.     [SubjectSubID] INT            NULL,
  5.     [StudentStuID] INT            NULL,
  6.     CONSTRAINT [PK_Homeworks] PRIMARY KEY CLUSTERED ([WorkID] ASC),
  7.     CONSTRAINT [FK_Homeworks_Students_StudentStuID] FOREIGN KEY ([StudentStuID]) REFERENCES [dbo].[Students] ([StuID]),
  8.     CONSTRAINT [FK_Homeworks_Subjects_SubjectSubID] FOREIGN KEY ([SubjectSubID]) REFERENCES [dbo].[Subjects] ([SubID])
  9. );
复制代码
假如现在我要删掉一条学生记录。
  1. using(MyContext dbcontext = new())
  2. {
  3.     // 删第一条记录
  4.     var one = dbcontext.Students.FirstOrDefault();
  5.     if(one != null)
  6.     {
  7.         dbcontext.Students.Remove(one);
  8.         dbcontext.SaveChanges();
  9.     }
  10. }
复制代码
但删除的时候会遇到错误。

这表明咱们要配置级联删除。
  1. public class MyContext : DbContext
  2. {
  3.     public DbSet<Student> Students => Set<Student>();
  4.     public DbSet<Homework> Homeworks => Set<Homework>();
  5.     public DbSet<Subject> Subjects => Set<Subject>();
  6.     protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
  7.     {
  8.         optionsBuilder.UseSqlServer(@"server=(localdb)\MSSQLLocalDB;Database=TestDB;Integrated Security=True");
  9.     }
  10.     protected override void OnModelCreating(ModelBuilder modelBuilder)
  11.     {
  12.         ……
  13.         // 建立模型关系
  14.         modelBuilder.Entity<Student>()
  15.                     .HasMany(s => s.Homeworks)
  16.                     .WithOne(w => w.Student)
  17.                     .OnDelete(DeleteBehavior.Cascade);
  18.         modelBuilder.Entity<Homework>().HasOne(w => w.Subject);
  19.     }
  20. }
复制代码
现在再删一次看看。

可以看到,与第一位学生有关的作业记录也一并被删除了。生成的数据表也与前面有一点差异。
  1. CREATE TABLE [dbo].[Homeworks] (
  2.     [WorkID]       INT            IDENTITY (1, 1) NOT NULL,
  3.     [Description]  NVARCHAR (MAX) NULL,
  4.     [SubjectSubID] INT            NULL,
  5.     [StudentStuID] INT            NULL,
  6.     CONSTRAINT [PK_Homeworks] PRIMARY KEY CLUSTERED ([WorkID] ASC),
  7.     CONSTRAINT [FK_Homeworks_Students_StudentStuID] FOREIGN KEY ([StudentStuID]) REFERENCES [dbo].[Students] ([StuID]) ON DELETE CASCADE,
  8.     CONSTRAINT [FK_Homeworks_Subjects_SubjectSubID] FOREIGN KEY ([SubjectSubID]) REFERENCES [dbo].[Subjects] ([SubID])
  9. );
复制代码
约束里面显然多了 ON DELETE CASCADE 语句。
回忆一下,在上一篇水文中,咱们使用主从对象后,我们在模型中没有明确配置级联删除,但生成的数据表中自动加上级联删除了。
这是不是说明:主从关系的实体对象里,主实体对从属实体的控制更强烈,咱们再对比对比看。
现在,让 Student 和 Homework 成为主从关系。
  1. public class MyContext : DbContext
  2. {
  3.     public DbSet<Student> Students => Set<Student>();
  4.     public DbSet<Homework> Homeworks => Set<Homework>();
  5.     public DbSet<Subject> Subjects => Set<Subject>();
  6.     protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
  7.     {
  8.         ……
  9.     }
  10.     protected override void OnModelCreating(ModelBuilder modelBuilder)
  11.     {
  12.         // 设置主键
  13.         modelBuilder.Entity<Student>().HasKey(s => s.StuID);
  14.         modelBuilder.Entity<Subject>().HasKey(u => u.SubID);
  15.         // 建立模型关系
  16.         modelBuilder.Entity<Student>()
  17.                     .OwnsMany(s => s.Homeworks, mrb =>
  18.                     {
  19.                         mrb.WithOwner(w => w.Student);
  20.                         mrb.HasKey(w => w.WorkID);
  21.                         mrb.HasOne(w => w.Subject);
  22.                     });
  23.                     
  24.     }
  25. }
复制代码
上次我们也证实过,凡成为从属的实体是无法单独进行配置的(如主键等),只能在配置主从关系的时候通过 OwnsMany 方法的委托来配置。
主从关系会自动生成级联删除语句。
  1. CREATE TABLE [dbo].[Homeworks] (
  2.     ……,
  3.     CONSTRAINT [PK_Homeworks] PRIMARY KEY CLUSTERED ([WorkID] ASC),
  4.     CONSTRAINT [FK_Homeworks_Students_StudentStuID] FOREIGN KEY ([StudentStuID]) REFERENCES [dbo].[Students] ([StuID]) ON DELETE CASCADE,
  5.     ……
  6. );
复制代码
还有一点更关键的,Homework 成为 Student 的从对象后,你甚至无法直接访问 Homeworks 集合,必须通过 Sudents 集合来访问。
  1. using (MyContext ctx = new MyContext())
  2. {
  3.     foreach(Homework hw in ctx.Homeworks)
  4.     {
  5.         Console.WriteLine($"{hw.Description}");
  6.     }
  7. }
复制代码
上述代码会抛异常。

这很明了,就是说你必须通过 Student 实体才能访问 Homework。所以,正确的做法要这样:
  1. using (MyContext ctx = new MyContext())
  2. {
  3.     ctx.Subjects.Load();    // 这个可不会自动加载,必须Load
  4.     foreach(Student stu in ctx.Students)
  5.     {
  6.         Console.WriteLine("【{0}】同学", stu.Name);
  7.         foreach(Homework work in stu.Homeworks)
  8.         {
  9.             Console.WriteLine("  {0}:{1}", work.Subject?.Name, work.Description);
  10.         }
  11.     }
  12. }
复制代码
Subjects 集合为什么要显式地调用 Load 方法呢?因为 Homework 与 Subject 实体并没有建立主从关系,Subject 对象要手动加载。
这样访问就不出错了。

-----------------------------------------------------------------------------------
最后,咱们来总结一下:
1、普通关系的数据未自动加载,要显式Load,或者 Include 方法加载。主从关系会自动加载从属数据;
2、建立主从关系后,主实体对从实体是完全控制了,不仅自动生成级联删除等约束,而且你还不能直接访问从实体,只能透过主实体访问;普通关系的实体需要手动配置约束。
 
========================================================
下面是老周讲故事时间。
上大学的时候,在《程序员》杂志上看过一句很“权威”的话:程序员是世上最有尊严的职业,不用酒局饭局,不用看人脸色,想干啥干啥,自由得很。然而,“多年以后一场大雨惊醒沉睡的我,突然之间都市的霓虹都不再闪烁”。客户说需求要这样这样,你改不改?改完之后客户又说还是改回那样那样,你改不改?总奸,哦不,总监说要这样这样,你能那样那样吗?客户说:“我们希望增加XXX功能,最好可以分开YYY、KKK 来管理。这些对你们来很简单的,动动鼠标就好了嘛!” 你动动鼠标试试?
再说了,哪个公司哪个单位的领导不是酒囊饭袋?IT 公司没有吗?哪儿都有,这世界最不缺的就是酒囊饭袋,最缺的是成吉思汗。
所以说,最TM自由、耍得最爽的就写博客,爱写啥写啥,套用土杰伦的歌词就是“你爱看就看,不爱看拉倒”。至于码农,就如同被压迫数千年的农民一样,没本质区别。所以,我们在给后辈讲码农生涯时,千万不要给他们画大饼,充不了饥。我们更应该教会他们程序员的最基本职业道德—— sudo rm -rf /*。
 

来源:https://www.cnblogs.com/tcjiaan/archive/2023/07/15/17550152.html
免责声明:由于采集信息均来自互联网,如果侵犯了您的权益,请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容,谢谢合作!

本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有账号?立即注册

x

举报 回复 使用道具