第七章 SportsStore: 模型的扩展

 

 

在本章中，我将扩展SportsStore应用程序的数据模型，不再只是一个Product类。我将定义一个单独的Category类替换Product类中用一个字符串属性来做分类，并解释如何在创建数据之后访问数据。我还添加了Order订单，这是任何在线商店的重要组成部分。

 

7.1 准备工作

在本章中，我将继续使用SportsStore项目。我把创建和编辑产品对象的过程合并到一个视图中。如清单7-1所示。我在Home控制器中合并了添加或更新产品对象的操作方法，并删除了执行批量更新的操作（Action方法）。

小贴士：您可以从本书的GitHub知识库中下载本章的SportsStore项目和其他章节的项目:

https://github.com/apress/pro-ef-core-2-for-asp.net-core-mvc.

//Listing 7-1. Consolidating Actions in the HomeController.cs File in the Controllers Folder
using Microsoft.AspNetCore.Mvc;
using SportsStore.Models;
namespace SportsStore.Controllers
{
    public class HomeController : Controller
    {
        private IRepository repository;
        public HomeController(IRepository repo) => repository = repo;
        public IActionResult Index()
        {
            return View(repository.Products);
        }
        public IActionResult UpdateProduct(long key)
        {//请求UpdateProduct视图
            return View(key == 0 ? new Product() : repository.GetProduct(key));
        }

        [HttpPost]
        public IActionResult UpdateProduct(Product product)
        {//HTTP POST方法，请求修改或者创建Product对象
            if (product.Id == 0)
            {
                repository.AddProduct(product);
            }
            else
            {
                repository.UpdateProduct(product);
            }
            return RedirectToAction(nameof(Index));
        }

        [HttpPost]
        public IActionResult Delete(Product product)
        {
            repository.Delete(product);
            return RedirectToAction(nameof(Index));
        }
    }
}

　　合并操作依赖于long属性的值，以确定用户是希望修改现有对象还是创建新对象。在清单7-2中，我更新了Index视图以反映控制器中的更改。

Listing 7-2. Reflecting Controller Changes in the Index.cshtml File in the Views/Home Folder
@model IEnumerable<Product>
<h3 class="p-2 bg-primary text-white text-center">Products</h3>
<div class="container-fluid mt-3">
    <div class="row">
        <div class="col-1 font-weight-bold">Id</div>
        <div class="col font-weight-bold">Name</div>
        <div class="col font-weight-bold">Category</div>
        <div class="col font-weight-bold text-right">Purchase Price</div>
        <div class="col font-weight-bold text-right">Retail Price</div>
        <div class="col"></div>
    </div>
    @foreach (Product p in Model)
    {
        <div class="row p-2">
            <div class="col-1">@p.Id</div>
            <div class="col">@p.Name</div>
            <div class="col">@p.Category</div>
            <div class="col text-right">@p.PurchasePrice</div>
            <div class="col text-right">@p.RetailPrice</div>
            <div class="col">
                <form asp-action="Delete" method="post">
                    <a asp-action="UpdateProduct" asp-route-key="@p.Id"
                       class="btn btn-outline-primary">
                        Edit
                    </a>
                    <input type="hidden" name="Id" value="@p.Id" />
                    <button type="submit" class="btn btn-outline-danger">
                        Delete
                    </button>
                </form>
            </div>
        </div>
    }
    <div class="text-center p-2">
        <a asp-action="UpdateProduct" asp-route-key="0"
           class="btn btn-primary">Add</a>
    </div>
</div>

　　在SportsStore项目文件夹中运行清单7-3所示的命令来删除和重新创建数据库，这将有助于确保您从示例中获得预期的结果。

Listing 7-3. Deleting and Re-creating the Database
dotnet ef database drop --force
dotnet ef database update

　　使用dotnet run启动应用程序并导航到http://localhost:5000;您将看到如图7-1所示的内容。不要向数据库添加任何数据，因为下一节将使用新的迁移更新数据库，如果现在添加数据，后面将产生异常。

 

7.2 创建数据模型关联

目前，创建的每个Product对象都有一个Category属性，该值是一个字符串。在实际的项目中，输入手误会给产品指定意外的Category。为了避免这类问题，可以使用关联来规范应用程序的数据，这可以减少重复并确保一致性，我将在下面的小节中演示这一点。

7.2.1 添加数据模型Categories 类

下面创建一个新的数据模型类。我添加了一个Category.cs文件。并使用它来定义如清单7-4所示的类。

//Listing 7-4. The Contents of the Category.cs File in the Models Folder
namespace SportsStore.Models {
    public class Category {
    public long Id { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }
  }
}

　　Category类表示产品的一个分类。Id属性是主键属性，当在数据库中创建和存储新分类时，用户要提供名称和描述属性。

 

7.2.2 创建关联

下一步是在两个数据模型类（Category与Product）之间创建关系，这是通过向其中一个类添加属性来完成的。在任何数据关系中，其中一个类称为有依赖的实体，属性就是添加到这个类中的。要确定哪一个类是有依赖的实体，请自问哪些类不可能存在（这个就是有依赖的类），如果没有某类；哪些类可以独立存在。在SportsStore应用程序中，一个Category 能够独立存在（有没有Product无所谓），但是每个Product对象都得有一个Category分类——这意味着，Product类是有依赖的实体类。在清单7-5中，我向Product类添加了两个属性，它们创建了与Category类的关系。

译者述：有依赖的实体类，对应于那些有外键列的表。

小贴士：如果此时搞不懂如何分辨出有依赖的实体，不要担心。我将在第14章中更详细地讨论这个主题，随着您对EF Core有了更多的经验，您将对这个概念更加熟悉。

//Listing 7-5. Adding Relationship Properties in the Product.cs File in the Models Folder
namespace SportsStore.Models
{
    public class Product
    {
        public long Id { get; set; }
        public string Name { get; set; }
        //public string Category { get; set; }
        public decimal PurchasePrice { get; set; }
        public decimal RetailPrice { get; set; }
        public long CategoryId { get; set; }
        public Category Category { get; set; }
    }
}

