C# 6 与 .NET Core 1.0 高级编程 - 38 章 实体框架核心（上） Professional C# 6 and .NET Core 1.0 - 38 Entity Framework

译文，我的原创，转载请注明出处（C# 6 与 .NET Core 1.0 高级编程 - 38 章 实体框架核心(上)），不对的地方欢迎指出与交流。 

章节出自《Professional C# 6 and .NET Core 1.0》。水平有限，各位阅读时仔细分辨，惟望莫误人子弟。

附英文版原文：Professional C# 6 and .NET Core 1.0 - 38 Entity Framework Core

本章节译文分为上下篇，下篇见： C# 6 与 .NET Core 1.0 高级编程 - 38 章 实体框架核心(下)

-------------------------------

本章内容

• Entity Framework Core 1.0简介
• 使用依赖注入实体框架
• 建立关系模型
• 使用.NET CLI工具和MSBuild进行迁移
• 对象跟踪
• 更新对象和对象树
• 冲突处理与更新
• 使用事务

Wrox.Com关于本章的源代码下载

本章的wrox.com代码下载位于 www.wrox.com/go/professionalcsharp6 下载代码选项卡。本章的代码主要有如下示例：

• Books Sample
• Books Sample with DI
• Menus Sample
• Menus with Data Annotations
• Conflict Handling Sample
• Transactions Sample 

实体框架的历史

实体框架是提供实体到关系的映射的框架。经过这种方式，能够建立映射到数据库表的类型，使用LINQ建立数据库查询，建立和更新对象，并将它们写入数据库。 

通过多年对Entity Framework的少许修改，最新的版本是一个彻底的重写。一块儿来看看Entity Framework的历史，以及重写的缘由。

• Entity Framework 1—Entity Framework的第一个版本没有准备好与.NET 3.5兼容，但它很快就能够与.NET 3.5 SP1兼容。另外一个产品LINQ to SQL提供了一些相似的功能，且已经可用于.NET 3.5。 LINQ to SQL和Entity Framework在很大程度上提供了相似的功能。LINQ to SQL更易于使用，但只能用于访问SQL Server。实体框架是基于提供程序的，并提供了对不一样关系数据库的访问。它包含更多的功能，例如多对多映射而不须要映射对象，n对n映射是可能的。 Entity Framework的一个缺点是它的模型类型须要由EntityObject基类派生。将对象映射到关系使用包含XML的EDMX文件完成的。包含的XML由三个模式组成：概念模式定义（CSD）定义具备其属性和关联的对象类型；存储模式定义（SSD）定义数据库表、列和关系；以及映射模式语言（MSL）定义CSD和SSD如何相互映射。
  
• Entity Framework 4—Entity Framework 4 在.NET 4中兼容，而且得到了重大改进，其中许多来自LINQ到SQL的想法。因为变化较大，版本2和3已被跳过。这个版本里增长了延迟加载以获取访问属性的关系。在使用SQL数据定义语言（DDL）设计模型以后，能够建立数据库。如今使用Entity Framework的两个模型是Database First或Model First。也许最重要的特性是支持简单对象类（POCO），所以再也不须要从基类EntityObject派生。
  

随着更新（例如Entity Framework 4.1,4.2），NuGet包增长了额外的功能，所以能更快地添加功能。 Entity Framework 4.1提供了Code First模型，其中用于定义映射的EDMX文件再也不使用。相反，全部的映射都使用C＃代码定义 - 使用属性或Fluent API来定义的映射。

Entity Framework 4.3增长了对迁移的支持。有了这一点，就可使用C＃代码定义数据库结构的更改。使用数据库从应用程序自动应用数据库更新。

• Entity Framework 5—Entity Framework 5的NuGet包支持.NET 4.5和.NET 4应用程序。可是，Entity Framework 5的许多功能均可用于.NET 4.5。 Entity Framework仍然基于.NET 4.5在系统上安装的类型。此版本的新增功能是性能改进以及支持新的SQL Server功能，例如空间数据类型。
  
• Entity Framework 6—Entity Framework 6解决了Entity Framework 5的一些问题，其中一部分是安装在系统上的框架的一部分，一部分经过NuGet扩展提供。目前Entity Framework的所有代码已移至NuGet包。为了避免形成冲突，使用了一个新的命名空间。将应用程序移植到新版本时，必须更改命名空间。
  

