标签：Relationships set get int class Entity Framework using public

更新记录
转载请注明出处：
2022年10月17日发布。
2022年10月10日从笔记迁移到博客。

配置实体关系的方式

使用数据特性
使用FluentAPI关系配置
使用关系属性

导航属性说明

一个类型为主体实体或从属实体的属性

无论它是指它的父实体还是持有一个或多个从属实体

都被称为导航属性（navigation property）

导航属性分类

说明

集合型导航属性（Collection navigation property）

引用型导航属性（Reference navigation property）

反向引用导航属性（Inverse navigation property）

集合型导航属性保存一个依赖实体的集合（或对依赖项列表的引用）

并且始终保存对多个项的引用

//博客实体
class Blog
{
    //主键
    [Key]
    public int Id { get; set; }
    public string Title { get; set; }
    //集合导航属性
    //评论属性
    public ICollection<Post> Posts { get; set; }
}

引用型导航属性保存对其父实体的引用，并且始终保存对单个项的引用

//评论实体
public class Post
{
  //其他代码...
  public int BlogId { get; set; }
  
  //引用型导航属性
  //关联的blog实体
  public Blog Blog { get; set; }
}

EF Core模型间关联（Modeling Relationships）

EF Core关联的默认约定(Conventions in a relationship)

定义两个实体之间的关系时，在两个实体内部都需要定义关联导航属性

并且从属实体应具有外键属性

如果这两个实体的导航属性相互指向，EF会将它们配置为反向导航属性

两实体都定义导航属性的实体关系叫做完全定义的关系（Fully-defined relationships）

//博客实体
public class Blog
{
    //定义集合导航属性
    public ICollection<Post> Posts { get; set; }    
}

//评论实体
public class Post
{
    //外键属性
    public int BlogId { get; set; }
    //反向导航属性
    public Blog Blog { get; set; }
}

如果使用主键属性名的主体实体名，EF将认为该属性为外键

public class Blog
{
    public int Id { get; set; }
}

public class Post
{
    public int BlogId { get; set; }
}

如果主体实体主键与依赖实体引用键匹配，EF将创建外键关系

public class Blog
{
    public int Id { get; set; }
}

public class Post
{
    public Blog SomeBlog { get; set; }
    public int SomeBlogId { get; set; }  //外键字段
}

注意：如果我们不创建外键字段，EF Core仍然会在底层自动创建

public class Blog
{
    public int Id { get; set; }
}

public class Post
{
    public Blog SomeBlog { get; set; }
}

注意：如果我们把外键关联属性也删除了，EF Core仍然会在底层自动创建外键字段

public class Blog
{
  public ICollection<Post> Posts { get; set; }    
}

public class Post
{
    //仍会创建外键字段
}

注意：如果实体间包含多个关联，还是需要自己设置反向关联

public class Blog
{
    [InverseProperty("SomeBlog")]
    public ICollection<Post> SomePosts { get; set; }
}

public class Post
{
  public int SomeBlogId { get; set; }
  public Blog SomeBlog { get; set; }
}

EF Core手动设置外键底层字段

除了使用EF默认的关联约定，还可以自己设置底层的外键字段

使用ForeignKey数据注解即可

public class Blog
{
  public ICollection<Post> Posts { get; set; }    
}

public class Post
{
  public int BlogSomeId { get; set; }
  //手动设置外键底层字段
  [ForeignKey("BlogSomeId")]
  public Blog Blog { get; set; }
}

Fluent API配置关系的方法

HasXXX(...).WithXXX(...);

有XXX、反之带有XXX。XXX可选值One、Many。

HasOne(...).WithMany(...);		//一对多
HasOne(...).WithOne (...);		//一对一
HasMany(...).WithMany(...);		//多对多

注意：不设置反向的属性的时候，Withxxxx()不设置参数即可。

技巧：

1.关系配置在任何一方都可以。

2.对于主从结构的“一对多”表关系，一般是声明双向导航属性。而对于其他的“一对多”表关系：如果表属于被很多表引用的基础表，则用单项导航属性，否则可以自由决定是否用双向导航属性。

3.对于一对一的关系，使用[ForeignKey]特性标注存储外键的关联属性，或者专门定义一个外键属性，或者使用FluentAPI。

builder.HasOne<Delivery>(o => o.Delivery).WithOne(d =>d.Order).HasForeignKey<Delivery>(d=>d.OrderId);

设置外键属性

1、在实体类中显式声明一个外键属性。
2、关系配置中通过HasForeignKey(c=>c.ArticleId)指定这个属性为外键。
3、除非必要，否则不用声明，因为会引入重复。

设置一对一（One-to-one relationships）-使用默认约定

设置方法

在两个实体对象中建立引用属性，然后添加外键属性即可

注意：务必将两个实体都加上[Key]主键修饰，否则无法设置一对一

本质是：在子表内设置外键字段，并将该字段设置为唯一

引用数据的实体（数据库中的子表）（引用数据方）：

Public 被引用Model名 被引用Model名 { get; set; }

public int? 被引用Model名Id { get; set; }

被引用数据的实体模型（数据库中的母表）（被引用数据方）：

public 引用Model名 引用Model名 { get; set; }

实例：一个人只能有一个身份证卡（一对一）（Fluent API）

IdCard.cs Id卡实体

using Microsoft.EntityFrameworkCore;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.ComponentModel.Design;

namespace PandaTest
{
    /// <summary>
    /// Id卡
    /// </summary>
    public class IdCard
    {
        [Key]
        public Guid Id { get; set; }
        public string? Name { get; set; }