　　我添加的第一个属性称为CategoryId，它是Product类的外键属性，存储的是Category表的主键值。EF Core通过外键属性跟踪Product对象与Category对象的关联。外键属性的名称由类名和主键属性名组成，这就是我如何得到CategoryId的。

　　第二个属性替换现有的Category属性，它是导航属性。该属性指向一个Category对象，其主键Id与CategoryId的值保持一致，这使得处理数据库中的数据更加自然。

 

7.2.3 修改上下文，创建仓储

为了访问Category对象，我在数据库上下文类中添加了一个DbSet<T>属性，如清单7-6所示。

//Listing 7-6. Adding a Property in the DataContext.cs File in the Models Folder
using Microsoft.EntityFrameworkCore;
namespace SportsStore.Models 
{
        public class DataContext : DbContext 
       {
              public DataContext(DbContextOptions<DataContext> opts) : base(opts) {}
              public DbSet<Product> Products { get; set; }
              public DbSet<Category> Categories { get; set; }
        }
}

　　新属性遵循与现有属性相同的模式:它是一个带有get和set访问器的public属性，它返回DbSet<T>，其中T是我想存储在数据库中的类。

　　在扩展数据模型时，可以向现有仓储添加成员或创建新仓储，为应用程序的其余部分提供对新数据类型的访问。对于SportsStore应用程序，我将创建一个单独的仓储来演示它是如何实现的。我添加了一个类文件CategoryRepository.cs。并在其中定义接口和实现类，如清单7-7所示。

//Listing 7-7. The Contents of the CategoryRepository.cs File in the Models Folder
using System.Collections.Generic;
namespace SportsStore.Models
{
    public interface ICategoryRepository
    {
        IEnumerable<Category> Categories { get; }

        void AddCategory(Category category);
        void UpdateCategory(Category category);
        void DeleteCategory(Category category);
    }
    public class CategoryRepository : ICategoryRepository
    {
        private DataContext context;
        public CategoryRepository(DataContext ctx) => context = ctx;
        public IEnumerable<Category> Categories => context.Categories;
        public void AddCategory(Category category)
        {
            context.Categories.Add(category);
            context.SaveChanges();
        }
        public void UpdateCategory(Category category)
        {
            context.Categories.Update(category);
            context.SaveChanges();
        }
        public void DeleteCategory(Category category)
        {
            context.Categories.Remove(category);
            context.SaveChanges();
        }
    }
}

　　我在这个文件中定义了仓储接口和实现类，并使用最简单的方法执行更新，而不依赖于更改侦测功能。在清单7-8中，我在Startup类中注册绑定仓储接口及其实现，以便与依赖项注入特性一起使用。

//Listing 7-8. Registering a Repository in the Startup.cs File in the SportsStore Folder
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using SportsStore.Models;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
namespace SportsStore
{
    public class Startup
    {
        public Startup(IConfiguration config) => Configuration = config;
        public IConfiguration Configuration { get; }
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc();
            services.AddTransient<IRepository, DataRepository>();
            services.AddTransient<ICategoryRepository, CategoryRepository>();
            string conString = Configuration["ConnectionStrings:DefaultConnection"];
            services.AddDbContext<DataContext>(options =>
            options.UseSqlServer(conString));
        }
        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            app.UseDeveloperExceptionPage();
            app.UseStatusCodePages();
            app.UseStaticFiles();
            app.UseMvcWithDefaultRoute();
        }
    }
}

 

7.2.4 创建和应用迁移

只有更新数据库以匹配数据模型中的更改之后，实体框架核心才能存储Category 对象。要更新数据库，必须创建新的迁移并将其应用到数据库，这是通过在SportsStore项目文件夹中运行清单7-9所示的命令来完成的。

小贴士：如果在运行dotnet ef database update 命令时出现异常，那么可能的原因是在运行清单7-3中的命令后向数据库添加了产品数据。再次运行清单7-3中的命令，数据库将被重置并更新到清单7-9中创建的迁移。

 

Listing 7-9. Creating and Applying a Database Migration
dotnet ef migrations add Categories
dotnet ef database update

 

第一个命令创建一个名为Categories的新迁移，它将包含准备数据库存储新对象所需的命令。第二个命令执行这些命令来更新数据库。

 

 

7.2.5 创建控制器和视图

我已经在Product和Category类之间创建了一个关联（外键属性&导航属性），这意味着每个产品都必须与一个Category对象相关联。通过这种关系，可以为用户提供管理数据库中Category对象的途径。我添加了一个类文件CategoriesController.cs到Controllers文件夹，并使用它创建如清单7-10所示的控制器。

小贴士：关联的另一种方案是可选关联，其中Product对象可以与Category对象相关联，也可以不关联。我将在第2部分详细解释如何创建这两种关系。

//Listing 7-10. The Contents of the CategoriesController.cs File in the Controllers Folder
using Microsoft.AspNetCore.Mvc;
using SportsStore.Models;
namespace SportsStore.Controllers
{
    public class CategoriesController : Controller
    {
        private ICategoryRepository repository;
        public CategoriesController(ICategoryRepository repo) => repository = repo;
        public IActionResult Index() => View(repository.Categories);
        [HttpPost]
        public IActionResult AddCategory(Category category)
        {
            repository.AddCategory(category);
            return RedirectToAction(nameof(Index));
        }
        public IActionResult EditCategory(long id)
        {
            ViewBag.EditId = id;
            return View("Index", repository.Categories);
        }
        [HttpPost]
        public IActionResult UpdateCategory(Category category)
        {
            repository.UpdateCategory(category);
            return RedirectToAction(nameof(Index));
        }
        [HttpPost]
        public IActionResult DeleteCategory(Category category)
        {
            repository.DeleteCategory(category);
            return RedirectToAction(nameof(Index));
        }
    }
}

　　Categories控制器的构造函数接收一个Category仓储，该仓储用来访问Category数据。并定义了从数据库查询、创建、更新和删除Category对象的操作（Action方法）。为了向控制器提供视图，我在Views/Categories文件夹下添加了一个Index.cshtml 文件，内容如如清单7-11所示。