本书讨论Entity Framework的最新版本，Entity Framework Core 1.0。此版本是一个删除旧的行为全面重写，再也不支持CSDL，SSDL和MSL的XML文件映射，只支持Code First - 使用Entity Framework 4.1添加的模型。Code First 并不意味着数据库不能先存在。您能够先建立数据库，或者仅从代码中定义数据库，以上两种选项都是可行的。

注意 Code First 这个名称某些程度上让人误会。Code First 先建立代码或先数据库都是可行的。最初Code First的测试版本名称是Code Only。由于其余模型选项在名称中有First，因此“Code Only”的名称也被更改。

Entity Framework 的全面重写不只支持关系数据库，还支持NoSql数据库 - 只须要一个提供程序。在撰写本文时，提供程序支持有限，但相信会随时间而增长。 

新版本的Entity Framework基于.NET Core，所以在Linux和Mac系统上也可使用此框架。 

Entity Framework Core 1.0不彻底支持Entity Framework 6提供的全部功能。随着时间的推移，Entity Framework的新版本将提供更多功能，留意所使用的Entity Framework的版本。尽管使用Entity Framework 6 不少有力的理由，但在非Windows平台上使用ASP.NET Core 1.0、Entity Framework和通用Windows平台(UWP)，以及非关系数据存储，都须要使用Entity Framework Core 1.0。 

本章介绍Entity Framework Core 1.0。从一个简单的模型读取和SQL Server中写入信息开始，稍后会介绍添加关系，在写入数据库时将介绍更改跟踪器和冲突处理。利用迁移建立和修改数据库结构是本章的另外一个重要部分。 

注意 本章使用Books数据库，此数据库包含在示例代码的下载包中 www.wrox.com/go/professionalcsharp6. 

实体框架简介

第一个示例使用单个Book类型，并将此类型映射到SQL Server数据库中的Books表。能够将记录写入数据库，而后读取，更新和删除它们。 

在第一个示例中，首先建立数据库。可使用Visual Studio 2015中的SQL Server对象资源管理器执行此操做。选择数据库实例（与Visual Studio一块儿安装的（localdb）\ MSSQLLocalDB），单击树视图中的数据库节点，而后选择“添加新数据库”。示例数据库只有一个名为Books的表。 

选择Books数据库中的表节点，而后选择"添加新表"来建立表Books。使用图38.1中所示的设计器，或者经过在T-SQL编辑器中输入SQL DDL语句，均可以建立表Books。如下代码段显示了用于建立表的T-SQL代码。单击“更新”按钮能够将更改提交到数据库。

CREATE TABLE [dbo].[Books]
(
  [BookId] INT NOT NULL PRIMARY KEY IDENTITY,
  [Title] NVARCHAR(50) NOT NULL,
  [Publisher] NVARCHAR(25) NOT NULL
)

建立模型 

用于访问Books数据库的示例应用程序BookSample是一个控制台应用程序（Package）。此示例使用如下依赖项和命名空间：

　　依赖项

NETStandard.Library
Microsoft.EntityFrameworkCore
Microsoft.EntityFrameworkCore.SqlServer

 　　命名空间

Microsoft.EntityFrameworkCore
System.ComponentModel.DataAnnotations.Schema
System
System.Linq
System.Threading.Tasks
static System.Console

 

图 38.1  

Book类是一个简单的实体类型，它定义了三个属性。 BookId属性映射到表的主键，Title属性指向标题列，Publisher属性指向Publisher列。Table属性应用于类型将类型映射到Books表（代码文件BooksSample / Book.cs）：

[Table("Books")]
public class Book
{
  public int BookId { get; set; }
  public string Title { get; set; }
  public string Publisher { get; set; }
}

建立上下文 

建立的BooksContext类完成Book表与数据库的关联。这个类派生自基类DbContext，BooksContext类定义Books属性类型为DbSet <Book>。此类型容许建立查询并添加Book实例以将其存储在数据库中。要定义链接字符串，能够重写DbContext的OnConfiguring方法。UseSqlServer扩展方法将上下文映射到SQL Server数据库（代码文件BooksSample / BooksContext.cs）：

