EFCore学习笔记（8）——关系

已于 2022-07-12 00:08:02 修改
阅读量1k 收藏 2
点赞数 1
分类专栏： .NET 数据库 文章标签： 学习 数据库
于 2022-07-05 14:57:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BadAyase/article/details/125558150
版权
.NET 同时被 2 个专栏收录
56 篇文章 43 订阅
订阅专栏
数据库
19 篇文章 0 订阅
订阅专栏

文章目录

关系

关系（relationship）定义了两个实体（entity）之间是怎样联系的。
在关系数据库中，这是由外键约束（foreign key constraint）来表示的。

注意：
本文中的大多数示例使用一对多的关系来说明概念。关于一对一的关系很简单，多对多关系的示例可以自行研究。

1. 术语的定义

用来描述关系的术语有许多：

这些术语对初学者来讲很头疼，但没办法，因为数据库这个东西，尤其是关系数据库，背后是有理论模型的，还有数学概念支撑。而这些理论模型、数学概念就是抽象的，它必然会产生一套概念、术语去描述它。所以在深入关系之前，有必要对这些概念有个大致了解。
关系数据库模型中有许多概念与EF Core中类似，甚至等同。但是我学习的时候发现它们的英文是不一样的，比如关系数据库中主键是primary key，而EF Core中有principal key，两者虽然看似相等，但实际上不完全是一个东西。
我想，作为初学者，应该谨慎对待。比如principal key，从微软文档来看，可能是主键或者候补键，那就不能和主键等同。

  • 依赖实体（Dependent entity）：也叫从实体或子实体，这是一个包含外键属性的实体。有时也被称为关系的孩子。我个人喜欢叫它从实体，因为还有主实体，主从嘛，比较好记。
  • 主体实体（Principal entity）：也叫主实体，这个实体包含了主键/候补键属性。有时候也称其为关系的父亲。

这对实体结合父子、主从的概念来看都是很好理解的。从/子实体通过外键来找到主/父实体，进而访问主/父实体。因为从实体中的外键属性值，在主实体中必然存在，且为键。

  • 主体键（Principal key）：这是一个唯一标识了主实体的属性。它可能是主键或候补键。我之所以称它为主体键，因为它是用来标识主实体的，而且这样命名可以与主键做区分。
  • 外键（Foreign key）：它是存在于从实体中的属性，用于存储相关联实体（主实体）的主体键的值。

外键：如果一个实体的某个字段指向另一个实体的主键，就称为外键。被指向的实体，称之为主实体，也叫父实体。负责指向的实体，称之为从实体，也叫子实体。从名字上也不难理解，外键就是外部（其他）实体的键。

  • 导航属性（Navigation property）：这是一个定义在主实体或从实体中来引用相关实体的的属性。

比如，我的博客中有许多文章，点击文章链接，就可以跳转到文章；又比如，我的文章中有标注所属的博客，我点击博客又可以跳转到我的博客信息。导航属性其实很简单，就是可以通过它跳转到别的实体上。就像导航栏的功能一样。

  • 导航属性还可细分为三种属性，
    • 集合导航属性（Collection navigation property）：它是一个包含对许多相关实体引用的导航属性。（往往是一个集合，它引用了不止单个实体）
    • 引用导航属性（Reference navigation property）：持有对单个相关实体的引用的导航属性。
    • 逆导航属性（Inverse navigation property）：在讨论一个特定的导航属性时，这个术语指的是该关系另一端的导航属性。
  1. 集合导航属性可以认为就是一个容器，容器中装了多个导航属性。
  2. 引用导航属性就是最基本的导航属性，就是单个引用。
  3. 逆导航属性就是该关系另一端的实体中的导航属性。比如，人和苹果是一对实体，人吃苹果，吃是一种关系。针对人吃苹果这个关系，人的实体中可以访问苹果，那苹果也可以访问人，苹果对于人的关系就是被吃。关键在于人吃苹果这个特定的关系。
  • 自参照关系（Self-referencing relationship）：依赖实体类型和主要实体类型相同的关系。

以下代码展示了Blog和Post之间一对多的关系：

public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }

    public List<Post> Posts { get; set; }
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }

    public int BlogId { get; set; }
    public Blog Blog { get; set; }
}

其中，

  • Post是一个从实体。
    将上面两实体类用二维表的形式表示，
    在这里插入图片描述

  • Blog是主实体。

  • Blog.BlogId是主体键（该场景中，它是主键而不是候补键）。

  • Post.BlogId是外键。

  • Post.Blog是引用导航属性。

  • Blog.Posts是集合导航属性。

  • Post.Blog是Blog.Posts的相反导航属性（反之亦然）。

2. 约定（即按照EF Core默认规定发现生成关系）

默认情况下，当在类型（指实体类）上发现导航属性时，就会创建关系。如果当前数据库提供程序无法将属性指向的类型映射为值类型（标量类型，scalar type），则该属性就被视为导航属性。（关系模型的域这个概念中有说到，域中元素，即属性的取值范围里的值都应该是原子的，而这边发现属性指向类型还能继续分，说明不符合域的原子性的约束，所以被数据库提供程序视为了导航属性）