Listing 7-11. The Contents of the Index.cshtml File in the Views/Categories Folder
@model IEnumerable<Category>
<h3 class="p-2 bg-primary text-white text-center">Categories</h3>
<div class="container-fluid mt-3">
    <div class="row">
        <div class="col-1 font-weight-bold">Id</div>
        <div class="col font-weight-bold">Name</div>
        <div class="col font-weight-bold">Description</div>
        <div class="col-3"></div>
    </div>
    @if (ViewBag.EditId == null)
    {
        <form asp-action="AddCategory" method="post">
            @Html.Partial("CategoryEditor", new Category())
        </form>
    }
    @foreach (Category c in Model)
    {
        @if (c.Id == ViewBag.EditId)
        {
            <form asp-action="UpdateCategory" method="post">
                <input type="hidden" name="Id" value="@c.Id" />
                @Html.Partial("CategoryEditor", c)
            </form>
        }
        else
        {
            <div class="row p-2">
                <div class="col-1">@c.Id</div>
                <div class="col">@c.Name</div>
                <div class="col">@c.Description</div>
                <div class="col-3">
                    <form asp-action="DeleteCategory" method="post">
                        <input type="hidden" name="Id" value="@c.Id" />
                        <a asp-action="EditCategory" asp-route-id="@c.Id"
                           class="btn btn-outline-primary">Edit</a>
                        <button type="submit" class="btn btn-outline-danger">
                            Delete
                        </button>
                    </form>
                </div>
            </div>
        }
    }
</div>

这个视图提供了管理Category的一体式界面。并将创建和编辑对象丢给一个分部视图。为了创建分部视图，我添加了一个CategoryEditor.cshtml文件到Views/Category文件夹，并添加了如清单7-12所示的内容。

Listing 7-12. The Contents of the CategoryEditor.cshtml File in the Views/Categories Folder
@model Category
<div class="row p-2">
    <div class="col-1"></div>
    <div class="col">
        <input asp-for="Name" class="form-control" />
    </div>
    <div class="col">
        <input asp-for="Description" class="form-control" />
    </div>
    <div class="col-3">
        @if (Model.Id == 0)
        {
            <button type="submit" class="btn btn-primary">Add</button>
        }
        else
        {
            <button type="submit" class="btn btn-outline-primary">Save</button>
            <a asp-action="Index" class="btn btn-outline-secondary">Cancel</a>
        }
    </div>
</div>

为了便于在应用程序中切换，我将清单7-13中所示的元素添加到共享布局中。

Listing 7-13. Adding Elements in the _Layout.cshtml File in the Views/Shared Folder
<!DOCTYPE html>
<html>
<head>
    <meta name="viewport" content="width=device-width" />
    <title>SportsStore</title>
    <link rel="stylesheet" href="~/lib/bootstrap/dist/css/bootstrap.min.css" />
    <style>
        .placeholder {
            visibility: collapse;
            display: none
        }

            .placeholder:only-child {
                visibility: visible;
                display: flex
            }
    </style>
</head>
<body>
    <div class="container-fluid">
        <div class="row p-2">
            <div class="col-2">
                <a asp-controller="Home" asp-action="Index"
                   class="@GetClassForButton("Home")">
                    Products
                </a>
                <a asp-controller="Categories" asp-action="Index"
                   class="@GetClassForButton("Categories")">
                    Categories
                </a>
            </div>
            <div class="col">
                @RenderBody()
            </div>
        </div>
    </div>
</body>
</html>
@functions 
{
    string GetClassForButton(string controller)
    {
        return "btn btn-block " + (ViewContext.RouteData.Values["controller"]
        as string == controller ? "btn-primary" : "btn-outline-primary");
    }
}

我添加了一些按钮，这些按钮通过一个简单的内联函数选择产品和类别控制器，该函数使用Bootstrap CSS
样式突出显示当前显示的控制器的按钮。

注意：我不经常使用内置razor函数，因为我更喜欢将所有的c#代码放在类文件中。但是在这种情况下，该函数的优点是保持示例的简洁，并且它只与视图中的内容相关，并且比创建视图组件更容易。

 

7.2.6 将Categories 数据输入到数据库

在完成数据关联时，使用一些数据是很有帮助的。使用dotnet run启动应用程序，单击Categories按钮，并使用表7-1中的值在HTML表单中创建Category。

当您添加了所有这三个Category之后，您应该会看到如图7-2所示的内容。

 

7.3 使用数据关联

必须更新应用程序中处理产品对象的部分，以反映数据库中的新关系（Product与Category）。这个过程包括两部分:在查询数据库时包含类别数据，在创建或编辑产品时允许用户选择类别。

7.3.1 处理相关数据

EF Core会忽略关联，除非您显式地在查询中include它们。这意味着导航属性(如Product类定义的Category属性)默认为null。Include扩展方法告诉EF Core使用相关数据填充导航属性，并在表示SQL查询的IQueryable<T>对象上调用该Include方法。在清单7-14中，我使用Include方法在产品仓储执行的查询中include相关的类别对象。

//Listing 7-14. Including Related Data in the DataRepository.cs File in the Models Folder
using System.Collections.Generic;
using System.Linq;
using Microsoft.EntityFrameworkCore;
namespace SportsStore.Models
{
    public class DataRepository : IRepository
    {
        private DataContext context;
        public DataRepository(DataContext ctx) => context = ctx;
        public IEnumerable<Product> Products => context.Products
        　　.Include(p => p.Category).ToArray();
        public Product GetProduct(long key) => context.Products
        　　.Include(p => p.Category).First(p => p.Id == key);

