落叶孤星泪 发表于 2023-7-15 18:32:51

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

上次老周扯了有关主、从实体的话题,本篇咱们再挖一下,主、从实体之间建立的关系,跟咱们常用的一对一、一对多这些关系之间有什么不同。
先看看咱们从学习数据库开始就特熟悉的常用关系——多对多、一对一、一对多说起。数据实体之间会建立什么样的关系,并不是规则性的,而是要看数据的功能。比如你家养的狗狗和水果(你家狗狗可能不吃水果,但老周养的动物基本是什么都吃的,因为从它们幼年起,老周就训练它们,对食物要来者不拒,就算哪天它们不想跟着老周混,出去流浪也不会饿死,适应性更强)。
假设:
1、你的数据是以狗狗为主,那么一条狗狗会吃多种水果。即狗狗对水果是一对多;
2、你的数据以水果为主,每种水果单独记录,然后在另一个表中记录水果被哪几条狗喜欢。例:雪梨,狗Y和狗B都喜欢吃。于是水果对狗狗也可以是一对多的关系。
再假设你有个幼儿园学生尿床登记表,表中记录每次尿床的时间、床号等。每一条尿床记录都有一个字段,引用自学生表,代表是哪们同学尿床了。多条尿床记录可能都是同一个人的,比如,小明一周有三次尿床。这样,尿床记录和学生之间可以是多对一关系了。
数据是为咱们人服务的,因此实体之间建立什么样的关系,得看咱们人类是怎么理解,以及这些实体的用途。
还是用上一篇水文中的学生 - 作业的例子。
public class Student
{
    // 主键:学生ID
    public int StuID { get; set; }
    // 学生姓名
    public string? Name { get; set; }
    // 年级
    public ushort Grade { get; set; }
    // 作业(导航属性)
    public IEnumerable<Homework> Homeworks { get; set; } = new List<Homework>();
}

public class Homework
{
    // 主键,ID
    public int WorkID { get; set; }
    // 作业描述
    public string? Description { get; set; }
    // 科目(导航属性)
    public Subject? Subject { get; set; }
    // 引用学生对象
    public Student? Student { get; set; }
}