public class BooksContext: DbContext
{
  private const string ConnectionString =  @"server= (localdb)\MSSQLLocalDb;database=Books;trusted_connection=true";
  public DbSet<Book> Books { get; set; }
  protected override void OnConfiguring(DbContextOptionsBuilder  optionsBuilder)
  {
    base.OnConfiguring(optionsBuilder);
    optionsBuilder.UseSqlServer(ConnectionString);
  }
}

定义链接字符串的另外一个选项是使用依赖注入，将在本章后面介绍。 

写入数据库

如今已建立了有Books表的数据库，也定义了模型和上下文类，而后能够用数据填充表。建立AddBookAsync方法将Book对象添加到数据库。首先，BooksContext对象被实例化，这里使用using语句确保数据库链接关闭。使用Add方法将对象添加到上下文以后，实体被写入调用SaveChangesAsync的数据库（代码文件BooksSample / Program.cs）：

private async Task AddBookAsync(string title, string publisher)
{
  using (var context = new BooksContext())
  {
    var book = new Book
    {
      Title = title,
      Publisher = publisher
    };
    context.Add(book);
    int records = await context.SaveChangesAsync();
 
    WriteLine($"{records} record added");
  }
  WriteLine();
} 

要添加书籍列表，可使用AddRange方法（代码文件BooksSample / Program.cs）：

private async Task AddBooksAsync()
{
  using (var context = new BooksContext())
  {
    var b1 = new Book
    {
      Title ="Professional C# 5 and .NET 4.5.1",
      Publisher ="Wrox Press"
    };
    var b2 = new Book
    {
      Title ="Professional C# 2012 and .NET 4.5",
      Publisher ="Wrox Press"
    };
    var b3 = new Book
    {
      Title ="JavaScript for Kids",
      Publisher ="Wrox Press"
    };
    var b4 = new Book
    {
      Title ="Web Design with HTML and CSS",
      Publisher ="For Dummies"
    };
    context.AddRange(b1, b2, b3, b4);
    int records = await context.SaveChangesAsync();
    WriteLine($"{records} records added");
  }
  WriteLine();
} 

 运行应用程序并调用这些方法后，可使用SQL Server对象资源管理器查看写入到数据库的数据。

从数据库读取

从C＃代码读取数据只须要调用BooksContext并访问Books属性。访问此属性会建立一个SQL语句从数据库中检索全部图书（代码文件BooksSample / Program.cs）：

private void ReadBooks()
{
  using (var context = new BooksContext())
  {
    var books = context.Books;
    foreach (var b in books)
    {
      WriteLine($"{b.Title} {b.Publisher}");
    }
  }
  WriteLine();
}

在调试期间打开 IntelliTrace Events窗口，能够看到发送到数据库的SQL语句（须要Visual Studio 企业版）：

SELECT [b].[BookId], [b].[Publisher], [b].[Title]
FROM [Books] AS [b]

Framework提供了一个LINQ提供程序，能够建立LINQ查询访问数据库。可使用以下所示语法的方法：

private void QueryBooks()
{
  using (var context = new BooksContext())
  {
    var wroxBooks = context.Books.Where(b => b.Publisher =="Wrox Press");
    foreach (var b in wroxBooks)
    {
      WriteLine($"{b.Title} {b.Publisher}");
    }
  }
  WriteLine();
}

或使用LINQ查询语法：

var wroxBooks = from b in context.Books
                where b.Publisher =="Wrox Press"
                select b;

使用这两种不一样的语法，都将发送下面的SQL语句到数据库：

SELECT [b].[BookId], [b].[Publisher], [b].[Title]
FROM [Books] AS [b]
WHERE [b].[Publisher] = 'Wrox Press'

注意 在第13章“语言集成查询”中详细讨论了LINQ。

更新记录

只需更改已加载上下文的对象并调用SaveChangesAsync便可轻松实现更新记录（代码文件BooksSample / Program.cs）：

private async Task UpdateBookAsync()
{
  using (var context = new BooksContext())
  {
    int records = 0;
    var book = context.Books.Where(b => b.Title =="Professional C# 6")
      .FirstOrDefault();
    if (book != null)
    {
      book.Title ="Professional C# 6 and .NET Core 5";
      records = await context.SaveChangesAsync();
    }
    WriteLine($"{records} record updated");
  }
  WriteLine();
}

删除记录