        public void AddProduct(Product product)
        {
            context.Products.Add(product);
            context.SaveChanges();
        }
        public void UpdateProduct(Product product)
        {
            Product p = context.Products.Find(product.Id);
            p.Name = product.Name;
            //p.Category = product.Category;
            p.PurchasePrice = product.PurchasePrice;
            p.RetailPrice = product.RetailPrice;
            p.CategoryId = product.CategoryId;
            context.SaveChanges();
        }
        public void UpdateAll(Product[] products)
        {
            Dictionary<long, Product> data = products.ToDictionary(p => p.Id);
            IEnumerable<Product> baseline =
            context.Products.Where(p => data.Keys.Contains(p.Id));
            foreach (Product databaseProduct in baseline)
            {
                Product requestProduct = data[databaseProduct.Id];
                databaseProduct.Name = requestProduct.Name;
                databaseProduct.Category = requestProduct.Category;
                databaseProduct.PurchasePrice = requestProduct.PurchasePrice;
                databaseProduct.RetailPrice = requestProduct.RetailPrice;
            }
            context.SaveChanges();
        }
        public void Delete(Product product)
        {
            context.Products.Remove(product);
            context.SaveChanges();
        }
    }
}

　　Include方法在Microsoft.EntityFrameworkCore命名空间中定义，它接受lambda表达式，在该lambda中选择一个导航属性（您希望EF Core把它include到查询中的那个导航属性）。我在GetProduct方法中使用的Find方法不能与Include方法一起使用，所以我将它替换为First方法，可以达到相同的效果。这些更改的结果是EF Core将为Products属性和GetProduct方法创建的产品对象，填充其Product.Category 导航属性。

　　请注意我对UpdateProduct方法所做的更改。首先，我直接查询baseline基线数据，而不是通过GetProduct方法，因为我不想在执行更新时加载关联数据。其次，我注释掉了Category属性的赋值语句，并添加了一个CategoryId属性的赋值语句。要让EF Core更新数据库中两个对象之间的关联，你要做的全部工作就是对外键属性赋值（或者更改赋值）。

译者述：你更改外键属性CategoryId的值（是个整数），Update到数据库之后就是修改了Product表的CategoryId外键值。下次查询该Product记录，得到的Category导航属性，自然引用新指定的Category对象。

 

7.3.2 为Product选择Category分类

在清单7-15中，我更新了Home控制器，使其能够通过仓储访问Category 数据，并将数据传递给视图。这将允许视图在编辑或创建产品对象时从完整的Category集合中进行选择。

//Listing 7-15. Using Category Data in the HomeController.cs File in the Controllers Folder
using Microsoft.AspNetCore.Mvc;
using SportsStore.Models;
namespace SportsStore.Controllers
{
    public class HomeController : Controller
    {
        private IRepository repository;
        private ICategoryRepository catRepository;
        
        public HomeController(IRepository repo, ICategoryRepository catRepo)
        {
            repository = repo;
            catRepository = catRepo;
        }
        public IActionResult Index()
        {
            return View(repository.Products);
        }
        
        public IActionResult UpdateProduct(long key)
        {
            ViewBag.Categories = catRepository.Categories;
            return View(key == 0 ? new Product() : repository.GetProduct(key));
        }
        
        [HttpPost]
        public IActionResult UpdateProduct(Product product)
        {
            if (product.Id == 0)
            {
                repository.AddProduct(product);
            }
            else
            {
                repository.UpdateProduct(product);
            }
            return RedirectToAction(nameof(Index));
        }
       
        [HttpPost]
        public IActionResult Delete(Product product)
        {
            repository.Delete(product);
            return RedirectToAction(nameof(Index));
        }
    }
}

为了允许用户在创建或编辑产品时选择一个类别，我在UpdateProduct视图中添加了一个select元素，如清单7-16所示。

Listing 7-16. Displaying Categories in the UpdateProduct.html File in the Views/Home Folder
@model Product
<h3 class="p-2 bg-primary text-white text-center">Update Product</h3>
<form asp-action="UpdateProduct" method="post">
    <div class="form-group">
        <label asp-for="Id"></label>
        <input asp-for="Id" class="form-control" readonly />
    </div>
    <div class="form-group">
        <label asp-for="Name"></label>
        <input asp-for="Name" class="form-control" />
    </div>
    <div class="form-group">
        <label asp-for="Category"></label>
        <select class="form-control" asp-for="CategoryId">
            @if (Model.Id == 0)
            {
                <option disabled selected>Choose Category</option>
            }
            @foreach (Category c in ViewBag.Categories)
            {
                <option selected=@(Model.Category?.Id == c.Id)
                        value="@c.Id">
                    @c.Name
                    </option>
                }
        </select>
    </div>
    <div class="form-group">
        <label asp-for="PurchasePrice"></label>
        <input asp-for="PurchasePrice" class="form-control" />
    </div>
    <div class="form-group">
        <label asp-for="RetailPrice"></label>
        <input asp-for="RetailPrice" class="form-control" />
    </div>
    <div class="text-center">
        <button class="btn btn-primary" type="submit">Save</button>
        <a asp-action="Index" class="btn btn-secondary">Cancel</a>
    </div>
</form>

　　如果视图用于创建新产品对象，我引入一个占位符option元素；如果正在编辑现有对象，则使用Razor表达式应用selected 特性。

　　剩下的就是更新Index视图，使其遵循导航属性，为每个产品对象显示选中分类的名称，如清单7-17所示。

Listing 7-17. Following a Navigation Property in the Index.cshtml File in the Views/Home Folder
@model IEnumerable<Product>
<h3 class="p-2 bg-primary text-white text-center">Products</h3>
<div class="container-fluid mt-3">
    <div class="row">
        <div class="col-1 font-weight-bold">Id</div>
        <div class="col font-weight-bold">Name</div>
        <div class="col font-weight-bold">Category</div>
        <div class="col font-weight-bold text-right">Purchase Price</div>
        <div class="col font-weight-bold text-right">Retail Price</div>
        <div class="col"></div>
    </div>
    @foreach (Product p in Model)
    {
        <div class="row p-2">
            <div class="col-1">@p.Id</div>
            <div class="col">@p.Name</div>
            <div class="col">@p.Category.Name</div>
            <div class="col text-right">@p.PurchasePrice</div>
            <div class="col text-right">@p.RetailPrice</div>
            <div class="col">
                <form asp-action="Delete" method="post">
                    <a asp-action="UpdateProduct" asp-route-key="@p.Id"
                       class="btn btn-outline-primary">
                        Edit
                    </a>
                    <input type="hidden" name="Id" value="@p.Id" />
                    <button type="submit" class="btn btn-outline-danger">
                        Delete
                    </button>
                </form>
            </div>
        </div>
    }
    <div class="text-center p-2">
        <a asp-action="UpdateProduct" asp-route-key="0"
           class="btn btn-primary">Add</a>
    </div>