        [ForeignKey("PersonId")]
        public Person? Person { get; set; }
    }
}

IdCardEntityConfig.cs Id卡实体配置

using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Builders;

namespace PandaTest
{
    /// <summary>
    /// 人员实体配置
    /// </summary>
    public class IdCardEntityConfig : IEntityTypeConfiguration<IdCard>
    {
        public void Configure(EntityTypeBuilder<IdCard> builder)
        {
        }
    }
}

Person.cs 人员实体

using Microsoft.EntityFrameworkCore;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.ComponentModel.Design;

namespace PandaTest
{
    /// <summary>
    /// 人员实体
    /// </summary>
    public class Person
    {
        [Key]
        public Guid Id { get; set; }
        public string? Name { get; set; }

        public IdCard? IdCard { get; set; }
    }
}

PersonEntityConfig.cs 人员实体配置

using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Builders;

namespace PandaTest
{
    /// <summary>
    /// 人员实体配置
    /// </summary>
    public class PersonEntityConfig : IEntityTypeConfiguration<Person>
    {
        public void Configure(EntityTypeBuilder<Person> builder)
        {
            //建立一对一的关联
            builder.HasOne(i => i.IdCard).WithOne(i => i.Person);
        }
    }
}

TestDbContext.cs 数据库上下文

using Microsoft.EntityFrameworkCore;
using System.Diagnostics;

namespace PandaTest
{
    /// <summary>
    /// 数据库上下文
    /// </summary>
    public class TestDbContext: DbContext
    {
        public TestDbContext()
        {

        }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            string connectionString = "Server=.;Database=Test;User Id=sa;Password=Password";
            optionsBuilder.UseSqlServer(connectionString);

            optionsBuilder.LogTo(x => { Debug.WriteLine(x); });
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
            //应用所有实体配置
            modelBuilder.ApplyConfigurationsFromAssembly(this.GetType().Assembly);
        }

        public DbSet<Person> Persons { get; set; }
        public DbSet<IdCard> IdCards { get; set; }
    }
}

Program.cs 主程序

using PandaTest;
using Microsoft.EntityFrameworkCore;

Console.WriteLine("Begin");

//创建DbContext
using (TestDbContext db = new TestDbContext())
{
    var Panda = new Person
    {
        Name = "Panda",
        IdCard = new IdCard() { Name = "PandaIdCard" }
    };


    //插入数据
    db.Persons.Add(Panda);
    await db.SaveChangesAsync();
}

Console.WriteLine("Success");

实例：一个人只能有一个对象（一对一）（自引用）（Fluent API）

Person.cs 人员实体

using Microsoft.EntityFrameworkCore;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.ComponentModel.Design;

namespace PandaTest
{
    /// <summary>
    /// 人员实体
    /// </summary>
    public class Person
    {
        [Key]
        public Guid Id { get; set; }
        public string? Name { get; set; }

        [ForeignKey("OtherHalfId")]
        public virtual Person? OtherHalf { get; set; }
    }
}

PersonEntityConfig.cs 人员实体配置

using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Builders;

namespace PandaTest
{
    /// <summary>
    /// 人员实体配置
    /// </summary>
    public class PersonEntityConfig : IEntityTypeConfiguration<Person>
    {
        public void Configure(EntityTypeBuilder<Person> builder)
        {
        }
    }
}

TestDbContext.cs 数据库上下文

using Microsoft.EntityFrameworkCore;
using System.Diagnostics;

namespace PandaTest
{
    /// <summary>
    /// 数据库上下文
    /// </summary>
    public class TestDbContext: DbContext
    {
        public TestDbContext()
        {

        }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            string connectionString = "Server=.;Database=Test;User Id=sa;Password=Password";
            optionsBuilder.UseSqlServer(connectionString);

            optionsBuilder.LogTo(x => { Debug.WriteLine(x); });
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
            //应用所有实体配置
            modelBuilder.ApplyConfigurationsFromAssembly(this.GetType().Assembly);
        }

        public DbSet<Person> Persons { get; set; }
    }
}

Program.cs 主程序

using PandaTest;
using Microsoft.EntityFrameworkCore;

Console.WriteLine("Begin");

//创建DbContext
using (TestDbContext db = new TestDbContext())
{
    var Panda = new Person
    {
        Name = "Panda",
    };

    var Donkey = new Person
    {
        Name = "Donkey",
        OtherHalf = Panda
    };

    //插入数据
    db.Persons.Add(Donkey);
    await db.SaveChangesAsync();

    var panda = db.Persons.Where(i => i.Name == "Panda").FirstOrDefault();
    panda.OtherHalf = Donkey;
    db.Persons.Update(panda);
    await db.SaveChangesAsync();
}


Console.WriteLine("Success");

实例：用户和户籍地址

一个用户只有一个户籍地址

一个户籍地址只对应一个用户

代码：

using System;
using System.ComponentModel.DataAnnotations;

namespace ConsoleApp3.Models
{
    public class Address
    {
        [Key]
        public int Id { get; set; }
        public string Description { get; set; }
        //外键
        public int UserId { get; set; }
        //关联用户模型
        public User User { get; set; }
    }
}

using System;
using System.ComponentModel.DataAnnotations;

namespace ConsoleApp3.Models
{
    public class User
    {
        [Key]
        public int Id { get; set; }
        public string Name { get; set; }
        //关联地址模型
        public Address Address { get; set; }
    }
}

实例：用户和颜色

一个用户有且只有一个颜色

一个颜色有且只对应一个用户

代码：

颜色实体Entity：