public class Subject
{
    // 主键:科目ID
    public int SubID { get; set; }
    // 科目名称
    public string? Name { get; set; }
}这次老周加了个实体——Subject,它表示作业的科目(数学、语文等)。
导航属性是用于建立实体关系的。
1、学生类中,Homeworks 属性建立与 Homework 对象的关系:一条学生信息可以对应多条作业信息,是一对多的关系;
2、作业类中,Subject 属性建立与 Subject 对象的关系。一对一的关系。
在 DbContext 的自定义类型中,三个实体间的关系配置如下:
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    // 设置主键
    modelBuilder.Entity<Student>().HasKey(s => s.StuID);
    modelBuilder.Entity<Homework>().HasKey(w => w.WorkID);
    modelBuilder.Entity<Subject>().HasKey(u => u.SubID);
    // 建立模型关系
    modelBuilder.Entity<Student>().HasMany(s => s.Homeworks).WithOne(w => w.Student);
    modelBuilder.Entity<Homework>().HasOne(w => w.Subject);
}这是咱们常规的关系配置方法,从当前实体到另一实体的关系描述为 HasXXX 方法;HasXXX 方法调用后,会顺带调用一个 WithXXX 方法。WithXXX 方法是反向描述,即描述另一个实体与当前实体的关系。这样调用可以建立比较完整的相对关系。
在上述代码中,Student -> Homework 是一对多,所以,Student 实体上调用 HasMany 方法;之后是反向关系,Homework -> Student 是一对一关系,也就是说,一条 Homework 记录通过外键只引用一条学生记录。因此调用了 WithOne 方法。
Homework -> Subject 是一对一,所以在 Homework 实体上调用 HasOne 方法。这里,Homework 与 Subject 两实体并没有建立相互引用的关系,仅仅是作业中引用了科目信息,而 Subject 实体自身可以独立,它不需要引用 Homework 的任何实例,因此没有调用 WithXXX 方法。
由于实体之间建立的关系是相对的,即参照当前对象。所以,上面代码也可以这样写:
modelBuilder.Entity<Homework>().HasOne(h => h.Student).WithMany(s => s.Homeworks);
modelBuilder.Entity<Homework>().HasOne(h => h.Subject);要注意的是,这两种关系配置其实是相同的,所以两者任选一即可,不要重复配置。
两种关系配置的差别就在选择谁来做“当前实体”,即以当前实体为参照而建立相对关系。第二种方法是以 Homework 实体为当前实体,一条作业信息只关联一位学生,所以是一对一,调用 HasOne 方法;反过来,一条学生信息可包含多条作业信息,所以是一对多,即调用 WithMany 方法。
定义几个静态方法,用于验证模型建得对不对。
首先,InitDatabase 方法负责运行阶段创建数据库,并插入一些测试数据。
static void InitDatabase()
{
    using MyContext cxt = new();
    // 确保数据已创建
    bool v = cxt.Database.EnsureCreated();
    // 如果数据库已存在,不用初始化数据
    if (!v)
      return;
    /*初始化数据*/
    // 这是科目
    Subject s1 = new(){ Name = "语文"};
    Subject s2 = new(){ Name = "数学"};
    Subject s3 = new(){ Name = "英语"};
    Subject s4 = new(){ Name = "物理"};
    Subject s5 = new(){ Name = "地理"};
    cxt.Subjects.AddRange(new[]{
      s1, s2, s3, s4, s5
    });
    // 学生和作业可以一起添加
    cxt.Students.Add(
      new Student{
            Name = "小华",
            Grade = 4,
            Homeworks = new []
            {
                new Homework
                {
                  Description = "背单词3500个",
                  Subject = s3
                },
                new Homework
                {
                  Description = "作文《我是谁,我在哪里》",
                  Subject = s1
                },
                new Homework
                {
                   Description = "手绘广州地铁网络图",
                   Subject = s5
                }
            }
      }
    );
    cxt.Students.Add(
      new Student
      {
            Name = "王双喜",
            Grade = 3,
            Homeworks = new[] {
                new Homework
                {
                  Description = "完型填空练习",
                  Subject = s3
                }
            }
      }
    );
    cxt.Students.Add(
      new Student
      {
            Name = "割麦小王子",
            Grade = 5,
            Homeworks = new[]{
                new Homework
                {
                  Description = "实验:用激光给蟑螂美容",
                  Subject = s4
                },
                new Homework{
                  Description = "翻译文言文《醉驾通鉴》",
                  Subject = s1
                }
            }
      }
    );
    // 保存到数据库
    cxt.SaveChanges();
}SaveChanges 方法记得调用,调用了才会保存数据。
ShowData 方法负责在控制台打印数据。
static void ShowData()
{
    using MyContext ctx = new();
    var students = ctx.Students.Include(s => s.Homeworks)
                .ThenInclude(hw => hw.Subject)
                .AsEnumerable();
    // 打印学生信息
    Console.WriteLine("{0,-5}{1,-10}{2,-6}", "学号", "姓名", "年级");
    Console.WriteLine("----------------------------------------------------");
    foreach(var stu in students)
    {
      Console.WriteLine($"{stu.StuID,-7}{stu.Name,-10}{stu.Grade,-4}");
      // 打印作业信息
      foreach(Homework wk in stu.Homeworks)
      {
            Console.Write(">> {0,-4}", wk.Subject!.Name);
            Console.WriteLine(wk.Description);
      }
      Console.Write("\n\n");
    }
}在加载数据时得小心,因为如果你只访问 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 来演示。
static void RemoveDatabase()
{
    using MyContext c = new();
    c.Database.EnsureDeleted();
}-------------------------------------------------------------------------------------------
用的时候,按顺调用这些方法,就可以测试了。
   Console.WriteLine("** 第一步:初始化数据库。【请按任意键继续】");
   _ = Console.ReadKey(true);
   InitDatabase();

   Console.WriteLine("** 第二步:显示数据。【请按任意键继续】");
   _ = Console.ReadKey(true);
   ShowData();

   //Console.WriteLine("** 第三步:删除数据库。【请按任意键继续】");
   //_ = Console.ReadKey();
   //RemoveDatabase();