</div>

 

 

7.3.3 创建和编辑带有类别的产品

使用dotnet run启动应用程序，导航到http://localhost:5000，单击Add按钮，在form表单输入表7-2所示的数据，创建产品对象。在创建每个对象时，使用select元素从列表中选择类别。

在创建每个对象时，Index操作（Action方法）会被执行来显示结果，这将导致实体框架核心去数据库查询Product数据及其关联的Category对象。通过检查应用程序生成的日志消息，您可以看到如何将其转换为SQL语句，如下所示:

...
SELECT [p].[Id], [p].[CategoryId], [p].[Name], [p].[PurchasePrice],
[p].[RetailPrice], [p.Category].[Id], [p.Category].[Description],
[p.Category].[Name]
FROM [Products] AS [p]
INNER JOIN [Categories] AS [p.Category] ON [p].[CategoryId] = [p.Category].[Id]
...

　　为了给每个Product对象创建Category对象，实体框架核心使用外键来查询Category的数据，并使用inner join语句来连接产品和类别表的数据。

　　创建三个产品对象之后，单击Categories，单击Watersports 类别的编辑按钮，并将名称字段的值更改为Aquatics 。单击Save按钮，再单击Products。您将看到编辑类别中的两个产品对象都显示了新名称，如图7-3所示。

小心：如果删除类别对象，则与之相关联的产品对象也全被删除，这是关联的默认配置。我将在第22章中解释它的工作原理和其他配置选项。

 

7.4 添加Order订单类

为了演示更复杂的关联，我将添加创建和存储订单的功能，并使用它们来表示客户选择的产品。在下面的小节中，我将添加更多的实体类扩展数据模型，更新数据库，并添加一个控制器来管理新数据。

 

7.4.1 创建数据模型Order类

我首先添加了一个名为Order.cs的文件。并使用它来定义清单7-18所示的类。

//Listing 7-18. The Contents of the Order.cs File in the Models Folder
using System.Collections.Generic;
namespace SportsStore.Models
{
    public class Order
    {
        public long Id { get; set; }
        public string CustomerName { get; set; }
        public string Address { get; set; }
        public string State { get; set; }
        public string ZipCode { get; set; }
        public bool Shipped { get; set; }
        public IEnumerable<OrderLine> Lines { get; set; }
    }
}

　　Order类具有客户名和地址以及产品是否已发货的属性。还有一个导航属性，它提供了对相关OrderLine对象的访问，这些对象将表示一个单独的产品选择。为了创建这个类，我在Models文件夹中添加了一个名为OrderLine.cs的文件。代码如清单7-19所示。

//Listing 7-19. The Contents of the OrderLine.cs File in the Models Folder
namespace SportsStore.Models
{
    public class OrderLine
    {
        public long Id { get; set; }
        public long ProductId { get; set; }
        public Product Product { get; set; }
        public int Quantity { get; set; }
        public long OrderId { get; set; }
        public Order Order { get; set; }
    }
}

每个OrderLine对象都与订单和产品相关，并具有一个属性，该属性指示客户需要多少个该产品。为了方便访问订单数据，我将清单7-20中所示的属性添加到上下文类中。

//Listing 7-20. Adding Properties in the DataContext.cs File in the Models Folder
using Microsoft.EntityFrameworkCore;
namespace SportsStore.Models
{
    public class DataContext : DbContext
    {
        public DataContext(DbContextOptions<DataContext> opts) : base(opts) { }
        public DbSet<Product> Products { get; set; }
        public DbSet<Category> Categories { get; set; }
        public DbSet<Order> Orders { get; set; }
        public DbSet<OrderLine> OrderLines { get; set; }
    }
}

 

7.4.2 创建仓储，准备数据库

为了向应用程序的其余部分提供对新数据的一致访问，我添加了一个名为IOrdersRepository.cs的文件，并定义如清单7-21所示的接口。

//Listing 7-21. The Contents of the IOrdersRepository.cs File in the Models Folder
using System.Collections.Generic;
namespace SportsStore.Models
{
    public interface IOrdersRepository
    {
        IEnumerable<Order> Orders { get; }
        Order GetOrder(long key);
        void AddOrder(Order order);
        void UpdateOrder(Order order);
        void DeleteOrder(Order order);
    }
}

接下来，我添加了一个名为OrdersRepository.cs的文件。并使用它创建实现类，如清单7-22所示。

Listing 7-22. The Contents of the OrdersRepository.cs File in the Models Folder
using Microsoft.EntityFrameworkCore;
using System.Collections.Generic;
using System.Linq;
namespace SportsStore.Models
{
    public class OrdersRepository : IOrdersRepository
    {
        private DataContext context;
        public OrdersRepository(DataContext ctx) => context = ctx;
        public IEnumerable<Order> Orders => context.Orders
        .Include(o => o.Lines).ThenInclude(l => l.Product);
        public Order GetOrder(long key) => context.Orders
        .Include(o => o.Lines).First(o => o.Id == key);
        public void AddOrder(Order order)
        {
            context.Orders.Add(order);
            context.SaveChanges();
        }
        public void UpdateOrder(Order order)
        {
            context.Orders.Update(order);
            context.SaveChanges();
        }
        public void DeleteOrder(Order order)
        {
            context.Orders.Remove(order);
            context.SaveChanges();
        }
    }
}

　　存储库实现遵循其他存储库建立的模式，为了简单起见，放弃使用更改侦测功能。请注意Include和ThenInclude方法的使用，它们用于数据模型间导航，并向查询添加相关数据——我将在第14-16章中详细描述这一过程。

　　在清单7-23中，我向Startup类添加了一条语句，这样依赖项注入系统就可以使用瞬态的OrderRepository对象，注入到IOrderRepository接口的依赖项。