所以按照约定，关系是在导航属性被发现的情况下被创建的。
注意：
按照约定发现的关系将始终以主实体的主键为目标。
要以候补键为目标，必须使用fluent API执行额外的配置。

2.1. 完全定义的关系

关于关系，最常用的模式是在关系的两端都定义导航属性，并在从/依赖实体类中定义外键属性。

  • 如果在两个类型之间发现了一对导航属性，那么他们将配置为具有相同关系的逆导航属性。
  • 如果从实体包含了一个属性，该属性名与下面模式中的某个相匹配，则它被配置为外键：
    • <navigation property name><principal key property name>
      <导航属性名> + <主体键属性名>
    • <navigation property name>Id
      <导航属性名> + Id
    • <principal entity name><principal key property name>
      <主实体名> + <主体键属性名>
    • <principal entity name>Id
      <主实体名> + Id
public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }

	// 1 集合导航属性
    public List<Post> Posts { get; set; }
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }

	// 2 外键
    public int BlogId { get; set; }
    // 3 导航属性
    public Blog Blog { get; set; }
}

本例中，标注的属性将被用于配置关系。

注意：
如果该属性是主键或其类型与主体键不兼容，则它不会被配置为外键。

2.2. 无外键属性（的关系）

尽管建议在从实体类中定义外键属性，但这不是必须的。如果没有找到外键属性，将会引入影子外键属性（shadow foreign key property），其名称为：

  • <navigation property name><principal key property name>
    <导航属性名> + <主体键属性名>
  • 或如果从实体类上没有导航属性时，
    <principal entity name><principal key property name>
    <主实体名> + <主体键属性名>。
public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }

	// 集合导航属性
    public List<Post> Posts { get; set; }
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }

	// 引用导航属性
    public Blog Blog { get; set; }
}

在本例中，影子外键是BlogId，因为前缀增加导航名显然是多余的（加了就变成了BlogBlogId）。

注意：
如果相同名称的属性已经存在，则影子属性名会加上数字后缀。

2.3. 单个导航属性

只包含一个导航属性（没有相反导航属性也没有外键属性）就足以由约定来定义关系。当然，你还可以添加导航属性和外键属性。

public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }

	// 集合导航属性
    public List<Post> Posts { get; set; }
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
}

2.4. 局限性

当在两个类型之间定义了多个导航属性时（就是说，不止一对导航指向彼此），由导航属性表示的关系比较模糊。你将需要手动配置它们来解决歧义。

2.5. 级联删除（Cascade delete）

按照约定，对于必需（required）的关系，级联删除将被设置为Cascade。对于可选的关系，设置为ClientSetNull。
Cascade意味着从实体也被删除。
ClientSetNull表示没有加载到内存的从实体将保持不变，必须手动删除，或更新以指向有效的主体实体。对于加载到内存中的实体，EF Core将尝试将外键属性设置为空。

3. 手动配置

手动是相对于约定的，约定是你按照EF Core的命名习惯去命名，EF Core会自己识别关系。
而手动是你自己显式地指明关系。

手动配置有两种方式，Fluent API和数据标注（Data annotations）。

  • Fluent API：
// Fluent API
// 要在Fluent API中配置关系，首先要标识组成关系的导航属性
// HasOne或HasMany用来标识实体类上的导航属性
// 然后，链接调用到WithOne或WithMany来标识逆导航
// HasOne/WithOne用于引用导航属性，HasMany/WithMany用于集合导航属性
internal class MyContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post> Posts { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Post>()	// 获取模型中的Post实体
            .HasOne(p => p.Blog)	// has，have有让、使的意思，可以理解为让某个属性成为导航属性
            .WithMany(b => b.Posts);// With有用的意思，可以理解为用某个属性指向该实体
            						// 至于One和Many，那就是数量上的区别了，引用和集合的区别
    }
}

public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }

    public List<Post> Posts { get; set; }
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }

    public Blog Blog { get; set; }
}
  • 数据标注：
// 你也可以使用数据标注来配置在从实体和主实体上导航属性配对的方式
// 在两个实体之间有超过一对的导航属性时，通常会这么做。
public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }

    public int AuthorUserId { get; set; }
    public User Author { get; set; }

    public int ContributorUserId { get; set; }
    public User Contributor { get; set; }
}

public class User
{
    public string UserId { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }

    [InverseProperty("Author")]
    public List<Post> AuthoredPosts { get; set; }

    [InverseProperty("Contributor")]
    public List<Post> ContributedToPosts { get; set; }
}

注意：
你只能在从实体的属性上使用[Required]来影响关系的必需性。
主实体导航属性上的[Required]通常被忽略（主体键本来就不能为空），但它可能导致实体变成依赖实体。