class Color
{
    [Key]
    public int ColorId { get; set; }
    public string ColorTitle { get; set; }
    public User User { get; set; }   //重点
}

用户实体Entity：

class User
{
    [Key]
    public int UserId { get; set; }
    public string UserName { get; set; }
    public Color Color { get; set; }
    public int? ColorId { get; set; }
}

设置一对一（One-to-one relationships）-使用FluentAPI

设置方法

本质是：在子表内设置外键字段，并将该字段设置为唯一

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    //设置外键关联
    modelBuilder.Entity<User>()
        .HasOne(x => x.Address) //设置关联到另一个唯一的实体
        .WithOne(x => x.User)   //配置一对一的关系
        .HasForeignKey<Address>(x => x.UserId); //配置外键
}

实例：用户和户籍地址

一个用户只有一个户籍地址

一个户籍地址只对应一个用户

代码：

using System;
using System.ComponentModel.DataAnnotations;

namespace ConsoleApp3.Models
{
    public class Address
    {
        [Key]
        public int Id { get; set; }
        public string Description { get; set; }
        public User User { get; set; }
        public int UserId { get; set; }
    }
}

using System;
using System.ComponentModel.DataAnnotations;

namespace ConsoleApp3.Models
{
    public class User
    {
        [Key]
        public int Id { get; set; }
        public string UserName { get; set; }
        public int Age { get; set; }
        public Address Address { get; set; }
    }
}

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    //设置映射到底层数据库的表名
    modelBuilder.Entity<Address>().ToTable("AddressTable");

    //设置外键关联
    modelBuilder.Entity<User>()
        .ToTable("UserTable")  //设置映射到底层数据库的表名
        .HasOne(x => x.Address) //设置关联到另一个唯一的实体
        .WithOne(x => x.User)   //配置一对一的关系
        .HasForeignKey<Address>(x => x.UserId); //配置外键
}

实例：学生和学生地址

一个学生对应一个学生地址

一个学生地址对应一个学生

学生实体：

//学生实体
public class Student
{
    public int Id { get; set; }
    public string Name { get; set; }
    //导航属性
    public StudentAddress Address { get; set; }
}

学生地址实体：

//学生地址实体
public class StudentAddress
{
    public int StudentAddressId { get; set; }
    public string Address { get; set; }
    //外键导航属性
    public int AddressOfStudentId { get; set; }
    //导航属性
    public Student Student { get; set; }
}

配置一对一关系：

//配置一对一关系
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Student>()
        .HasOne(s => s.Address)
        .WithOne(d => d.Student)
        .HasForeignKey<StudentAddress>(d => d.StudentAddressId);
}

除了可以在Student实体上配置，还可以在StudentAddress实体上配置：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<StudentAddress>()
        .HasOne<Student>(d => d.Student)
        .WithOne(s => s.Address)
        .HasForeignKey<StudentAddress>(d => d.AddressOfStudentId);
}

生成的数据库如同所示：

设置一对多（One-to-many relationships）-使用默认约定

设置方法1（EF约定1）- 单方设置引用属性

直接在单个实体模型中定义引用

//学生
public class Student
{
    public int Id { get; set; }
    public string Name { get; set; }
    //关联的年级
    public Grade Grade { get; set; }
}

//年级
public class Grade
{
    public int GradeId { get; set; }
    public string GradeName { get; set; }
    public string Section { get; set; }
}

这种方式最终在数据库中的表会生成一个外键字段

注意：

这种方式生成的外键字段GradeId是可以为null的

可以通过FluentAPI设置其禁止为NULL

设置方法2（EF约定2）- 多方设置引用

//学生实体
public class Student
{
    public int StudentId { get; set; }
    public string StudentName { get; set; }
}

//年级实体
public class Grade
{
    public int GradeId { get; set; }
    public string GradeName { get; set; }
    public string Section { get; set; }
    //关联多个学生
    public ICollection<Student> Students { get; set; } 
}

设置方法3（EF约定3）- 双方都建立引用属性

本质就是：约定1+约定2

//学生实体
public class Student
{
    public int Id { get; set; }
    public string Name { get; set; }
    //引用属性
    public Grade Grade { get; set; }
}

//年级实体
public class Grade
{
    public int GradeID { get; set; }
    public string GradeName { get; set; }
    //集合引用属性
    public ICollection<Student> Students { get; set; }
}

设置方法4（EF约定4）- 设置额外的外键属性

在约定3的基础上再增加外键字段属性

//学生实体
public class Student
{
    public int Id { get; set; }
    public string Name { get; set; }
    //外键字段属性
    public int GradeId { get; set; }
    //引用属性
    public Grade Grade { get; set; }
}

//年级实体
public class Grade
{
    public int GradeId { get; set; }
    public string GradeName { get; set; }
    //集合引用属性
    public ICollection<Student> Students { get; set; }
}

注意：

这种方式定义的数据库的表的外键字段是不可以为Null的

如果需要字段是可以为NULL的，请使用：

public int? GradeId { get; set; }

实例：用户和产品

一个用户对应多个产品

一个产品对应一个用户

产品Entity：

class Product
{
    [Key]
    public int ProdcutId { get; set; }
    public string ProductTitle { get; set; }
    public decimal Price { get; set; }
    public virtual User User { get; set; }
    [ForeignKey("UserId")]
    public int? UserId { get; set; }
}

用户实体Entity：

class User
{
    [Key]
    public int UserId { get; set; }
    public string UserTitle { get; set; }
    public int age { get; set; }
    public virtual ICollection<Product> Products { get; set; } = new List<Product>();
}