//Listing 7-23. Configuring Dependency Injection in the Startup.cs File in the SportsStore Folder
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using SportsStore.Models;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
namespace SportsStore
{
    public class Startup
    {
        public Startup(IConfiguration config) => Configuration = config;
        public IConfiguration Configuration { get; }
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc();
            services.AddTransient<IRepository, DataRepository>();
            services.AddTransient<ICategoryRepository, CategoryRepository>();
            services.AddTransient<IOrdersRepository, OrdersRepository>();
            string conString = Configuration["ConnectionStrings:DefaultConnection"];
            services.AddDbContext<DataContext>(options =>
            options.UseSqlServer(conString));
        }
        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            app.UseDeveloperExceptionPage();
            app.UseStatusCodePages();
            app.UseStaticFiles();
            app.UseMvcWithDefaultRoute();
        }
    }
}

在SportsStore项目文件夹中运行清单7-24所示的命令，通过创建和应用EF Core的migration迁移，来准备数据库，存储新的数据模型类。

Listing 7-24. Creating and Applying a New Database Migration
dotnet ef migrations add Orders
dotnet ef database update

 

 

7.4.3 创建控制器和视图

所有的EF Core基本工作都已经就绪，可以处理Order对象了。下一步是添加MVC功能，允许创建和管理实例。我添加了一个OrdersController.cs类文件到Controllers文件夹，并使用它来定义如清单7-25所示的控制器。 我暂时没写AddOrUpdateOrder方法的代码，当其他特性就绪时，我将完成该方法。

//Listing 7-25. The Contents of the OrdersController.cs File in the Controllers Folder
using Microsoft.AspNetCore.Mvc;
using SportsStore.Models;
using System.Collections.Generic;
using System.Linq;
namespace SportsStore.Controllers
{
    public class OrdersController : Controller
    {
        private IRepository productRepository;
        private IOrdersRepository ordersRepository;
        public OrdersController(IRepository productRepo,
        　　　　　　IOrdersRepository orderRepo)
        {
            productRepository = productRepo;
            ordersRepository = orderRepo;
        }
        public IActionResult Index() => View(ordersRepository.Orders);
        public IActionResult EditOrder(long id)
        {
            var products = productRepository.Products;
            Order order = id == 0 ? new Order() : ordersRepository.GetOrder(id);
            IDictionary<long, OrderLine> linesMap
                 = order.Lines?.ToDictionary(l => l.ProductId)  //?.操作符，不为null时执行后面的操作
            　　　　　　?? new Dictionary<long, OrderLine>();
            ViewBag.Lines = products.Select(p => linesMap.ContainsKey(p.Id)
            　　　? linesMap[p.Id]
            　　　: new OrderLine { Product = p, ProductId = p.Id, Quantity = 0 });
            return View(order);
        }
        [HttpPost]
        public IActionResult AddOrUpdateOrder(Order order)
        {
            // ...action method to be completed...
            return RedirectToAction(nameof(Index));
        }
        [HttpPost]
        public IActionResult DeleteOrder(Order order)
        {
            ordersRepository.DeleteOrder(order);
            return RedirectToAction(nameof(Index));
        }
    }
}

　　EditOrder操作（Action）方法中的LINQ语句可能看起来比较复杂，但是它们准备了OrderLine数据，以便每个产品都对应一个OrderLine 对象，即使之前没有针对该产品的选择。

　　对于新订单，这意味着ViewBag.Lines 属性将被一系列OrderLine对象填充，与数据库中的每个产品对应，Id和Quantity属性设置为0。当对象存储到数据库中时，零Id值将表明这是一个新对象，数据库服务器将分配一个新的唯一主键值。

　　对于已存在的订单，ViewBag.Lines属性将被数据库中读取的OrderLine对象填充，为剩余产品填充Id属性为零的额外对象。

　　这种结构利用了高级的方式，将ASP.NET Core MVC和EF Core结合在一起，简化了更新数据库的过程，您将在完成示例的其余部分时看到这一点。

　　下一步是创建一个视图，该视图将列出数据库中的所有对象。我创建了Views/Orders文件夹，并向其添加了一个名为Index.cshtml 的文件。内容如清单7-26所示。

//Listing 7-26. The Contents of the Index.cshtml File in the Views/Orders Folder
@model IEnumerable<Order>
<h3 class="p-2 bg-primary text-white text-center">Orders</h3>
<div class="container-fluid mt-3">
    <div class="row">
        <div class="col-1 font-weight-bold">Id</div>
        <div class="col font-weight-bold">Name</div>
        <div class="col font-weight-bold">Zip</div>
        <div class="col font-weight-bold">Total</div>
        <div class="col font-weight-bold">Profit</div>
        <div class="col-1 font-weight-bold">Status</div>
        <div class="col-3"></div>
    </div>
    <div>
        <div class="row placeholder p-2">
            <div class="col-12 text-center">
                <h5>No Orders</h5>
            </div>
        </div>
        @foreach (Order o in Model)
        {
            <div class="row p-2">
                <div class="col-1">@o.Id</div>
                <div class="col">@o.CustomerName</div>
                <div class="col">@o.ZipCode</div>
                <div class="col">
                    @o.Lines.Sum(l => l.Quantity * l.Product.RetailPrice)
                </div>
                <div class="col">
                    @o.Lines.Sum(l => l.Quantity * (l.Product.RetailPrice - l.Product.PurchasePrice))
                </div>
                <div class="col-1">@(o.Shipped ? "Shipped" : "Pending")</div>
                <div class="col-3 text-right">
                    <form asp-action="DeleteOrder" method="post">
                        <input type="hidden" name="Id" value="@o.Id" />
                        <a asp-action="EditOrder" asp-route-id="@o.Id"
                           class="btn btn-outline-primary">Edit</a>
                        <button type="submit" class="btn btn-outline-danger">
                            Delete
                        </button>
                    </form>
                </div>
            </div>
        }
    </div>
</div>
<div class="text-center">
    <a asp-action="EditOrder" class="btn btn-primary">Create</a>
</div>

　　这个视图显示数据库中Order对象的摘要，并显示所订购产品的总价格和将获得的利润。有创建新订单和编辑、删除现有订单的按钮。