注意：
数据标注[ForeignKey]和[InverseProperty]在命名空间System.ComponentModel.DataAnnotations.Schema中可用。
[Required]在命名空间System.ComponentModel.DataAnnotations中可用。

3.1. 单个导航属性

如果你只有一个导航属性，那么就可以用WithOne和WithMany的无参重载。这表明在关系的另一端存在一个概念上的引用或集合，但在实体类中不包含导航属性。

internal class MyContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post> Posts { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Blog>()
            .HasMany(b => b.Posts)
            .WithOne();
    }
}

public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }

    public List<Post> Posts { get; set; }
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
}

3.2. 配置导航属性

注意：
EF Core 5.0中引入的该特性。

在创建导航属性后，你需要进一步配置它。

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()		// 从模型中获取Blog实体
        .HasMany(b => b.Posts)		// 让Posts成为集合导航属性
        .WithOne();					// 用主实体中的逆导航属性指向Blog实体

    modelBuilder.Entity<Blog>()
        .Navigation(b => b.Posts)	// 获取Blog实体中的Posts导航属性
        .UsePropertyAccessMode(PropertyAccessMode.Property);
}

注意：
此调用无法用于创建导航属性。它只用于配置导航属性，该属性是先前通过定义关系或根据约定创建的。（也就是说你得用其他方法先创建了导航属性，才能配置它）

3.3. 外键

  • Fluent API（单键）
// Fluent API （单键）
// 你可以使用Fluent API来配置给定关系用作外键的属性：
internal class MyContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post> Posts { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Post>()
            .HasOne(p => p.Blog)
            .WithMany(b => b.Posts)
            .HasForeignKey(p => p.BlogForeignKey);	// 将Post中的BlogForeignKey配置为外键就可以了？是的，它会去找主体中的主体键的
    }
}

public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }

    public List<Post> Posts { get; set; }
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }

    public int BlogForeignKey { get; set; }
    public Blog Blog { get; set; }
}
  • Fluent API（组合键）
// 用Fluent API来配置给定关系的用作组合键的属性
internal class MyContext : DbContext
{
    public DbSet<Car> Cars { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Car>()
            .HasKey(c => new { c.State, c.LicensePlate });

        modelBuilder.Entity<RecordOfSale>()
            .HasOne(s => s.Car)
            .WithMany(c => c.SaleHistory)
            .HasForeignKey(s => new { s.CarState, s.CarLicensePlate });
    }
}

public class Car
{
    public string State { get; set; }
    public string LicensePlate { get; set; }
    public string Make { get; set; }
    public string Model { get; set; }

    public List<RecordOfSale> SaleHistory { get; set; }
}

public class RecordOfSale
{
    public int RecordOfSaleId { get; set; }
    public DateTime DateSold { get; set; }
    public decimal Price { get; set; }

    public string CarState { get; set; }
    public string CarLicensePlate { get; set; }
    public Car Car { get; set; }
}
  • 数据标注（单键）
// 你可以使用数据标注来配置给定关系中用作外键的属性。
// 当按约定未发现外键属性时，通常会这么做：
public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }

    public List<Post> Posts { get; set; }
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }

    public int BlogForeignKey { get; set; }

    [ForeignKey("BlogForeignKey")]
    public Blog Blog { get; set; }
}

提示：
[ForeignKey]标注可以放在关系中的任意导航属性上。
它不需要在从（依赖）实体类中的导航属性上。

注意：
在导航属性上使用[ForeignKey]指定的属性不需要存在于从实体类（依赖类）中。
不存在的情况下，会创建指定的名称的影子外键。

3.4. 影子外键

你可以使用 HasForeignKey(…)的字符串重载来配置一个影子属性作为外键（如果是使用对象导航的形式，是已经存在的属性，那就直接是外键了；而字符串格式的是不存在的属性，是影子外键）。我们建议在使用影子属性作为外键之前，显式地将其添加到模型中（如下所示）。

internal class MyContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post> Posts { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Add the shadow property to the model
        modelBuilder.Entity<Post>()
            .Property<int>("BlogForeignKey");

        // Use the shadow property as a foreign key
        modelBuilder.Entity<Post>()
            .HasOne(p => p.Blog)
            .WithMany(b => b.Posts)
            .HasForeignKey("BlogForeignKey");
    }
}

public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }

    public List<Post> Posts { get; set; }
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }

    public Blog Blog { get; set; }
}

3.5. 外键约束名称

按照惯例，当目标为关系数据库时，外键约束名称为
FK_<dependent type name><principal type name><foreign key property name>，
即FK_从实体类名_主实体类名_外键属性名。
对于组合外键，<foreign key property name>会变成一个下划线分割的外键属性名称表。
你也可以按照以下方式来配置约束名：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Post>()
        .HasOne(p => p.Blog)
        .WithMany(b => b.Posts)
        .HasForeignKey(p => p.BlogId)
        .HasConstraintName("ForeignKey_Post_Blog");
}

3.6. 不带导航属性

你也不是一定要提供导航属性，你可以简单地在关系的另一端提供一个外键。