实例：用户和车

一个用户对应多台车

一台车只属于一个用户

用户实体Entity：

class User
{
    public int UserId { get; set; }
    [StringLength(100)]
    public string UserName { get; set; }
    public ICollection<Car> Cars { get; set; } = new List<Car>();
}

车实体Entity：

class Car
{
    public int CarId { get; set; }
    public string CarBrand { get; set; }
    public virtual User User { get; set; }  //重点
    [ForeignKey("UserId")]
    public int? UserId { get; set; }        //重点
}

实例：用户和用户自定义配置信息

一个用户有多个自定义配置信息

多个自定义配置信息对应一个用户

用户实体：

public class User
{
    [Key]
    public int Id { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
    public DateTime JoinDateTime { get; set; }
    public ICollection<Configuration> Configurations { get; set; }
}

配置项实体：

public class Configuration
{
    [Key]
    public int Id { get; set; }
    public string Code { get; set; }
    public string Title { get; set; }
    public string Description { get; set; }
    public virtual User BelongUser { get; set; }
}

实例：博客文章和评论

一篇博客可以有多条评论

多条评论对应一篇博客

代码：

评论实体模型：

using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel.DataAnnotations;

namespace ConsoleApp3.Models
{
    public class Post
    {
        [Key]
        public int Id { get; set; }
        public string Title { get; set; }
        public string Context { get; set; }
        public Blog Blog { get; set; }
        public int BlogId { get; set; }
    }
}

博客文章实体模型：

using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel.DataAnnotations;

namespace ConsoleApp3.Models
{
    public class Blog
    {
        [Key]
        public int Id { get; set; }
        public string Title { get; set; }
        public string Content { get; set; }
        public ICollection<Post> Posts { get; set; }
    }
}

设置一对多（One-to-many relationships）-使用FluentAPI

设置方法（EF约定）

创建实体模型：学生和年级

一个学生对应一个年级，一个年级有多个学生

学生实体：

public class Student
{
    public int Id { get; set; }
    public string Name { get; set; }
    //外键导航属性
    public int CurrentGradeId { get; set; }
    //导航属性
    public Grade Grade { get; set; }
}

年级实体：

public class Grade
{
    public int GradeId { get; set; }
    public string GradeName { get; set; }
    public string Section { get; set; }
    //集合导航属性
    public ICollection<Student> Students { get; set; }
}

定义FluentAPI

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Student>()
        .HasOne<Grade>(s => s.Grade)    //（一）学生实体只有一个年级导航属性
        .WithMany(g => g.Students)      //（多）年级实体对应多个学生
        .HasForeignKey(s => s.CurrentGradeId);  //学生实体有一个外键导航属性
}

关系如图所示：

除了在学生实体上进行定义与年级实体的关联
还可以在年级实体上定义与学生实体的关联

protected override void OnModelCreating(ModelBuilder modelBuilder)
{

    modelBuilder.Entity<Grade>()
        .HasMany<Student>(g => g.Students)  //（多）年级实体对应多个学生
        .WithOne(s => s.Grade)              //（一）学生实体只有一个年级导航属性
        .HasForeignKey(s => s.CurrentGradeId);   //学生实体有一个外键导航属性
}

实例：父亲和儿子

一个父亲可以有多个儿子

一个儿子只有一个亲生父亲

父亲实体：

//父亲实体
public class Father
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
    //集合导航属性
    public ICollection<Son> Sons { get; set; }
}

儿子实体：

//儿子实体
public class Son
{
    public int Id { get; set; }
    public string Name { get; set; }
    //外键导航属性
    public int FatherId { get; set; }
    //导航属性
    public Father Father { get; set; }
}

定义FluentAPI：

//定义FluentAPI
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    //定义一对多
    modelBuilder.Entity<Father>()
        .HasMany(f => f.Sons)
        .WithOne(s => s.Father)
        .HasForeignKey(s => s.FatherId);
}

或者定义FluentAPI：

//定义FluentAPI
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    //定义多对一
    modelBuilder.Entity<Son>()
        .HasOne(s => s.Father)
        .WithMany(f => f.Sons)
        .HasForeignKey(s => s.FatherId);
}

实例：一个人对应多台车（一对多）（Fluent API）

Car.cs 汽车实体

using System.ComponentModel.DataAnnotations;
using System.ComponentModel.Design;

namespace PandaTest
{
    /// <summary>
    /// 汽车实体
    /// </summary>
    public class Car
    {
        public Guid Id { get; set; }
        public string CarName { get; set; }

        public Person BelongPerson { get; set; }
    }
}

Person.cs 人员实体

using Microsoft.EntityFrameworkCore;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.Design;

namespace PandaTest
{
    /// <summary>
    /// 人员实体
    /// </summary>
    public class Person
    {
        public Guid Id { get; set; }
        public string Name { get; set; }
        public List<Car> Cars { get; set; }
    }
}

PersonEntityConfig.cs 人员实体配置

using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Builders;

namespace PandaTest
{
    /// <summary>
    /// 人员实体配置
    /// </summary>
    public class PersonEntityConfig : IEntityTypeConfiguration<Person>
    {
        public void Configure(EntityTypeBuilder<Person> builder)
        {
            //配置关联(一个人有多台车，一个车只属于一个人)
            builder.HasMany(p => p.Cars).WithOne(c => c.BelongPerson);
        }
    }
}

CarEntityConfig.cs 汽车实体配置

using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Builders;

