ASP.NET Core 中的 Razor 页面和 EF Core - 数据模型_w3cschool

link管理

链接快照平台

输入网页链接，自动生成快照
标签化管理网页链接

使用特性自定义数据模型

DataType 特性

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
namespace ContosoUniversity.Models
    public class Student
        public int ID { get; set; }
        public string LastName { get; set; }
        public string FirstMidName { get; set; }
        [DataType(DataType.Date)]
        [DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]
        public DateTime EnrollmentDate { get; set; }
        public ICollection<Enrollment> Enrollments { get; set; }

DataType 特性指定比数据库内部类型更具体的数据类型。在此情况下，应仅显示日期，而不是日期加时间。 DataType 枚举提供多种数据类型，例如日期、时间、电话号码、货币、电子邮件地址等。应用还可通过 DataType 特性自动提供类型特定的功能。例如:

mailto: 链接将依据 DataType.EmailAddress 自动创建。
大多数浏览器中都提供面向 DataType.Date 的日期选择器。

DataType 特性发出 HTML 5 data-（读作 data dash）特性供 HTML 5 浏览器使用。 DataType 特性不提供验证。

DataType.Date 不指定显示日期的格式。默认情况下，日期字段根据基于服务器的 CultureInfo 的默认格式进行显示。

DisplayFormat 特性用于显式指定日期格式：

[DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]

ApplyFormatInEditMode 设置指定还应对编辑 UI 应用该格式设置。某些字段不应使用 ApplyFormatInEditMode。例如，编辑文本框中通常不应显示货币符号。

DisplayFormat 特性可由其本身使用。搭配使用 DataType 特性和 DisplayFormat 特性通常是很好的做法。 DataType 特性按照数据在屏幕上的呈现方式传达数据的语义。 DataType 特性可提供 DisplayFormat 中所不具有的以下优点：

浏览器可启用 HTML5 功能。例如，显示日历控件、区域设置适用的货币符号、电子邮件链接、客户端输入验证等。
默认情况下，浏览器将根据区域设置采用正确的格式呈现数据。

有关详细信息，请参阅 <input> 标记帮助器文档。

运行应用。导航到学生索引页。将不再显示时间。使用 Student 模型的每个视图将显示日期，不显示时间。

“学生”索引页显示不带时间的日期

StringLength 特性

可使用特性指定数据验证规则和验证错误消息。 StringLength 特性指定数据字段中允许的字符的最小长度和最大长度。 StringLength 特性还提供客户端和服务器端验证。最小值对数据库架构没有任何影响。

使用以下代码更新 Student 模型：

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
namespace ContosoUniversity.Models
    public class Student
        public int ID { get; set; }
        [StringLength(50)]
        public string LastName { get; set; }
        [StringLength(50, ErrorMessage = "First name cannot be longer than 50 characters.")]
        public string FirstMidName { get; set; }
        [DataType(DataType.Date)]
        [DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]
        public DateTime EnrollmentDate { get; set; }
        public ICollection<Enrollment> Enrollments { get; set; }

上面的代码将名称限制为不超过 50 个字符。 StringLength 特性不会阻止用户在名称中输入空格。 RegularExpression 特性用于向输入应用限制。例如，以下代码要求第一个字符为大写，其余字符按字母顺序排列：

[RegularExpression(@"^[A-Z]+[a-zA-Z""'\s-]*$")]

运行应用：

导航到学生页。
选择“新建”并输入不超过 50 个字符的名称。
选择“创建”时，客户端验证会显示一条错误消息。

显示字符串长度错误的“学生索引”页

在“SQL Server 对象资源管理器”(SSOX) 中，双击 Student 表，打开 Student 表设计器。

迁移前 SSOX 中的 Student 表

上图显示 Student 表的架构。名称字段的类型为 nvarchar(MAX)，因为数据库上尚未运行迁移。稍后在本教程中运行迁移时，名称字段将变成 nvarchar(50)。

Column 特性

特性可以控制类和属性映射到数据库的方式。在本部分，Column 特性用于将 FirstMidName 属性的名称映射到数据库中的“FirstName”。

创建数据库后，模型上的属性名将用作列名（使用 Column 特性时除外）。

Student 模型使用 FirstMidName 作为名字字段，因为该字段也可能包含中间名。

用以下突出显示的代码更新 Student.cs 文件：

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
namespace ContosoUniversity.Models
    public class Student
        public int ID { get; set; }
        [StringLength(50)]
        public string LastName { get; set; }
        [StringLength(50, ErrorMessage = "First name cannot be longer than 50 characters.")]
        [Column("FirstName")]
        public string FirstMidName { get; set; }
        [DataType(DataType.Date)]
        [DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]
        public DateTime EnrollmentDate { get; set; }
        public ICollection<Enrollment> Enrollments { get; set; }

