Asp.netCore3.1数据库访问

ASP.NET Core 中的 Razor 页面和 EF Core - 数据模型 - 第 5 个教程（共 8 个）

作者：Tom Dykstra 和 Rick Anderson

Contoso University Web 应用演示了如何使用 EF Core 和 Visual Studio 创建 Razor 页面 Web 应用。若要了解系列教程，请参阅第一个教程。

如果遇到无法解决的问题，请下载已完成的应用，然后对比该代码与按教程所创建的代码。

前面的教程介绍了由三个实体组成的基本数据模型。本教程将演示如何：

添加更多实体和关系。
通过指定格式设置、验证和数据库映射规则来自定义数据模型。

完成的数据模型如下图所示：

实体关系图

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
        {
            get
            {
                return LastName + ", " + FirstMidName;
            }
        }

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

前面的代码将添加一个 FullName 属性，并将以下特性添加到现有属性：

[DataType]
[DisplayFormat]
[StringLength]
[Column]
[Required]
[Display]

FullName 计算属性

FullName 是计算属性，可返回通过串联两个其他属性创建的值。无法设置 FullName，因此它只有一个 get 访问器。数据库中不会创建任何 FullName 列。

DataType 特性

[DataType(DataType.Date)]

对于学生注册日期，目前所有页面都显示时间和日期，但只有日期是相关的。使用数据注释特性，可更改一次代码，修复每个页面中数据的显示格式。

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

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

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

DisplayFormat 特性

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

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

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

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

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

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

StringLength 特性

[StringLength(50, ErrorMessage = "First name cannot be longer than 50 characters.")]

可使用特性指定数据验证规则和验证错误消息。 StringLength 特性指定数据字段中允许的字符的最小长度和最大长度。显示的代码将名称限制为不超过 50 个字符。稍后显示一个设置最小字符串长度的示例。

StringLength 特性还提供客户端和服务器端验证。最小值对数据库架构没有任何影响。

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

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

Visual Studio

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

上图显示 Student 表的架构。名称字段具有类型 nvarchar(MAX)。在本教程的后续部分创建和应用迁移时，因为字符串的长度特性，名称字段将变为 nvarchar(50)。
Visual Studio Code

在 SQLite 工具中检查 Student 表的列定义。名称字段具有类型 Text。请注意，首个名称字段名为 FirstMidName。下一节会将该列的名称更改为 FirstName。

Column 特性

[Column("FirstName")]
public string FirstMidName { get; set; }

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

创建数据库后，模型上的属性名将用作列名（使用 Column 特性时除外）。 Student 模型使用 FirstMidName 作为名字字段，因为该字段也可能包含中间名。

使用 [Column] 特性，数据模型中的 Student.FirstMidName 可映射到 Student 表的 FirstName 列。添加 Column 特性后，SchoolContext 的支持模型会发生改变。 SchoolContext 的支持模型将不再与数据库匹配。这种差异将通过在本教程后面添加迁移来解决。

Required 特性

[Required]

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

Required 特性必须与 MinimumLength 结合使用才能强制执行 MinimumLength。

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

MinimumLength 和 Required 允许通过空格来满足验证。使用 RegularExpression 特性来完全控制字符串。

Display 特性

[Display(Name = "Last Name")]

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

创建迁移

运行应用并转到“学生”页。此时引发异常。 [Column] 特性导致 EF 希望查找名为 FirstName 的列，但数据库中的列名称仍为 FirstMidName。

Visual Studio
错误消息类似于以下示例：
```
SqlException: Invalid column name 'FirstName'.
```
- 在 PMC 中，输入以下命令以创建新迁移并更新数据库：
```
Add-Migration ColumnFirstName
Update-Database
```
  其中的第一个命令将生成以下警告消息：
```
An operation was scaffolded that may result in the loss of data.
Please review the migration for accuracy.
```
  生成警告的原因是名称字段现已限制为 50 个字符。如果数据库中的名称超过 50 个字符，则第 51 个字符及后面的所有字符都将丢失。
- 在 SSOX 中打开 Student 表：
  
  执行迁移前，名称列的类型为 nvarchar (MAX)。名称列现在的类型为 nvarchar(50)。列名已从 FirstMidName 更改为 FirstName。
Visual Studio Code
错误消息类似于以下示例：
```
SqliteException: SQLite Error 1: 'no such column: s.FirstName'.
```
- 在项目文件夹中打开命令窗口。输入以下命令以创建新迁移并更新数据库：
```
dotnet ef migrations add ColumnFirstName
dotnet ef database update
```
  数据库更新命令显示类似于以下示例的错误：