最后，让咱们清理数据库并删除全部记录。能够经过检索全部记录并调用Remove或RemoveRange方法来设置上下文中要删除的对象的状态。而后调用SaveChangesAsync方法便可从数据库中删除记录，DbContext会为每一个要删除的对象调用SQL Delete语句（代码文件BooksSample / Program.cs）：

private async Task DeleteBooksAsync()
{
  using (var context = new BooksContext())
  {
    var books = context.Books;
    context.Books.RemoveRange(books);
    int records = await context.SaveChangesAsync();
    WriteLine($"{records} records deleted");
  }
  WriteLine();
}

注意 对象关系映射工具（如Entity Framework）在并不是在全部方案中均可用。使用示例代码没法有效地删除全部对象。您可使用一个SQL语句删除全部而不是逐条删除记录。在第37章“ADO.NET”中解释了如何作到这一点。

了解了如何添加、查询、更新和删除记录，本章将介绍幕后的功能，并使用Entity Framework进入高级场景。

使用依赖注入  

Entity Framework Core 1.0内置了对依赖注入的支持。链接和SQL Server选择能够经过使用依赖注入框架注入，而非定义和而后使用DbContext派生类的SQL Server链接。 

要查看此操做，BooksSampleWithDI示例项目对上一个代码示例项目进行了修改。 

此示例使用如下依赖项和命名空间：

　　依赖项

NETStandard.Library
Microsoft.EntityFrameworkCore
Microsoft.EntityFrameworkCore.SqlServer
Microsoft.Framework.DependencyInjection 

　　命名空间

Microsoft.EntityFrameworkCore
System.Linq
System.Threading.Tasks
static System.Console

BooksContext类如今看起来很简单，只需定义Books属性（代码文件BooksSampleWithDI / BooksContext.cs）：

public class BooksContext: DbContext
{
  public DbSet<Book> Books { get; set; }
}

BooksService是使用BooksContext的新类。BooksContext经过注入构造函数注入。方法AddBooksAsync和ReadBooks与上一个示例中的这些方法很是类似，但他们使用BooksService类的上下文成员，而不是建立一个新的（代码文件BooksSampleWithDI / BooksService.cs）：

public class BooksService
{
  private readonly BooksContext _booksContext;
  public BooksService(BooksContext context)
  {
    _booksContext = context;
  }
 
  public async Task AddBooksAsync()
  {
    var b1 = new Book
    {
      Title ="Professional C# 5 and .NET 4.5.1",
      Publisher ="Wrox Press"
    };
    var b2 = new Book
    {
      Title ="Professional C# 2012 and .NET 4.5",
      Publisher ="Wrox Press"
    };
    var b3 = new Book
    {
      Title ="JavaScript for Kids",
      Publisher ="Wrox Press"
    };
    var b4 = new Book
    {
      Title ="Web Design with HTML and CSS",
      Publisher ="For Dummies"
    };
    _booksContext.AddRange(b1, b2, b3, b4);
    int records = await _booksContext.SaveChangesAsync();
 
    WriteLine($"{records} records added");
  }
 
  public void ReadBooks()
  {
    var books = _booksContext.Books;
    foreach (var b in books)
    {
      WriteLine($"{b.Title} {b.Publisher}");
    }
    WriteLine();
  }
} 

依赖注入框架的容器在 InitializeServices 方法中初始化。建立一个ServiceCollection实例，将BooksService类添加到此集合中，并进行临时生命周期管理。这样，每次请求该服务时都会实例化 ServiceCollection。对于注册Entity Framework和SQL Server，能够用扩展方法AddEntityFramework，AddSqlServer和AddDbContext。 AddDbContext方法须要一个Action委托做为参数，其中接收到一个DbContextOptionsBuilder参数。有了该选项参数，可使用UseSqlServer扩展方法配置上下文。这里用Entity Framework注册SQL Server与上一个示例是相似的功能（代码文件BooksSampleWithDI / Program.cs）：

private void InitializeServices()
{
  const string ConnectionString =@"server= (localdb)\MSSQLLocalDb;database=Books;trusted_connection=true";
  var services = new ServiceCollection();
  services.AddTransient<BooksService>();
  services.AddEntityFramework()
    .AddSqlServer()
    .AddDbContext<BooksContext>(options =>
      options.UseSqlServer(ConnectionString));
  Container = services.BuildServiceProvider();
}
 
public IServiceProvider Container { get; private set; }