产生的数据表如下图所示:

 
我们上面的这个模型还是有点问题的,可以看一下,生成的数据表是没有删除约束的。
CREATE TABLE . (
           INT            IDENTITY (1, 1) NOT NULL,
    NVARCHAR (MAX) NULL,
    INT            NULL,
    INT            NULL,
    CONSTRAINT PRIMARY KEY CLUSTERED ( ASC),
    CONSTRAINT FOREIGN KEY () REFERENCES . (),
    CONSTRAINT FOREIGN KEY () REFERENCES . ()
);假如现在我要删掉一条学生记录。
using(MyContext dbcontext = new())
{
    // 删第一条记录
    var one = dbcontext.Students.FirstOrDefault();
    if(one != null)
    {
      dbcontext.Students.Remove(one);
      dbcontext.SaveChanges();
    }
}但删除的时候会遇到错误。

这表明咱们要配置级联删除。
public class MyContext : DbContext
{
    public DbSet<Student> Students => Set<Student>();
    public DbSet<Homework> Homeworks => Set<Homework>();
    public DbSet<Subject> Subjects => Set<Subject>();

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
      optionsBuilder.UseSqlServer(@"server=(localdb)\MSSQLLocalDB;Database=TestDB;Integrated Security=True");
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
      ……
      // 建立模型关系
      modelBuilder.Entity<Student>()
                  .HasMany(s => s.Homeworks)
                  .WithOne(w => w.Student)
                  .OnDelete(DeleteBehavior.Cascade);
      modelBuilder.Entity<Homework>().HasOne(w => w.Subject);
    }
}现在再删一次看看。

可以看到,与第一位学生有关的作业记录也一并被删除了。生成的数据表也与前面有一点差异。
CREATE TABLE . (
           INT            IDENTITY (1, 1) NOT NULL,
    NVARCHAR (MAX) NULL,
    INT            NULL,
    INT            NULL,
    CONSTRAINT PRIMARY KEY CLUSTERED ( ASC),
    CONSTRAINT FOREIGN KEY () REFERENCES . () ON DELETE CASCADE,
    CONSTRAINT FOREIGN KEY () REFERENCES . ()
);约束里面显然多了 ON DELETE CASCADE 语句。
回忆一下,在上一篇水文中,咱们使用主从对象后,我们在模型中没有明确配置级联删除,但生成的数据表中自动加上级联删除了。
这是不是说明:主从关系的实体对象里,主实体对从属实体的控制更强烈,咱们再对比对比看。
现在,让 Student 和 Homework 成为主从关系。
public class MyContext : DbContext
{
    public DbSet<Student> Students => Set<Student>();
    public DbSet<Homework> Homeworks => Set<Homework>();
    public DbSet<Subject> Subjects => Set<Subject>();

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
      ……
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
      // 设置主键
      modelBuilder.Entity<Student>().HasKey(s => s.StuID);
      modelBuilder.Entity<Subject>().HasKey(u => u.SubID);
      // 建立模型关系
      modelBuilder.Entity<Student>()
                  .OwnsMany(s => s.Homeworks, mrb =>
                  {
                        mrb.WithOwner(w => w.Student);
                        mrb.HasKey(w => w.WorkID);
                        mrb.HasOne(w => w.Subject);
                  });
                  
    }
}上次我们也证实过,凡成为从属的实体是无法单独进行配置的(如主键等),只能在配置主从关系的时候通过 OwnsMany 方法的委托来配置。
主从关系会自动生成级联删除语句。
CREATE TABLE . (
    ……,
    CONSTRAINT PRIMARY KEY CLUSTERED ( ASC),
    CONSTRAINT FOREIGN KEY () REFERENCES . () ON DELETE CASCADE,
    ……
);还有一点更关键的,Homework 成为 Student 的从对象后,你甚至无法直接访问 Homeworks 集合,必须通过 Sudents 集合来访问。
using (MyContext ctx = new MyContext())
{
    foreach(Homework hw in ctx.Homeworks)
    {
      Console.WriteLine($"{hw.Description}");
    }
}上述代码会抛异常。

这很明了,就是说你必须通过 Student 实体才能访问 Homework。所以,正确的做法要这样:
using (MyContext ctx = new MyContext())
{
    ctx.Subjects.Load();    // 这个可不会自动加载,必须Load
    foreach(Student stu in ctx.Students)
    {
      Console.WriteLine("【{0}】同学", stu.Name);
      foreach(Homework work in stu.Homeworks)
      {
            Console.WriteLine("{0}:{1}", work.Subject?.Name, work.Description);
      }
    }
}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】 我们会及时删除侵权内容,谢谢合作!
页: [1]
查看完整版本: 【EF Core】主从实体关系与常见实体关系的区别