internal class MyContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post> Posts { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Post>()
            .HasOne<Blog>()
            .WithMany()
            .HasForeignKey(p => p.BlogId);
    }
}

public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }

    public int BlogId { get; set; }
}

3.7. 主体键

如果希望外键引用主键（primary key）以外的属性，可以使用Fluent API来配置关系的主体键（principal key）属性。配置为主体键的属性将自动设置为候补键。

  • 单键的情况，Simple key
internal class MyContext : DbContext
{
    public DbSet<Car> Cars { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<RecordOfSale>()
            .HasOne(s => s.Car)
            .WithMany(c => c.SaleHistory)
            .HasForeignKey(s => s.CarLicensePlate)
            .HasPrincipalKey(c => c.LicensePlate);
    }
}

public class Car
{
    public int CarId { get; set; }
    public string LicensePlate { get; set; }
    public string Make { get; set; }
    public string Model { get; set; }

    public List<RecordOfSale> SaleHistory { get; set; }
}

public class RecordOfSale
{
    public int RecordOfSaleId { get; set; }
    public DateTime DateSold { get; set; }
    public decimal Price { get; set; }

    public string CarLicensePlate { get; set; }
    public Car Car { get; set; }
}
  • 组合键的情况，Composite key
internal class MyContext : DbContext
{
    public DbSet<Car> Cars { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<RecordOfSale>()
            .HasOne(s => s.Car)
            .WithMany(c => c.SaleHistory)
            .HasForeignKey(s => new { s.CarState, s.CarLicensePlate })
            .HasPrincipalKey(c => new { c.State, c.LicensePlate });
    }
}

public class Car
{
    public int CarId { get; set; }
    public string State { get; set; }
    public string LicensePlate { get; set; }
    public string Make { get; set; }
    public string Model { get; set; }

    public List<RecordOfSale> SaleHistory { get; set; }
}

public class RecordOfSale
{
    public int RecordOfSaleId { get; set; }
    public DateTime DateSold { get; set; }
    public decimal Price { get; set; }

    public string CarState { get; set; }
    public string CarLicensePlate { get; set; }
    public Car Car { get; set; }
}

警告：
指定主体键属性的顺序必须与外键指定的顺序匹配。

3.8. 必需的和可选的关系

可以使用Fluent API来配置一个关系是必需的还是可选的。最终，这将会控制外键属性是必需的还是可选的。当使用影子外键时，这非常有用。如果你的实体类中有一个外键属性，那么关系的需要性取决于外键属性是必需的还是可选的。

外键属性位于依赖实体类型上，因此如果它们被配置为必需的，就意味着每个从实体都需要一个对应的主实体。

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Post>()
        .HasOne(p => p.Blog)
        .WithMany(b => b.Posts)
        .IsRequired();
}

注意：
调用IsRequired(false)也会使外键属性变成可选的，除非在其它地方配置了。

3.9. 级联删除

使用Fluent API来为给定的关系显式配置级联删除行为。
关于级联删除的详细信息，可以参阅级联删除章节Cascade delete。

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Post>()
        .HasOne(p => p.Blog)
        .WithMany(b => b.Posts)
        .OnDelete(DeleteBehavior.Cascade);
}

4. 其它关系模式

4.1. 一对一

一对一关系在关系两边都有一个引用导航属性。它们遵循与一对多关系相同的约定，但是在外键属性上引入了唯一的索引来确保只有一个从实体与每个主实体相关。

public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }

    public BlogImage BlogImage { get; set; }
}

public class BlogImage
{
    public int BlogImageId { get; set; }
    public byte[] Image { get; set; }
    public string Caption { get; set; }

    public int BlogId { get; set; }
    public Blog Blog { get; set; }
}

注意：
EF会根据其检测外键属性的能力来选择一个实体作为依赖项。如果选择了错误的实体作为依赖/从实体，你可以使用Fluent API来纠正。

当使用Fluent API来配置关系时，可以使用HasOne和WithOne方法。
在配置外键时，你需要指定从实体类型 —— 注意下面列出的提供给HasForeignKey的泛型参数。在一对多关系中，带有引用导航属性的实体是从实体，而带有集合导航属性的实体是主实体，这点非常明显。但在一对一的关系中就不那么明显了——因此需要显式地定义它。

internal class MyContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<BlogImage> BlogImages { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Blog>()
            .HasOne(b => b.BlogImage)
            .WithOne(i => i.Blog)
            .HasForeignKey<BlogImage>(b => b.BlogForeignKey);
    }
}

public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }

    public BlogImage BlogImage { get; set; }
}

public class BlogImage
{
    public int BlogImageId { get; set; }
    public byte[] Image { get; set; }
    public string Caption { get; set; }

    public int BlogForeignKey { get; set; }
    public Blog Blog { get; set; }
}