namespace PandaTest
{
    /// <summary>
    /// 汽车实体配置
    /// </summary>
    public class CarEntityConfig : IEntityTypeConfiguration<Car>
    {
        public void Configure(EntityTypeBuilder<Car> builder)
        {
            
        }
    }
}

TestDbContext.cs 数据库上下文

using Microsoft.EntityFrameworkCore;

namespace PandaTest
{
    /// <summary>
    /// 数据库上下文
    /// </summary>
    public class TestDbContext: DbContext
    {
        public TestDbContext()
        {

        }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            string connectionString = "Server=.;Database=Test;User Id=sa;Password=Password";
            optionsBuilder.UseSqlServer(connectionString);
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
            //应用所有实体配置
            modelBuilder.ApplyConfigurationsFromAssembly(this.GetType().Assembly);
        }

        public DbSet<Car> Cars { get; set; }
        public DbSet<Person> Persons { get; set; }
    }
}

Program.cs 主程序

using PandaTest;

Console.WriteLine("Begin");

//创建DbContext
using (TestDbContext db = new TestDbContext())
{
    //插入数据
    db.Persons.Add(
        new Person{
            Name = "Panda",
            Cars = new List<Car>{
                new Car()
                {
                    Id = Guid.NewGuid(),
                    CarName = "PandaCar1"
                },
                new Car()
                {
                    Id = Guid.NewGuid(),
                    CarName = "PandaCar2"
                }
            }
        });
    await db.SaveChangesAsync();
}

Console.WriteLine("Success");

设置多对多（Many-to-many relationships）-使用默认约定

设置方法1（使用中间表）

折中方式，采用中间实体的形式实现，建立2个实体与中间实体的一对多的约定

多对多在数据库内部通过中间表的方式实现，所以需要添加一个中间Model

本质是：通过中间Model对两端Model的一对多的关系完成的

中间表Entity：

注意：还可以将CompanyId和 ConsumerId设置为Key，形成唯一pair

class ConsumerAndCompany
{
    [Key]
    public int ConsumerAndCompanyId { get; set; }
    [Required]
    public int CompanyId { get; set; }
    public virtual Company Company { get; set; }
    [Required]
    public int ConsumerId { get; set; }
    public virtual Consumer Consumer { get; set; }
    //建立客户关系的时间
    public DateTime ConnectionDateTime { get; set; }
    //建立客户关系的备注
    public String Note { get; set; }
}

Consumer Entity：

class Consumer
{
    [Key]
    public int ConsumerId { get; set; }
    public string ConsumerName { get; set; }
    public virtual List<ConsumerAndCompany> ConsumerAndCompanys { get; set; } = new List<ConsumerAndCompany>();
}

Company Entity：

class Company
{
    [Key]
    public int CompanyId { get; set; }
    public string CompanyName { get; set; }
    public virtual List<ConsumerAndCompany> CompanyAndConsumers { get; set; } = new List<ConsumerAndCompany>();
}

设置方法2（使用默认约定）

两个实体之间都建立引用对方的集合导航属性即可

注意：EF2.0中不支持多对多的默认约定，只可以采用中间实体的方式折中表达

提示：这样会自动生成中间表，无需手动创建

学生实体：

//学生实体
public class Student
{
    [Key]
    public int StudentId { get; set; }
    public string Name { get; set; }
    //集合导航属性
    public IList<Course> Courses { get; set; }
}

课程实体：

//课程实体
public class Course
{
    [Key]
    public int CourseId { get; set; }
    public string CourseName { get; set; }
    //集合导航属性
    public IList<Student> Students { get; set; }
}

实例：文章和标签

一篇文章可以有多个标签

一个标签可以对应多篇文章

代码：

文章实体：

using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel.DataAnnotations;

namespace ConsoleApp3.Models
{
    public class Blog
    {
        [Key]
        public int Id { get; set; }
        public string Title { get; set; }
        public string Content { get; set; }
        public ICollection<TagsAndBlogs> TagsAndBlogs { get; set; }
    }
}

标签实体：

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApp3.Models
{
    public class Tag
    {
        public int Id { get; set; }
        public string Title { get; set; }
        public ICollection<TagsAndBlogs> TagsAndBlogs { get; set; }
    }
}

中间表实体：

using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel.DataAnnotations;

namespace ConsoleApp3.Models
{
    public class TagsAndBlogs
    {
        public int Id { get; set; }
        public DateTime AddDateTime { get; set; }
        //对博客的外键
        public int BlogId { get; set; }
        public Blog Blog { get; set; }
        //对标签的外键
        public int TagId { get; set; }
        public Tag Tag { get; set; }

    }
}

实例：消费者和公司

一个公司对应多个消费者

一个消费者对应多个公司

中间表Entity：

注意：还可以将CompanyId和 ConsumerId设置为Key，形成唯一pair

class ConsumerAndCompany
{
    [Key]
    public int ConsumerAndCompanyId { get; set; }
    [Required]
    public int CompanyId { get; set; }
    public virtual Company Company { get; set; }
    [Required]
    public int ConsumerId { get; set; }
    public virtual Consumer Consumer { get; set; }
    //建立客户关系的时间
    public DateTime ConnectionDateTime { get; set; }
    //建立客户关系的备注
    public String Note { get; set; }
}

Consumer Entity：

class Consumer
{
    [Key]
    public int ConsumerId { get; set; }
    public string ConsumerName { get; set; }
    public virtual List<ConsumerAndCompany> ConsumerAndCompanys { get; set; } = new List<ConsumerAndCompany>();
}

Company Entity：

class Company
{
    [Key]
    public int CompanyId { get; set; }
    public string CompanyName { get; set; }
    public virtual List<ConsumerAndCompany> CompanyAndConsumers { get; set; } = new List<ConsumerAndCompany>();
}

