EF CodeFirst系列（5）---配置1對1，1對多，多對多關系

這一節介紹EF CodeFirst模式中的1對0/1，1對多，多對多關系的配置，只有梳理清楚實體間的關系，才能進行愉快的開發，因此這節雖然很簡單但是還是記錄了一下。

1. 1對0/1關系配置

1. 通過數據注釋屬性配置1對0/1關系

我們將要實現一個Student和StudentAddress實體的1對0/1關系，1對0/1關系指的是一個Student可有一個或者零個住址StudentAddress，但是一個StudentAddress必須對應一個Student。在數據庫中表現形式是StudentId在Student表中是主鍵，StudentAddressId在數據庫中同時是StudentAddress的主鍵和外鍵。實體類的代碼如下：

public class Student
{
    public int StudentId { get; set; }
    public string StudentName { get; set; }

    public virtual StudentAddress Address { get; set; }
}
     
public class StudentAddress 
{
    [ForeignKey("Student")]
    public int StudentAddressId { get; set; }
        
    public string Address1 { get; set; }
    public string Address2 { get; set; }
    public string City { get; set; }
    public int Zipcode { get; set; }
    public string State { get; set; }
    public string Country { get; set; }

    public virtual Student Student { get; set; }
}

上邊代碼中會遵循EF CodeFirst默認約定，StudentId作為Students表的主鍵，StudentAddressId作為StudentAddresses表的主鍵，我們不需要自己去配置主鍵了，默認約定不會把StudentAddressId設置為指向Student實體的外鍵，這就我們需要自己去配置。在StudentAddressId通過[ForeignKey("Student")]修飾即可。

在1對0/1關系中，Student在沒有StudentAddress時可以保存成功，但是StudentAddress沒有分配Student時進行保存就會拋出異常。

2. 通過FluentApi配置1對0/1關系

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    // 配置Student和StudentAddress實體
    modelBuilder.Entity<Student>()
                .HasOptional(s => s.Address) // 給Student設置可空的StudentAddress屬性
                .WithRequired(ad => ad.Student); //給StudentAddress設置不能為空的Student屬性.沒有Student時，StudentAddress不能保存
}

生成數據庫如下：

2. 1對多關系配置

　　這一部分介紹EF中CodeFirst模式下1對多關系的配置，我們要實現Student和Grade的關系配置，一個學生只能有一個班級而一個班級可以有多個學生，實體類如下：

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; }
}

1.通過默認約定配置1對多關系

 1.生成可空的外鍵（Student可以沒有班級）

//Student實體中的Grade引用導航屬性和Grade實體中的Students集合導航屬性，兩者有一個即可，生成的是可空的外鍵
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; }
    
    public ICollection<Student> Students { get; set; }
}

運行程序后生成的數據庫如下，我們看到生成了可空的Grade_GradeId外鍵

2.生成不可空的外鍵（Student必須有班級）

 生成不可空的外鍵也很簡單，只要讓默認的外鍵不為空即可，代碼如下：

public class Student
{
    public int Id { get; set; }
    public string Name { get; set; }
    
    public int GradeId { get; set; }//如果改成 public int? GradeId則生成可空的外鍵
    public Grade Grade { get; set; }
}

public class Grade
{

    public int GradeId { get; set; }
    public string GradeName { get; set; }
    
    public ICollection<Student> Student { get; set; }
}

生成的數據庫如下：

2. 通過FluentApi配置1對多關系

　　通常我們不需要配置1對多的關系，因為EF的默認約定就能幫我們很好地解決這個問題，如果為了讓關系更好維護，我們也可以通過FluentApi來配置1對多關系。

FluentApi配置1對多關系代碼如下：

    public class SchoolContext : DbContext
    {
        public SchoolContext() : base()
        {
        }
        public DbSet<Student> Students { get; set; }
        public DbSet<Grade> Grade { get; set; }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Student>()
                .HasRequired(s => s.Grade)//Student有必需的導航屬性Grade,這會創建一個not null的外鍵
                .WithMany(g => g.Students)//Grade實體有集合導航屬性Student
                .HasForeignKey(s=> s.GradeId);//設置外鍵（如果Student中屬性不遵循約定我們自己指定外鍵，如HasForeignKey(s=>s.GradeKey)）
        }
    }