```
SQLite does not support this migration operation ('AlterColumnOperation'). For more information, see http://go.microsoft.com/fwlink/?LinkId=723262.
```
在本教程中，解决此错误的方法是删除并重新创建初始迁移。有关详细信息，请参阅迁移教程顶部的 SQLite 警告说明。
- 删除“Migrations”文件夹。
- 运行以下命令以删除数据库，创建新的初始迁移，并应用该迁移：
```
dotnet ef database drop --force
dotnet ef migrations add InitialCreate
dotnet ef database update
```
- 在 SQLite 工具中检查 Student 表。以前为 FirstMidName 的列现在为 FirstName。

运行应用并转到“学生”页。
请注意，时间和日期既未输入，也未显示。
选择“新建”，尝试输入不超过 50 个字符的名称。

备注

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

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 定义为集合。

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

讲师最多可以有一个办公室，因此 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.OfficeAssignment 导航属性可以为 null，因为给定的讲师可能没有 OfficeAssignment 行。一名讲师可能没有办公室分配。

OfficeAssignment.Instructor 导航属性将始终具有一个 Instructor 实体，因为外键 InstructorID 类型为 int，不可为 null 的值类型。没有讲师则不可能存在办公室分配。

当 Instructor 实体具有相关 OfficeAssignment 实体时，每个实体都具有对其导航属性中的另一个实体的引用。

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 不要求此模型具有外键属性。 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 值由数据库生成。数据库生成通常是最佳方法。 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 和导航属性可反映以下关系：

一个系可能有也可能没有管理员。
管理员始终由讲师担任。因此，InstructorID 属性作为到 Instructor 实体的 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 将配置级联删除规则。在这种情况下，指定为管理员的讲师被删除时，该学院将被删除。在这种情况下，限制规则将更有意义。以下 fluent API 将设置限制规则并禁用级联规则。

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

Enrollment 实体

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

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 ：

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

“讲师-课程”的多对多关系要求使用联接表，而该联接表的实体则为 CourseAssignment。

讲师-课程 m:M

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

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

组合键

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

组合键可确保：

允许一门课程对应多行。
允许一名讲师对应多行。
不允许同一讲师和课程对应多行。

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

请在 FK 字段上添加唯一索引，或
配置具有主要组合键（与 CourseAssignment 类似）的 Enrollment。有关详细信息，请参阅索引。

更新数据库上下文

使用以下代码更新 Data/SchoolContext.cs ：

using ContosoUniversity.Models;
using Microsoft.EntityFrameworkCore;

namespace ContosoUniversity.Data
{
    public class SchoolContext : DbContext
    {
        public SchoolContext(DbContextOptions<SchoolContext> options) : base(options)
        {
        }

        public DbSet<Course> Courses { get; set; }
        public DbSet<Enrollment> Enrollments { get; set; }
        public DbSet<Student> Students { 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 针对已完成的学校模型创建的关系图。

实体关系图

上面的关系图显示：

几条一对多关系线（1 到 *）。
Instructor 和 OfficeAssignment 实体之间的一对零或一关系线（1 到 0..1）。
Instructor 和 Department 实体之间的零或一到多关系线（0..1 到 *）。

设定数据库种子

更新 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.Students.Any())
            {
                return;   // DB has been seeded
            }

            var students = new Student[]
            {
                new Student { FirstMidName = "Carson",   LastName = "Alexander",
                    EnrollmentDate = DateTime.Parse("2016-09-01") },
                new Student { FirstMidName = "Meredith", LastName = "Alonso",
                    EnrollmentDate = DateTime.Parse("2018-09-01") },
                new Student { FirstMidName = "Arturo",   LastName = "Anand",
                    EnrollmentDate = DateTime.Parse("2019-09-01") },
                new Student { FirstMidName = "Gytis",    LastName = "Barzdukas",
                    EnrollmentDate = DateTime.Parse("2018-09-01") },
                new Student { FirstMidName = "Yan",      LastName = "Li",
                    EnrollmentDate = DateTime.Parse("2018-09-01") },
                new Student { FirstMidName = "Peggy",    LastName = "Justice",
                    EnrollmentDate = DateTime.Parse("2017-09-01") },
                new Student { FirstMidName = "Laura",    LastName = "Norman",
                    EnrollmentDate = DateTime.Parse("2019-09-01") },
                new Student { FirstMidName = "Nino",     LastName = "Olivetto",
                    EnrollmentDate = DateTime.Parse("2011-09-01") }
            };