默认情况下，从/依赖实体侧被认为是可选的（optional），不过可以根据需要配置为必需的（required）。但是，EF不会验证是否提供了一个从实体，所以只有当数据库映射允许强制执行时，该配置才会有所不同。一个常见的场景是引用自己拥有的类型，默认情况下使用表拆分。

modelBuilder.Entity<Order>(
    ob =>
    {
        ob.OwnsOne(
            o => o.ShippingAddress,
            sa =>
            {
                sa.Property(p => p.Street).IsRequired();
                sa.Property(p => p.City).IsRequired();
            });

        ob.Navigation(o => o.ShippingAddress)
            .IsRequired();
    });

通过此配置，与ShippingAddress对应的列将在数据库中标记为不可为空。

注意：
如果你使用了不可为空引用类型，那调用IsRequired就不是必要的。

注意：
配置从实体是否必需的功能是EF Core 5.0引入的。

4.2. 多对多

多对多关系需要关系两端都有集合导航属性。它们会像其他关系类型一样被默认约定发现。

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }

	// 集合导航属性
    public ICollection<Tag> Tags { get; set; }
}

public class Tag
{
    public string TagId { get; set; }
	// 集合导航属性
    public ICollection<Post> Posts { get; set; }
}

在数据库中实现这种关系的方式是使用一张连接表（join table），该表包含了指向Post和Tag的外键。例如，以下就是EF在关系数据库中为上述模型创建的内容。

CREATE TABLE [Posts] (
    [PostId] int NOT NULL IDENTITY,
    [Title] nvarchar(max) NULL,
    [Content] nvarchar(max) NULL,
    CONSTRAINT [PK_Posts] PRIMARY KEY ([PostId])
);

CREATE TABLE [Tags] (
    [TagId] nvarchar(450) NOT NULL,
    CONSTRAINT [PK_Tags] PRIMARY KEY ([TagId])
);

CREATE TABLE [PostTag] (
    [PostsId] int NOT NULL,
    [TagsId] nvarchar(450) NOT NULL,
    CONSTRAINT [PK_PostTag] PRIMARY KEY ([PostsId], [TagsId]),
    CONSTRAINT [FK_PostTag_Posts_PostsId] FOREIGN KEY ([PostsId]) REFERENCES [Posts] ([PostId]) ON DELETE CASCADE,
    CONSTRAINT [FK_PostTag_Tags_TagsId] FOREIGN KEY ([TagsId]) REFERENCES [Tags] ([TagId]) ON DELETE CASCADE
);

在其内部，EF创建了一个实体类型来表示连接表，它被称作连接实体类型。
现在，Dictionary<string， object>用于处理外键属性的任意组合（通过词典键值对，使用外键名来获取访问对象）。
模型中可以存在多个多对多的关系，因此必须为连接实体类型提供一个唯一的名称，在本例中为PostTag。允许这么做的特性被称为共享类型的实体类型。

重要点：
根据约定，用于连接实体类型的CLR类型可能会在未来的版本中发生更改以提高性能。不要依赖于连接类型的Dictionary<string, object>；除非你已经显式地配置了它。//？？

多对多导航被称为跳过（skip）导航，因为它们能有效地跳过连接实体类型。如果你使用批量配置，所有跳过导航都可以从GetSkipNavigations获得。

foreach (var entityType in modelBuilder.Model.GetEntityTypes())
{
    foreach (var skipNavigation in entityType.GetSkipNavigations())
    {
        Console.WriteLine(entityType.DisplayName() + "." + skipNavigation.Name);
    }
}
4.2.1. 连接实体类型配置

给连接实体类型应用配置是很常见的，这个操作可通过UsingEntity来完成。

modelBuilder
    .Entity<Post>()
    .HasMany(p => p.Tags)
    .WithMany(p => p.Posts)
    .UsingEntity(j => j.ToTable("PostTags"));

可以使用匿名类型来为连接实体类型提供模型种子数据（model seed data）。你可以检测模型调试视图来确认由约定创建的属性名。

modelBuilder
    .Entity<Post>()
    .HasData(new Post { PostId = 1, Title = "First" });

modelBuilder
    .Entity<Tag>()
    .HasData(new Tag { TagId = "ef" });

modelBuilder
    .Entity<Post>()
    .HasMany(p => p.Tags)
    .WithMany(p => p.Posts)
    .UsingEntity(j => j.HasData(new { PostsPostId = 1, TagsTagId = "ef" }));

附加数据可以存储在连接实体类型中，但如果是为此，最好创建一个定制的CLR类型。

internal class MyContext : DbContext
{
    public MyContext(DbContextOptions<MyContext> options)
        : base(options)
    {
    }