设置多对多（Many-to-many relationships）-使用FluentAPI

设置方法1（使用中间表）

折中方式，采用中间实体的形式实现，建立2个实体与中间实体的一对多的约定

多对多在数据库内部通过中间表的方式实现，所以需要添加一个中间Model

本质是：通过中间Model对两端Model的一对多的关系完成的

学生实体

//学生实体
public class Student
{
    [Key]
    public int StudentId { get; set; }
    public string Name { get; set; }
    //集合导航属性
    public IList<StudentCourse> StudentCourses { get; set; }
}

课程实体：

//课程实体
public class Course
{
    [Key]
    public int CourseId { get; set; }
    public string CourseName { get; set; }
    public string Description { get; set; }
    //集合导航属性
    public IList<StudentCourse> StudentCourses { get; set; }
}

学生课程关联关系中间实体：

//学生课程关联关系中间实体
public class StudentCourse
{
    //外键导航属性
    public int StudentId { get; set; }
    //导航属性
    public Student Student { get; set; }
    //外键导航属性
    public int CourseId { get; set; }
    //导航属性
    public Course Course { get; set; }
    //添加日期
    public DateTime AddDateTime { get; set; }
}

建立2个实体到中间实体的一对多的关系：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    //设置StudentCourse实体的主键为StudentId+CourseId
    modelBuilder.Entity<StudentCourse>()
                    .HasKey(sc => new { sc.StudentId, sc.CourseId });

    //建立2个实体到中间实体的一对多的关系
    modelBuilder.Entity<StudentCourse>()
        .HasOne<Student>(sc => sc.Student)
        .WithMany(s => s.StudentCourses)
        .HasForeignKey(sc => sc.SId);

    modelBuilder.Entity<StudentCourse>()
        .HasOne<Course>(sc => sc.Course)
        .WithMany(s => s.StudentCourses)
        .HasForeignKey(sc => sc.CId);
}

设置方式2（使用HasMany、WithMany FluentAPI）

提示：这样会自动生成中间表，无需手动创建

学生实体：

//学生实体
public class Student
{
    [Key]
    public int StudentId { get; set; }
    public string Name { get; set; }
    //集合导航属性
    public IList<Course> Courses { get; set; }
}

课程实体：

//课程实体
public class Course
{
    [Key]
    public int CourseId { get; set; }
    public string CourseName { get; set; }
    //集合导航属性
    public IList<Student> Students { get; set; }
}

在Student实体上配置多对多：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    //建立多对多
    modelBuilder.Entity<Student>()
        .HasMany(s => s.Courses)
        .WithMany(c => c.Students);
}

也可以在Course实体上配置多对多：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    //建立多对多
    modelBuilder.Entity<Course>()
        .HasMany(c => c.Students)
        .WithMany(S => S.Courses);
}

实例：一个人有多个公司，一个公司可以属于多个人（多对多）（Fluent API）

Company.cs 公司实体

using Microsoft.EntityFrameworkCore;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.Design;

namespace PandaTest
{
    /// <summary>
    /// 公司实体
    /// </summary>
    public class Company
    {
        public Guid Id { get; set; }
        public string Name { get; set; }
        public List<Person> Persons { get; set; }
    }
}

Person.cs 人员实体

using Microsoft.EntityFrameworkCore;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.Design;

namespace PandaTest
{
    /// <summary>
    /// 人员实体
    /// </summary>
    public class Person
    {
        public Guid Id { get; set; }
        public string Name { get; set; }
        public List<Company> Companies { get; set; }
    }
}

CompanyEntityConfig.cs 公司实体配置

using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Builders;

namespace PandaTest
{
    /// <summary>
    /// 公司实体配置
    /// </summary>
    public class CompanyEntityConfig : IEntityTypeConfiguration<Company>
    {
        public void Configure(EntityTypeBuilder<Company> builder)
        {
            //配置多对多
            builder.HasMany(i => i.Persons).WithMany(i => i.Companies);
        }
    }
}

PersonEntityConfig.cs 人员实体配置

using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Builders;

namespace PandaTest
{
    /// <summary>
    /// 人员实体配置
    /// </summary>
    public class PersonEntityConfig : IEntityTypeConfiguration<Person>
    {
        public void Configure(EntityTypeBuilder<Person> builder)
        {
        }
    }
}

TestDbContext.cs 数据库上下文

using Microsoft.EntityFrameworkCore;

namespace PandaTest
{
    /// <summary>
    /// 数据库上下文
    /// </summary>
    public class TestDbContext: DbContext
    {
        public TestDbContext()
        {

        }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            string connectionString = "Server=.;Database=Test;User Id=sa;Password=Password";
            optionsBuilder.UseSqlServer(connectionString);
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
            //应用所有实体配置
            modelBuilder.ApplyConfigurationsFromAssembly(this.GetType().Assembly);
        }

        public DbSet<Company> Companies { get; set; }
        public DbSet<Person> Persons { get; set; }
    }
}

Program.cs 主程序

using PandaTest;

Console.WriteLine("Begin");

//创建DbContext
using (TestDbContext db = new TestDbContext())
{
    //插入数据
    db.Persons.Add(
        new Person{
            Name = "Panda6",
            Companies = new List<Company>
            {
                new Company(){ Name = "公司1"},
                new Company(){ Name = "公司2"},
            }
        });
    //插入数据
    db.Companies.Add(new Company
    {
        Name = "公司3",
        Persons = new List<Person>
        {
            new Person(){ Name = "Cat"},
        }
    });
    await db.SaveChangesAsync();
}