我們也可以通過Grade實體來實現Student和Grade的1對多關系，代碼如下：

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Grade>()
                .HasMany(g => g.Students)
                .WithRequired(s => s.Grade)
                .HasForeignKey(s => s.GradeKey);
        }

運行程序，生成的數據庫如下：

3. 配置1對多的級聯刪除

　　級聯刪除指當刪除父級記錄時會自動刪除子級記錄，如刪除班級時，將在這個班級的所有學生記錄一並刪除(EF中是將這個班級的Student中的GradeId列都設成null)，通過FluentApi很容易配置級聯刪除。

modelBuilder.Entity<Grade>()
    .HasMany<Student>(g => g.Students)
    .WithRequired(s => s.CurrentGrade)
    .WillCascadeOnDelete();//開啟級聯刪除，刪除班級時會一並刪除所有這個班級的學生
    //.WillCascadeOnDelete(false);不開啟級聯刪除

一點補充：EF中的級聯刪除默認是打開的，EF中級聯刪除執行策略

　　1對1：如Student和StudentAddress，刪除Student時會把StudentAddress一並刪除。

　　1對多：如Student和Grade，刪除Grade時，會把該年級下的學生的GradId設成為null。

　　多對多：見下邊的Student和Course，刪除一門課程時，會刪除中間表中該門課程的記錄。

3.配置多對多關系

1.通過默認約定配置多對多關系

這一部分介紹多對多關系的配置，以Student和Course為例，一個學生可以學多門課，每門課的學生可以是多個。EF6包含了多對多關系的默認約定。在Student實體類添加一個Course的集合導航屬性，在Course實體類下添加一個Student集合導航屬性，不需額外的配置，EF會幫我們創建Student和Course的多對多關系。代碼如下：

    public class Student
    {
        public int StudentId { get; set; }
        public string StudentName { get; set; }
        public  ICollection<Course> Courses { get; set; }
    }

    public class Course
    {
        public int CourseId { get; set; }
        public string CourseName { get; set; }
        public ICollection<Student> Students { get; set; }
    }

    public class SchoolContext : DbContext
    {
        public SchoolContext() : base()
        {
        }
        public DbSet<Student> Students { get; set; }
        public DbSet<Course> Grade { get; set; }

    }

運行程序后生成的數據庫如下，EF創建了Courses，Students表，同時創建了一個StudentCourses中間表：

2.通過FluentApi配置多對多關系

直接上代碼：

    modelBuilder.Entity<Student>()
                .HasMany<Course>(s => s.Courses)//配置一個學生有多個課程
                .WithMany(c => c.Students)      //配置一門課程有多個學生
                .Map(cs =>
                        {
                            cs.MapLeftKey("StudentRefId");  //因為通過Entity<Student>()開始的，所以左表是Student
                            cs.MapRightKey("CourseRefId");  //右表是Course
                            cs.ToTable("StudentCourse");    //生成StudentCourse中間表
                        });

3.多對多的數據重置

在EF中如果中間表只有兩個實體的主鍵列，那么EF會自動幫我們維護，一個重置學生課程的案例（常用的User-Role-Action權限控制也能這樣重置角色和權限）：

       static void Main(string[] args)
        {
            using (SchoolContext context=new SchoolContext())
            {
                //必須要把對應的Courses查出來，不然添加時會報空指針異常
                var stu1 = context.Students.Include("Courses").Where(s=>s.StudentId==3).First();
                
                var co1 = context.Courses.Find(1);
                var co2= context.Courses.Find(2);
                //先清空再添加
                stu1.Courses.Clear();
                stu1.Courses.Add(co1);
                stu1.Courses.Add(co2);
                context.SaveChanges();
            }
        }