进行上述更改后，应用中的 Student.FirstMidName 将映射到 Student 表的 FirstName 列。

添加 Column 特性后，SchoolContext 的支持模型会发生改变。 SchoolContext 的支持模型将不再与数据库匹配。如果在执行迁移前运行应用，则会生成如下异常：

SQL

SqlException: Invalid column name 'FirstName'.

若要更新数据库：

生成项目。
在项目文件夹中打开命令窗口。输入以下命令以创建新迁移并更新数据库：

PMC

Add-Migration ColumnFirstName
Update-Database

migrations add ColumnFirstName 命令将生成如下警告消息：

text

An operation was scaffolded that may result in the loss of data.
Please review the migration for accuracy.

生成警告的原因是名称字段现已限制为 50 个字符。如果数据库中的名称超过 50 个字符，则第 51 个字符及后面的所有字符都将丢失。

测试应用。

在 SSOX 中打开 Student 表：

迁移后 SSOX 中的 Students 表

执行迁移前，名称列的类型为 nvarchar (MAX) 。名称列现在的类型为 nvarchar(50)。列名已从 FirstMidName 更改为 FirstName。

备注

在下一部分中，在某些阶段生成应用会生成编译器错误。说明用于指定生成应用的时间。

Student 实体更新

用以下代码更新 Models/Student.cs：

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
namespace ContosoUniversity.Models
    public class Student
        public int ID { get; set; }
        [Required]
        [StringLength(50)]
        [Display(Name = "Last Name")]
        public string LastName { get; set; }
        [Required]
        [StringLength(50, ErrorMessage = "First name cannot be longer than 50 characters.")]
        [Column("FirstName")]
        [Display(Name = "First Name")]
        public string FirstMidName { get; set; }
        [DataType(DataType.Date)]
        [DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]
        [Display(Name = "Enrollment Date")]
        public DateTime EnrollmentDate { get; set; }
        [Display(Name = "Full Name")]
        public string FullName
                return LastName + ", " + FirstMidName;
        public ICollection<Enrollment> Enrollments { get; set; }

Required 特性

Required 特性使名称属性成为必填字段。值类型（DateTime、int、double）等不可为 NULL 的类型不需要 Required 特性。系统会将不可为 NULL 的类型自动视为必填字段。

不能用 StringLength 特性中的最短长度参数替换 Required 特性：

[Display(Name = "Last Name")]
[StringLength(50, MinimumLength=1)]
public string LastName { get; set; }

Display 特性

Display 特性指定文本框的标题栏应为“FirstName”、“LastName”、“FullName”和“EnrollmentDate”。标题栏默认不使用空格分隔词语，如“Lastname”。

FullName 计算属性

FullName 是计算属性，可返回通过串联两个其他属性创建的值。 FullName 不能设置并且仅具有一个 get 访问器。数据库中不会创建任何 FullName 列。

创建 Instructor 实体

用以下代码创建 Models/Instructor.cs：

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
namespace ContosoUniversity.Models
    public class Instructor
        public int ID { get; set; }
        [Required]
        [Display(Name = "Last Name")]
        [StringLength(50)]
        public string LastName { get; set; }
        [Required]
        [Column("FirstName")]
        [Display(Name = "First Name")]
        [StringLength(50)]
        public string FirstMidName { get; set; }
        [DataType(DataType.Date)]
        [DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]
        [Display(Name = "Hire Date")]
        public DateTime HireDate { get; set; }
        [Display(Name = "Full Name")]
        public string FullName
            get { return LastName + ", " + FirstMidName; }
        public ICollection<CourseAssignment> CourseAssignments { get; set; }
        public OfficeAssignment OfficeAssignment { get; set; }

一行可包含多个特性。可按如下方式编写 HireDate 特性：

[DataType(DataType.Date),Display(Name = "Hire Date"),DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]

CourseAssignments 和 OfficeAssignment 导航属性

CourseAssignments 和 OfficeAssignment 是导航属性。

一名讲师可以教授任意数量的课程，因此 CourseAssignments 定义为集合。

public ICollection<CourseAssignment> CourseAssignments { get; set; }

如果导航属性包含多个实体：

它必须是可在其中添加、删除和更新实体的列表类型。

导航属性类型包括：

ICollection<T>
List<T>
HashSet<T>

如果指定了 ICollection<T>，EF Core 会默认创建 HashSet<T> 集合。

CourseAssignment 实体在“多对多关系”部分进行介绍。

Contoso University 业务规则规定一名讲师最多可获得一间办公室。 OfficeAssignment 属性包含一个 OfficeAssignment 实体。如果未分配办公室，则 OfficeAssignment 为 NULL。