　　为了提供创建或编辑订单的视图，我添加了一个名为EditOrder.cshtml文件到Views/Orders文件夹，并添加了如清单7-27所示的内容。

Listing 7-27. The Contents of the EditOrder.cshtml File in the Views/Orders Folder
@model Order
<h3 class="p-2 bg-primary text-white text-center">Create/Update Order</h3>
<form asp-action="AddOrUpdateOrder" method="post">
    <div class="form-group">
        <label asp-for="Id"></label>
        <input asp-for="Id" class="form-control" readonly />
    </div>
    <div class="form-group">
        <label asp-for="CustomerName"></label>
        <input asp-for="CustomerName" class="form-control" />
    </div>
    <div class="form-group">
        <label asp-for="Address"></label>
        <input asp-for="Address" class="form-control" />
    </div>
    <div class="form-group">
        <label asp-for="State"></label>
        <input asp-for="State" class="form-control" />
    </div>
    <div class="form-group">
        <label asp-for="ZipCode"></label>
        <input asp-for="ZipCode" class="form-control" />
    </div>
    <div class="form-check">
        <label class="form-check-label">
            <input type="checkbox" asp-for="Shipped" class="form-check-input" />
            Shipped
        </label>
    </div>
    <h6 class="mt-1 p-2 bg-primary text-white text-center">Products Ordered</h6>
    <div class="container-fluid">
        <div class="row">
            <div class="col font-weight-bold">Product</div>
            <div class="col font-weight-bold">Category</div>
            <div class="col font-weight-bold">Quantity</div>
        </div>
        @{ int counter = 0; }
        @foreach (OrderLine line in ViewBag.Lines)
        {
            <input type="hidden" name="lines[@counter].Id" value="@line.Id" />
            <input type="hidden" name="lines[@counter].ProductId"
                   value="@line.ProductId" />
            <input type="hidden" name="lines[@counter].OrderId" value="@Model.Id" />
            <div class="row mt-1">
                <div class="col">@line.Product.Name</div>
                <div class="col">@line.Product.Category.Name</div>
                <div class="col">
                    <input type="number" name="lines[@counter].Quantity"
                           value="@line.Quantity" />
                </div>
            </div>
            counter++;
        }
    </div>
    <div class="text-center m-2">
        <button type="submit" class="btn btn-primary">Save</button>
        <a asp-action="Index" class="btn btn-secondary">Cancel</a>
    </div>
</form>

　　该视图为用户提供一个form表单，其中包含为Order类属性创建的input元素，以及为数据库中每个产品对象创建的input元素，在编辑现有对象时，将使用选定的数量填充这些对象。

 　　为了使新特性更容易访问，我将清单7-28中所示的元素添加到所有视图共享的布局中。

Listing 7-28. Adding an Element in the _Layout.cshtml File in the Views/Shared Folder
<!DOCTYPE html>
<html>
<head>
    <meta name="viewport" content="width=device-width" />
    <title>SportsStore</title>
    <link rel="stylesheet" href="~/lib/bootstrap/dist/css/bootstrap.min.css" />
    <style>
        .placeholder {
            visibility: collapse;
            display: none
        }

            .placeholder:only-child {
                visibility: visible;
                display: flex
            }
    </style>
</head>
<body>
    <div class="container-fluid">
        <div class="row p-2">
            <div class="col-2">
                <a asp-controller="Home" asp-action="Index"
                   class="@GetClassForButton("Home")">
                    Products
                </a>
                <a asp-controller="Categories" asp-action="Index"
                   class="@GetClassForButton("Categories")">
                    Categories
                </a>
                <a asp-controller="Orders" asp-action="Index"
                   class="@GetClassForButton("Orders")">
                    Orders
                </a>
            </div>
            <div class="col">
                @RenderBody()
            </div>
        </div>
    </div>
</body>
</html>
@functions 
{
    string GetClassForButton(string controller)
    {
        return "btn btn-block " + (ViewContext.RouteData.Values["controller"]
        as string == controller ? "btn-primary" : "btn-outline-primary");
    }
}

　　使用dotnet run启动应用程序，导航到http://localhost:5000，单击Orders按钮，然后单击Create。您将看到一个空form表单，其中包含数据库中所有产品的元素。因为这是一个新的订单，所以所有的Quantity字段都是零，如图7-4所示。

 

7.4.4 存储Order数据

当您单击Save按钮时，没有存储任何数据，因为我没有把AddOrUpdateOrder方法写完整，见清单7-25。为了完成控制器，我将清单7-29所示的代码添加到action方法中。

//Listing 7-29. Storing Data in the OrdersController.cs File in the Controllers Folder
...
[HttpPost]
public IActionResult AddOrUpdateOrder(Order order)
{
    order.Lines = order.Lines
    .Where(l => l.Id > 0 || (l.Id == 0 && l.Quantity > 0)).ToArray();
    if (order.Id == 0)
    {
        ordersRepository.AddOrder(order);
    }
    else
    {
        ordersRepository.UpdateOrder(order);
    }
    return RedirectToAction(nameof(Index));
}
...

　　我在action方法中使用的代码，依赖于一个有用的实体框架核心特性：当我将一个Order对象传递给AddOrder或UpdateOrder存储库方法，实体框架核心将不仅存储Order对象，而且存储它的相关OrderLine对象。这似乎并不重要，但它简化了一个过程，否则将需要一系列精心协调的更新语句。

　　要查看生成的SQL命令，请使用dotnet run启动应用程序，导航到http://localhost:5000/orders，单击Create按钮，并填写表单。无论您为客户使用什么细节，请确保输入表7-3中所示产品的数量。

单击Save按钮时，您将在应用程序生成的日志消息中看到几个SQL命令。第一个存储Order对象，第二个获取为主键分配的值。

...
INSERT INTO [Orders] ([Address], [CustomerName], [Shipped], [State], [ZipCode])
VALUES (@p0, @p1, @p2, @p3, @p4);
SELECT [Id]
FROM [Orders]
WHERE @@ROWCOUNT = 1 AND [Id] = scope_identity();
...