Console.WriteLine("Success");

实例：文章和标签

一篇文章可以有多个标签

一个标签可以对应多篇文章

代码：

文章实体：

using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel.DataAnnotations;

namespace ConsoleApp3.Models
{
    public class Blog
    {
        [Key]
        public int Id { get; set; }
        public string Title { get; set; }
        public string Content { get; set; }
        public ICollection<TagsAndBlogs> TagsAndBlogs { get; set; }
    }
}

标签实体：

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApp3.Models
{
    public class Tag
    {
        public int Id { get; set; }
        public string Title { get; set; }
        public ICollection<TagsAndBlogs> TagsAndBlogs { get; set; }
    }
}

中间表实体：

using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel.DataAnnotations;

namespace ConsoleApp3.Models
{
    public class TagsAndBlogs
    {
        public int Id { get; set; }
        public DateTime AddDateTime { get; set; }
        //对博客的外键
        public int BlogId { get; set; }
        public Blog Blog { get; set; }
        //对标签的外键
        public int TagId { get; set; }
        public Tag Tag { get; set; }

    }
}

FluentAPI：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    //设置对应到底层数据的数据库的表名
    modelBuilder.Entity<Blog>().ToTable("Blog");
    modelBuilder.Entity<Tag>().ToTable("Tag");

    //设置中间表到标签的一对多关系
    modelBuilder.Entity<TagsAndBlogs>()
                            .ToTable("TagsAndBlogs")
                            .HasOne(x => x.Tag)
                            .WithMany(x => x.TagsAndBlogs)
                            .HasForeignKey(x => x.TagId);
    
    //设置中间表到博客的一对多关系
    modelBuilder.Entity<TagsAndBlogs>()
                        .ToTable("TagsAndBlogs")
                        .HasOne(x => x.Blog)
                        .WithMany(x => x.TagsAndBlogs)
                        .HasForeignKey(x => x.BlogId);
}

实例：学生和课程

一个学生可以学习多门课程

一门课程可以被多名学生学习

学生实体：

//学生实体
public class Student
{
    [Key]
    public int StudentId { get; set; }
    public string Name { get; set; }
    //集合导航属性
    public IList<StudentCourse> StudentCourses { get; set; }
}

课程实体：

//课程实体
public class Course
{
    [Key]
    public int CourseId { get; set; }
    public string CourseName { get; set; }
    public string Description { get; set; }
    //集合导航属性
    public IList<StudentCourse> StudentCourses { get; set; }
}

学生课程关联关系中间实体：

//学生课程关联关系中间实体
public class StudentCourse
{
    //外键导航属性
    public int StudentId { get; set; }
    //导航属性
    public Student Student { get; set; }
    //外键导航属性
    public int CourseId { get; set; }
    //导航属性
    public Course Course { get; set; }
    //添加日期
    public DateTime AddDateTime { get; set; }
}

建立2个实体到中间实体的一对多的关系：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    //设置StudentCourse实体的主键为StudentId+CourseId
    modelBuilder.Entity<StudentCourse>()
                    .HasKey(sc => new { sc.StudentId, sc.CourseId });

    //建立2个实体到中间实体的一对多的关系
    modelBuilder.Entity<StudentCourse>()
        .HasOne<Student>(sc => sc.Student)
        .WithMany(s => s.StudentCourses)
        .HasForeignKey(sc => sc.SId);

    modelBuilder.Entity<StudentCourse>()
        .HasOne<Course>(sc => sc.Course)
        .WithMany(s => s.StudentCourses)
        .HasForeignKey(sc => sc.CId);
}

其他关联

枚举关联（Enum Mapping）

对于属性的值是枚举值的情况，可以直接使用枚举关联

实例：

//定义需要用到的枚举
public enum Direction
{
    Up = 0,
    Down = 1
}

public class CarState
{
    [Key]
    public int Id {get;set;}
    //枚举关联
    public Direction Direction {get;set;}
}

实体继承映射（Entity Inheritance Mapping）

说明

EF5支持2种类型的实体继承映射

一个继承一个表（table-per-hierarchy）和一个类型一个表（table-per-type）

默认是一个继承一个表（table-per-hierarchy）

一个继承一个表（table-per-hierarchy）

子类和父类的属性放在集中的一个表中

实例：使用Fluent API定义

//形状实体
public class Shape
{
    public int Width { get; set; }
    public int Height { get; set; }
}

//立体实体
public class Cube : Shape
{
    public int Length { get; set; }
}

使用层次结构表意味着，Shape、Cube所有字段会被放在1张数据库表中

不同实体类的字段还可以自定义映射区别字段：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Shape>()
        .HasDiscriminator<string>("ShapeType")
        .HasValue<Shape>("S")
        .HasValue<Cube>("C");
}

最终数据库中的表如下：

Width	Height	Length	ShapeType
			"S"
			"C"

一个类型一个表（table-per-type）

一个类型对应到底下一个数据库表，继承的属性分开存储到单独的表

实例：使用数据注解定义

[Table("Shape")]
public class Shape
{
    public int Width { get; set; }
    public int Height { get; set; }
}

[Table("Cube")]
public class Cube : Shape
{
    public int Length { get; set; }
}

实例：使用Fluent API定义

public class Shape
{
    public int Width { get; set; }
    public int Height { get; set; }
}

public class Cube : Shape
{
    public int Length { get; set; }
}

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Shape>().ToTable("Shape");
    modelBuilder.Entity<Cube>().ToTable("Cube");
}