服务的初始化以及BooksService的使用是从Main方法完成的。经过调用IServiceProvider的GetService方法来检索BooksService（代码文件BooksSampleWithDI / Program.cs）：

static void Main()
{
  var p = new Program();
  p.InitializeServices();
 
  var service = p.Container.GetService<BooksService>();
  service.AddBooksAsync().Wait();
  service.ReadBooks();
}

运行应用程序能够看到记录已添加到图书数据库中而后从中读取记录。

注意 在第31章“XAML应用程序的模式”中阅读有关依赖注入和Microsoft.Framework.DependencyInjection包的更多信息，还能够参见第40章“ASP.NET Core”和第41章“ ASP.NET MVC“。

建立模型  

本章的第一个示例映射单个表。第二个例子显示了建立表之间的关系。在本节中使用C＃代码建立数据库而没有使用SQL DDL语句（或经过使用设计器）建立数据库。 

示例应用程序MenusSample使用如下依赖项和命名空间：

　　依赖项

NETStandard.Library
Microsoft.EntityFrameworkCore
Microsoft.EntityFrameworkCore.SqlServer

　　命名空间

Microsoft.EntityFrameworkCore
Microsoft.EntityFrameworkCore.ChangeTracking
System
System.Collections.Generic
System.ComponentModel.DataAnnotations
System.ComponentModel.DataAnnotations.Schema
System.Linq
System.Threading
System.Threading.Tasks
static System.Console

建立关系

让咱们开始建立一个模型。示例项目使用MenuCard和Menu类型定义一对多关系。MenuCard包含Menu对象的列表。这种关系由List <Menu>类型的Menu属性简单定义（代码文件MenusSample / MenuCard.cs）：

public class MenuCard
{
  public int MenuCardId { get; set; }
  public string Title { get; set; }
  public List<Menu> Menus { get; } = new List<Menu>();
 
  public override string ToString() => Title;
}

该关系也能够从另外一个角度访问，菜单可使用MenuCard属性访问MenuCard。指定 MenuCardId 属性去定义外键关系（代码文件MenusSample / Menu.cs）：

public class Menu
{
  public int MenuId { get; set; }
  public string Text { get; set; }
  public decimal Price { get; set; }
 
  public int MenuCardId { get; set; }
  public MenuCard MenuCard { get; set; }
 
  public override string ToString() => Text;
}

到数据库的映射由MenusContext类完成。这个类定义为与上一个上下文类型相似的类型，它只包含两个属性来映射两个对象类型：属性Menus和MenuCards（代码文件MenusSamples / MenusContext.cs）：

public class MenusContext: DbContext
{
  private const string ConnectionString = @"server=(localdb)\MSSQLLocalDb;" +     "Database=MenuCards;Trusted_Connection=True";
  public DbSet<Menu> Menus { get; set; }
  public DbSet<MenuCard> MenuCards { get; set; }
 
  protected override void OnConfiguring(DbContextOptionsBuilder  optionsBuilder)
  {
    base.OnConfiguring(optionsBuilder);
    optionsBuilder.UseSqlServer(ConnectionString);
  }
}

使用.NET CLI进行迁移

要使用C＃代码自动建立数据库，可使用enet工具使用package dotnet-ef扩展.NET CLI工具。此软件包包含用于为迁移建立C＃代码的命令。经过安装dotnet-ef NuGet包可使命令可用。您能够经过从项目配置文件（代码文件MenusSample / project.json）中的工具部分引用此软件包来安装它：

"tools": {
  "dotnet-ef":"1.0.0-*"
 }

ef命令提供如下命令：数据库、dbcontext和迁移。数据库命令用于将数据库升级到特定的迁移状态。 dbcontext命令列出项目中的全部DbContext派生类型（dbcontext list），并从数据库（dbcontext scaffold）建立上下文和实体。 migrations命令则建立和删除迁移，以及建立SQL脚本去建立包含全部迁移的数据库。若是生产数据库只能从SQL管理员使用SQL代码建立和修改，能够将生成的脚本移交给SQL管理员。 

为了建立初始迁移以从代码建立数据库，能够从开发人员命令提示符调用如下命令，该命令建立名为InitMenuCards的迁移：

>dotnet ef migrations add InitMenuCards