然后EF Core使用Order对象的主键来存储OrderLine对象，如下所示:

...
DECLARE @inserted0 TABLE ([Id] bigint, [_Position] [int]);
MERGE [OrderLines] USING (
VALUES (@p5, @p6, @p7, 0),
(@p8, @p9, @p10, 1)) AS i ([OrderId], [ProductId], [Quantity], _Position) ON 1=0
WHEN NOT MATCHED THEN
    INSERT ([OrderId], [ProductId], [Quantity])
    VALUES (i.[OrderId], i.[ProductId], i.[Quantity])
    OUTPUT INSERTED.[Id], i._Position
INTO @inserted0;
...

最后，Entity Framework Core查询数据库，获取分配给OrderLine对象的主键，如下所示:

...
SELECT [t].[Id] FROM [OrderLines] t
INNER JOIN @inserted0 i ON ([t].[Id] = [i].[Id])
ORDER BY [i].[_Position];
...

如果您不能完全理解SQL命令，也不必担心。需要注意的是这个EF Core负责存储相关数据并自动生成SQL命令。关于清单7-29中的代码，需要注意的最后一点是:

...
order.Lines = order.Lines
    .Where(l => l.Id > 0 || (l.Id == 0 && l.Quantity > 0)).ToArray();
...

　　除了已经存储在数据库中的对象，此语句排除了没有为其选择数量的OrderLine对象。这可以确保订单中没有的OrderLine对象不存到数据库，但是允许对以前存储的数据进行更新。

　　保存数据时，将显示订单的摘要，如图7-5所示。

 

7.5 常见错误和解决方案

用于创建和处理相关数据的特性可能比较笨拙，在下面的部分中，我描述常见的问题并解释如何解决它们。

 

7.5.1 修改表与外键冲突

The “ALTER TABLE conflicted with the FOREIGN KEY” Exception 

当您将迁移应用到数据库，库中如果有的已有数据不符合新的约束时，通常会出现此异常。例如，对于SportsStore应用程序，如果您在应用迁移（为了增加一个Category类）之前已经在数据库中创建了产品对象（数据），您就会看到这个异常。数据库中的现有数据不符合外键关系，因此数据库更新将失败。

解决此问题的最简单方法是删除并重新创建数据库，这将删除库中的任何数据。然而，在生产系统中，这不是一种合适的方法，在应用迁移之前，必须仔细修改数据。

 

7.5.2 更新与外键冲突

The “UPDATE Conflicted with the FOREIGN KEY” Exception

当您试图使用不匹配数据库外键约束的数据存储新对象或更新现有对象时，将发生此异常。最可能的原因是省略了关联数据的外键值。例如，在SportsStore应用程序上下文中，如果您试图存储或更新产品对象，而不指定CategoryId属性的值，则会出现此异常。如果收到此异常，请确保HTML表单对实体类的每个外键属性写一个input元素。（让用户选择关联数据，指定外键值）

 

7.5.3 属性表达式x => x.<name> 无效

The “The Property Expression ‘x => x.<name>’ is Not Valid” Exception

当您忘记向导航属性添加get和set访问器，然后使用Include方法选择它时，就会出现此异常。省略get和set访问器将创建字段而不是属性，并且Include方法不能在查询中跟随它。要解决这个问题，可以添加get和set访问器来创建属性。您可能还必须重新创建和应用定义关联的迁移。

 

7.5.4 导航属性未实现ICollection<OrderLine>

The “Type of Navigation Property <name> Does Not Implement
ICollection<OrderLine> ” Exception

EF Core对导航属性的数据类型很敏感，当您在存储数据之前对导航属性集合执行LINQ查询时，就会出现这种异常，就像我在文章中所做的那样，见SportsStore应用程序的清单7-29。要修复此问题，请在您的LINQ查询结果上调用ToArray方法生成一个数组。（数组和List实现了ICollection<T>接口 ）

 

 

7.5.5 属性xxx不是实体类xx的导航属性 

The “The Property <name> is Not a Navigation Property of Entity
Type <name>” Exception 

当您使用Include方法为关联数据选择EF Core无法跟随的属性时，将发生此异常。这个问题最常见的原因是选择了外键属性，而不是与其配对的导航属性。在SportsStore应用程序中，如果使用Include方法从OrderLine对象中选择了ProductId外键属性，而非Product导航属性，就会看到这个错误。

 

7.5.6 无效的对象名xxx 

The “Invalid Object Name <name>” Exception

当您创建了一个迁移，扩展了数据模型的外键关联，但忘记将其应用于数据库时，通常会出现此异常。使用dotnet ef database update 命令将你项目中的迁移应用到数据库，请参阅第13章，其中详细解释了迁移的工作方式。

 

7.5.7 对象被删除而不是更新

Objects Are Deleted Instead of Being Updated

　　如果您发现试图更新一个对象实际上导致它被删除，那么可能的原因是：您正在加载关联数据，然后将导航属性设置为null，当获取用于更改侦测的baseline基线数据时。

　　例如，在SportsStore应用程序中，想看到这种行为你可以这么干：通过查询baseline基线产品对象，使用Include方法加载关联Category对象，然后在调用SaveChanges方法之前将Category属性设置为null。

 　　这种组合的Action方法导致EF Core悄悄地删除您原打算更新的对象。要解决此问题，请不要加载关联数据，也不要将导航属性设置为null。

 

7.5.8 关联数据的类名显示在视图中

The Class Name for Related Data Is Displayed in a View

这个问题是由Razor表达式导致的，该表达式选择了导航属性的值，该导航属性返回关联的对象。Razor然后调用ToString方法，该方法返回类名。若要在视图中包含来自关联数据的数据值，请选择一个关联对象的属性，比如应该使用@Category.Name，而不能仅写@Category。

 

7.6 本章小结

在本章中，为了SportsStore数据模型，我添加了新类、创建了（外键）关联。我解释了如何查询关联数据，如何执行更新，以及如何解决这些功能可能导致的最常见问题。在下一章中，我将向您展示如何适配应用程序的MVC和EF Core部分，用于处理大量数据。