public OfficeAssignment OfficeAssignment { get; set; }

创建 OfficeAssignment 实体

用以下代码创建 Models/OfficeAssignment.cs：

using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
namespace ContosoUniversity.Models
    public class OfficeAssignment
        [Key]
        public int InstructorID { get; set; }
        [StringLength(50)]
        [Display(Name = "Office Location")]
        public string Location { get; set; }
        public Instructor Instructor { get; set; }

Key 特性

[Key] 特性用于在属性名不是 classnameID 或 ID 时将属性标识为主键 (PK)。

Instructor 和 OfficeAssignment 实体之间存在一对零或一关系。仅当与分配到办公室的讲师之间建立关系时才存在办公室分配。 OfficeAssignment PK 也是其到 Instructor 实体的外键 (FK)。 EF Core 无法自动将 InstructorID 识别为 OfficeAssignment 的 PK，因为：

InstructorID 不遵循 ID 或 classnameID 命名约定。

因此，Key 特性用于将 InstructorID 识别为 PK：

[Key]
public int InstructorID { get; set; }

默认情况下，EF Core 将键视为非数据库生成，因为该列面向的是识别关系。

Instructor 导航属性

Instructor 实体的 OfficeAssignment 导航属性可以为 NULL，因为：

OfficeAssignment 实体具有不可为 NULL 的 Instructor 导航属性，因为：

[Required] 特性可以应用于 Instructor 导航属性：

[Required]
public Instructor Instructor { get; set; }

上面的代码指定必须存在相关的讲师。上面的代码没有必要，因为 InstructorID 外键（也是 PK）不可为 NULL。

修改 Course 实体

用以下代码更新 Models/Course.cs：

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
namespace ContosoUniversity.Models
    public class Course
        [DatabaseGenerated(DatabaseGeneratedOption.None)]
        [Display(Name = "Number")]
        public int CourseID { get; set; }
        [StringLength(50, MinimumLength = 3)]
        public string Title { get; set; }
        [Range(0, 5)]
        public int Credits { get; set; }
        public int DepartmentID { get; set; }
        public Department Department { get; set; }
        public ICollection<Enrollment> Enrollments { get; set; }
        public ICollection<CourseAssignment> CourseAssignments { get; set; }

Course 实体具有外键 (FK) 属性 DepartmentID。 DepartmentID 指向相关的 Department 实体。 Course 实体具有 Department 导航属性。

当数据模型具有相关实体的导航属性时，EF Core 不要求此模型具有 FK 属性。

EF Core 可在数据库中的任何所需位置自动创建 FK。 EF Core 为自动创建的 FK 创建阴影属性。数据模型中包含 FK 后可使更新更简单和更高效。例如，假设某个模型中不包含 FK 属性 DepartmentID。当提取 Course 实体进行编辑时：

如果未显式加载 Department 实体，则该实体将为 NULL。
若要更新 Course 实体，则必须先提取 Department 实体。

如果数据模型中包含 FK 属性 DepartmentID，则无需在更新前提取 Department 实体。

DatabaseGenerated 特性

[DatabaseGenerated(DatabaseGeneratedOption.None)] 特性指定 PK 由应用程序提供而不是由数据库生成。

[DatabaseGenerated(DatabaseGeneratedOption.None)]
[Display(Name = "Number")]
public int CourseID { get; set; }

默认情况下，EF Core 假定 PK 值由数据库生成。由数据库生成 PK 值通常是最佳方法。 Course 实体的 PK 由用户指定。例如，对于课程编号，数学系可以使用 1000 系列的编号，英语系可以使用 2000 系列的编号。

DatabaseGenerated 特性还可用于生成默认值。例如，数据库可以自动生成日期字段以记录数据行的创建或更新日期。有关详细信息，请参阅生成的属性。

外键和导航属性

Course 实体中的外键 (FK) 属性和导航属性可反映以下关系：

课程将分配到一个系，因此将存在 DepartmentID FK 和 Department 导航属性。

public int DepartmentID { get; set; }
public Department Department { get; set; }

参与一门课程的学生数量不定，因此 Enrollments 导航属性是一个集合：

public ICollection<Enrollment> Enrollments { get; set; }

一门课程可能由多位讲师讲授，因此 CourseAssignments 导航属性是一个集合：

public ICollection<CourseAssignment> CourseAssignments { get; set; }

CourseAssignment 在后文介绍。

创建 Department 实体

