学习 Entity Framework (第3天): ASP.NET Web API 2 配合 Entity Framework 6 Code First 迁移

• 下载 PDF 文章 - 3 MB
• 下载源代码 - 228.3 KB

目录

• 引言
• 路线图
• Web API
• 创建 Web API 项目
• 创建模型
• 添加 API 控制器
• Entity Framework Code First 迁移
• 探索生成的数据库
• 运行应用程序并设置 Postman
• 端点和数据库操作
  • GET
  • POST
  • PUT
  • 删除
• 参考文献
• 结论

引言

在上一篇学习 Entity Framework 的文章 《Entity Framework 学习（第2天）：Code First 方法和 Code First 迁移》 中，我们学习了 Code First 方法和 Code First 迁移。在本文中，我们将学习如何使用 ASP.NET Web API2 和 Entity Framework 执行 CRUD 操作。我们将以教程的形式一步一步地设置一个基本的 Web API 项目，并使用 Entity Framework 的 Code First 方法来生成数据库和执行 CRUD 操作。如果您是 Entity Framework 的新手，请按照我之前关于 Entity Framework 数据访问方法解释的文章 《Entity Framework 学习（第1天）：数据访问方法》 进行学习。本文将偏重实践，而非理论，以便我们了解如何设置 Web API 项目、Entity Framework 并执行 CRUD 操作。我们不会为这个应用程序创建客户端，而是使用 Postman 这个工具来测试 REST 端点。

路线图

我们将遵循一个五篇文章的系列来详细学习 Entity Framework 的主题。所有文章都将是教程形式，最后一篇除外，我将在其中介绍 Entity Framework 的理论、历史和用法。该系列的议题如下。

• 学习 Entity Framework（第 1 天）：.NET 中 Entity Framework 的数据访问方法
• 学习 Entity Framework（第 2 天）：.NET 中 Entity Framework 的 Code First 迁移
• 学习 Entity Framework（第 3 天）：.NET 中 ASP.NET WebAPI 2.0 的 Code First 迁移
• 学习 Entity Framework（ 第 4 天）： 理解 Entity Framework Core 和 EF Core 中的 Code First Migrations
• 学习 Entity Framework（第 5 天）：Entity Framework（理论篇）

Web API

我完全同意来自 Microsoft 文档 的以下摘录。

“HTTP 不仅仅用于提供网页。HTTP 还是构建 API 的强大平台，可以公开服务和数据。HTTP 简单、灵活且无处不在。几乎任何您能想到的平台都有 HTTP 库，因此 HTTP 服务可以触达广泛的客户端，包括浏览器、移动设备和传统桌面应用程序。ASP.NET Web API 是一个在 .NET Framework 之上构建 Web API 的框架。”

您可以在 MSDN 上阅读大量关于 Web API 的理论知识。

实体框架

Microsoft Entity Framework 是一个 ORM（对象关系映射）。来自 Wikipedia 的定义对于 ORM 非常直接且基本不言自明，

“在 计算机科学 中，对象关系映射（ORM、O/RM 和 O/R 映射工具）是一种使用 面向对象 编程语言将数据在不兼容的 类型系统 之间转换的 编程 技术。这实际上创建了一个可以从编程语言内部使用的‘虚拟 对象数据库’。”

作为一个 ORM，Entity Framework 是 Microsoft 提供的数据访问框架，有助于在应用程序中建立对象与数据结构之间的关系。它建立在传统的 ADO.NET 之上，作为 ADO.NET 的包装器，是对 ADO.NET 的增强，以更自动化的方式提供数据访问，从而减少了开发人员在连接、数据读取器或数据集方面的烦恼。它对所有这些进行了抽象，并且在其提供的功能方面更强大。开发人员可以更好地控制他们需要的数据、数据的形式以及数据的数量。没有数据库开发背景的开发人员可以利用 Entity Framework 和 LINQ 的功能来编写优化的查询以执行数据库操作。SQL 或数据库查询的执行将由 Entity Framework 在后台处理，它会处理所有可能发生的事务和并发问题。Entity Framework 提供了三种数据库访问方法，在本教程中，我们将使用这三种方法中的 Code First 方法。