    public DbSet<Post> Posts { get; set; }
    public DbSet<Tag> Tags { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Post>()
            .HasMany(p => p.Tags)
            .WithMany(p => p.Posts)
            .UsingEntity<PostTag>(
                j => j
                    .HasOne(pt => pt.Tag)
                    .WithMany(t => t.PostTags)
                    .HasForeignKey(pt => pt.TagId),
                j => j
                    .HasOne(pt => pt.Post)
                    .WithMany(p => p.PostTags)
                    .HasForeignKey(pt => pt.PostId),
                j =>
                {
                    j.Property(pt => pt.PublicationDate).HasDefaultValueSql("CURRENT_TIMESTAMP");
                    j.HasKey(t => new { t.PostId, t.TagId });
                });
    }
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }

    public ICollection<Tag> Tags { get; set; }
    public List<PostTag> PostTags { get; set; }
}

public class Tag
{
    public string TagId { get; set; }

    public ICollection<Post> Posts { get; set; }
    public List<PostTag> PostTags { get; set; }
}

public class PostTag
{
    public DateTime PublicationDate { get; set; }

    public int PostId { get; set; }
    public Post Post { get; set; }

    public string TagId { get; set; }
    public Tag Tag { get; set; }
}
4.2.2. 连接关系配置

EF在连接实体类型上使用两个一对多的关系来表示多对多关系。你可以在UsingEntity参数中来配置这些关系。

modelBuilder.Entity<Post>()
    .HasMany(p => p.Tags)
    .WithMany(p => p.Posts)
    .UsingEntity<Dictionary<string, object>>(
        "PostTag",
        j => j
            .HasOne<Tag>()
            .WithMany()
            .HasForeignKey("TagId")
            .HasConstraintName("FK_PostTag_Tags_TagId")
            .OnDelete(DeleteBehavior.Cascade),
        j => j
            .HasOne<Post>()
            .WithMany()
            .HasForeignKey("PostId")
            .HasConstraintName("FK_PostTag_Posts_PostId")
            .OnDelete(DeleteBehavior.ClientCascade));

注意：
配置多对多关系的功能是在EF Core 5.0引入的。之前的版本使用的是以下方法。

4.2.3. 间接的多对多关系

你也可以通过添加连接实体类型和映射两个独立的一对多关系来代表多对多关系。

public class MyContext : DbContext
{
    public MyContext(DbContextOptions<MyContext> options)
        : base(options)
    {
    }

    public DbSet<Post> Posts { get; set; }
    public DbSet<Tag> Tags { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<PostTag>()
            .HasKey(t => new { t.PostId, t.TagId });

        modelBuilder.Entity<PostTag>()
            .HasOne(pt => pt.Post)
            .WithMany(p => p.PostTags)
            .HasForeignKey(pt => pt.PostId);

        modelBuilder.Entity<PostTag>()
            .HasOne(pt => pt.Tag)
            .WithMany(t => t.PostTags)
            .HasForeignKey(pt => pt.TagId);
    }
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }

    public List<PostTag> PostTags { get; set; }
}

public class Tag
{
    public string TagId { get; set; }

    public List<PostTag> PostTags { get; set; }
}

public class PostTag
{
    public DateTime PublicationDate { get; set; }

    public int PostId { get; set; }
    public Post Post { get; set; }

    public string TagId { get; set; }
    public Tag Tag { get; set; }
}

注意：
支持对数据库搭建多对多关系的功能还未添加。