用以下代码创建 Models/Department.cs：

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
namespace ContosoUniversity.Models
    public class Department
        public int DepartmentID { get; set; }
        [StringLength(50, MinimumLength = 3)]
        public string Name { get; set; }
        [DataType(DataType.Currency)]
        [Column(TypeName = "money")]
        public decimal Budget { get; set; }
        [DataType(DataType.Date)]
        [DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]
        [Display(Name = "Start Date")]
        public DateTime StartDate { get; set; }
        public int? InstructorID { get; set; }
        public Instructor Administrator { get; set; }
        public ICollection<Course> Courses { get; set; }

Column 特性

Column 特性以前用于更改列名映射。在 Department 实体的代码中，Column 特性用于更改 SQL 数据类型映射。 Budget 列通过数据库中的 SQL Server 货币类型进行定义：

[Column(TypeName="money")]
public decimal Budget { get; set; }

通常不需要列映射。 EF Core 通常基于属性的 CLR 类型选择相应的 SQL Server 数据类型。 CLR decimal 类型会映射到 SQL Server decimal 类型。 Budget 用于货币，但货币数据类型更适合货币。

外键和导航属性

FK 和导航属性可反映以下关系：

导航属性名为 Administrator，但其中包含 Instructor 实体：

public int? InstructorID { get; set; }
public Instructor Administrator { get; set; }

上面代码中的问号 (?) 指定属性可以为 NULL。

一个系可以有多门课程，因此存在 Course 导航属性：

public ICollection<Course> Courses { get; set; }

注意:按照约定，EF Core 能针对不可为 NULL 的 FK 和多对多关系启用级联删除。级联删除可能导致形成循环级联删除规则。循环级联删除规则会在添加迁移时引发异常。

例如，如果未将 Department.InstructorID 属性定义为可以为 NULL：

EF Core 会配置将在删除系时删除讲师的级联删除规则。
在删除系时删除讲师并不是预期行为。

如果业务规则要求 InstructorID 属性不可为 NULL，请使用以下 Fluent API 语句：

modelBuilder.Entity<Department>()
   .HasOne(d => d.Administrator)
   .WithMany()
   .OnDelete(DeleteBehavior.Restrict)

上面的代码会针对“系-讲师”关系禁用级联删除。

更新 Enrollment 实体

一份注册记录面向一名学生所注册的一门课程。

用以下代码更新 Models/Enrollment.cs：

using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
namespace ContosoUniversity.Models
    public enum Grade
        A, B, C, D, F
    public class Enrollment
        public int EnrollmentID { get; set; }
        public int CourseID { get; set; }
        public int StudentID { get; set; }
        [DisplayFormat(NullDisplayText = "No grade")]
        public Grade? Grade { get; set; }
        public Course Course { get; set; }
        public Student Student { get; set; }

外键和导航属性

FK 属性和导航属性可反映以下关系：

注册记录面向一门课程，因此存在 CourseID FK 属性和 Course 导航属性：

public int CourseID { get; set; }
public Course Course { get; set; }

一份注册记录针对一名学生，因此存在 StudentID FK 属性和 Student 导航属性：

public int StudentID { get; set; }
public Student Student { get; set; }

多对多关系

Student 和 Course 实体之间存在多对多关系。 Enrollment 实体充当数据库中“具有有效负载”的多对多联接表。 “具有有效负载”表示 Enrollment 表除了联接表的 FK 外还包含其他数据（本教程中为 PK 和 Grade）。

下图显示这些关系在实体关系图中的外观。（此关系图是使用适用于 EF 6.X 的 EF Power Tools 生成的。本教程不介绍如何创建此关系图。）

学生-课程之间的多对多关系

每条关系线的一端显示 1，另一端显示星号 (*)，这表示一对多关系。

如果 Enrollment 表不包含年级信息，则它只需包含两个 FK（CourseID 和 StudentID）。无有效负载的多对多联接表有时称为纯联接表 (PJT)。

Instructor 和 Course 实体具有使用纯联接表的多对多关系。

注意:EF 6.x 支持多对多关系的隐式联接表，但 EF Core 不支持。有关详细信息，请参阅 EF Core 2.0 中的多对多关系。

CourseAssignment 实体

用以下代码创建 Models/CourseAssignment.cs：

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
namespace ContosoUniversity.Models
    public class CourseAssignment
        public int InstructorID { get; set; }
        public int CourseID { get; set; }
        public Instructor Instructor { get; set; }
        public Course Course { get; set; }

讲师-课程

讲师-课程的多对多关系：

常规做法是将联接实体命名为 EntityName1EntityName2。例如，使用此模式的“讲师-课程”联接表是 CourseInstructor。但是，我们建议使用可描述关系的名称。

数据模型开始时很简单，其内容会逐渐增加。无有效负载联接 (PJT) 通常会发展为包含有效负载。该名称以描述性实体名称开始，因此不需要随联接表更改而更改。理想情况下，联接实体在业务领域中可能具有专业名称（可能是一个词）。例如，可以使用名为“阅读率”的联接实体链接“书籍”和“读客”。对于“讲师-课程”的多对多关系，使用 CourseAssignment 比使用CourseInstructor更合适。