EF模型间关联（Modeling Relationships）

https://docs.microsoft.com/en-us/ef/core/modeling/relationships

设置一对一（One-to-one relationships）

设置一对多（One-to-many relationships）

实体对象的关系图如下：

注意：其中Product表的Category字段是外键，关联Category表的Id字段

EF代码结构：

Product.cs中除了正常声明字段外，还要用以下代码声明关联关系：

public virtual Category Category1 { get; set; }

Product.cs完整代码：

[Table("Product")]
public partial class Product
{
    public int Id { get; set; }
    [Required]
    [StringLength(100)]
    public string Name { get; set; }
    public int CategoryId { get; set; }
    public virtual Category Category { get; set; }
}

Category.cs中需要使用以下代码表示有外键关联到自身

public virtual ICollection<Product> Product { get; set; }

Category.cs完整代码：

public partial class Category
{
    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors")]
    public Category()
    {
        Product = new HashSet<Product>();
    }

    public int Id { get; set; }

    [Required]
    [StringLength(100)]
    public string NAME { get; set; }

    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly")]
    public virtual ICollection<Product> Product { get; set; }
}

设置多对多（Many-to-many relationships）

多对多需要使用中间表方式实现，实体关系图如下：

Product表示产品、Order表示订单、OrderDetail表示订单详细的产品内容信息

Product.cs中有一个字段被其他表引用，所以需要声明

public partial class Product
{
    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors")]
    public Product()
    {
        OrderDetail = new HashSet<OrderDetail>();
    }

    public int ProductId { get; set; }

    [Required]
    [StringLength(200)]
    public string ProductName { get; set; }

    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly")]
    public virtual ICollection<OrderDetail> OrderDetail { get; set; }
}

Order.cs中有一个字段被其他表引用，所以需要在类中声明关联关系

public partial class Order
{
    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors")]
    public Order()
    {
        OrderDetail = new HashSet<OrderDetail>();
    }

    public int OrderId { get; set; }

    public DateTime OrderCreateDateTime { get; set; }

    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly")]
    public virtual ICollection<OrderDetail> OrderDetail { get; set; }
}

OrderDetail.cs中有2个字段是外键，所以需要在类中声明关联信息

[Table("OrderDetail")]
public partial class OrderDetail
{
    public int OrderDetailId { get; set; }

    public int OrderId { get; set; }

    public int ProductId { get; set; }

    public virtual Order Order { get; set; }

    public virtual Product Product { get; set; }
}

SQL Server数据类型与 .NET数据类型对应关系

标签：Relationships,set,get,int,class,Entity,Framework,using,public
From： https://www.cnblogs.com/cqpanda/p/16783493.html

Entity Framework教程-Entity Framework-模型关系（Model Relationships）

配置实体关系的方式

导航属性（navigation property）

导航属性说明

导航属性分类

说明

集合型导航属性（Collection navigation property）

引用型导航属性（Reference navigation property）

反向引用导航属性（Inverse navigation property）

EF Core模型间关联（Modeling Relationships）

EF Core关联的默认约定(Conventions in a relationship)

EF Core手动设置外键底层字段

Fluent API配置关系的方法

设置外键属性

设置一对一（One-to-one relationships）-使用默认约定

设置方法

实例：一个人只能有一个身份证卡（一对一）（Fluent API）

实例：一个人只能有一个对象（一对一）（自引用）（Fluent API）

实例：用户 和 户籍地址

实例：用户 和 颜色

设置一对一（One-to-one relationships）-使用FluentAPI

设置方法

实例：用户 和 户籍地址

实例：学生 和 学生地址

设置一对多（One-to-many relationships）-使用默认约定

设置方法1（EF约定1）- 单方设置引用属性

设置方法2（EF约定2）- 多方设置引用

设置方法3（EF约定3）- 双方都建立引用属性

设置方法4（EF约定4）- 设置额外的外键属性

实例：用户 和 产品

实例：用户 和 车

实例：用户 和 用户自定义配置信息

实例：博客文章 和 评论

设置一对多（One-to-many relationships）-使用FluentAPI

设置方法（EF约定）

实例：父亲 和 儿子

实例：一个人对应多台车（一对多）（Fluent API）

设置多对多（Many-to-many relationships）-使用默认约定

设置方法1（使用中间表）

设置方法2（使用默认约定）

实例：文章 和 标签

实例：消费者 和 公司

设置多对多（Many-to-many relationships）-使用FluentAPI

设置方法1（使用中间表）

设置方式2（使用HasMany、WithMany FluentAPI）

实例：一个人有多个公司，一个公司可以属于多个人（多对多）（Fluent API）

实例：文章 和 标签

实例：学生 和 课程

其他关联

枚举关联（Enum Mapping）

实体继承映射（Entity Inheritance Mapping）

说明

一个继承一个表（table-per-hierarchy）

一个类型一个表（table-per-type）

EF模型间关联（Modeling Relationships）

设置一对一（One-to-one relationships）

设置一对多（One-to-many relationships）

设置多对多（Many-to-many relationships）

SQL Server数据类型 与 .NET数据类型对应关系

相关文章

赞助商

阅读排行

实例：用户和户籍地址

实例：用户和颜色

实例：用户和户籍地址

实例：学生和学生地址

实例：用户和产品

实例：用户和车

实例：用户和用户自定义配置信息

实例：博客文章和评论

实例：父亲和儿子

实例：文章和标签

实例：消费者和公司

实例：文章和标签

实例：学生和课程

SQL Server数据类型与 .NET数据类型对应关系