命令migrations add使用反射以及相反的引用模型访问DbContext派生类。此信息建立两个类来建立和更新数据库。使用Menu，MenuCard和MenusContext类建立两个类，MenusContextModelSnapshot和InitMenuCards。命令成功后能够在Migrations文件夹中找到这两种类型。

MenusContextModelSnapshot类包含构建数据库的模型的当前状态：

[DbContext(typeof(MenusContext))] partial class MenusContextModelSnapshot: ModelSnapshot { protected override void BuildModel(ModelBuilder modelBuilder) { modelBuilder .HasAnnotation("ProductVersion","7.0.0-rc1-16348") .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn); modelBuilder.Entity("MenusSample.Menu", b => { b.Property<int>("MenuId") .ValueGeneratedOnAdd(); b.Property<int>("MenuCardId"); b.Property<decimal>("Price"); b.Property<string>("Text"); b.HasKey("MenuId"); }); modelBuilder.Entity("MenusSample.MenuCard", b => { b.Property<int>("MenuCardId") .ValueGeneratedOnAdd(); b.Property<string>("Title"); b.HasKey("MenuCardId"); }); modelBuilder.Entity("MenusSample.Menu", b => { b.HasOne("MenusSample.MenuCard") .WithMany() .HasForeignKey("MenuCardId"); }); } }

InitMenuCards类定义了Up和Down方法。 Up方法列出了建立MenuCard和菜单表所需的全部操做，包括主键、列和关系。 Down方法删除两个表：

public partial class InitMenuCards: Migration
{
  protected override void Up(MigrationBuilder migrationBuilder)
  {
    migrationBuilder.CreateTable(
      name:"MenuCard",
      columns: table => new
      {
        MenuCardId = table.Column<int>(nullable: false)
          .Annotation("SqlServer:ValueGenerationStrategy",
            SqlServerValueGenerationStrategy.IdentityColumn),
        Title = table.Column<string>(nullable: true)
      },
      constraints: table =>
      {
        table.PrimaryKey("PK_MenuCard", x => x.MenuCardId);
      });
 
    migrationBuilder.CreateTable(
      name:"Menu",
      columns: table => new
      {
        MenuId = table.Column<int>(nullable: false)
          .Annotation("SqlServer:ValueGenerationStrategy",
            SqlServerValueGenerationStrategy.IdentityColumn),
        MenuCardId = table.Column<int>(nullable: false),
        Price = table.Column<decimal>(nullable: false),
        Text = table.Column<string>(nullable: true)
      },
      constraints: table =>
      {
        table.PrimaryKey("PK_Menu", x => x.MenuId);
        table.ForeignKey(
          name:"FK_Menu_MenuCard_MenuCardId",
          column: x => x.MenuCardId,
          principalTable:"MenuCard",
          principalColumn:"MenuCardId",
          onDelete: ReferentialAction.Cascade);
      });
  }
 
  protected override void Down(MigrationBuilder migrationBuilder)
  {
    migrationBuilder.DropTable("Menu");
    migrationBuilder.DropTable("MenuCard");
  }
}

注意 正在进行的每一个更改均可以建立另外一个迁移。新迁移仅定义从先前版本到新版本所需的更改。若是客户的数据库须要从任意早期的版本更新，迁移数据库时调用必要的迁移。 

在开发过程当中，也行不须要全部的迁移，可能须要从项目中建立，由于可能没有该类临时状态的数据库存在。在这种状况下能够删除迁移并建立一个较大的新迁移。

使用MSBuild进行迁移  

若是您正在使用基于MSBuild的项目Entity Framework迁移而不是DNX，迁移命令是不一样的。使用完整框架控制台应用程序、WPF应用程序或ASP.NET 4.6项目类型，须要在NuGet包管理器控制台中指定迁移命令，而不是开发人员命令提示符。从Visual Studio经过 工具➪库管理器控制台➪包管理器控制台 启动包管理器控制台。

在包管理器控制台可使用PowerShell脚本添加和删除迁移。命令以下

> Add-Migration InitMenuCards

建立一个Migrations文件夹，其中包含如前所示的迁移类。

建立数据库 

随着迁移类型到位，能够建立数据库。 DbContext派生类MenusContext包含一个返回DatabaseFacade对象的Database属性。使用DatabaseFacade能够建立和删除数据库。若是数据库不存在，EnsureCreated方法会建立数据库；若是数据库已存在，则不执行任何操做。方法EnsureDeletedAsync删除数据库。如下代码片断建立数据库（若是它不存在）（代码文件MenusSample / Program.cs）：