组合键

FK 不能为 NULL。 CourseAssignment 中的两个 FK（InstructorID 和 CourseID）共同唯一标识 CourseAssignment 表的每一行。 CourseAssignment 不需要专用的 PK。 InstructorID 和 CourseID属性充当组合 PK。使用 Fluent API 是向 EF Core 指定组合 PK 的唯一方法。下一部分演示如何配置组合 PK。

组合键可确保：

Enrollment 联接实体定义其自己的 PK，因此可能会出现此类重复。若要防止此类重复：

更新数据库上下文

将以下突出显示的代码添加到 Data/SchoolContext.cs：

using ContosoUniversity.Models;
using Microsoft.EntityFrameworkCore;
namespace ContosoUniversity.Models
    public class SchoolContext : DbContext
        public SchoolContext(DbContextOptions<SchoolContext> options) : base(options)
        public DbSet<Course> Courses { get; set; }
        public DbSet<Enrollment> Enrollment { get; set; }
        public DbSet<Student> Student { get; set; }
        public DbSet<Department> Departments { get; set; }
        public DbSet<Instructor> Instructors { get; set; }
        public DbSet<OfficeAssignment> OfficeAssignments { get; set; }
        public DbSet<CourseAssignment> CourseAssignments { get; set; }
        protected override void OnModelCreating(ModelBuilder modelBuilder)
            modelBuilder.Entity<Course>().ToTable("Course");
            modelBuilder.Entity<Enrollment>().ToTable("Enrollment");
            modelBuilder.Entity<Student>().ToTable("Student");
            modelBuilder.Entity<Department>().ToTable("Department");
            modelBuilder.Entity<Instructor>().ToTable("Instructor");
            modelBuilder.Entity<OfficeAssignment>().ToTable("OfficeAssignment");
            modelBuilder.Entity<CourseAssignment>().ToTable("CourseAssignment");
            modelBuilder.Entity<CourseAssignment>()
                .HasKey(c => new { c.CourseID, c.InstructorID });

上面的代码添加新实体并配置 CourseAssignment 实体的组合 PK。

用 Fluent API 替代特性

上面代码中的 OnModelCreating 方法使用 Fluent API 配置 EF Core 行为。 API 称为“Fluent”，因为它通常在将一系列方法调用连接成单个语句后才能使用。下面的代码是 Fluent API 的示例：

protected override void OnModelCreating(ModelBuilder modelBuilder)
    modelBuilder.Entity<Blog>()
        .Property(b => b.Url)
        .IsRequired();

在本教程中，Fluent API 仅用于不能通过特性完成的数据库映射。但是，Fluent API 可以指定可通过特性完成的大多数格式设置、验证和映射规则。

MinimumLength 等特性不能通过 Fluent API 应用。 MinimumLength 不会更改架构，它仅应用最小长度验证规则。

某些开发者倾向于仅使用 Fluent API 以保持实体类的“纯净”。特性和 Fluent API 可以相互混合。某些配置只能通过 Fluent API 完成（指定组合 PK）。有些配置只能通过特性完成 (MinimumLength)。使用 Fluent API 或特性的建议做法：

选择以下两种方法之一。
尽可能以前后一致的方法使用所选的方法。

本教程中使用的某些特性可用于：

仅限验证（例如，MinimumLength）。
仅限 EF Core 配置（例如，HasKey）。
验证和 EF Core 配置（例如，[StringLength(50)]）。

有关特性和 Fluent API 的详细信息，请参阅配置方法。

显示关系的实体关系图

下图显示 EF Power Tools 针对已完成的学校模型创建的关系图。

上面的关系图显示：

使用测试数据为数据库设定种子

更新 Data/DbInitializer.cs 中的代码：