创建 Web API 项目

请按照下面提到的步骤和图片来创建一个 Web API 2 项目。

1. 本教程使用 Visual Studio 2017。打开 Visual Studio 并添加一个新项目。

   

2. 在已安装的模板中选择“Web”选项，然后选择“ASP.NET Web Application (.NET Framework)”。更改解决方案和项目的名称，例如，项目名称可以是“StudentManagement”，解决方案名称可以是“WebAPI2WithEF”。选择 .NET Framework 4.6 作为框架。点击“OK”。

   

3. 点击“OK”后，系统会提示您选择 ASP.NET Web 应用程序的类型。选择 Web API，然后点击“OK”。

   

4. 点击“OK”后，您将获得一个默认的基本 Web API 项目，其中包含必需的 NuGet 包、文件和文件夹，以及用于运行应用程序的 Views 和 Controllers。

   

创建模型

我们将创建一个模型类，它将充当 Student 的实体，我们需要对该实体执行数据库操作。为了便于理解其工作原理，我们将保持简单。您可以创建多个模型类，甚至可以在它们之间建立关系。

1. 右键单击“Models”文件夹并添加一个新类。将该类命名为“Student”。

   

2. 将该类设置为 public，并为其添加两个属性：Id 和 Name。Id 将作为此实体的​​主键。

   

   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Web;
    
   namespace StudentManagement.Models
   {
       public class Student
       {
           public int Id { get; set; }
           public string Name { get; set; }
       }
   }

3. 重新生成解决方案。

   

添加 API 控制器

让我们添加一个控制器，其中将包含对我们的模型类进行创建、更新、读取和删除的数据库操作。

1. 右键单击“controller”文件夹，选择添加新 controller 类的选项。

   

2. 在下一个提示中，选择使用 Entity Framework 创建带操作的 Web API 2 Controller 的选项。点击“Add”按钮。

   

3. 接下来，在 Model 类选项中选择我们创建的模型，即 Student 模型。

   

4. 由于我们的应用程序没有数据上下文，请点击 Data context class 选项下拉列表旁边的 + 按钮，并在显示的文本框中输入名称“StudentManagementContext”，然后点击“Add”。

   

5. 控制器的名称应为“StudentsController”。点击“Add”完成。

   

6. 点击“Add”完成后，它会尝试创建一个控制器脚手架模板，该模板使用 Entity Framework 和我们的模型类包含所有读/写操作。由于我们在添加控制器时的第二步中提到了我们希望控制器使用 Entity Framework 执行数据库操作，因此它会很智能地理解这一点，并添加 Entity Framework 和相关 NuGet 包的引用。创建脚手架模板可能需要一些时间。

   