private static async Task CreateDatabaseAsync()
{
  using (var context = new MenusContext())
  {
bool created = await context.Database.EnsureCreatedAsync();
    string createdText = created ?"created":"already exists";
    WriteLine($"database {createdText}");
  }
}

注意 若是数据库存在可是一个较旧的结构版本，EnsureCreatedAsync方法不会应用结构更改。这时能够经过调用Migrate方法来进行结构升级。 Migrate是Microsoft.Data.Entity命名空间中定义的DatabaseFacade类的扩展方法。

运行程序将建立表MenuCard和Menu。基于默认约定，表与实体类型是相同的名称。另外一个约定用于建立主键：MenuCardId列会被定义为主键，由于属性名以Id结束。

CREATE TABLE [dbo].[MenuCard] (
  [MenuCardId] INT            IDENTITY (1, 1) NOT NULL,
  [Title]      NVARCHAR (MAX) NULL,
  CONSTRAINT [PK_MenuCard] PRIMARY KEY CLUSTERED ([MenuCardId] ASC)
);

Menu表定义了MenuCardId，它是MenuCard表的外键。因为DELETE CASCADE，删除MenuCard也会删除全部关联的Menu行：

CREATE TABLE [dbo].[Menu] (
  [MenuId]     INT             IDENTITY (1, 1) NOT NULL,
  [MenuCardId] INT             NOT NULL,
  [Price]      DECIMAL (18, 2) NOT NULL,
  [Text]       NVARCHAR (MAX)  NULL,
  CONSTRAINT [PK_Menu] PRIMARY KEY CLUSTERED ([MenuId] ASC),
  CONSTRAINT [FK_Menu_MenuCard_MenuCardId] FOREIGN KEY ([MenuCardId])
  REFERENCES [dbo].[MenuCard] ([MenuCardId]) ON DELETE CASCADE
);

在建立代码中有一些部分改变是有用的。例如，Text 和 Title 列的大小能够从NVARCHAR（MAX）减少，SQL Server定义了可用于Price列的Money类型，而且结构名称能够从dbo更改。 Entity Framework提供了两个选项从代码中执行这些更改：数据批注和Fluent API，下面将讨论。

数据批注

影响生成的数据库的一种方法是向实体类型添加数据注释。能够利用Table属性更改表的名称。要更改结构名称，Table属性定义Schema属性。若是要为字符串类型指定不一样的长度，可使用MaxLength属性（代码文件MenusWithDataAnnotations / MenuCard.cs）：

[Table("MenuCards", Schema ="mc")]
public class MenuCard
{
  public int MenuCardId { get; set; }
  [MaxLength(120)]
  public string Title { get; set; }
  public List<Menu> Menus { get; }
}

Menu类的Table和MaxLength属性一样能够应用。使用Column属性更改SQL类型（代码文件MenusWithDataAnnotations / Menu.cs）：

[Table("Menus", Schema ="mc")]
public class Menu
{
  public int MenuId { get; set; }
  [MaxLength(50)]
  public string Text { get; set; }
  [Column(TypeName ="Money")]
  public decimal Price { get; set; }
  public int MenuCardId { get; set; }
  public MenuCard MenuCard { get; set; }
}

应用迁移建立数据库后能够看到结构名称下表的新名称，以及Title、Text 和 Price 字段中已更改的数据类型：

CREATE TABLE [mc].[MenuCards] (
  [MenuCardId] INT            IDENTITY (1, 1) NOT NULL,
  [Title]      NVARCHAR (120) NULL,
  CONSTRAINT [PK_MenuCard] PRIMARY KEY CLUSTERED ([MenuCardId] ASC)
);
 
CREATE TABLE [mc].[Menus] (
  [MenuId]     INT           IDENTITY (1, 1) NOT NULL,
  [MenuCardId] INT           NOT NULL,
  [Price]      MONEY         NOT NULL,
  [Text]       NVARCHAR (50) NULL,
  CONSTRAINT [PK_Menu] PRIMARY KEY CLUSTERED ([MenuId] ASC),
  CONSTRAINT [FK_Menu_MenuCard_MenuCardId] FOREIGN KEY ([MenuCardId])
    REFERENCES [mc].[MenuCards] ([MenuCardId]) ON DELETE CASCADE
);