using System;
using System.Linq;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using ContosoUniversity.Models;
namespace ContosoUniversity.Data
    public static class DbInitializer
        public static void Initialize(SchoolContext context)
            //context.Database.EnsureCreated();
            // Look for any students.
            if (context.Student.Any())
                return;   // DB has been seeded
            var students = new Student[]
                new Student { FirstMidName = "Carson",   LastName = "Alexander",
                    EnrollmentDate = DateTime.Parse("2010-09-01") },
                new Student { FirstMidName = "Meredith", LastName = "Alonso",
                    EnrollmentDate = DateTime.Parse("2012-09-01") },
                new Student { FirstMidName = "Arturo",   LastName = "Anand",
                    EnrollmentDate = DateTime.Parse("2013-09-01") },
                new Student { FirstMidName = "Gytis",    LastName = "Barzdukas",
                    EnrollmentDate = DateTime.Parse("2012-09-01") },
                new Student { FirstMidName = "Yan",      LastName = "Li",
                    EnrollmentDate = DateTime.Parse("2012-09-01") },
                new Student { FirstMidName = "Peggy",    LastName = "Justice",
                    EnrollmentDate = DateTime.Parse("2011-09-01") },
                new Student { FirstMidName = "Laura",    LastName = "Norman",
                    EnrollmentDate = DateTime.Parse("2013-09-01") },
                new Student { FirstMidName = "Nino",     LastName = "Olivetto",
                    EnrollmentDate = DateTime.Parse("2005-09-01") }
            foreach (Student s in students)
                context.Student.Add(s);
            context.SaveChanges();
            var instructors = new Instructor[]
                new Instructor { FirstMidName = "Kim",     LastName = "Abercrombie",
                    HireDate = DateTime.Parse("1995-03-11") },
                new Instructor { FirstMidName = "Fadi",    LastName = "Fakhouri",
                    HireDate = DateTime.Parse("2002-07-06") },
                new Instructor { FirstMidName = "Roger",   LastName = "Harui",
                    HireDate = DateTime.Parse("1998-07-01") },
                new Instructor { FirstMidName = "Candace", LastName = "Kapoor",
                    HireDate = DateTime.Parse("2001-01-15") },
                new Instructor { FirstMidName = "Roger",   LastName = "Zheng",
                    HireDate = DateTime.Parse("2004-02-12") }
            foreach (Instructor i in instructors)
                context.Instructors.Add(i);
            context.SaveChanges();
            var departments = new Department[]
                new Department { Name = "English",     Budget = 350000,
                    StartDate = DateTime.Parse("2007-09-01"),
                    InstructorID  = instructors.Single( i => i.LastName == "Abercrombie").ID },
                new Department { Name = "Mathematics", Budget = 100000,
                    StartDate = DateTime.Parse("2007-09-01"),
                    InstructorID  = instructors.Single( i => i.LastName == "Fakhouri").ID },
                new Department { Name = "Engineering", Budget = 350000,
                    StartDate = DateTime.Parse("2007-09-01"),
                    InstructorID  = instructors.Single( i => i.LastName == "Harui").ID },
                new Department { Name = "Economics",   Budget = 100000,
                    StartDate = DateTime.Parse("2007-09-01"),
                    InstructorID  = instructors.Single( i => i.LastName == "Kapoor").ID }
            foreach (Department d in departments)
                context.Departments.Add(d);
            context.SaveChanges();
            var courses = new Course[]
                new Course {CourseID = 1050, Title = "Chemistry",      Credits = 3,
                    DepartmentID = departments.Single( s => s.Name == "Engineering").DepartmentID
                new Course {CourseID = 4022, Title = "Microeconomics", Credits = 3,
                    DepartmentID = departments.Single( s => s.Name == "Economics").DepartmentID
                new Course {CourseID = 4041, Title = "Macroeconomics", Credits = 3,
                    DepartmentID = departments.Single( s => s.Name == "Economics").DepartmentID
                new Course {CourseID = 1045, Title = "Calculus",       Credits = 4,
                    DepartmentID = departments.Single( s => s.Name == "Mathematics").DepartmentID
                new Course {CourseID = 3141, Title = "Trigonometry",   Credits = 4,
                    DepartmentID = departments.Single( s => s.Name == "Mathematics").DepartmentID
                new Course {CourseID = 2021, Title = "Composition",    Credits = 3,
                    DepartmentID = departments.Single( s => s.Name == "English").DepartmentID
                new Course {CourseID = 2042, Title = "Literature",     Credits = 4,
                    DepartmentID = departments.Single( s => s.Name == "English").DepartmentID
            foreach (Course c in courses)
                context.Courses.Add(c);
            context.SaveChanges();
            var officeAssignments = new OfficeAssignment[]
                new OfficeAssignment {
                    InstructorID = instructors.Single( i => i.LastName == "Fakhouri").ID,
                    Location = "Smith 17" },
                new OfficeAssignment {
                    InstructorID = instructors.Single( i => i.LastName == "Harui").ID,
                    Location = "Gowan 27" },
                new OfficeAssignment {
                    InstructorID = instructors.Single( i => i.LastName == "Kapoor").ID,
                    Location = "Thompson 304" },
            foreach (OfficeAssignment o in officeAssignments)
                context.OfficeAssignments.Add(o);
            context.SaveChanges();
            var courseInstructors = new CourseAssignment[]
                new CourseAssignment {
                    CourseID = courses.Single(c => c.Title == "Chemistry" ).CourseID,
                    InstructorID = instructors.Single(i => i.LastName == "Kapoor").ID
                new CourseAssignment {
                    CourseID = courses.Single(c => c.Title == "Chemistry" ).CourseID,
                    InstructorID = instructors.Single(i => i.LastName == "Harui").ID
                new CourseAssignment {
                    CourseID = courses.Single(c => c.Title == "Microeconomics" ).CourseID,
                    InstructorID = instructors.Single(i => i.LastName == "Zheng").ID
                new CourseAssignment {
                    CourseID = courses.Single(c => c.Title == "Macroeconomics" ).CourseID,
                    InstructorID = instructors.Single(i => i.LastName == "Zheng").ID
                new CourseAssignment {
                    CourseID = courses.Single(c => c.Title == "Calculus" ).CourseID,
                    InstructorID = instructors.Single(i => i.LastName == "Fakhouri").ID
                new CourseAssignment {
                    CourseID = courses.Single(c => c.Title == "Trigonometry" ).CourseID,
                    InstructorID = instructors.Single(i => i.LastName == "Harui").ID
                new CourseAssignment {
                    CourseID = courses.Single(c => c.Title == "Composition" ).CourseID,
                    InstructorID = instructors.Single(i => i.LastName == "Abercrombie").ID
                new CourseAssignment {
                    CourseID = courses.Single(c => c.Title == "Literature" ).CourseID,
                    InstructorID = instructors.Single(i => i.LastName == "Abercrombie").ID
            foreach (CourseAssignment ci in courseInstructors)
                context.CourseAssignments.Add(ci);
            context.SaveChanges();
            var enrollments = new Enrollment[]
                new Enrollment {
                    StudentID = students.Single(s => s.LastName == "Alexander").ID,
                    CourseID = courses.Single(c => c.Title == "Chemistry" ).CourseID,
                    Grade = Grade.A
                    new Enrollment {
                    StudentID = students.Single(s => s.LastName == "Alexander").ID,
                    CourseID = courses.Single(c => c.Title == "Microeconomics" ).CourseID,
                    Grade = Grade.C
                    new Enrollment {
                    StudentID = students.Single(s => s.LastName == "Alexander").ID,
                    CourseID = courses.Single(c => c.Title == "Macroeconomics" ).CourseID,
                    Grade = Grade.B
                    new Enrollment {
                        StudentID = students.Single(s => s.LastName == "Alonso").ID,
                    CourseID = courses.Single(c => c.Title == "Calculus" ).CourseID,
                    Grade = Grade.B
                    new Enrollment {
                        StudentID = students.Single(s => s.LastName == "Alonso").ID,
                    CourseID = courses.Single(c => c.Title == "Trigonometry" ).CourseID,
                    Grade = Grade.B
                    new Enrollment {
                    StudentID = students.Single(s => s.LastName == "Alonso").ID,
                    CourseID = courses.Single(c => c.Title == "Composition" ).CourseID,
                    Grade = Grade.B
                    new Enrollment {
                    StudentID = students.Single(s => s.LastName == "Anand").ID,
                    CourseID = courses.Single(c => c.Title == "Chemistry" ).CourseID
                    new Enrollment {
                    StudentID = students.Single(s => s.LastName == "Anand").ID,
                    CourseID = courses.Single(c => c.Title == "Microeconomics").CourseID,
                    Grade = Grade.B
                new Enrollment {
                    StudentID = students.Single(s => s.LastName == "Barzdukas").ID,
                    CourseID = courses.Single(c => c.Title == "Chemistry").CourseID,
                    Grade = Grade.B
                    new Enrollment {
                    StudentID = students.Single(s => s.LastName == "Li").ID,
                    CourseID = courses.Single(c => c.Title == "Composition").CourseID,
                    Grade = Grade.B
                    new Enrollment {
                    StudentID = students.Single(s => s.LastName == "Justice").ID,
                    CourseID = courses.Single(c => c.Title == "Literature").CourseID,
                    Grade = Grade.B
            foreach (Enrollment e in enrollments)
                var enrollmentInDataBase = context.Enrollment.Where(
                            s.Student.ID == e.StudentID &&
                            s.Course.CourseID == e.CourseID).SingleOrDefault();
                if (enrollmentInDataBase == null)
                    context.Enrollment.Add(e);
            context.SaveChanges();

前面的代码为新实体提供种子数据。大多数此类代码会创建新实体对象并加载示例数据。示例数据用于测试。有关如何对多对多联接表进行种子设定的示例，请参阅 Enrollments 和 CourseAssignments。

添加迁移

生成项目。

PMC

Add-Migration ComplexDataModel

前面的命令显示可能存在数据丢失的相关警告。

text

An operation was scaffolded that may result in the loss of data.
Please review the migration for accuracy.
Done. To undo this action, use 'ef migrations remove'

如果运行 database update 命令，则会生成以下错误：

text

The ALTER TABLE statement conflicted with the FOREIGN KEY constraint "FK_dbo.Course_dbo.Department_DepartmentID". The conflict occurred in
database "ContosoUniversity", table "dbo.Department", column 'DepartmentID'.

应用迁移

现已有一个数据库，需要考虑如何将未来的更改应用到其中。本教程演示两种方法：

删除并重新创建数据库
将迁移应用到现有数据库。虽然此方法更复杂且耗时，但在实际应用和生产环境中为首选方法。说明：这是本教程的一个可选部分。你可以执行删除和重新创建的相关步骤并跳过此部分。如果希望执行本部分中的步骤，请勿执行删除和重新创建步骤。

删除并重新创建数据库

已更新 DbInitializer 中的代码将为新实体添加种子数据。若要强制 EF Core 创建新的 DB，请删除并更新 DB：

在“包管理器控制台”(PMC) 中运行以下命令：

PMC

Drop-Database
Update-Database

从 PMC 运行 Get-Help about_EntityFrameworkCore ，获取帮助信息。

运行应用。运行应用后将运行 DbInitializer.Initialize 方法。 DbInitializer.Initialize 将填充新数据库。

在 SSOX 中打开数据库：

如果之前已打开过 SSOX，请单击“刷新”按钮。
展开“表”节点。随后将显示出已创建的表。

SSOX 中的表

查看 CourseAssignment 表：

右键单击 CourseAssignment 表，然后选择“查看数据”。
验证 CourseAssignment 表包含数据。

SSOX 中的 CourseAssignment 数据

将迁移应用到现有数据库

本部分是可选的。只有当跳过之前的删除并重新创建数据库部分时才可以执行上述步骤。

当现有数据与迁移一起运行时，可能存在不满足现有数据的 FK 约束。使用生产数据时，必须采取步骤来迁移现有数据。本部分提供修复 FK 约束冲突的示例。务必在备份后执行这些代码更改。如果已完成上述部分并更新数据库，则不要执行这些代码更改。

{timestamp}_ComplexDataModel.cs 文件包含以下代码：

migrationBuilder.AddColumn<int>(
    name: "DepartmentID",
    table: "Course",
    type: "int",
    nullable: false,
    defaultValue: 0);

上面的代码将向 Course 表添加不可为 NULL 的 DepartmentID FK。前面教程中的数据库在 Course中包含行，以便迁移时不会更新表。

若要使 ComplexDataModel 迁移可与现有数据搭配运行：

请更改代码以便为新列 (DepartmentID) 赋予默认值。
创建名为“临时”的虚拟系来充当默认的系。

修复外键约束

更新 ComplexDataModel 类 Up 方法：

migrationBuilder.AlterColumn<string>(
    name: "Title",
    table: "Course",
    maxLength: 50,
    nullable: true,
    oldClrType: typeof(string),
    oldNullable: true);
//migrationBuilder.AddColumn<int>(
//    name: "DepartmentID",
//    table: "Course",
//    nullable: false,
//    defaultValue: 0);

添加以下突出显示的代码。新代码在 .CreateTable( name: "Department" 块后：

migrationBuilder.CreateTable(
    name: "Department",
    columns: table => new
        DepartmentID = table.Column<int>(type: "int", nullable: false)
            .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
        Budget = table.Column<decimal>(type: "money", nullable: false),
        InstructorID = table.Column<int>(type: "int", nullable: true),
        Name = table.Column<string>(type: "nvarchar(50)", maxLength: 50, nullable: true),
        StartDate = table.Column<DateTime>(type: "datetime2", nullable: false)
    constraints: table =>
        table.PrimaryKey("PK_Department", x => x.DepartmentID);
        table.ForeignKey(
            name: "FK_Department_Instructor_InstructorID",
            column: x => x.InstructorID,
            principalTable: "Instructor",
            principalColumn: "ID",
            onDelete: ReferentialAction.Restrict);
 migrationBuilder.Sql("INSERT INTO dbo.Department (Name, Budget, StartDate) VALUES ('Temp', 0.00, GETDATE())");
// Default value for FK points to department created above, with
// defaultValue changed to 1 in following AddColumn statement.
migrationBuilder.AddColumn<int>(
    name: "DepartmentID",
    table: "Course",
    nullable: false,
    defaultValue: 1);

经过上面的更改，Course 行将在 ComplexDataModel Up 方法运行后与“临时”系建立联系。

生产应用可能：

包含用于将 Department 行和相关 Course 行添加到新 Department 行的代码或脚本。
不会使用“临时”系或 Course.DepartmentID 的默认值。