7. 模板生成完成后，您可以在 Web API 项目的“Controller”文件夹中看到添加的 controller 类。此类从 ApiController 类派生，并包含执行 student 实体数据库操作所需的所有方法。如果我们检查方法名称，它们会以前缀 HTTP 动词的名称开头。这是请求被映射到操作的方式。如果您不希望操作以 HTTP 动词为前缀，可以在方法上使用 HTTP 动词属性装饰方法，或者在操作上应用属性路由。我们不会详细讨论这些，而是坚持使用当前的实现。

   

   Controller 类代码

   using System;
   using System.Collections.Generic;
   using System.Data;
   using System.Data.Entity;
   using System.Data.Entity.Infrastructure;
   using System.Linq;
   using System.Net;
   using System.Net.Http;
   using System.Web.Http;
   using System.Web.Http.Description;
   using StudentManagement.Models;
    
   namespace StudentManagement.Controllers
   {
       public class StudentsController : ApiController
       {
           private StudentManagementContext db = new StudentManagementContext();
    
           // GET: api/Students
           public IQueryable<Student> GetStudents()
           {
               return db.Students;
           }
    
           // GET: api/Students/5
           [ResponseType(typeof(Student))]
           public IHttpActionResult GetStudent(int id)
           {
               Student student = db.Students.Find(id);
               if (student == null)
               {
                   return NotFound();
               }
    
               return Ok(student);
           }
    
           // PUT: api/Students/5
           [ResponseType(typeof(void))]
           public IHttpActionResult PutStudent(int id, Student student)
           {
               if (!ModelState.IsValid)
               {
                   return BadRequest(ModelState);
               }
    
               if (id != student.Id)
               {
                   return BadRequest();
               }
   
               db.Entry(student).State = EntityState.Modified;
    
               try
               {
                   db.SaveChanges();
               }
               catch (DbUpdateConcurrencyException)
               {
                   if (!StudentExists(id))
                   {
                       return NotFound();
                   }
                   else
                   {
                       throw;
                   }
               }
    
               return StatusCode(HttpStatusCode.NoContent);
           }
    
           // POST: api/Students
           [ResponseType(typeof(Student))]
           public IHttpActionResult PostStudent(Student student)
           {
               if (!ModelState.IsValid)
               {
                   return BadRequest(ModelState);
               }
    
               db.Students.Add(student);
               db.SaveChanges();
    
               return CreatedAtRoute("DefaultApi", new { id = student.Id }, student);
           }
    
           // DELETE: api/Students/5
           [ResponseType(typeof(Student))]
           public IHttpActionResult DeleteStudent(int id)
           {
               Student student = db.Students.Find(id);
               if (student == null)
               {
                   return NotFound();
               }
    
               db.Students.Remove(student);
               db.SaveChanges();
    
               return Ok(student);
           }
    
           protected override void Dispose(bool disposing)
           {
               if (disposing)
               {
                   db.Dispose();
               }
               base.Dispose(disposing);
           }
    
           private bool StudentExists(int id)
           {
               return db.Students.Count(e => e.Id == id) > 0;
           }
       }
   }

Entity Framework Code First 迁移

设想一种场景，您想添加一个新的模型/实体，并且不希望在更新数据库（包含新添加的模型类）时删除或更改现有数据库。Code First 迁移可以帮助您使用新添加的模型类来更新现有数据库，而您的现有数据库将保持不变，包含现有数据。因此，数据和架构不会被重新创建。这是一种 Code First 方法，我们将逐步了解如何在我们的应用程序中启用它。

1. 打开程序包管理器控制台，并将默认项目选择为您的 WebAPI 项目。键入命令 **Enable-Migrations** 并按 Enter 键。

   

2. 命令执行后，它会对我们的解决方案进行一些更改。作为添加迁移的一部分，它会创建一个 Migrations 文件夹，并添加一个名为 **“Configuration.cs”** 的类文件。此类派生自 DbMigrationsConfiguration 类。此类包含一个 Seed 方法，该方法以 context 类为参数，这是我们在 Models 文件夹中生成的。Seed 是一个重写方法，这意味着它包含基类中的一个 virtual 方法，并且派生自 DbMigrationsConfiguration 的类可以重写它并添加自定义功能。如果我们在创建数据库时希望某些表包含一些数据，我们可以利用 Seed 方法向数据库提供种子数据或主数据。

   

   DbMigrationsConfiguration 类

   

3. 让我们利用这个 Seed 方法，向 Students 模型中添加一些学生。我将添加三个名为 Allen、Kim 和 Jane 的学生。

   

   Configuration 类

   using StudentManagement.Models;
    
   namespace StudentManagement.Migrations
   {
       using System;
       using System.Data.Entity;
       using System.Data.Entity.Migrations;
       using System.Linq;
    
       internal sealed class Configuration : 
       DbMigrationsConfiguration<StudentManagement.Models.StudentManagementContext>
       {
           public Configuration()
           {
               AutomaticMigrationsEnabled = false;
           }
    
           protected override void Seed(StudentManagement.Models.StudentManagementContext context)
           {
               context.Students.AddOrUpdate(p => p.Id,
                   new Student { Name = "Allen" },
                   new Student { Name = "Kim" },
                   new Student { Name = "Jane" }
               ); 
           }
       }
   }