Fluent API  

影响建立的表的另外一种方法是使用Fluent API中DbContext派生类的OnModelCreating方法。它的优势是能够保持实体类型简单，而不添加任何属性，Fluent API还提供了比应用属性更多的选项。 

如下代码片断显示了BooksContext类重写OnModelCreating方法。做为参数接收的ModelBuilder类提供了一些方法，并定义了几种扩展方法。 HasDefaultSchema是其中一个扩展方法，它将默认结构应用于目前全部类型的模型。 Entity方法返回一个EntityTypeBuilder，使您可以自定义实体，例如将其映射到特定的表名和定义键和索引（代码文件MenusSample / MenusContext.cs）：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
  base.OnModelCreating(modelBuilder);
 
  modelBuilder.HasDefaultSchema("mc");
 
  modelBuilder.Entity<MenuCard>()
    .ToTable("MenuCards")
    .HasKey(c => c.MenuCardId);
 
  // etc.
 
  modelBuilder.Entity<Menu>()
    .ToTable("Menus")
    .HasKey(m => m.MenuId);
 
  // etc.
}

EntityTypeBuilder定义了一个Property方法来配置属性。 Property方法返回PropertyBuilder，可以依次配置具备最大长度值，必要的设置和SQL类型的属性，并指定是否应自动生成值（例如标识列）：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
  // etc.
 
  modelBuilder.Entity<MenuCard>()
    .Property<int>(c => c.MenuCardId)
    .ValueGeneratedOnAdd();
 
  modelBuilder.Entity<MenuCard>()
    .Property<string>(c => c.Title)
    .HasMaxLength(50);
 
  modelBuilder.Entity<Menu>()
    .Property<int>(m => m.MenuId)
    .ValueGeneratedOnAdd();
 
  modelBuilder.Entity<Menu>()
.Property<string>(m => m.Text)
    .HasMaxLength(120);
 
  modelBuilder.Entity<Menu>()
    .Property<decimal>(m => m.Price)
    .HasColumnType("Money");
 
  // etc.
} 

EntityTypeBuilder定义映射方法去定义一对多映射。HasMany 结合 WithOne 方法定义了多Menus 和一个Menu Card 的映射。 HasMany须要与WithOne连接，即HasOne方法须要一个带WithMany或WithOne的链。连接 HasOne 和 WithMany定义了一对多关系，连接HasOne与WithOne定义了一对一的关系：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
  // etc.
 
  modelBuilder.Entity<MenuCard>()
    .HasMany(c => c.Menus)
    .WithOne(m => m.MenuCard);
  modelBuilder.Entity<Menu>()
    .HasOne(m => m.MenuCard)
    .WithMany(c => c.Menus)
    .HasForeignKey(m => m.MenuCardId);
}

在OnModelCreating方法中建立映射以后能够建立如前所示的迁移。

从数据库建立模型  

从模型能够建立数据库，相反从数据库也能够建立模型。 

要从SQL Server数据库执行此操做，除了其余包，还必须将NuGet包添加到DNX项目中，EntityFramework.MicrosoftSqlServer.Design。而后能够在开发人员命令提示符使用如下命令：

> dnx ef dbcontext scaffold 
"server=(localdb)\MSSQLLocalDb;database=SampleDatabase; trusted_connection=true""EntityFramework.MicrosoftSqlServer"

dbcontext命令可以从项目中列出DbContext对象，同时也建立DBContext对象。命令scaffold建立DbContext派生类以及模型类。 dnx ef dbcontext scaffold 须要两个必要的参数：数据库的链接字符串和使用的提供程序。前面所示的语句中，在SQL Server（localdb）\ MSSQLLocalDb上访问数据库SampleDatabase。使用的提供程序是EntityFramework.MicrosoftSqlServer。这个NuGet包以及具备相同名称和设计后缀的NuGet包必须添加到项目中。 

运行此命令后，能够看到DbContext派生类以及生成的模型类型。默认状况下，模型的配置使用fluent API完成。可是也能够将其更改成使用提供-a选项的数据批注。还能够影响生成的上下文类名称以及输出目录。只需使用选项-h检查不一样的可用选项。

 

----------------未完待续