MelonSuika
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
学习笔记——数论——约数
01-06
1.d/n 等价于n%d==0. 2.一个整数N的约数个数的上界为. 3.1-N 每个数的约数个数综合大约为N * log N 个。 4.1-1e9中的数，约数个数最多的数仅有1536个约数 倍数法求1-N中所有数的约数集合：NlogN void gao() { vectorfactor[M]; for(int i=1;i<=n;i++)for(int j=i;j<=n;j+=i)v[j].push_back(i); } 数论分块： k/i    (1<=i<=n)   L,R每块的范围，x每块k/i的取值 for(int L=1,R;L<=n;L=R+1)
Solidworks学习笔记——随形变化.docx
07-13
Solidworks学习笔记——随形变化.docxSolidworks学习笔记——随形变化.docxSolidworks学习笔记——随形变化.docxSolidworks学习笔记——随形变化.docxSolidworks学习笔记——随形变化.docxSolidworks学习笔记——随形变化.docx
JBPM学习笔记——流程设计与控制
03-03
火龙果软件工程技术中心  相关资料：《jBPM学习笔记(V3.2环境部署)》《jBPM学习笔记(框架设计简介)》背景本片文章，我们将从业务流程的设计开始，通过带领大家完成一个完整工作流的程序设计，来学习jPDL的使用。业务流程设计这里我们实现一个相对简化的公司借款申请流程。流程图如下：在jPDL中，与流程设计相关的文件有三个：processdefinition.xml、gdp.xml、processimage.jpg。其中processdefinition.xml是流程定义的描述文件；gpd.xml是对图形界面呈现的XML描述；而processimage.jpg则是对图形界面的快照。下面我们将
Android学习笔记之——Content Providers
01-03
之前博文《 Android学习笔记之——Android Studio的安装（3.6版本）、Java的基本语法及Android的概述 》曾经介绍过android有四大组件。本博文学习一下Content Providers（内容提供器） 目录 Android运行时 （Android runtime）权限 在程序运行时申请权限 内容提供器简介 访问其他程序中的数据 Android运行时 （Android runtime）权限 Android开发团队在Android 6.0系统中引用了运行时权限这个功能，从而更好地保护了用户的安全和隐私。在之前博文《 Android学习笔记之——Broadcast
EF Core 2.0 已经支持自动生成父子关系表的实体
10-18 622
现在我们在SQL Server数据库中有Person表如下： CREATE TABLE [dbo].[Person]( [ID] [int] IDENTITY(1,1) NOT NULL, [Code] [nvarchar](50) NULL, [Name] [nvarchar](50) NULL, [ParentCode] [nvarcha...
EFCore主外键映射关系数据查询问题
比海更深
05-11 1565
在联查主子表数据的时候出现了一个问题，正序查询的时候分页20条，但是只查出来10条，但是第二页是有数据，真叫人头大，这里只记录解决过程。 在这次的业务场景下，需要啊查询子表的数据，但是每一条子表数据都需要带上其关联的主表的数据。 问题来了，因为EFCore的机制，采用的是实体类映射数据库的字段进行数据查询，所以在数据库表的字段定义上并没有那么严谨。 数据库中的的定义： 主表与子表并没有建立主外键约束 实体类中的定义：主表实体类与子表实体类在DataBuilder上建立了主外键关系 这样做是没有问题的，
EFCore中如何移除主外键关系
weixin_40581617的博客
09-25 1213
EFCore中如何移除主外键关系 场景介绍 我用EFCore写了一个blog程序，我要通过写文章来分享自己的知识，我定义了一个Article用来存放文章信息，我还定义了一个Category用来存放文章的分类，Category与Article是一对的关系。我的代码实现如下： Article public class Article { public int Id {get;set;...
EF核心一对多关系HasOne(),WithMany(),vs HasMany(),WithOne()
彭大摩的博客
03-23 5026
假设我有以下两种型号： public class Blog { public int BlogId { get; set; } public string Url { get; set; } public List<Post> Posts { get; set; } } public class Post { public int PostId { get; set; } public string Title { get; set; } pu
Entity Framework Core 选择数据表的外键
赫的BLOG
05-18 4436
entityTypeBuilder .HasOne() .WithMany(p => p.Geraete) .HasForeignKey(b => b.GeraeteArtId) .OnDelete(Microsoft.Data.Entity.Metadata.DeleteBehavior.SetNull); HasOne选择外键所在的表，withMany可以先忽
11. 迁移
singhwong
07-21 233
可以在现有的数据库中使用EF Core(称为"数据库优先")。在许多使用EF Core的场景中，数据库已经存在。数据库的模型类更新独立于应用程序，并且在数据库更改完成后更新应用程序。在这种情况下，EF Core迁移没有多大帮助。 如果使用应用程序创建数据库，EF Core迁移将非常有用。更改代码模型时，可以自动更新数据库。如果客户都有自己的数据库，并且使用应用程序的更新版本更改数据库模式，那么使用旧的应用程序版本更新客户可能是一个挑战。EF Core迁移可以解决这个问题：通过迁移，可以轻松地从版本x升级到
EF Core -- 关系
最新发布
kalvin_y_liu的博客
01-29 375
EF Core – 关系 一对多 // Dependent Entity 主表 public class Blog { // Principal Key 标识键/可能是主键或者备用键（唯一性约束） public int BlogId { get; set; } public string Url { get; set; } // Collection navigation property 关联多个从表的属性集合（集合属性） public List<
C# EF 6 Core 避坑杂谈
D13712787484的博客
11-12 855
EF 级联 删除
初识SQL Server代理&作业
三千幻想乡
10-13 5711
别人写的程序在数据库中生成了一些表，并且会不停更新表中数据。现在有个需求，定期根据表中的数据做一些运算，然后重新生成一张表。我将新表的表名、字段给第三方使用。关键是，我无法修改别人的代码，好在我可以登录该系统所运行电脑的数据库。经过一番搜索后，我发现了触发器和SQL Server代理这两种工具。进一步分析后，觉得SQL Server代理可能更符合我的需求。❗注意本文不讨论多SQL Server实例的情况。
《数据库系统概念》——实体-联系模型
三千幻想乡
07-10 4620
最近在学习如何使用.NET中的EF Core来访问数据，从一开始的SQL语句直接访问到后来的EF Core（O/RM）访问，再到EF Core用了一段时间后，发现数据表及关系设计也很关键。其实只是访问数据库一点问题都没有，问题是随着理解变深，数据变复杂，我的数据表还有表间的关系到底该怎么设计，怎么设计才能访问的更舒服，还有表与表之间的联系本质到底是什么。本以为学了EF Core，会简单使用就好了，结果发现用的过程中问题越来越多，疑惑越来越大。所以只能继续对概念进行深入学习理解。 正好前段时间看到《数据库系统
Navicat Premium简易报表
三千幻想乡
02-19 4131
前言  Navicat Premium可以做简易的数据报表，当数据量相对比较大，excel处理不过来，而又没有充足的时间给你写代码的时候，你可以使用它。 使用方法  右键你的数据库，新建报表，  在设计窗口区，可以往里面拖入各种内容模块，  选择数据窗口区时，你可以新建数据查询向导（数据管道），  它可以将你需要的数据从数据库中筛选出来，供你在设计区导入到图表中，生成可视化图表。  筛选过...
EFCore学习笔记（6）——EF6中使用DbContext
三千幻想乡
07-02 2183
前面几篇EF Core相关的学习笔记讲了不少EF Core中概念性的东西，但没有实际编程操作过。这篇算是开始简单使用DbContext的基本功能。相信通过前面文章对实体、上下文、数据标注这些基本概念有一定了解后，能很快地上手使用DbContext来访问数据。如果对这些概念没有太多了解也没事，因为本文是偏应用型的。那么为了使用EF来操作.NET对象进行查询、插入、更新和删除数据，首先需要创建一个Model，这个Model将定义在其中的实体和关系映射到数据库中的表上。一旦你有了一个Model，与应用程序交互的基
《数据库系统概念》——关系数据库
三千幻想乡
07-04 1362
前面根据网上资料拼凑，已经写过一篇关系数据库的文章了。但是总感觉有些概念模糊不清，甚至部分概念都没有介绍。虽然对整个关系数据库已经有了大概认识，但从它作为当下最主流的数据库之一这点来讲，这个理解程度应该是远远不够的。所以这次主要对《数据库系统概念》（第六版）的第一、二章——关系数据库及关系模型进行学习。这类书可能不那么有趣，但是概念上的完整性，逻辑的严谨度是有保障的。数据模型是描述数据、数据联系、数据语义以及一致性约束的概念工具的集合。关系模型现已称为主要的数据模型。之所以占据主要位置，是因为与早期的数据模
EFCore学习笔记（2）——实体类型
三千幻想乡
06-27 1234
上下文（Context的派生类）中包含一种类型的DbSet意味着它存在于EF Core的模型中； 通常称这样的类型为实体（Entity）（所以实体就是那个类，而不是DbSet xxx）。EF Core能从数据库中读数据至实体的实例或将实体实例写入数据库，并且如果你用的是关系数据库，EF Core能通过migrations为你的实体建表。按照约定（指的是EF Core这套技术设计/使用上的规定），在你定义的上下文中的DbSet属性暴露的类型会作为实体被包含在model中。在OnModelCreating...
EFCore学习笔记（4）——键
三千幻想乡
07-01 1170
前面学了关系数据库中键这个概念之后，再回过来看，EF Core中的键与关系数据库中的键可以说是一样的。 键（也称码、或者关键字）。 键是用作每个实体实例的唯一标识符的。EF中的大部分实体都有一个键，它会映射到关系数据库中的主键（primary key，简称PK）这个概念（还有一部分实体是可以没有键的，称为无键实体，这边不展开讲）。 实体还可以拥有除了主键外的其他键（候补键，或称候补码）。按照约定，一个属性命名为Id或者 Id就会被配置成实体的主键。 你可以按以下方式将单个属性配置为主...........
【K210】K210学习笔记五——串口通信
09-11
你好！感谢提问。下面是有关 K210 学习笔记五中串口通信的一些内容： 在 K210 开发板上，串口是一种常见的通信接口，用于将数据从一个设备传输到另一个设备。串口通信通常使用 UART (Universal Asynchronous Receiver/Transmitter) 协议。 要在 K210 上进行串口通信，首先需要使用两个引脚：一个用于接收数据（RX），一个用于发送数据（TX）。这些引脚可以通过 GPIO 端口与外部设备连接。 在 K210 的开发环境中，可以使用 MaixPy 或者 Kendryte Standalone SDK 进行串口编程。 在 MaixPy 中，可以使用 `uart` 模块来进行串口通信。例如，要初始化一个串口对象并设置波特率为 115200，可以使用以下代码： ```python from machine import UART uart = UART(UART.UART1, 115200) ``` 然后，可以使用 `uart.write()` 函数发送数据，使用 `uart.read()` 函数接收数据。例如： ```python uart.write("Hello, world!\n") data = uart.read(10) ``` 在 Kendryte Standalone SDK 中，可以使用 `uart.h` 头文件中的函数来进行串口通信。例如，要初始化一个串口对象并设置波特率为 115200，可以使用以下代码： ```c #include "uart.h" uart_init(UART_DEVICE_1, 115200); ``` 然后，可以使用 `uart_send_data()` 函数发送数据，使用 `uart_receive_data()` 函数接收数据。例如： ```c uart_send_data(UART_DEVICE_1, "Hello, world!\n", 14); char buffer[10]; uart_receive_data(UART_DEVICE_1, buffer, 10); ``` 以上是关于 K210 学习笔记五中串口通信的简要介绍。如果你有更具体的问题，请随时提问！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值