4. context 参数是我们添加控制器时生成的 context 类的实例。我们将其命名为 StudentManagementContext。此类派生自 DbContext 类。此类负责数据库架构，并且该类的 DbSet 属性基本上是我们创建数据库时将拥有的表。它添加了 Students 作为 DbSet 属性，该属性返回我们的 Student 模型/实体，并将直接映射到数据库中将要生成的表。

   

5. 下一步是执行名为“Add-Migrations”的命令。在程序包管理器控制台，执行此命令并加上您选择的参数，该参数将是我们第一次迁移的名称。我称之为“Initial”。因此，命令将是 **Add-Migrations Initial**。

   

6. 命令执行后，会添加一个新文件，其名称为“Initial”，前面带有日期时间戳。它添加日期时间戳是为了能够跟踪开发过程中添加的各种迁移并将它们区分开。打开文件，我们看到一个名为“Initial”的类，它派生自 DbMigration 类。此类包含两个从 DbMigration 类（即基类）重写的方法。方法名称是 Up() 和 Down()。Up 方法用于向数据库添加所有初始配置，并包含 LINQ 格式的创建命令。这有助于生成表以及模型上完成的所有修改。Down 命令与 Up 命令相反。文件中的代码是不言自明的。这里的 Up 命令包含创建 Students 表并将 Id 设置为主键的代码。所有这些信息都来自模型及其更改。

   

   初始迁移

   namespace StudentManagement.Migrations
   {
       using System;
       using System.Data.Entity.Migrations;
      
       public partial class Initial : DbMigration
       {
           public override void Up()
           {
               CreateTable(
                   "dbo.Students",
                   c => new
                       {
                           Id = c.Int(nullable: false, identity: true),
                           Name = c.String(),
                       })
                   .PrimaryKey(t => t.Id);           
           }
          
           public override void Down()
           {
               DropTable("dbo.Students");
           }
       }
   }

7. 再次在程序包管理器控制台，运行命令“Update-Database”。

   

8. 这是创建数据库和相应表（基于我们的上下文和模型）的最终命令。它执行我们添加的初始迁移，然后从配置类运行 seed 方法。此命令能够智能地检测要运行的迁移。例如，它不会运行之前执行过的迁移，并且每次都会考虑执行所有新添加的迁移来更新数据库。它维护此跟踪，因为数据库首次创建时会包含一个名为 __MigrationHistory 的额外表，该表会跟踪所有完成的迁移。

   

9. 命令成功执行后，它会在您的本地数据库服务器中创建数据库，并在 Web.Config 文件中添加相应的连接字符串。连接字符串的名称与我们的上下文类名称相同，这就是上下文类和连接字符串之间关联的方式。

   

        // POST: api/Students
        [ResponseType(typeof(Student))]
        public IHttpActionResult PostStudent(Student student)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }
 
            db.Students.Add(student);
            db.SaveChanges();
 
            return CreatedAtRoute("DefaultApi", new { id = student.Id }, student);
        }

        // PUT: api/Students/5
        [ResponseType(typeof(void))]
        public IHttpActionResult PutStudent(int id, Student student)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }
 
            if (id != student.Id)
            {
                return BadRequest();
            }
 
            db.Entry(student).State = EntityState.Modified;
 
            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!StudentExists(id))
                {
                    return NotFound();
                }
                else
                {
                    throw;
                }
            }
 
            return StatusCode(HttpStatusCode.NoContent);
        }

        // DELETE: api/Students/5
        [ResponseType(typeof(Student))]
        public IHttpActionResult DeleteStudent(int id)
        {
            Student student = db.Students.Find(id);
            if (student == null)
            {
                return NotFound();
            }
 
            db.Students.Remove(student);
            db.SaveChanges();
 
            return Ok(student);
        }