            foreach (Student s in students)
            {
                context.Students.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.Enrollments.Where(
                    s =>
                            s.Student.ID == e.StudentID &&
                            s.Course.CourseID == e.CourseID).SingleOrDefault();
                if (enrollmentInDataBase == null)
                {
                    context.Enrollments.Add(e);
                }
            }
            context.SaveChanges();
        }
    }
}

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

添加迁移

生成项目。

Visual Studio

在 PMC 中运行以下命令。

Add-Migration ComplexDataModel

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

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

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

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'.

下一节将介绍如何处理此错误。

Visual Studio Code

如果添加迁移并运行 database update 命令，则将生成以下错误：

SQLite does not support this migration operation ('DropForeignKeyOperation').
For more information, see http://go.microsoft.com/fwlink/?LinkId=723262.

下一节将介绍如何避免此错误。

应用迁移或删除并重新创建

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

删除并重新创建数据库。如果使用 SQLite，请选择此部分。
将迁移应用到现有数据库。本部分的说明仅适用于 SQL Server，不适用于 SQLite 。

这两个选项都适用于 SQL Server。虽然应用迁移方法更复杂且耗时，但在实际应用和生产环境中为首选方法。

删除并重新创建数据库

如果使用 SQL Server 并且想要在以下部分执行应用迁移方法，请跳过此部分。

若要强制 EF Core 创建新的数据库，请删除并更新该数据库：

Visual Studio
- 在“包管理器控制台”(PMC) 中运行以下命令：
```
Drop-Database
```
- 删除“Migrations”文件夹，然后运行以下命令：
```
Add-Migration InitialCreate
Update-Database
```
Visual Studio Code
- 打开命令窗口并导航到项目文件夹。项目文件夹包含 ContosoUniversity.csproj 文件。
- 运行下面的命令：
```
dotnet ef database drop --force
```
- 删除“Migrations”文件夹，然后运行以下命令：
```
dotnet ef migrations add InitialCreate
dotnet ef database update
```

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

Visual Studio
在 SSOX 中打开数据库：
- 如果之前已打开过 SSOX，请单击“刷新”按钮。
- 展开“表”节点。随后将显示出已创建的表。
- 查看 CourseAssignment 表：
  - 右键单击 CourseAssignment 表，然后选择“查看数据” 。
  - 验证 CourseAssignment 表包含数据。
Visual Studio Code
使用 SQLite 工具检查数据库：
- 新的表和列。
- 表中设定种子的数据，例如 CourseAssignment 表。

应用迁移

本部分是可选的。这些步骤仅适用于 SQL Server LocalDB，并且仅当跳过前面的删除并重新创建数据库部分时才适用。

当现有数据与迁移一起运行时，可能存在不满足现有数据的 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 方法：

打开 {timestamp}_ComplexDataModel.cs 文件。
对将 DepartmentID 列添加到 Course 表的代码行添加注释。

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 的默认值。

Visual Studio
- 在“包管理器控制台”(PMC) 中运行以下命令：
```
Update-Database
```
由于 DbInitializer.Initialize 方法仅适用于空数据库，因此请使用 SSOX 删除 Student 表和 Course 表中的所有行。（级联删除将负责 Enrollment 表。）
Visual Studio Code
- 如果在 Visual Studio Code 中使用 SQL Server LocalDB，请运行以下命令：
```
dotnet ef database update
```

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

后续步骤

接下来的两个教程演示如何读取和更新相关数据。

上一篇：ASP.NET Core 中的 Razor 页面和 EF Core - 迁移 - 第 4 个教程（共 8 个）

下一篇：ASP.NET Core 中的 Razor 页面和 EF Core - 读取相关数据 - 第 6 个教程（共 8 个）

分类导航

关注微信小程序

扫描二维码
程序员编程王

Asp.netCore3.1数据库访问

ASP.NET Core 中的 Razor 页面和 EF Core - 数据模型 - 第 5 个教程（共 8 个）

Student 实体

FullName 计算属性

DataType 特性

DisplayFormat 特性

StringLength 特性

Column 特性

Required 特性

Display 特性

创建迁移

Instructor 实体

导航属性

OfficeAssignment 实体

Key 特性

Instructor 导航属性

Course 实体

DatabaseGenerated 特性

外键和导航属性

Department 实体

Column 特性

外键和导航属性

Enrollment 实体

外键和导航属性

多对多关系

CourseAssignment 实体

组合键

更新数据库上下文

用 Fluent API 替代特性

实体关系图

设定数据库种子

添加迁移

应用迁移或删除并重新创建

删除并重新创建数据库

应用迁移

修复外键约束

后续步骤