博客园_冠军

翻译：Contoso 大学 - 10 - 高级 EF 应用场景

2012-05-05T05:09:00Z

By Tom Dykstra, Tom Dykstra is a Senior Programming Writer on Microsoft's Web Platform & Tools Content Team.

原文地址：http://www.asp.net/mvc/tutorials/getting-started-with-ef-using-mvc/advanced-entity-framework-scenarios-for-an-mvc-web-application
全文目录：Contoso 大学 - 使用 EF Code First 创建 MVC 应用

在上一个教程中，你已经实现了仓储和工作单元模式。这个教程涵盖下列主题：

执行原始的 SQL 查询
执行没有跟踪的查询
检查发送到数据库的查询
使用代理类
禁用修改的自动检测
在保存修改时禁用验证

多数内容使用你已经创建的页面。为了使用原始的 SQL 进行批更新，你需要创建一个新的更新数据库中所有课程学分的页面。

以及在 Department 编辑页面中增加新的验证逻辑，使用非跟踪的查询。

10-1 执行原始的 SQL 查询

在 EF 中包含有允许你直接将 SQL 命令发送到数据库的 API 方法，你有以下选择：

使用 DbSet.SqlQuery 方法进行查询以返回实体类型。返回的对象类型必须是 DbSet 对象期望的类型。除非你关掉追踪，数据库上下文将自动追踪。( 查看随后关于 AsNoTracking 方法 )
使用 DbDatabase.SqlQuery 方法进行查询，返回类型不是实体。返回的数据不会被数据库上下文追踪，即使使用这个方法获取实体类型。
使用 DbDatabase.SqlCommand 用于非查询命令。

使用 EF 的好处是使你不用过分关注处理存储数据的特定方法。它通过自动生成需要的查询命令来完成，这样你就不用亲自编写这些代码。但是，一个例外就是你可能需要执行手动创建的特殊命令，这些方法可以为你处理类似的意外场景。
在 Web 中执行 SQL 命令有一点总是对的，你必须注意保护你的站点免于 SQL 注入攻击。一种方法就是使用参数化查询来防止提交的命令没有被注入。在这个教程中，在使用用户的输入生成查询的时候将会使用参数化查询。

10-1-1 调用返回实体的查询

假设你希望 GenericRepository 类需要提供一个额外的过滤和排序灵活方法，而不需要你创建一个派生类，然后增加一个额外的方法。一种方法就是增加一个接受原始 SQL 命令的方法。这样你就可以在控制其中指定任何类型的过滤和排序处理。比如 Where 子句依赖于连接或者子查询。在这一节中，你将要看到如何实现这样的方法。
通过将如下代码增加到 GenericRepository.cs 中，创建 GetWithRawSql 方法

public virtual IEnumerable<TEntity> GetWithRawSql(string query, params object[] parameters)
{
return dbSet.SqlQuery(query, parameters).ToList();
}

在 CourseController.cs 中，在 Details 方法中调用新的方法，如下所示：

public ActionResult Details(int id)
{
var query = "SELECT * FROM Course WHERE CourseID = @p0";
return View(unitOfWork.CourseRepository.GetWithRawSql(query, id).Single());
}

在这里，你可以使用 GetByID 方法，但是，通过调用 GetWithSql 方法来验证 GetWithRawSQL 方法正常工作。
运行 Details 页面，验证选择查询正确工作 ( 选择 Course 窗格，然后选择某个课程的 Details )

10-1-2 调用查询返回其它类型的对象

早前的时候，你创建过一个关于页面，其中显示了每个注册日注册学生的数量。位于 HomeController.cs 中的代码使用 LINQ 完成。

var data = from student in db.Students
group student by student.EnrollmentDate into dateGroup
select new EnrollmentDateGroup()
{
EnrollmentDate = dateGroup.Key,
StudentCount = dateGroup.Count()
};

假设你希望通过借助编写的 SQL 而不是使用 LINQ 来获取这些数据。要做到这个目的，你需要执行返回一些其他数据而不是实体对象的查询语句，这意味着你需要使用 Database.SqlQuery 方法。
在 HomeController.cs 中，使用下面的代码替换原来 About 方法中的 LINQ。

var query = "SELECT EnrollmentDate, COUNT(*) AS StudentCount "
+ "FROM Person "
+ "WHERE EnrollmentDate IS NOT NULL "
+ "GROUP BY EnrollmentDate";
var data = db.Database.SqlQuery<EnrollmentDateGroup>(query);

运行 About 页面，它会像从前一样显示出来。

10-1-3 调用更新查询

假设 Contoso 大学的管理员希望能够在数据库中执行批量更新，例如修改每门课程的学分。如果大学有大量的课程，就意味着需要低效率地获取全部的课程实体，然后一个一个修改，在这一节中，你将要实现一个 Web 页面，允许用户设定所有课程的学分，通过执行一个 SQL 的更新 UPDATE 语句完成。这个页面如下图所示。

在 Course 控制器中，以前你已经使用泛型的仓储来读取和更新课程实体。这与这次的批更新处理，需要创建一个不在泛型仓储中的新仓储方法。为了达到这个目的，你需要创建一个派生自 GenericRepository 基类的派生类 CourseRepository 。
在 DAL 文件夹中，创建 CourseRepository.cs ，使用下面的代码替换生成的代码。

using System;
using ContosoUniversity.Models;

namespace ContosoUniversity.DAL
{
public class CourseRepository : GenericRepository<Course>
{
public CourseRepository(SchoolContext context)
: base(context)
{
}

public int UpdateCourseCredits(int multiplier)
{
return context.Database.ExecuteSqlCommand("UPDATE Course SET Credits = Credits * {0}", multiplier);
}

}
}

在 UnitOfWork.cs 中，将 Course 仓储类型从 GenericRepository< Course > 修改为 CourseRepository:

private CourseRepository courseRepository;

public CourseRepository CourseRepository
{
get
{

if (this.courseRepository == null)
{
this.courseRepository = new CourseRepository(context);
}
return courseRepository;
}
}

在 CourseController.cs 中，增加 UpdateCourseCredits 方法

public ActionResult UpdateCourseCredits(int? multiplier)
{
if (multiplier != null)
{
ViewBag.RowsAffected = unitOfWork.CourseRepository.UpdateCourseCredits(multiplier.Value);
}
return View();
}

这个方法将会同时用于 HttpGet 和 HttpPost 。当调用 GET 方式的 UpdateCourseCredits 方法的时候，变量 multiplier 会是 null，视图将会显示空的文本框和提交按钮，如前所示。
当 Update 按钮被点击之后，将会以 POST 方式调用方法。Multiplier 将会得到在文本框中输入的值。代码调用仓储的 UpdateCourseCredits 方法，方法返回受到影响的行数，这个值存储在 ViewBag 对象中。视图通过 ViewBag 获取受到影响的行数，它将显示这个数字而不是文本框和提交按钮，如下图所示。

在 View\Course 文件夹中创建一个用来更新课程学分的视图。

在 View\Course\UpdateCourseCredits.cshtml 中，使用下面的代码替换原有代码。

@model ContosoUniversity.Models.Course

@{
ViewBag.Title = "UpdateCourseCredits";
}

<h2>Update Course Credits</h2>

@if (ViewBag.RowsAffected == null)
{
using (Html.BeginForm())
{
<p>
Enter a number to multiply every course's credits by: @Html.TextBox("multiplier")
</p>
<p>
<input type="submit" value="Update" />
</p>
}
}
@if (ViewBag.RowsAffected != null)
{
<p>
Number of rows updated: @ViewBag.RowsAffected
</p>
}
<div>
@Html.ActionLink("Back to List", "Index")
</div>

通过选择 Course 窗格运行页面，然后增加 “/UpdateCourseCredits” 到浏览器地址栏中，( 例如：http://localhost:50205/Course/UpdateCourseCredits )。在文本框中输入一个数字。

点击 Update，你会看到受影响的行数。

点击 Back to List 查看修订之后的课程学分列表。

关于执行原始查询的更多内容，请查阅 EF 团队博客的 Raw SQL Queries

10-2 非追踪的查询

当数据库上下文从数据库获取数据行然后表示为实体的时候，默认情况下，会保持对内存中实体对象是否与数据库中数据同步的追踪。内存中的数据作为缓存，当你更新实体的时候被用来更新。这个缓存在 Web 应用程序中通常没有必要，因为上下文对象的实例生命期很短 ( 对于每一次请求创建一个新的，然后释放 ) ，在实体被再次使用之前数据库上下文读取的实体对象已经被释放了。
你可以通过 AsNoTracking 方法来指定上下文对象是否追踪实体对象。使用这个方法常见的场景如下：

对于查询大量数据的查询来说，关闭追踪可以提高性能。
你更希望重新连接一个对象用来更新，尽管基于不同的目的以前获取过同样的对象。由于数据库上下文已经追踪了这个实体，你就不能连接你希望修改的实体。防止出现这种情况的一种方式就是在原来的查询中使用 AsNoTracking 选项。

在这一节，你将要实现演示第二种场景的业务逻辑。具体来说，希望确认强制的业务规则：一个教师不能成为多个系的管理员。
在 DepartmentController.cs 中，增加一个可以在 Edit 和 Create 方法中调用的方法，确认两个系不能有同一个的管理员。

private void ValidateOneAdministratorAssignmentPerInstructor(Department department)
{
if (department.PersonID != null)
{
var duplicateDepartment = db.Departments
.Include("Administrator")
.Where(d => d.PersonID == department.PersonID)
.FirstOrDefault();
if (duplicateDepartment != null && duplicateDepartment.DepartmentID != department.DepartmentID)
{
var errorMessage = String.Format(
"Instructor {0} {1} is already administrator of the {2} department.",
duplicateDepartment.Administrator.FirstMidName,
duplicateDepartment.Administrator.LastName,
duplicateDepartment.Name);
ModelState.AddModelError(string.Empty, errorMessage);
}
}
}

增加在 HttpPost Edit 方法中的 try 代码块，如果经过验证的话，调用新的方法。Try 代码块如下所示。

if (ModelState.IsValid)
{
ValidateOneAdministratorAssignmentPerInstructor(department);
}
if (ModelState.IsValid)
{
db.Entry(department).State = EntityState.Modified;
db.SaveChanges();
return RedirectToAction("Index");
}

运行 Department 的 Edit 页面，试着将已经是某个系管理员的教师设置为其他系的管理员。你会得到期望中的错误信息。

再次运行 Department 的 Edit 页面，这一次修改 Budget ，当点击 Save 的时候，你会看到如下信息。

异常提示信息是 “An object with the same key already exists in the ObjectStateManager. The ObjectStateManager cannot track multiple objects with the same key.” 这是因为顺序发生了一下事件：

Edit 方法调用 ValidateOneAdministratorAssignmentPerInstructor 方法，这导致获取了 Kim Abercrombie 作为管理员的所有 Department 。结果是名为 English 的 Department 被读取到内存中。因为这个 Department 被编辑了，不会有错误报告，作为这次读取操作的结果，然而，从数据库读取的 English Department 实体已经被数据库上下文跟踪了。
Edit 方法试图设置通过模型绑定得到的 English Department 实体的 Modified 标志，但是失败了，因为数据库上下文已经跟踪了 English 实体。

解决这个问题的一个方案是保持数据库上下文，从内存中获取跟踪的 Department 实体。这样做没有什么好处，因为并不需要更新这个实体或者通过从内存中再次读取这个实体来获取好处。
在 DepartmentController.cs 文件的 ValidateOneAdministratorAssignmentPerInstructor 方法中，指定不需要跟踪，如下所示：

var duplicateDepartment = db.Departments
.Include("Administrator")
.Where(d => d.PersonID == department.PersonID)
.AsNoTracking()
.FirstOrDefault();

重新编辑Department 的 Budget 。这次操作成功了。站点返回了预期的 Department Index 页面，显示了修改之后的 Budget 值。

10-3 检查发送到数据库的查询

有的时候，能够看到实际发送到数据库的 SQL 很有帮助，如果希望的话，可以通过在调试器中检查查询变量或者调用查询的 ToString 方法。尝试一下，对一个简单的查询增加一些选项，例如预先加载，过滤和排序等等，看看发生了什么。
在 Controller/CourseController.cs 中，使用下面的代码替换 Index 方法。

public ViewResult Index()
{
var courses = unitOfWork.CourseRepository.Get();
return View(courses.ToList());
}

现在，在 GenericRepository.cs 文件中GET 方法的 return query.ToList() 方法调用语句以及 orderBy( query ).ToList() 语句上增加一个断点，在调试模式运行项目，选择 Course 的 Index 页面。当执行到断点的时候，检查 query 变量。你就会看到发送到数据库的 SQL 语句。是简单的 Select 语句。

{SELECT
[Extent1].[CourseID] AS [CourseID],
[Extent1].[Title] AS [Title],
[Extent1].[Credits] AS [Credits],
[Extent1].[DepartmentID] AS [DepartmentID]
FROM [Course] AS [Extent1]}

在 Visual Studio 的调试器窗口中，查询语句可能很长，不便于显示出来。为了查看完整的查询，你可以复制变量的值粘贴到文本编辑器中。

现在你需要为 Course 的 Index 页面上增加一个下拉列表，用户可以用来过滤特定的 Department。通过标题可以进行排序，对 Department 导航属性使用贪婪加载，在 CourseController.cs 文件中，使用下面的代码替换原有内容。

public ActionResult Index(int? SelectedDepartment)
{
var departments = unitOfWork.DepartmentRepository.Get(
orderBy: q => q.OrderBy(d => d.Name));
ViewBag.SelectedDepartment = new SelectList(departments, "DepartmentID", "Name", SelectedDepartment);

int departmentID = SelectedDepartment.GetValueOrDefault();
return View(unitOfWork.CourseRepository.Get(
filter: d => !SelectedDepartment.HasValue || d.DepartmentID == departmentID,
orderBy: q => q.OrderBy(d => d.CourseID),
includeProperties: "Department"));
}

这个方法通过 SelectedDepartment 参数获取下拉列表中的选中的值。如果没有任何项目选中，参数为 null。
SelectList 集合中包含传递到视图的下拉列表中的 Department。传递给 SelectList 构造器的参数设置了字段名称，文本域名称，以及选中的项目。
对于 Course 仓储的 Get 方法来说，代码设置了过滤表达式，排序顺序，预先加载 Department 导航属性。如果下拉列表没有选中的话，过滤表达式总是返回 true ( 也就是说 SelectedDepartment 是 null )。
在 View\Course\Index.cshtml 中，在 table 开始标记之前，增加如下的代码创建下拉列表和提交按钮。

@using (Html.BeginForm())
{
<p>Select Department: @Html.DropDownList("SelectedDepartment","All")
<input type="submit" value="Filter" /></p>
}

由于在 GenericRepository 类的断点仍然有效，运行 Course 的 Index 页面，重复上次的操作以命中断点，在浏览器显示页面之后，从下拉列表中选中一个 Department，然后点击 Filter。

这一次第一个断点出现在下拉列表查询 Department 的时候，跳过之后，在下次代码到达断点的时候，查看 query 变量中的 Course 查询，你应该看到类似如下的查询语句。

{SELECT
[Extent1].[CourseID] AS [CourseID],
[Extent1].[Title] AS [Title],
[Extent1].[Credits] AS [Credits],
[Extent1].[DepartmentID] AS [DepartmentID],
[Extent2].[DepartmentID] AS [DepartmentID1],
[Extent2].[Name] AS [Name],
[Extent2].[Budget] AS [Budget],
[Extent2].[StartDate] AS [StartDate],
[Extent2].[PersonID] AS [PersonID],
[Extent2].[Timestamp] AS [Timestamp]
FROM [Course] AS [Extent1]
INNER JOIN [Department] AS [Extent2] ON [Extent1].[DepartmentID] = [Extent2].[DepartmentID]
WHERE (@p__linq__0 IS NULL) OR ([Extent1].[DepartmentID] = @p__linq__1)}

你会看到现在是联合查询，通过Where 子句，依据 Course 数据加载了 Department 数据。

10.4 使用代理类

当 EF 创建实体对象的时候 ( 例如，在执行查询的时候 )，EF 经常会创建动态生成的派生自实体的代理对象。代理重写了实体的虚拟属性来插入在访问属性的时候自动执行的钩子。例如，这种机制用来支持延迟加载或者关联。
多数时候你并不能察觉使用了代理，除了下面的情况之外：

有一些场景，你需要阻止 EF 创建代理实例。例如，序列化非代理的对象实例可能比序列化代理对象实例更加有效。
当使用 new 操作符实例化实体的时候，你并没有得到代理实例。这意味着你不能获得诸如延迟加载以及自动追踪的能力。一般没有问题，通常并不需要延迟加载，因为你在创建数据库中并不存在的实体。在将实体标记为 Added 状态的时候，也不需要追踪。然而，如果你需要延迟加载，需要改变追踪，就可以通过 DbSet 类的 Create 方法来创建实体代理对象。
可能需要通过代理类型对象实例获取真实实体类型。可以使用 ObjectContext 类的 GetObjectType 方法来通过代理对象获取实际对象。

更多信息，参看 EF 团队博客的 Working with Proxies

10.5 禁用变化自动跟踪

EF 通过比较实体的当前值与原始值来决定实体如何变化 ( 依此来决定发送到数据库的更新 )。在查询或者连接的时候原始值被保存起来。导致自动变化跟踪监测的一些方法如下：

DbSet.Find
DbSet.Local
DbSet.Remove
DbSet.Add
DbSet.Attach
DbContext.SaveChanges
DbContext.GetValidationErrors
DbContext.Entry
DbChangeTracker.Entries

如果你跟踪大量的实体，而且在循环中多次调用上面提到的方法，通过使用 AutoDetectChangesEnabled 属性暂时关闭变化检测，可以得到显著的性能提升，更多信息，参见 EF 团队博客的 Automatically Detecting Changes。

10-6 在保存的时候禁用验证

在调用 SaveChanges 方法的时候，在更新到数据库之前，EF 验证所有被修改实体的数据的所有属性。如果你更新了大量的实体，而且你已经验证了数据，这些工作就是不必要的，通过 ValidateOnSaveEntity 属性临时关闭验证可以花费更要的时间保存修改。更多信息，参见 EF 团队博客的 Validation。

10-7 EF 资源链接

更多地 EF 资源，参见如下资源：

下面的 EF 团队的博客提供了教程涉及的更多资源。

Fluent API Samples. How to customize mapping using fluent API method calls.
Connections and Models. How to connect to different types of databases.
Pluggable Conventions. How to change conventions.
Finding Entities. How to use the Find method with composite keys.
Loading Related Entities. Additional options for eager, lazy, and explicit loading.
Load and AsNoTracking. More on explicit loading.

一些这里提到的博客是关于 CTP 版本的 EF Code First，多数资料是准确的，但是在正式发布版本中会有一些变化。
在 EF 中使用 LINQ 的信息，参见 MSDN 的 LINQ to Entities
使用 MVC 和 EF 的更多信息，参见 MVC Music Store.
在项目创建之后，如何发布的问题，参见 MSDN 的 ASP.NET Deployment Content

本文链接

翻译：Contoso 大学 - 9 - 实现仓储和工作单元模式

2012-05-01T13:38:00Z

By Tom Dykstra, Tom Dykstra is a Senior Programming Writer on Microsoft's Web Platform & Tools Content Team.

原文地址：http://www.asp.net/mvc/tutorials/getting-started-with-ef-using-mvc/implementing-the-repository-and-unit-of-work-patterns-in-an-asp-net-mvc-application
全文目录：Contoso 大学 - 使用 EF Code First 创建 MVC 应用

在上一次的教程中，你已经使用继承来消除在 Student 和 Instructor 实体之间的重复代码。在这个教程中，你将要看到使用仓储和工作单元模式进行增、删、改、查的一些方法。像前面的教程一样，你将要修改已经创建的页面中代码的工作方式，而不是新创建的页面。

9-1 仓储和工作单元模式

仓储和工作单元模式用来在数据访问层和业务逻辑层之间创建抽象层。实现这些模式有助于隔离数据存储的变化，便于自动化的单元测试或者测试驱动的开发 ( TDD )。
在这个教程中，你将要为每个实体类型实现一个仓储类。对于 Student 实体来说，你需要创建一个仓储接口和一个仓储类。当在控制器中实例化仓储对象的时候。你将会通过接口来使用它，当控制器在 Web 服务器上运行的时候，控制器将会接受任何实现仓储接口的对象引用。通过接收仓储对象进行数据的存储管理，使得你可以容易地控制测试，就像使用内存中的集合一样。
在教程的最后，你将要在 Course 控制器中对 Course 和 Department 实体使用多个仓储和一个工作单元类。工作单元类则通过创建一个所有仓储共享的数据库上下文对象，来组织多个仓储对象。如果你希望执行自动化的单元测试，你也应该对 Student类通过相同的方式创建和使用接口。不管怎样，为了保持教程的简单，你将不会通过接口创建和使用这些类。
下面的截图展示了在控制器和上下文之间的概念图，用来比较与不使用仓储或工作单元模式的区别。

在这个教程中不会创建单元测试，在 MVC 应用中使用仓储模式进行 TDD 的相关信息，可以查看 MSDN 网站中的 Walkthrough: Using TDD with ASP.NET MVC ，EF 团队博客中的 Using Repository and Unit of Work patterns with Entity Framework 4.0 ，以及 Julie Lerman 的博客 Agile Entity Framework 4 Repository 系列。
注意：有多种方式可以实现仓储和工作单元模式。配合工作单元类可以使用也可以不使用仓储类。可以对所有的实体类型实现一个简单的仓储，或者每种类型一个。如果为每种类型实现一个仓储，还可以通过分离的类，或者泛型的基类然后派生，或者抽象基类然后派生。可以将业务逻辑包含在仓储中，或者限制只有数据访问逻辑。也可以通过在实体中使用 IDbSet 接口代替 DbSet 类为数据库上下文类创建一个抽象层。在这个教程中展示的目标实现了抽象层，只是其中一种考虑，并不是针对所有的场景和环境都适用。

9-2 创建 Student 仓储类

在 DAL 文件夹中，创建一个文件名为 IStudentRepository.cs 的文件，将当前的代码使用如下代码替换。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using ContosoUniversity.Models;

namespace ContosoUniversity.DAL
{
public interface IStudentRepository : IDisposable
{
IEnumerable<Student> GetStudents();
Student GetStudentByID(int studentId);
void InsertStudent(Student student);
void DeleteStudent(int studentID);
void UpdateStudent(Student student);
void Save();
}
}

代码定义了一套典型的增、删、改、查方法。包括两个读取方法 – 一个返回所有的学生实体，一个通过 ID 查询单个实体。
在 DAL 文件夹中，创建名为 StudentRepository.cs 的类文件，使用下面的代码替换原有的代码，这个类实现了 IStudentRepository 接口。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Data;
using ContosoUniversity.Models;

namespace ContosoUniversity.DAL
{
public class StudentRepository : IStudentRepository, IDisposable
{
private SchoolContext context;

public StudentRepository(SchoolContext context)
{
this.context = context;
}

public IEnumerable<Student> GetStudents()
{
return context.Students.ToList();
}

public Student GetStudentByID(int id)
{
return context.Students.Find(id);
}

public void InsertStudent(Student student)
{
context.Students.Add(student);
}

public void DeleteStudent(int studentID)
{
Student student = context.Students.Find(studentID);
context.Students.Remove(student);
}

public void UpdateStudent(Student student)
{
context.Entry(student).State = EntityState.Modified;
}

public void Save()
{
context.SaveChanges();
}

private bool disposed = false;

protected virtual void Dispose(bool disposing)
{
if (!this.disposed)
{
if (disposing)
{
context.Dispose();
}
}
this.disposed = true;
}

public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
}
}

数据库上下文是类中定义的一个成员变量，构造函数期望传递一个数据库上下文对象实例。

private SchoolContext context;

public StudentRepository(SchoolContext context)
{
this.context = context;
}

你需要创建一个新的数据库上下文实例，但是如果在控制器中需要使用多个仓储类，每一个会得到一个不同的数据库上下文对象。后面在 Course 控制器中，你将要使用多个仓储，会看到如何使用工作单元类来保证所有的仓储使用相同的数据库上下文对象。
仓储类还实现了 IDisposable 接口，如同在前面控制器中所见，释放数据库上下文，仓储的增删改查方法也如前所见调用数据库上下文的方法。

9-3 修改 Student 控制器使用仓储

在 StudentController.cs 中，使用下面的代码替换现有的代码。

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Entity;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using ContosoUniversity.Models;
using ContosoUniversity.DAL;
using PagedList;

namespace ContosoUniversity.Controllers
{
public class StudentController : Controller
{
private IStudentRepository studentRepository;

public StudentController()
{
this.studentRepository = new StudentRepository(new SchoolContext());
}

public StudentController(IStudentRepository studentRepository)
{
this.studentRepository = studentRepository;
}

//
// GET: /Student/

public ViewResult Index(string sortOrder, string currentFilter, string searchString, int? page)
{
ViewBag.CurrentSort = sortOrder;
ViewBag.NameSortParm = String.IsNullOrEmpty(sortOrder) ? "Name desc" : "";
ViewBag.DateSortParm = sortOrder == "Date" ? "Date desc" : "Date";

if (Request.HttpMethod == "GET")
{
searchString = currentFilter;
}
else
{
page = 1;
}
ViewBag.CurrentFilter = searchString;

var students = from s in studentRepository.GetStudents()
select s;
if (!String.IsNullOrEmpty(searchString))
{
students = students.Where(s => s.LastName.ToUpper().Contains(searchString.ToUpper())
|| s.FirstMidName.ToUpper().Contains(searchString.ToUpper()));
}
switch (sortOrder)
{
case "Name desc":
students = students.OrderByDescending(s => s.LastName);
break;
case "Date":
students = students.OrderBy(s => s.EnrollmentDate);
break;
case "Date desc":
students = students.OrderByDescending(s => s.EnrollmentDate);
break;
default:
students = students.OrderBy(s => s.LastName);
break;
}

int pageSize = 3;
int pageNumber = (page ?? 1);
return View(students.ToPagedList(pageNumber, pageSize));
}

//
// GET: /Student/Details/5

public ViewResult Details(int id)
{
Student student = studentRepository.GetStudentByID(id);
return View(student);
}

//
// GET: /Student/Create

public ActionResult Create()
{
return View();
}

//
// POST: /Student/Create

[HttpPost]
public ActionResult Create(Student student)
{
try
{
if (ModelState.IsValid)
{
studentRepository.InsertStudent(student);
studentRepository.Save();
return RedirectToAction("Index");
}
}
catch (DataException)
{
//Log the error (add a variable name after DataException)
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists see your system administrator.");
}
return View(student);
}

//
// GET: /Student/Edit/5

public ActionResult Edit(int id)
{
Student student = studentRepository.GetStudentByID(id);
return View(student);
}

//
// POST: /Student/Edit/5

[HttpPost]
public ActionResult Edit(Student student)
{
try
{
if (ModelState.IsValid)
{
studentRepository.UpdateStudent(student);
studentRepository.Save();
return RedirectToAction("Index");
}
}
catch (DataException)
{
//Log the error (add a variable name after DataException)
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists see your system administrator.");
}
return View(student);
}

//
// GET: /Student/Delete/5

public ActionResult Delete(int id, bool? saveChangesError)
{
if (saveChangesError.GetValueOrDefault())
{
ViewBag.ErrorMessage = "Unable to save changes. Try again, and if the problem persists see your system administrator.";
}
Student student = studentRepository.GetStudentByID(id);
return View(student);
}

//
// POST: /Student/Delete/5

[HttpPost, ActionName("Delete")]
public ActionResult DeleteConfirmed(int id)
{
try
{
Student student = studentRepository.GetStudentByID(id);
studentRepository.DeleteStudent(id);
studentRepository.Save();
}
catch (DataException)
{
//Log the error (add a variable name after DataException)
return RedirectToAction("Delete",
new System.Web.Routing.RouteValueDictionary {
{ "id", id },
{ "saveChangesError", true } });
}
return RedirectToAction("Index");
}

protected override void Dispose(bool disposing)
{
studentRepository.Dispose();
base.Dispose(disposing);
}
}
}

在控制器中定义了一个 IStudentRepository 接口的类变量，而不是直接的数据库上下文。

private IStudentRepository studentRepository;

默认的构造函数创建一个新的上下文接口，可选的构造函数允许调用者传递一个数据库上下文实例。

public StudentController()
{
this.studentRepository = new StudentRepository(new SchoolContext());
}

public StudentController(IStudentRepository studentRepository)
{
this.studentRepository = studentRepository;
}

( 如果使用依赖注入，或者 DI，就不需要默认构造函数，因为 DI 容器会为你创建正确的仓储对象 )
在 CRUD 方法中，调用仓储方法来而不是数据库上下文的方法。

var students = from s in studentRepository.GetStudents()
select s;

Student student = studentRepository.GetStudentByID(id);

studentRepository.InsertStudent(student);
studentRepository.Save();

studentRepository.UpdateStudent(student);
studentRepository.Save();

studentRepository.DeleteStudent(id);
studentRepository.Save();

现在的 Dispose 方法释放仓储而不是数据库上下文。

studentRepository.Dispose();

运行程序，点击 Students 窗格。

现在的页面显示与使用仓储之前完全相同。其他的学生页面也一样。实际上，在 Index 控制器方法的过滤和排序中，存在一个重要的不同，原来版本的代码如下：

var students = from s in context.Students
select s;
if (!String.IsNullOrEmpty(searchString))
{
students = students.Where(s => s.LastName.ToUpper().Contains(searchString.ToUpper())
|| s.FirstMidName.ToUpper().Contains(searchString.ToUpper()));
}

在原来版本的代码中，students 变量的类型是 IQueryable ，查询在使用诸如 ToList 方法转换为集合之前并不会发送到数据库中。这意味着这里的 Where 方法在处理到数据库中的时候变成 SQL 中的 where 子句。同时意味着仅仅选中的实体从数据库中返回。从 context.Students 修改为 studentRepository.GetStudents() 之后，代码中的 students 变量类型成为 IEnumerable 集合，包括数据库中所有的学生。通过 Where 方法得到的结果是一样的，但是处理在 Web 服务器的内存中进行，而不是在数据库中。对于大量的数据来说，这样做是低效的。后继的段落展示如何通过仓储方法实现在数据库中完成。
现在你已经在控制器和 EF 数据库上下文之间创建了抽象层。如果你将在这个程序中执行自动化的单元测试，可以在单元测试项目中创建一个替代的实现接口 IStudentRepository 仓储类，来代替实际的上下文完成读写数据。这个模拟 ( Mock ) 的仓储类可以通过操作内存中的集合来测试控制器功能。

9-4 实现泛型的仓储和工作单元

对每一个实体类型创建一个仓储将会导致大量重复代码。还会带来部分更新的问题。例如，假设在一个事务中更新两个不同的实体。如果每一个仓储使用不同的数据库上下文实例，一个可能成功了，另外一个失败了。一种减少冗余代码的方式是使用泛型仓储，另一种方式是使用工作单元类来确保所有的仓储都使用同样的数据库上下文 ( 来协调所有的更新 )。
在这一节中，你将要创建 GenericRepository 类和 UnitOfWork 类。在 Course 控制器中使用它们来访问 Department 和 Course 实体集。如前所述，为了保持教程的简单，不为这些类创建接口，但是为了以后使用它们进行 TDD 的便利，你应该像在 Student 仓储中一样通过接口实现。

9-4-1 创建泛型仓储

在 DAL 文件夹中，创建 GenericRepository.cs ，使用下面的代码替换原有代码。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Data;
using System.Data.Entity;
using ContosoUniversity.Models;
using System.Linq.Expressions;

namespace ContosoUniversity.DAL
{
public class GenericRepository<TEntity> where TEntity : class
{
internal SchoolContext context;
internal DbSet<TEntity> dbSet;

public GenericRepository(SchoolContext context)
{
this.context = context;
this.dbSet = context.Set<TEntity>();
}

public virtual IEnumerable<TEntity> Get(
Expression<Func<TEntity, bool>> filter = null,
Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,
string includeProperties = "")
{
IQueryable<TEntity> query = dbSet;

if (filter != null)
{
query = query.Where(filter);
}

foreach (var includeProperty in includeProperties.Split
(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
query = query.Include(includeProperty);
}

if (orderBy != null)
{
return orderBy(query).ToList();
}
else
{
return query.ToList();
}
}

public virtual TEntity GetByID(object id)
{
return dbSet.Find(id);
}

public virtual void Insert(TEntity entity)
{
dbSet.Add(entity);
}

public virtual void Delete(object id)
{
TEntity entityToDelete = dbSet.Find(id);
Delete(entityToDelete);
}

public virtual void Delete(TEntity entityToDelete)
{
if (context.Entry(entityToDelete).State == EntityState.Detached)
{
dbSet.Attach(entityToDelete);
}
dbSet.Remove(entityToDelete);
}

public virtual void Update(TEntity entityToUpdate)
{
dbSet.Attach(entityToUpdate);
context.Entry(entityToUpdate).State = EntityState.Modified;
}
}
}

为数据库上下文创建变量，以及仓储代表的实体集。

internal SchoolContext context;
internal DbSet dbSet;

构造函数接受一个数据库上下文实例，然后初始化实体集变量。

public GenericRepository(SchoolContext context)
{
this.context = context;
this.dbSet = context.Set();
}

Get 方法接受 Lambda 表达式，允许调用代码通过 Lambda 表达式来传递过滤条件和排序列，字符串参数允许调用者传递一个逗号分隔的导航属性进行预先加载。

public virtual IEnumerable<TEntity> Get(
Expression<Func<TEntity, bool>> filter = null,
Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,
string includeProperties = "")

代码 Expression<Func<TEntity, bool>> filter 表示调用方需要提供一个基于 TEntity 类型的 Lambda 表达式，表达式将会返回 bool 类型的值。例如，如果仓储实例化为 Student 类型，调用的方法可能为 filter 传递的参数为 student => student.LastName == "Smith"
代码 Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy 也表示调用方需要提供一个 Lambda 表达式，在这里，表达式是 TEntity 类型的 IQueryable 对象。返回排序版本的 IQueryable 对象。例如，如果仓储实例化为 Student 实体类型，代码为 orderBy 参数传递的参数可能为 q => q.OrderBy(s => s.LastName) 。
Get 方法创建一个 IQueryable 对象，如果存在过滤条件的话，再使用过滤条件。

IQueryable<TEntity> query = dbSet;

if (filter != null)
{
query = query.Where(filter);
}

然后，在解析逗号分隔的列表之后，应用预先加载。

foreach (var includeProperty in includeProperties.Split
(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
query = query.Include(includeProperty);
}

最后，如果存在排序条件，应用 orderBy 表达式，否则它返回没有排序的查询。

if (orderBy != null)
{
return orderBy(query).ToList();
}
else
{
return query.ToList();
}

在调用 Get 方法的时候，你可以不提供这些参数，而通过方法返回的 IEnumerable 集合进行过滤和排序，但是排序和过滤将会在 Web 服务器的内存中进行。通过使用这些参数，可以使这些工作在数据库中进行而不是在 Web 服务器上进行。另外一种替代方式是为特定的实体类型创建派生类，增加特定的 Get 方法，诸如 GetStudentsInNameOrder 或者 GetStudentsByName。然而，在复杂的应用中，这会导致大量的派生类和特定方法，在维护的时候会导致大量的工作。
在 GetByID， Insert 和 Update 中的方法如同在非泛型方法中一样简单 ( 在 GetByID 方法扎没有提供预先加载参数，因为不能对 Find 方法进行预先加载 )。
Delete 方法有两个重载。

public virtual void Delete(object id)
{
TEntity entityToDelete = dbSet.Find(id);
dbSet.Remove(entityToDelete);
}

public virtual void Delete(TEntity entityToDelete)
{
if (context.Entry(entityToDelete).State == EntityState.Detached)
{
dbSet.Attach(entityToDelete);
}
dbSet.Remove(entityToDelete);

}

一个允许仅仅传递实体的 ID 进行删除，另外一个使用实体实例。像在处理并发中所见，对于并发处理你需要 Delete 方法获取包含追踪属性原始值的实体实例。
泛型仓储可以处理典型的 CRUD 需求。当特定的实体有特定的需求时，例如更加复杂的过滤或者排序，可以通过创建派生类来增加额外的方法。

9-4-2 创建工作单元类

工作单元类服务于一个目的：当你使用多个仓储的时候，共享单个的数据库上下文实例。因此，当工作单元完成的时候，你可以通过在这个数据库上下文实例上调用 SaveChanges 方法来保证相关的所有操作被协调处理。所有这个类需要的就是一个 Save 方法和每个仓储一个的属性。每个仓储属性返回使用相同的数据库上下文对象创建的仓储对象实例。
在 DAL 文件夹中，创建名为 UnitOfWork.cs 的文件，使用下面的代码替换原有内容。

using System;
using ContosoUniversity.Models;

namespace ContosoUniversity.DAL
{
public class UnitOfWork : IDisposable
{
private SchoolContext context = new SchoolContext();
private GenericRepository<Department> departmentRepository;
private GenericRepository<Course> courseRepository;

public GenericRepository<Department> DepartmentRepository
{
get
{

if (this.departmentRepository == null)
{
this.departmentRepository = new GenericRepository<Department>(context);
}
return departmentRepository;
}
}

public GenericRepository<Course> CourseRepository
{
get
{

if (this.courseRepository == null)
{
this.courseRepository = new GenericRepository<Course>(context);
}
return courseRepository;
}
}

public void Save()
{
context.SaveChanges();
}

private bool disposed = false;

protected virtual void Dispose(bool disposing)
{
if (!this.disposed)
{
if (disposing)
{
context.Dispose();
}
}
this.disposed = true;
}

public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
}
}

代码为数据库上下文以及每个仓储创建类级成员变量。对于 context 变量，新的上下文对象被实例化。

private SchoolContext context = new SchoolContext();
private GenericRepository<Department> departmentRepository;
private GenericRepository<Course> courseRepository;

每个仓储属性检查仓储是否已经被创建了，如果没有，就传递数据库上下文对象，初始化仓储对象，因此，所有的仓储共享相同的数据库上下文。

public GenericRepository<Department> DepartmentRepository
{
get
{

if (this.departmentRepository == null)
{
this.departmentRepository = new GenericRepository<Department>(context);
}
return departmentRepository;
}
}

像在类中实例化数据库上下文的其他类一样， UnitOfWork 类也实现了 IDisposable 接口来释放数据库上下文。

9-4-3 修改 CourseController 使用工作单元类和仓储

使用如下代码替换当前的 CourseController.cs。

代码中增加了 UnitOfWork 类级成员变量。( 如果在这里使用接口，就不需要在这里实例化对象，相反，应该实现类似前面 Student 仓储的两个构造函数 )

private UnitOfWork unitOfWork = new UnitOfWork();

在类中的其他部分，所有引用的数据库上下文替换为适当的仓储。使用 UnitOfWork 属性来访问仓储。Dispose 方法用来释放 UnitOfWork 实例。

var courses = unitOfWork.CourseRepository.Get(includeProperties: "Department");
// ...
Course course = unitOfWork.CourseRepository.GetByID(id);
// ...
unitOfWork.CourseRepository.Insert(course);
unitOfWork.Save();
// ...
Course course = unitOfWork.CourseRepository.GetByID(id);
// ...
unitOfWork.CourseRepository.Update(course);
unitOfWork.Save();
// ...
var departmentsQuery = unitOfWork.DepartmentRepository.Get(
orderBy: q => q.OrderBy(d => d.Name));
// ...
Course course = unitOfWork.CourseRepository.GetByID(id);
// ...
unitOfWork.CourseRepository.Delete(id);
unitOfWork.Save();
// ...
unitOfWork.Dispose();

运行程序，点击 Courses 窗格。

页面工作如同既往修改之前一样，Course 页面也同样工作。
你现在已经实现了仓储和工作单元模式。在泛型仓储中使用 Lambda 表达式作为参数。更多对 IQueryable 对象使用表达式的信息，可以参阅 MSDN 库中的 IQueryable(T) Interface (System.Linq) 。下一次，将学习如何处理一些高级场景。

本文链接

翻译：Contoso 大学 - 8 – 实现继承

2012-04-28T07:56:00Z

By Tom Dykstra, Tom Dykstra is a Senior Programming Writer on Microsoft's Web Platform & Tools Content Team.

原文地址：http://www.asp.net/mvc/tutorials/getting-started-with-ef-using-mvc/implementing-inheritance-with-the-entity-framework-in-an-asp-net-mvc-application
全文目录：Contoso 大学 - 使用 EF Code First 创建 MVC 应用

在上一次教程中，你已经能够处理并发异常。这个教程将会展示如何在数据模型中实现继承。
在面向对象的程序设计中，你可以通过继承来清除冗余的代码。在这个教程中，你将要通过修改教师 Instructor 和学生 Student 类，以便使他们从包含类似 LastName 属性的 Person 类中派生。对于 Web 页面不需要任何改动，你需要修改一点代码，这些修改将会被自动反射到数据库中。

8-1 单表继承 (Table-per-Hierarchy) 对类型表 (Table-per-Type) 继承

在面向对象的程序设计中，你可以通过对相关的类使用继承来使得工作更加简单。例如，教师 Instructor 和学生 Student 类在学校 School 数据模型中共享多个属性，带来了冗余的代码。

假设你希望清除在教师 Instructor 和学生 Student 之间所共享的属性带来的冗余代码。可以创建一个 Person 基类，其中仅仅包含他们共享的属性，然后，使得教师 Instructor 和学生 Student 类从 Person 基类派生，如下图所示。

在数据库中这种继承结构可以有多种表现形式，可以创建一个名为 Person 的表，在这个独立的表中包含教师和学生所有的信息。既包括他们独自拥有的属性 ( 例如教师的 HireDate ，以及学生的 EnrollmentDate )，也包括它们共有的属性 ( 例如 LastName, FirstName )。通常你还需要一个用于识别当前类型的列 discriminator 来标识当前行的类型。( 在这里，标识列的内容为 Instructor 来表示教师，Student 来表示学生 )

使用单个数据库表来生成实体继承结构的模式称为单表继承模式 TPH (table-per-hierarchy )。
另外一种方式是使得数据库看起来类似继承结构。例如，在 Person 表中仅仅包含他们共有的名字属性，而将不同的时间分别保存到独立的 Instructor 和 Student 表中。

这种每种实体类对应一张数据库表的模式称为类型表 TPT 继承 (table per type )。
在 EF 中，TPH 继承比 TPT 继承有更好的性能，因为 TPT 继承需要复杂的连接查询。这个教程演示如何实现 TPH 继承。你需要完成如下的步骤：

创建 Person 类，将 Instructor 和 Student 类从 Person 类中派生
在数据库上下文类中增加模型到数据库的映射代码
将项目中的 InstructorID 和 StudentID 修改为使用 PersonID.

8-2 创建 Person 类

在 Model 文件夹中，创建 Person.cs ，使用下面的代码替换原有的代码。

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace ContosoUniversity.Models
{
public abstract class Person
{
[Key]
public int PersonID { get; set; }

[Required(ErrorMessage = "Last name is required.")]
[Display(Name="Last Name")]
[MaxLength(50)]
public string LastName { get; set; }

[Required(ErrorMessage = "First name is required.")]
[Column("FirstName")]
[Display(Name = "First Name")]
[MaxLength(50)]
public string FirstMidName { get; set; }

public string FullName
{
get
{
return LastName + ", " + FirstMidName;
}
}
}
}

在 Instructor.cs 文件中，将 Instructor 从 Person 派生出来，删除 key 和 name 字段。代码如下所示。

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace ContosoUniversity.Models
{
public class Instructor : Person
{
[DisplayFormat(DataFormatString = "{0:d}", ApplyFormatInEditMode = true)]
[Required(ErrorMessage = "Hire date is required.")]
[Display(Name = "Hire Date")]
public DateTime? HireDate { get; set; }

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

public virtual OfficeAssignment OfficeAssignment { get; set; }
}
}

对 Student.cs 文件进行类似的修改，修改后的 Student 类如下所示。

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace ContosoUniversity.Models
{
public class Student : Person
{
[Required(ErrorMessage = "Enrollment date is required.")]
[DisplayFormat(DataFormatString = "{0:d}", ApplyFormatInEditMode = true)]
[Display(Name = "Enrollment Date")]
public DateTime? EnrollmentDate { get; set; }

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

8-3 在模型中增加 Person 实体类型

在 SchoolContext.cs 文件中，对 Person 实体类型增加一个 DbSet 类型的属性。

public DbSet<Person> People { get; set; }

这就是在 EF 中配置 TPH 继承所有需要完成的工作。如你所见，当数据库重建的时候，EF 会自动创建 Person 表。

8-4 修改 InstructorID 和 StudentID 为 PersonID

在 SchoolContext.cs 文件中，在教师对课程的映射语句中，将 MapRightKey(“InstructorID”) 修改为 MapRightKey(“PersonID”)。

modelBuilder.Entity<Course>()
.HasMany(c => c.Instructors).WithMany(i => i.Courses)
.Map(t => t.MapLeftKey("CourseID")
.MapRightKey("PersonID")
.ToTable("CourseInstructor"));

这个修改不是必须的，它仅仅修改了在表多对多连接中 InstructorID 的名字。如果你保留名为仍然为 InstructorID，程序还是可以正常工作的。
下一步，进行一次全局的替换 ( 项目中所有的文件 )，将 InstructorID 修改为 PersonID，StudentID 修改为 PersonID。注意区分大小写。( 这里演示了使用类名加上 ID 作为主键的一个缺点。如果你没有使用类名加上 ID 作为主键，这里就不需要重新命名 )

8-5 在初始化器中修改主键的值

在 SchoolInitializer.cs 中，代码假设对于 Student 和 Instructor 实体的主键数字是分离的。这对于 Student 实体来说仍然正确 ( 他们仍然从 1 到 8 )，但是对于 Instructor 实体来说，将不再从 1-5 而是修改为 9-13，因为在初始化类中的代码将教师增加在同一张表的学生之后。使用下面的代码修改 Department 和 OfficeAssignment 实体中的代码，以便使用新的教师 ID。

var departments = new List<Department>
{
new Department { Name = "English", Budget = 350000, StartDate = DateTime.Parse("2007-09-01"), PersonID = 9 },
new Department { Name = "Mathematics", Budget = 100000, StartDate = DateTime.Parse("2007-09-01"), PersonID = 10 },
new Department { Name = "Engineering", Budget = 350000, StartDate = DateTime.Parse("2007-09-01"), PersonID = 11 },
new Department { Name = "Economics", Budget = 100000, StartDate = DateTime.Parse("2007-09-01"), PersonID = 12 }
};

var officeAssignments = new List<OfficeAssignment>
{
new OfficeAssignment { PersonID = 9, Location = "Smith 17" },
new OfficeAssignment { PersonID = 10, Location = "Gowan 27" },
new OfficeAssignment { PersonID = 11, Location = "Thompson 304" },
};

8-6 将 OfficeAssignment 调整为延迟加载

当前版本的 EF 对导航属性使用了 TPH继承模式后的派生类，在一对一，或者一对零的关系上不支持预先加载模式。这对于 Instructor 实体上的 OfficeAssignment 属性是个问题。解决这个问题，需要删除在这个属性上使用的预先加载处理。
在 InstructorController.cs 文件中，删除三次出现的如下代码。

.Include(i => i.OfficeAssignment)

8-7 测试

运行程序，在各个页面上检查一下，所有的工作如以前一样。
在解决方案管理器上，双击 School.sdf 数据库，在服务器资源管理器中打开，展开 School.sdf，然后选择 Tables，你会看到 Student 和 Instructor 表已经被 Person 表替换掉了。展开 Person 表，你会看到其中拥有原来 Student 和 Instructor 中所有的列，加上 discriminator 列。

下图展示了新的 School 数据库的结构。

对于 Person ，Student 和 Instructor 类，通过 TPH 实现了继承。对于更多的关于其他继承结构，可以查看 Morteza Manavi 的博客 Inheritance Mapping Strategies。在下一次的教程中，将会学习实现仓储和单元模式的一些途径。

本文链接

翻译：Contoso 大学 - 7 – 处理并发

2012-04-22T14:56:00Z

【摘要】在上一次的教程中我们处理了关联数据问题。这个教程演示如何处理并发问题。你将使用 Department 实体创建一个页面，这个页面在支持编辑和删除的同时，还可以处理并发错误。下面的截图演示了 Index 页面和 Delete 页面，包括在出现并发冲突的时候提示的一些信息。 http://www.cnblogs.com/haogj/archive/2012/04/22/2465613.html

本文链接

翻译：Contoso 大学 - 6 – 更新关联数据

2012-04-18T15:34:00Z

By Tom Dykstra, Tom Dykstra is a Senior Programming Writer on Microsoft's Web Platform & Tools Content Team.

原文地址：http://www.asp.net/mvc/tutorials/getting-started-with-ef-using-mvc/updating-related-data-with-the-entity-framework-in-an-asp-net-mvc-application

全文目录：Contoso 大学 - 使用 EF Code First 创建 MVC 应用

在上一次的课程中，你已经学习了如何显示关联的数据，我们将要更新关联的数据。大多数情况下，可能就是更新表的外键字段。对于多对多的关系来说，由于 EF 并没有直接将表与表之间的连接关系暴露出来，你就必须通过显式对相关的导航属性进行添加或者删除实体来完成。

下面的截图展示了我们马上要完成的工作。

6-1 定制课程的创建和编辑页面

当新的课程实体创建的时候，必须包含相关的 Department。为了达到这个目的，脚手架创建的代码，包括创建和编辑的控制器以及视图，都包含了对 Department 的下拉列表的支持。下拉列表设置 Course.DepartmentId 外键属性，这对于 EF 通过 Department 导航属性来加载 Department 实体来说是必须的。下面将要对脚手架生成的代码进行一些小的改动，增加错误的处理以及对列表内容进行排序。

打开 CourseController.cs, 删除原来的 Edit 和 Create 方法，使用下面的代码替换它们。

public ActionResult Create()
{
PopulateDepartmentsDropDownList();
return View();
}

[HttpPost]
public ActionResult Create(Course course)
{
try
{
if (ModelState.IsValid)
{
db.Courses.Add(course);
db.SaveChanges();
return RedirectToAction("Index");
}
}
catch (DataException)
{
//Log the error (add a variable name after DataException)
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists, see your system administrator.");
}
PopulateDepartmentsDropDownList(course.DepartmentID);
return View(course);
}

public ActionResult Edit(int id)
{
Course course = db.Courses.Find(id);
PopulateDepartmentsDropDownList(course.DepartmentID);
return View(course);
}

[HttpPost]
public ActionResult Edit(Course course)
{
try
{
if (ModelState.IsValid)
{
db.Entry(course).State = EntityState.Modified;
db.SaveChanges();
return RedirectToAction("Index");
}
}
catch (DataException)
{
//Log the error (add a variable name after DataException)
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists, see your system administrator.");
}
PopulateDepartmentsDropDownList(course.DepartmentID);
return View(course);
}

private void PopulateDepartmentsDropDownList(object selectedDepartment = null)
{
var departmentsQuery = from d in db.Departments
orderby d.Name
select d;
ViewBag.DepartmentID = new SelectList(departmentsQuery, "DepartmentID", "Name", selectedDepartment);
}

PopulateDepartmentsDropDownList 方法获取经过对 Name 进行排序的 Department，然后创建用于下拉列表的 SelectList 集合，通过 ViewBag 传递到视图中。这个方法包含一个参数，允许调用方可选地传递一个初始选中项目的值。

HttpGet Create 方法调用没有设置选中项的 PopulateDepartmentsDropDownList 方法，因为对于新创建的课程来说，还没有确定归属的系。

public ActionResult Create()
{
PopulateDepartmentsDropDownList();
return View();
}

HttpGet Edit 方法则设置了当前选中的项目，基于当前被编辑课程的 DepartmentId。

public ActionResult Edit(int id)
{
Course course = db.Courses.Find(id);
PopulateDepartmentsDropDownList(course.DepartmentID);
return View(course);
}

对于 Create 和 Edit 的 HttpPost 方法来说，在错误信息处理之后，都包含了设置当前选中项目的代码。

catch (DataException)
{
//Log the error (add a variable name after DataException)
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists, see your system administrator.");
}
PopulateDepartmentsDropDownList(course.DepartmentID);
return View(course);

代码用来保证即使在显示错误的页面上，也会保持选中的项目。

在 Views\Course\Create.cshtml, 在 Title 之前增加一个新的字段，允许用户输入课程编号。想之前演示的那样，脚手架没有生成主键字段，因为主键字段对用户没有意义。所以需要添加以便用户能够输入这个值。

<div class="editor-label">
@Html.LabelFor(model => model.CourseID)
</div>
<div class="editor-field">
@Html.EditorFor(model => model.CourseID)
@Html.ValidationMessageFor(model => model.CourseID)
</div>

运行 Create 页面 ( 在课程的 Index 页面，点击 Create New )，然后输入新的课程。

点击 Create，在 Index 中应该可以看到包含新创建课程的列表。系的名称通过导航属性获取到，显示的数据是正确的。

运行编辑页面 ( 在课程的 Index 页面中在某个课程上选择 Edit )

修改一些数据，然后点击 Save，可以看到更新之后的课程数据。

6-2 增加教师的编辑页面

在修改教师信息的时候，我们希望也能够修改教师的办公室分配。教师实体 Instructor 和办公室分配 OfficeAssignment存在一对一或者一对零的关系，这意味着你必须处理如下的状态：

如果教师原来存在一个办公室分配，但是用户删除了它，那么，你必须移除并且删除这个办公室分配 OfficeAssignment 实体。
如果教师原来没有办公室分配，但是用户输入了一个，你必须创建一个新的办公室分配。
如果用户修改了原来的办公室分配，你必须修改当前的办公分配 OfficeAssignment 实体。

打开 InstructorController.cs，看一下 HttpGet Edit 方法。

public ActionResult Edit(int id)
{
Instructor instructor = db.Instructors.Find(id);
ViewBag.InstructorID = new SelectList(db.OfficeAssignments, "InstructorID", "Location", instructor.InstructorID);
return View(instructor);
}

脚手架生成的代码不是我们希望的，它生成了一个下拉列表，但是我们希望是文本框，将这个方法使用下面的代码替换掉。

代码中删除了 ViewBag 语句，增加了使用预先加载的相关 OfficeAssignment 和 Course 实体 ( 现在还不需要课程实体，一会就会用到 )。由于 Find 方法不能使用预先加载，所以这里使用 Where 和 Single 方法来获取教师。

将 HttpPost 的 Edit 方法使用下面的代码替换，这里处理了 OfficeAssignment 更新。

[HttpPost]
public ActionResult Edit(int id, FormCollection formCollection)
{
var instructorToUpdate = db.Instructors
.Include(i => i.OfficeAssignment)
.Include(i => i.Courses)
.Where(i => i.InstructorID == id)
.Single();
if (TryUpdateModel(instructorToUpdate, "", null, new string[] { "Courses" }))
{
try
{
if (String.IsNullOrWhiteSpace(instructorToUpdate.OfficeAssignment.Location))
{
instructorToUpdate.OfficeAssignment = null;
}

db.Entry(instructorToUpdate).State = EntityState.Modified;
db.SaveChanges();

return RedirectToAction("Index");
}
catch (DataException)
{
//Log the error (add a variable name after DataException)
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists, see your system administrator.");
return View();
}
}
return View(instructorToUpdate);
}

代码中处理了如下的内容：

从数据库中获取了教师 Instructor 实体，并且预先加载了相关的的办公室分配 OfficeAssignment 和课程 Course 导航属性。如同在 HttpGet 的 Edit 方法一样。
使用通过模型绑定获取的数据，更新 Instructor 实体，除了课程 Course 导航属性之外。

If (TryUpdateModel(instructorToUpdate, "", null, new string[] { "Courses" }))

( 第二和第三个参数在属性名的前面没有前缀，而且没有被包含的属性列表 )，如果验证失败， TryUpdateModel 方法返回 false，程序将直接转到方法最后的 return View 语句。

如果办公位置为空，设置 Instructor.OfficeAssignment 属性为 null，在 OfficeAssignment 表相关的行将会被删除。

if (String.IsNullOrWhiteSpace(instructorToUpdate.OfficeAssignment.Location))
{
instructorToUpdate.OfficeAssignment = null;
}

将修改保存到数据库中。

在 Views\Instructor\Edit.cshtml, 在 Hire Date 字段的 div 元素之后，增加新的字段来编辑办公位置。

<div class="editor-label">
@Html.LabelFor(model => model.OfficeAssignment.Location)
</div>
<div class="editor-field">
@Html.EditorFor(model => model.OfficeAssignment.Location)
@Html.ValidationMessageFor(model => model.OfficeAssignment.Location)
</div>

运行页面 ( 选中教师 Instructors ，点击某个教师的 Edit 链接 )

修改办公室位置的值，然后保存 Save。

新的办公位置出现在 Index 页面上，打开数据库中的 OfficeAssgnment 表，可以看到表中的数据行。

运行编辑页面，将办公位置 Office Location 清除掉，然后保存 Save。在 Index 页面上办公位置将显示为空白，在表中的行被删除了。

6-3 在教师编辑页面增加课程分配

教师可以教授任意数量的课程。现在你需要扩展教师的编辑页面，增加通过一系列复选框分配可能的能力，如下所示。

在课程 Course 和教师 Instructor 之间存在多对多的关系，这意味着你不需要直接访问表之间的关联。而是通过增加或者删除 Instructor. Course 实体来完成。

在 UI 界面上，与教师相关的课程被显示为一组复选框，在数据库中的每一门课程都有一个对应的复选框，教师当前教授的课程对应的复选框处于被选中状态。用户可以通过选中或者取消选中来改变教师教授的课程。如果课程的数量巨大，你可能需要采取其他的方式来显示这些数据，但是你可以使用类似的方式来控制导航属性以便创建和删除关系。

为了为视图提供复选框数据，你需要使用视图模型 ViewModel，在 ViewModels 文件夹中创建 AssignedCourseData.cs，使用下面的代码替换生成的代码。

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace ContosoUniversity.ViewModels
{
public class AssignedCourseData
{
public int CourseID { get; set; }
public string Title { get; set; }
public bool Assigned { get; set; }
}
}

在 InstructorController.cs 中，找到 HttpGet Edit 方法，调用通过视图模型为视图中复选框提供数据的新方法，如下所示。

public ActionResult Edit(int id)
{
Instructor instructor = db.Instructors
.Include(i => i.OfficeAssignment)
.Include(i => i.Courses)
.Where(i => i.InstructorID == id)
.Single();
PopulateAssignedCourseData(instructor);
return View(instructor);
}

private void PopulateAssignedCourseData(Instructor instructor)
{
var allCourses = db.Courses;
var instructorCourses = new HashSet<int>(instructor.Courses.Select(c => c.CourseID));
var viewModel = new List<AssignedCourseData>();
foreach (var course in allCourses)
{
viewModel.Add(new AssignedCourseData
{
CourseID = course.CourseID,
Title = course.Title,
Assigned = instructorCourses.Contains(course.CourseID)
});
}
ViewBag.Courses = viewModel;
}

新创建的方法中，读取所有的课程实体，加载到视图模型中，对于每一个课程，检查这个课程是否存在于教师实体的 Courses 导航集合属性中。为了更加有效地遍历教师讲授的课程，将教师讲授的课程通过 HashSet 集合处理，课程中教师讲授的课程的 Assigned 属性被赋予 true。在视图中通过这个属性来判断复选框是否显示为选中状态。最后，这个集合通过 ViewBag 传递到视图中。

然后，增加当用户点击 Save 后执行的代码。将 HttpPost 中的 Edit 方法使用下面的代码替换掉，这里通过调用一个新的方法将教师 Instructor 的导航属性 Courses 更新。

[HttpPost]
public ActionResult Edit(int id, FormCollection formCollection, string[] selectedCourses)
{
var instructorToUpdate = db.Instructors
.Include(i => i.OfficeAssignment)
.Include(i => i.Courses)
.Where(i => i.InstructorID == id)
.Single();
if (TryUpdateModel(instructorToUpdate, "", null, new string[] { "Courses" }))
{
try
{
if (String.IsNullOrWhiteSpace(instructorToUpdate.OfficeAssignment.Location))
{
instructorToUpdate.OfficeAssignment = null;
}

UpdateInstructorCourses(selectedCourses, instructorToUpdate);

db.Entry(instructorToUpdate).State = EntityState.Modified;
db.SaveChanges();

return RedirectToAction("Index");
}
catch (DataException)
{
//Log the error (add a variable name after DataException)
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists, see your system administrator.");
}
}
PopulateAssignedCourseData(instructorToUpdate);
return View(instructorToUpdate);
}

private void UpdateInstructorCourses(string[] selectedCourses, Instructor instructorToUpdate)
{
if (selectedCourses == null)
{
instructorToUpdate.Courses = new List<Course>();
return;
}

var selectedCoursesHS = new HashSet<string>(selectedCourses);
var instructorCourses = new HashSet<int>
(instructorToUpdate.Courses.Select(c => c.CourseID));
foreach (var course in db.Courses)
{
if (selectedCoursesHS.Contains(course.CourseID.ToString()))
{
if (!instructorCourses.Contains(course.CourseID))
{
instructorToUpdate.Courses.Add(course);
}
}
else
{
if (instructorCourses.Contains(course.CourseID))
{
instructorToUpdate.Courses.Remove(course);
}
}
}
}

如果没有复选框被选中，在 UpdateInstructorCourse 方法中，使用一个空的集合来初始化 Courses 导航属性。

if (selectedCourses == null)
{
instructorToUpdate.Courses = new List();
return;
}

然后，代码遍历数据库中所有的课程，如果课程的复选框被选中了，但是没有包含在教师 Insturctor 的 Courses 集合中。这个课程将会被加入到导航属性集合中。

if (selectedCoursesHS.Contains(course.CourseID.ToString()))
{
if (!instructorCourses.Contains(course.CourseID))
{
instructorToUpdate.Courses.Add(course);
}
}

如果课程没有被选中，但是在教师的导航属性 Courses 集合中，就从集合属性中删除掉。

else
{
if (instructorCourses.Contains(course.CourseID))
{
instructorToUpdate.Courses.Remove(course);
}
}

在 Views\Instructor\Edit.cshtml 中，在 OfficeAssignment 区域的 div 之后，增加一个 Courses 区域，通过一组复选框来显示课程的状态。

<div class="editor-field">
<table>
<tr>
@{
int cnt = 0;
List<ContosoUniversity.ViewModels.AssignedCourseData> courses = ViewBag.Courses;

foreach (var course in courses) {
if (cnt++ % 3 == 0) {
@: </tr> <tr>
}
@: <td>
<input type="checkbox"
name="selectedCourses"
value="@course.CourseID"
@(Html.Raw(course.Assigned ? "checked=\"checked\"" : "")) />
@course.CourseID @: @course.Title
@:</td>
}
@: </tr>
}
</table>
</div>

代码创建一个 HTML 的三列表格，每一列中显示课程的标题和编号，后面跟着一个复选框。复选框的名称是相同的 ( “selectedCourses” )，这样在模型绑定的时候就会被连接成一组。复选框的 value 属性设置为 CourseID。当提交页面的时候，选中的复选框代表的 CourseID 将以数组的形式传递给控制器。

在复选框被初始化的时候，选中课程对应的复选框的 checked 属性被设置为选中状态。

在修改了课程状态之后，当回到 Index 页面的时候，需要验证这些修改。因此，需要在页面的表格中增加一列，在这里不需要使用 ViewBag，因为需要的信息已经通过教师实体 Instructor 的导航属性 Courses 传递到页面了。

在 Views\Instuctor\Index.cshtml 中，在 <th>Office</th> 之后，增加一个 <th>Course</th> 的标题列，如下所示。

<tr>
<th></th>
<th>Last Name</th>
<th>First Name</th>
<th>Hire Date</th>
<th>Office</th>
<th>Courses</th>
</tr>

然后，在办公位置的单元格之后增加一个详细内容的单元格。

<td>
@{
foreach (var course in item.Courses)
{
@course.CourseID @: @course.Title <br />
}
}
</td>

运行 Instructor 的 Index 页面，检查教师的授课情况。

点击 Edit 查看编辑页面。

修改一些课程的授课情况，然后保存 Save，修改的结果在 Index 页面中可以看到。

你已经完成了修改关联数据的工作。通过目前的课程你已经可以完成增、删、改、查所有的操作，但是还没有考虑并发问题。下一次我们将探讨并发问题，展示处理并发的方式，然后对已经完成的实体的增、删、改、查的代码增加并发处理。

本文链接

翻译：Contoso 大学 - 5 – 读取关联数据

2012-04-13T14:32:00Z

By Tom Dykstra, Tom Dykstra is a Senior Programming Writer on Microsoft's Web Platform & Tools Content Team.

原文地址：http://www.asp.net/mvc/tutorials/getting-started-with-ef-using-mvc/reading-related-data-with-the-entity-framework-in-an-asp-net-mvc-application

全文目录：Contoso 大学 - 使用 EF Code First 创建 MVC 应用

在前面的课程中已经完成了 School 数据模型。在这次的课程中，将要读取和显示相关的数据，这里指的是 EF 通过导航属性加载的数据。

下面的截图展示了你将好创建的页面。

5 – 1 延迟，饿汉，以及显式加载关联数据

EF 有多种方式可以通过导航属性加载关联的数据。

延迟加载 Lazy Loading。当实体第一次读取的时候，关联的数据并不会被获取。实际上，当第一次你实际访问关联属性的时候，被导航属性关联的数据才会被自动的读取。这可能导致多次查询被发送到数据库 – 一次是读取实体本身，对于关联的每个实体也需要分别读取。

饿汉加载 Eager Loaing。当实体加载的时候，相关联的数据也一起被加载。典型地用在一次连接查询返回所有需要的相关数据，通过使用 Include 方法实现饿汉加载。

显式加载 Explict Loading。这种方式类似于延迟加载，除了需要在代码中显式获取数据。在你访问导航属性的时候，不会出现自动加载。你自己手动加载关联的数据，通过访问对象状态管理器来获取实体，调用 Collection.Load 方法获取集合，或者通过调用持有单个实体的属性的 Reference.Load 方法。( 在下面的示例中，如果你希望加载 Administrator 导航属性，你应该将 Collection( x=>x.Course ) 替换为 Reference( x=>x.Administrator ) 。

因为不会立即获取关联属性的值，延迟加载和显式加载又被称为延后加载。

一般来说，如果你知道你需要每个实体的关联属性，饿汉加载提供了最好的性能。因为只有一次查询被发送到数据库，比对每个实体都要向数据库发出一次查询要更加有效。例如，在上面的例子中，假设每个系都有相关的课程，饿汉加载只需要一次联合查询就可以获得。而使用延迟加载或者显式加载则需要 11 次查询。

从另外的角度来说，如果你不常访问实体的导航属性，或者仅仅访问一小部分实体的导航属性，延迟加载更加有效，因为饿汉加载会加载更多地不必要的数据。通常情况下，在关闭了延迟加载的情况下使用显式加载。一个关闭延迟加载的场景是在进行序列化的时候，当你知道不需要所有的导航属性数据加载。如果延迟加载启用，所有的导航属性将会自动加载，因为序列化会访问所有的属性。

数据库上下文默认支持延迟加载，有两种方法可以关闭延迟加载：

对于特定的导航属性，在定义属性的时候取消 virtual
对于所有的导航属性，设置 LazyLoadingEnabled 为假。

延迟加载可能导致性能问题，例如，代码中没有指定使用饿汉加载或者显式加载，但是在处理大量实体的时候，遍历每个实体并访问其导航属性可能导致低效率 ( 因为多次访问数据库 )，但是使用延迟加载不会出现问题。在代码使用延迟加载的时候临时禁用延迟加载可能导致出现问题。因为导航属性为 null 而导致代码访问对象失败。

5 -2 创建显示系名称的课程页面

课程 Course实体包含一个所属系 Department 的导航属性，为了显示课程所属系的名称，你需要通过课程所属的系 Department 导航属性来获取系的名称 Name。

为课程实体 Course 创建一个控制器，使用与前面的学生 Student 相同的设置，如下图所示：

打开 Controllers\CourseController.cs ，找到 Index 方法。

public ViewResult Index()
{
var courses = db.Courses.Include(c => c.Department);
return View(courses.ToList());
}

自动生成的脚手架代码调用 Include 方法使用饿汉模式加载相关的系 Department 导航属性。

打开 Views\Course\Index.cshtml 文件，使用下面的代码替换原有代码。

@model IEnumerable<ContosoUniversity.Models.Course>

@{
ViewBag.Title = "Courses";
}

<h2>Courses</h2>

<p>
@Html.ActionLink("Create New", "Create")
</p>
<table>
<tr>
<th></th>
<th>Number</th>
<th>Title</th>
<th>Credits</th>
<th>Department</th>
</tr>

@foreach (var item in Model) {
<tr>
<td>
@Html.ActionLink("Edit", "Edit", new { id=item.CourseID }) |
@Html.ActionLink("Details", "Details", new { id=item.CourseID }) |
@Html.ActionLink("Delete", "Delete", new { id=item.CourseID })
</td>
<td>
@Html.DisplayFor(modelItem => item.CourseID)
</td>
<td>
@Html.DisplayFor(modelItem => item.Title)
</td>
<td>
@Html.DisplayFor(modelItem => item.Credits)
</td>
<td>
@Html.DisplayFor(modelItem => item.Department.Name)
</td>
</tr>
}
</table>

这段代码对脚手架代码做了如下的修改：

将标题从 Index 修改为 Course
将行的链接移到了左边
在列 Number 中显示了 CourseID 属性的值。( 脚手架不生成主键，因为通常没有字面的意义。在这里我们希望显示这个值而已 )
将最后一列标题从 DepartmentId 修改为 Department ( 系实体中的系名 )

注意，脚手架代码显示通过导航属性 Department 加载的系实体的 Name 属性值。

<td>
@Html.DisplayFor(modelItem => item.Department.Name)
</td>

重新运行这个页面，( 在 Contoso 大学的首页中选择 Courses )来显示系名称的列表。

5-3 创建显示课程和注册信息的教师页面

在这一节中，我们创建控制器和视图来显示教师实体。

这个页面使用下面的途径来读取和显示关联的数据：

教师列表中的办公室分配 OfficeAssignment 实体。教师实体与办公室分配之间是一对一或者一对零的关系，你将使用饿汉模式来加载办公室分配实体。从前所述，饿汉模式适合于当你需要主键表关联数据的时候，在这里，你需要显示所有教师的办公室分配。
当用户选中一个教师的时候，需要显示这个教师相关的课程实体。教师和课程之间存在多对多的关系。你将使用饿汉模式加载课程和相关的系实体。在这里，延迟加载可能更加有效，因为仅仅需要显示选中的教师的课程，实际上，这个例子展示了如何使用饿汉模式加载导航属性中的导航属性。
当用户选择课程之后，相关的注册实体 Enrollments 将会显示出来。Course 和 Enrollment 实体存在一对多的关系。你将使用显式加载来处理 Enrollment 实体，以及相关的学生 Student 实体。( 由于默认支持延迟加载，所以显示加载不是必须的。这里专门演示显式加载 )

5-3-1 创建教师页面的视图模型

教师页面显示三个不同的表。因此，需要创建一个新的视图模型，通过三个属性表示出来，每一个持有一张表的数据。

在 ViewModels 文件夹中，创建 InstructorIndexData.cs ，将生成的代码替换为以下代码。

using System;
using System.Collections.Generic;
using ContosoUniversity.Models;

namespace ContosoUniversity.ViewModels
{
public class InstructorIndexData
{
public IEnumerable<Instructor> Instructors { get; set; }
public IEnumerable<Course> Courses { get; set; }
public IEnumerable<Enrollment> Enrollments { get; set; }
}
}

5-3-2 对选中的行增加一个样式

需要通过不同的背景色来标识选中的行，为 UI 提供一种新的样式，将下面的代码增加到 Content/Site.css 文件中标记为 MISC 的节中，如下所示。

/* MISC
----------------------------------------------------------*/
.selectedrow
{
background-color: #EEEEEE;
}

5-3-3 创建教师控制器和视图

为教师实体类型创建一个控制器。使用类似前面 Student 控制器的方式创建，如下所示：

打开 Controllers\InstructorController.cs ，为 ViewModels 命名空间增加 using 引用。

using ContosoUniversity.ViewModels;

脚手架生成的代码仅仅对 OfficeAssignment 导航属性使用饿汉加载模式。

public ViewResult Index()
{
var instructors = db.Instructors.Include(i => i.OfficeAssignment);
return View(instructors.ToList());
}

使用下面的代码替换原有的 Index 方法，读取关联的数据，通过 ViewModel 来保存。

public ActionResult Index(Int32? id, Int32? courseID)
{
var viewModel = new InstructorIndexData();
viewModel.Instructors = db.Instructors
.Include(i => i.OfficeAssignment)
.Include(i => i.Courses.Select(c => c.Department))
.OrderBy(i => i.LastName);

if (id != null)
{
ViewBag.InstructorID = id.Value;
viewModel.Courses = viewModel.Instructors.Where(i => i.InstructorID == id.Value).Single().Courses;
}

if (courseID != null)
{
ViewBag.CourseID = courseID.Value;
viewModel.Enrollments = viewModel.Courses.Where(x => x.CourseID == courseID).Single().Enrollments;
}

return View(viewModel);
}

方法通过查询串接收一个可选的教师 Id 和选中的课程，然后将所有需要的数据传递给视图。查询串通过页面上的 Select 超级链接提供。

代码首先创建 ViewModel 的实例，然后将教师实体列表保存在其中。

var viewModel = new InstructorIndexData();
viewModel.Instructors = db.Instructors
.Include(i => i.OfficeAssignment);
.Include(i => i.Courses.Select(c => c.Department))
.OrderBy(i => i.LastName);

代码使用饿汉模式加载 Instructor.OfficeAssignment 和 Instructor.Courses 导航属性。对于关联的 Course 实体，通过在 Inclue 中使用 Select 方法饿汉模式加载，结果使用 LastName 进行排序。

如果某个教师被选中了，选中的教师从 ViewModel 中的教师列表中被选出。视图模型的 Courses 属性通过教师的 Courses 属性加载相关的课程 Course 实体。

if (id != null)
{
ViewBag.InstructorID = id.Value;
viewModel.Courses = viewModel.Instructors.Where(i => i.InstructorID == id.Value).Single().Courses;
}

Where 方法返回一个集合，但是这里的情况将仅仅返回一个教师实体，Single 方法将集合转化成一个单个的实体，以便访问这个实体的 Course 属性。

在你知道集合中仅仅包含一个实体的时候，可以使用 Single 方法。Single 方法在集合中为空的时候将会抛出异常，或者在集合中包含多于一个实体的时候也会抛出异常。另外一个替换的方法是 SingleOrDefault 方法，在集合为空的时候，这个方法返回 null。实际上，在这里还是会抛出异常 ( 试图在空引用上访问 Courses 属性的时候 )，异常的信息将会简单地说明这个问题，在调用 Single 方法的时候，还可以传递一个条件来代替通过 Where 传递的条件。

.Single(i => i.InstructorID == id.Value)

替换掉：

.Where(I => i.InstructorID == id.Value).Single()

下一步，如何选中了一个课程 Course，选中的课程从视图模型 ViewModel 的 Courses 属性中获取，然后，模型的 Enrollments 属性通过课程对象的 Enrollments 导航属性被加载。

if (courseID != null)
{
ViewBag.CourseID = courseID.Value;
viewModel.Enrollments = viewModel.Courses.Where(x => x.CourseID == courseID).Single().Enrollments;
}

最后，模型被传递到视图。

return View(viewModel);

5-3-4 修改教师 Instructor 视图

打开 Views\Instructor\Index.cshtml, 使用如下的代码替换原有内容。

@model ContosoUniversity.ViewModels.InstructorIndexData

@{
ViewBag.Title = "Instructors";
}

<h2>Instructors</h2>

<p>
@Html.ActionLink("Create New", "Create")
</p>
<table>
<tr>
<th></th>
<th>Last Name</th>
<th>First Name</th>
<th>Hire Date</th>
<th>Office</th>
</tr>
@foreach (var item in Model.Instructors)
{
string selectedRow = "";
if (item.InstructorID == ViewBag.InstructorID)
{
selectedRow = "selectedrow";
}
<tr class="@selectedRow" valign="top">
<td>
@Html.ActionLink("Select", "Index", new { id = item.InstructorID }) |
@Html.ActionLink("Edit", "Edit", new { id = item.InstructorID }) |
@Html.ActionLink("Details", "Details", new { id = item.InstructorID }) |
@Html.ActionLink("Delete", "Delete", new { id = item.InstructorID })
</td>
<td>
@item.LastName
</td>
<td>
@item.FirstMidName
</td>
<td>
@String.Format("{0:d}", item.HireDate)
</td>
<td>
@if (item.OfficeAssignment != null)
{
@item.OfficeAssignment.Location
}
</td>
</tr>
}
</table>

我们对原有的代码做了如下的变动：

将标题从 Index 替换成Instructors
将行的链接移到了左边
删除了 FullName 列
增加了 Office 列，仅在 item.OfficeAssignment 非空的时候显示 item.OfficeAssignment.Location 属性。( 这里是一对一或者一对零的关系，可能没有关联的 OfficeAssignment 实体 )

<td>
@if (item.OfficeAssignment != null)
{
@item.OfficeAssignment.Location
}
</td>

对选中教师对应行的 tr 元素，通过代码动态增加样式 class=”selectedrow”。这里通过前面创建的样式类对选中的行设置背景色。( 在你在表中增加多行的列时， valign 属性非常有用 )

string selectedRow = "";
if (item.InstructorID == ViewBag.InstructorID)
{
selectedRow = "selectedrow";
}
<tr class="@selectedRow" valign="top">

在其他链接的前面，增加了一个名为 Select 的新的 ActionLink ，用来将选中的教师 Id 传递到 Index 方法。

运行页面，查看教师列表，页面上显示了教师相关的 OfficeAssignment 导航属性的 Location 属性值，如果没有相关的办公室则显示为空。

如果 Views\Instructor\Index.cshtml 文件还打开，在 table 元素的后面，增加如下的代码，用来显示选中教师的课程列表。

@if (Model.Courses != null)
{
<h3>Courses Taught by Selected Instructor</h3>
<table>
<tr>
<th></th>
<th>ID</th>
<th>Title</th>
<th>Department</th>
</tr>

@foreach (var item in Model.Courses)
{
string selectedRow = "";
if (item.CourseID == ViewBag.CourseID)
{
selectedRow = "selectedrow";
}
<tr class="@selectedRow">
<td>
@Html.ActionLink("Select", "Index", new { courseID = item.CourseID })
</td>
<td>
@item.CourseID
</td>
<td>
@item.Title
</td>
<td>
@item.Department.Name
</td>
</tr>
}

</table>
}

代码读取 ViewModel 的 Courses 属性来显示课程列表。同时还提供了 Select 链接用来发送选中的课程 Id 给 Index 方法。

运行页面，选中一个教师，现在可以显示这个教师的课程列表，可以看到每个课程所属的系。

注意，如果选中的行没有被高亮显示，刷新一下浏览器，可能需要重新加载页面相关的样式表文件。

在刚刚增加的代码块之后，增加如下的代码，用来显示注册到选中课程的学生列表。

@if (Model.Enrollments != null)
{
<h3>
Students Enrolled in Selected Course</h3>
<table>
<tr>
<th>Name</th>
<th>Grade</th>
</tr>
@foreach (var item in Model.Enrollments)
{
<tr>
<td>
@item.Student.FullName
</td>
<td>
@Html.DisplayFor(modelItem => item.Grade)
</td>
</tr>
}
</table>
}

代码从视图模型读取 Enrollments 属性来显示注册到课程的学生列表，DisplayFor 方法住手方法用来是的在成绩为 null 的时候显示 “No grade”，如在这个属性的 DisplayFormat 特性中定义的那样。

运行页面，选中教师，然后选中一个课程来查看注册课程的学生和他们的成绩。

5-3-5 增加显式加载

打开InstructorController.cs 文件，查看Index 方法如何获取注册学生的列表。

if (courseID != null)
{
ViewBag.CourseID = courseID.Value;
viewModel.Enrollments = viewModel.Courses.Where(x => x.CourseID == courseID).Single().Enrollments;
}

在获取教师列表的时候，使用饿汉模式加载 Courses 导航属性值，以及 Department 导航属性的值。然后将结果保存到视图模型的 Courses 集合中，再从这个集合的一个实体中访问注册实体。因为没有对Course.Enrollements 属性指定饿汉加载，出现在页面上时将使用延迟加载。

如果仅仅禁用延迟加载而不采取其他的措施，Enrollments 属性将是 null ，而不管实际上有多少注册。在这种情况下，就必须要么指定饿汉加载，要么指定显式加载。你已经见到了如何使用饿汉加载，因为展示如何使用显式加载，将 Index 方法中替换为如下的代码，这里使用显式加载来读取 Enrollments 属性。

public ActionResult Index(Int32? id, Int32? courseID)
{
var viewModel = new InstructorIndexData();
viewModel.Instructors = db.Instructors
.Include(i => i.OfficeAssignment)
.Include(i => i.Courses.Select(c => c.Department))
.OrderBy(i => i.LastName);

if (id != null)
{
ViewBag.InstructorID = id.Value;
viewModel.Courses = viewModel.Instructors.Where(i => i.InstructorID == id.Value).Single().Courses;
}

if (courseID != null)
{
ViewBag.CourseID = courseID.Value;

var selectedCourse = viewModel.Courses.Where(x => x.CourseID == courseID).Single();
db.Entry(selectedCourse).Collection(x => x.Enrollments).Load();
foreach (Enrollment enrollment in selectedCourse.Enrollments)
{
db.Entry(enrollment).Reference(x => x.Student).Load();
}

viewModel.Enrollments = selectedCourse.Enrollments;
}

return View(viewModel);
}

在获取了选中的 Course 实体后，新的代码显式加载课程的 Enrollments 导航属性。

db.Entry(selectedCourse).Collection(x => x.Enrollments).Load();

然后显式加载每个注册 Enrollment 实体相关的学生 Student 实体。

db.Entry(enrollment).Reference(x => x.Student).Load();

注意这里使用 Collection 方法来加载属性集合。对于单值得导航属性，使用 Reference 方法。再次运行程序，显示的页面并没有什么不同，虽然已经修改了获取数据的方式。

现在，你已经使用了三种加载方式 ( 延迟，饿汉，显式 )来加载导航属性相关的数据，下一次，我们将学习如何更新相关的数据。

本文链接

jQuery DatePicker 与ASP.NET的验证控件结合 Bug 处理

2012-04-12T14:15:00Z

我们开发ASP.NET站点时，如果将jQuery UI Datepicker与ASP.NET的验证控件（如：RequiredFieldValidator）组合使用：
<asp:TextBoxID="txtDate"runat="server"></asp:TextBox>
<asp:RequiredFieldValidatorID="reqDate"runat="server"ControlToValidate="txtDate"ErrorMessage="*"></asp:RequiredFieldValidator>
<scripttype="text/javascript">$("#<%= txtDate.ClientID %>").datepicker();
</script>
那么当我们在Datepicker中选择某个日期时就会出现“'length'为空或不是对象”的错误。这由于Datepicker的bug造成的，经过我的研究，找到了一个很简单的解决方法——捕获Datepicker的onSelect事件，但不做任何处理：
$("#<%= txtDate.ClientID %>").datepicker({
onSelect: function(dateText, inst) {
// 不做任何处理
}
});
现在我们选择某个日期后就不会出现“'length'为空或不是对象”的错误了，而ASP.NET验证控件也可照常运行。

本文链接

翻译：Contoso 大学 - 4 - 创建更加复杂的数据模型

2012-04-10T14:12:00Z

原文地址：http://www.asp.net/mvc/tutorials/getting-started-with-ef-using-mvc/creating-a-more-complex-data-model-for-an-asp-net-mvc-application

全文目录：Contoso 大学 - 使用 EF Code First 创建 MVC 应用

4 – 创建更加复杂的数据模型

在前面的课程中，你已经创建了一个简单的由三个实体组成的数据模型。在这个课程中，你将要增加更多的实体，以及关系，使用数据标注特性来控制模型类的行为。

在完成的时候，实体类表示的完整数据模型如下所示：

4-1 使用特性控制格式、验证以及数据库映射

在这一节中，你将会看到如何使用特性来控制数据模型的格式化、验证以及数据库映射。然后在后继的节中，将要通过为已经创建的类、新创建的类增加特性，来创建完整的 School 数据模型。

4-1-1 DisplayFormat 特性

对于学生的注册日期来说，虽然你只关心注册的日期，但是现在的页面在日期之后还显示了时间。通过使用数据标注特性，可以通过一点代码就可以在所有的地方修补这个问题。看一下示例，你就可以为 Student 类的 EnrollmentDate 属性增加一个特性了。

在 Models\Student.cs ，在开始部分为命名空间 System.ComponentModel.DataAnnotations 增加一个 using 语句，然后在 EnrollmentDate 属性上增加一个 DisplayFormat 的特性。如下所示：

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace ContosoUniversity.Models
{
public class Student
{
public int StudentID { get; set; }
public string LastName { get; set; }
public string FirstMidName { get; set; }

[DisplayFormat(DataFormatString = "{0:d}", ApplyFormatInEditMode = true)]
public DateTime EnrollmentDate { get; set; }

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

格式化串指定了在显示这个属性的时候仅仅使用短日期格式。ApplyFormatInEditMode 指定即使在将这个属性的值显示在文本框中进行编辑的时候也应用这个特性。( 有些字段不需要这些特殊设置，比如，在文本框中编辑货币的时候，就不会希望出现货币符号 )。

再次运行程序，你会注意到注册时间不再是长日期格式了，如果你查看其他的学生页面也会看到同样的结果。

4-1-2 MaxLength 特性

还可以通过特性来指定数据验证规则和错误提示信息。假设你希望用户在输入名字的时候不能超过 50 个字符长度，对于这个限制，可以为 LastName 属性和 FirstName 属性增加 MaxLength 特性，如下所示.

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace ContosoUniversity.Models
{
public class Student
{
public int StudentID { get; set; }

[MaxLength(50)]
public string LastName { get; set; }

[MaxLength(50, ErrorMessage = "First name cannot be longer than 50 characters.")]
public string FirstMidName { get; set; }

[DisplayFormat(DataFormatString = "{0:d}", ApplyFormatInEditMode = true)]
public DateTime EnrollmentDate { get; set; }

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

如果用户为 LastName 输入一个超长的名字，默认的错误信息就会显示出来，如果输入一个超长的 FirstName，你定制的错误信息会被显示出来。

运行程序，输入两个超过 50 个字符的超长名字，然后点击 Create 来查看错误信息。( 但是你需要输入一个正确的日期来通过验证 )

对于字符串属性总是指定最大长度是个好主意。如果没有这样做，在 CodeFirst 创建数据库的时候，相关的数据库中的列宽度就会被设置为字符串的最大长度，这可能会导致低效的数据库结构。

4-1-3 Column 特性

还可以通过特性来控制你的模型类及属性如何映射到数据库。假设你已经使用 FirstMidName 来表示名字，因为属性也包含了中间名，但是你希望数据库中的列名为 FirstName，因为编写本地查询的用户习惯使用这个名字，要完成这种映射，你可以使用 Column 特性。

Column 特性在数据库创建的时候被使用。Student 的属性 FirstMidName 在数据库中将被命名为 FirstName。也就是说，当你的代码使用 Student.FirstMidName 的时候，数据将来自数据库中 Student 表的 FirstName 列 ( 如果你没有指定列名，默认将与属性同名 )

为 FirstMidName 增加列名的映射特性，如下所示。

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

再次运行程序，你会发现没有任何变化。( 不能仅仅运行程序，然后查看主页。你需要选择 Student 的 Index 页面，因为这将导致对数据库的访问，这会使数据库首先被自动删除，然后重建 )。实际上，如果你在服务器资源管理器中打开数据库，展开 Student 表，就会发现列名 FirstName。

在属性窗口，你还会发现与此列相关的字段被定义为 50 个字符长度，与你在前面增加的 MaxLength 特性相一致。

在另外一些情况下，你还可以通过方法调用进行映射，后面就会看到。

在后面的段落中，你使用到更多的数据标注来扩展学校数据模型。在每节中，你要为实体创建一个类，或者修改前面创建的类。

注意：如果在完成所有的实体之间，你试图编译，可能会遇到编译错误。

4-2 创建 Instructor 实体

创建 Models\Instructor.cs, 使用下面的代码替换生成的代码。

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace ContosoUniversity.Models
{
public class Instructor
{
public Int32 InstructorID { get; set; }

[Required(ErrorMessage = "Last name is required.")]
[Display(Name="Last Name")]
[MaxLength(50)]
public string LastName { get; set; }

[Required(ErrorMessage = "First name is required.")]
[Column("FirstName")]
[Display(Name = "First Name")]
[MaxLength(50)]
public string FirstMidName { get; set; }

[DisplayFormat(DataFormatString = "{0:d}", ApplyFormatInEditMode = true)]
[Required(ErrorMessage = "Hire date is required.")]
[Display(Name = "Hire Date")]
public DateTime? HireDate { get; set; }

public string FullName
{
get
{
return LastName + ", " + FirstMidName;
}
}

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

注意Student 和 Instructor 实体多数属性是类似的。在这个系列后面实现继承的部分，会对代码进行重构，使用继承来消除重复。

4-2-1 Required 和 Display 特性

在 LastName 属性上的特性指定这是一个必须字段，在编辑的文本框上的提示文本应该为 “Last Name” ( 代替属性名称，属性名中间没有空格 )，而且字段的值不能超过 50 个字符。

[Required(ErrorMessage = "Last name is required.")]
[Display(Name="Last Name")]
[MaxLength(50)]
public string LastName { get; set; }

4-2-2 FullName 计算属性

FullName 是计算属性，返回其他两个属性计算出的结果。因此它只有 get 访问方法，而且在数据库中没有名为 FullName 的字段。

public string FullName
{
get
{
return LastName + ", " + FirstMidName;
}
}

4-2-3 Courses 和 OfficeAssignment 导航属性

Courses 和 OfficeAssignment 属性是导航属性，像我们在前面说明的，它们典型地被定义为虚拟的 virtual，以便 EF 的延迟加载特性可以提供帮助，另外，如果导航属性可以包含多个实体，它的类型必须为 ICollection。

一个教师可以教授多门课程，所以 Courses 被定义为 Course 的集合。另一方面，一个教师仅有一间办公室，所以 OfficeAssignment 被定义为单个的 OfficeAssignment 实体 ( 如果没有办公室的话，可能为 null )。

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

4-3 创建 OfficeAssignment 实体

创建 Models\OfficeAssignment.cs, 将生成的代码替换为以下代码。

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace ContosoUniversity.Models
{
public class OfficeAssignment
{
[Key]
public int InstructorID { get; set; }

[MaxLength(50)]
[Display(Name = "Office Location")]
public string Location { get; set; }

public virtual Instructor Instructor { get; set; }
}
}

4-3-1 Key 特性

在 Instructor 和 OfficeAssignment 实体之间存在一对一或者一对零的关系。一个办公室分配仅仅存在于被分配给教师的时候。进而，它的主键也应该是 Instructor 实体的外键。但是 EF 并不能自动将 InstructorID 作为分配的主键，因为名字不符合约定，既不是 ID ，也不是类名加上 ID，因此，使用 Key 特性来标识这是一个主键。

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

在主键的属性名既不是 Id 也不是类名加上 ID 的时候，可以通过 Key 特性。

4-3-2 Instructor 导航属性

Instructor 实体有一个可空的 OfficeAssignment 导航属性 ( 因为教师可能没有分配办公室 )，在 OfficeAssignment 实体上则有一个不可为空的 Instructor 导航属性 ( 因为办公室分配不可能在没有教师的情况下存在 )，当 Instructor 实体关联到 OfficeAssignment 实体的时候，它们可以通过导航属性相互引用对方。

4-4 修改 Course 实体

在 Models\Course.cs, 将原来的代码替换为如下代码。

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

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

[Required(ErrorMessage = "Title is required.")]
[MaxLength(50)]
public string Title { get; set; }

[Required(ErrorMessage = "Number of credits is required.")]
[Range(0,5,ErrorMessage="Number of credits must be between 0 and 5.")]
public int Credits { get; set; }

[Display(Name = "Department")]
public int DepartmentID { get; set; }

public virtual Department Department { get; set; }
public virtual ICollection<Enrollment> Enrollments { get; set; }
public virtual ICollection<Instructor> Instructors { get; set; }
}
}

4-4-1 DatabaseGenerated 特性

在 CourseID 属性上的DatabaseGenerated 特性，使用了 None 参数，指定主键将由用户提供，而不是通过数据库自动生成。

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

默认情况下，EF 假设主键由数据库自动生成。这可以用于大多数场景下，但是，对于 Course 实体来说，你希望使用自定义的课程编号，例如：1000 序列表示一个系，2000 序列表示另外一个系等等。

4-4-2 外键和导航属性

在 Course 实体中的外键属性和导航属性，反射了如下的关系：

一个课程属于一个系，所以存在一个 DepartmentID 外键和一个 Department 导航属性：

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

一个课程可以被多个学生注册，所以存在一个 Enrollments 导航属性

public virtual ICollection Enrollments { get; set; }

一个课程可能被多名教师教授，所以这里存在一个 Instructors 导航属性。

public virtual ICollection<Instructor> Instructors { get; set; }

4-5 创建 Department 实体

创建 Models\Department.cs, 使用下面的代码替换生成的内容，如下所示。

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace ContosoUniversity.Models
{
public class Department
{
public int DepartmentID { get; set; }

[Required(ErrorMessage = "Department name is required.")]
[MaxLength(50)]
public string Name { get; set; }

[DisplayFormat(DataFormatString="{0:c}")]
[Required(ErrorMessage = "Budget is required.")]
[Column(TypeName="money")]
public decimal? Budget { get; set; }

[DisplayFormat(DataFormatString="{0:d}", ApplyFormatInEditMode=true)]
[Required(ErrorMessage = "Start date is required.")]
public DateTime StartDate { get; set; }

[Display(Name="Administrator")]
public int? InstructorID { get; set; }

public virtual Instructor Administrator { get; set; }
public virtual ICollection<Course> Courses { get; set; }
}
}

4-5-1 Column 特性

前面我们使用 Column 特性改变了默认的列名映射。在 Department 实体中，Column 特性被用来改变 SQL 数据类型映射，以便在数据库中使用 SQL Server 的 money 数据类型。

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

通常并不需要，因为 EF 会基于属性的 CLR 数据类型来选择合适的 SQL Server 数据类型。对于 CLR 中的 decimal 类型会映射到 SQL Server 中的 decimal 类型。但在这里，你知道这个列将会保存合计，所以 money 数据类型更加合适。

4-5-2 外键和导航属性

外键和导航属性反映了如下关系：

一个系可能有或者没有一个系主任，系主任通常是教师。进而 InstructorID 属性包含了一个教师实体的外键。加在 int 类型后面的问号表示这是一个可空类型，导航属性名为 Administrator ，实际保存 Instructor 实体的引用。

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

一个系可能有多个课程，所以 Courses 是导航属性。

public virtual ICollection Courses { get; set; }

注意：

默认情况下， EF 允许非空外键和多对多关系的级联删除。这可能会导致环形删除，在你的初始化代码运行的时候导致异常。例如，如果你没有定义 Department.InstructorID 属性作为可空类型，在初始化的时候，你会得到如下的异常："The referential relationship will result in a cyclical reference that's not allowed."

4-6 修改 Student 实体

打开 Models\Student.cs, 将早前的代码替换为如下代码。

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace ContosoUniversity.Models
{
public class Student
{
public int StudentID { get; set; }

[Required(ErrorMessage = "Last name is required.")]
[Display(Name="Last Name")]
[MaxLength(50)]
public string LastName { get; set; }

[Required(ErrorMessage = "First name is required.")]
[Column("FirstName")]
[Display(Name = "First Name")]
[MaxLength(50)]
public string FirstMidName { get; set; }

[Required(ErrorMessage = "Enrollment date is required.")]
[DisplayFormat(DataFormatString = "{0:d}", ApplyFormatInEditMode = true)]
[Display(Name = "Enrollment Date")]
public DateTime? EnrollmentDate { get; set; }

public string FullName
{
get
{
return LastName + ", " + FirstMidName;
}
}

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

这段代码中仅仅增加了一些你已经见过的特性。

4-7 修改 Enrollment 实体

打开 Models\Enrollment.cs，使用如下代码替换原来的代码。

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace ContosoUniversity.Models
{
public class Enrollment
{
public int EnrollmentID { get; set; }

public int CourseID { get; set; }

public int StudentID { get; set; }

[DisplayFormat(DataFormatString="{0:#.#}",ApplyFormatInEditMode=true,NullDisplayText="No grade")]
public decimal? Grade { get; set; }

public virtual Course Course { get; set; }
public virtual Student Student { get; set; }
}
}

4-7-1 外键和导航属性

外键和导行属性反映了如下的关系：

一条注册信息用于单个课程，所以存在一个 CourseID 外键属性和一个 Course 导航属性。

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

一条注册信息用于一个学生，所以存在一个 StudentID 外键和一个 Student 导航属性。

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

4-7-2 多对多关系

在学生实体和课程实体之间存在多对多的关系。在数据库中，Enrollment 实体在两张表之间承担了多对多的关联。这意味着 Enrollment 表中还包含了关联表中额外的数据 ( 在这里，一个主键和一个成绩 Grade 属性 )。

下图展示了在实体图中的关系。( 这张图使用 EF 的设计器生成，创建这种图不是这个系列关注的内容，这里仅仅用来说明 )。

每个关联线的两端有一个 1 和一个星 *，表示一对多的关系。

如果注册表中不包含成绩信息，那就可以仅仅包含两个外键 CourseId 和 StudentId。在这中情况下，在关联表中就没有额外的信息 ( 或者是纯的链接表 )，你也就完全没有必要创建这个注册的模型。教师 Instructor 和课程 Course 实际直接使用多对多关联，如你所见，在它们之间没有其他的实体。

在数据库中需要一个关联表，如下所示。

EF 将会自动创建 CourseInstructor 表，你可以间接地读取或者更新其中的数据，通过读写 Instructor.Courses 和 Course.Instructors 导航属性。

4-7-3 DisplayFormat 特性

在成绩 Grade 属性上的 DisplayFormat 特性指定数据如何被格式化。

[DisplayFormat(DataFormatString="{0:#.#}",ApplyFormatInEditMode=true,NullDisplayText="No grade")]
public decimal? Grade { get; set; }

成绩显示为通过圆点分割的两个数字，例如：3.5 或者 4.0
在编辑模式 ( 例如文本框中 )也需要这样显示。
如果没有成绩 ( 在 decimal 后面的问号表示这是可空类型 )，显示 “No”

4-8 实体关系图

下面是通过 EF 设计器创建的学校实体关系图。

除了多对多的关联线，以及一对多的关联线。还可以看到在 Instructor 与 OfficeAssignment之间的一对一或一对零的关联线，Instructor 与 Department 实体之间的零或一对多的关联线。

4-9 定制数据库上下文

下一步将要为 SchoolContext 增加一些新的实体，通过 Fluent API 调用定义一些映射关系( 这个 API 被称为流畅的，是因为经常将一连串的调用写在一行语句中 )。有些时候你需要通过调用方法而不是使用特性，因为对于某些特定的功能没有合适的特性可用，如果存在的话，可以在使用特性和方法之间进行选择。( 有些人不喜欢使用特性 )

将 DAL\SchoolContext.cs 中的代码替换为如下内容：

using System;
using System.Collections.Generic;
using System.Data.Entity;
using ContosoUniversity.Models;
using System.Data.Entity.ModelConfiguration.Conventions;

namespace ContosoUniversity.Models
{
public class SchoolContext : DbContext
{
public DbSet<Course> Courses { get; set; }
public DbSet<Department> Departments { get; set; }
public DbSet<Enrollment> Enrollments { get; set; }
public DbSet<Instructor> Instructors { get; set; }
public DbSet<Student> Students { get; set; }
public DbSet<OfficeAssignment> OfficeAssignments { get; set; }

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
modelBuilder.Entity<Instructor>()
.HasOptional(p => p.OfficeAssignment).WithRequired(p => p.Instructor);
modelBuilder.Entity<Course>()
.HasMany(c => c.Instructors).WithMany(i => i.Courses)
.Map(t => t.MapLeftKey("CourseID")
.MapRightKey("InstructorID")
.ToTable("CourseInstructor"));
modelBuilder.Entity<Department>()
.HasOptional(x => x.Administrator);
}
}
}

在 OnModelCreating 方法中的新的语句指定了如下关系：

在 Instructor 和 OfficeAssignment 之间一对一或者一对零的关系

modelBuilder.Entity<Instructor>()
.HasOptional(p => p.OfficeAssignment).WithRequired(p => p.Instructor);

在 Instructor 和 Course 实体之间多对多的关系。代码中指定了关联表及其列名。EF CodeFirst 不需要这些代码就可以自动为你配置关系，但是，如果没有调用它，你会得到默认的名称，例如对于 InstructorID 列来说得到 InstructorInstructorID 。

modelBuilder.Entity<Course>()
.HasMany(c => c.Instructors).WithMany(i => i.Courses)
.Map(t => t.MapLeftKey("CourseID")
.MapRightKey("InstructorID")
.ToTable("CourseInstructor"));

在 Instructor 和 Department 表之间的零对多或者一对多关系，或者说，一个系可能有也可能没有一个教师被作为系主任，作为系主任的教师通过导航属性 Department.Administrator 表示。

modelBuilder.Entity<Department>()
.HasOptional(x => x.Administrator);

关于更加详细的 Fluent API 语法说明，可以参见博客 Fluent API 。

4-10 使用测试数据初始化数据库

在前面的课程中，你已经创建了 DAL\SchoolInitializer.cs 用测试数据初始化数据库，现在使用下面的代码替换掉原有的代码，以便使用新创建的实体。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Data.Entity;
using ContosoUniversity.Models;

namespace ContosoUniversity.DAL
{
public class SchoolInitializer : DropCreateDatabaseIfModelChanges<SchoolContext>
{
protected override void Seed(SchoolContext context)
{
var students = new List<Student>
{
new Student { FirstMidName = "Carson", LastName = "Alexander", EnrollmentDate = DateTime.Parse("2005-09-01") },
new Student { FirstMidName = "Meredith", LastName = "Alonso", EnrollmentDate = DateTime.Parse("2002-09-01") },
new Student { FirstMidName = "Arturo", LastName = "Anand", EnrollmentDate = DateTime.Parse("2003-09-01") },
new Student { FirstMidName = "Gytis", LastName = "Barzdukas", EnrollmentDate = DateTime.Parse("2002-09-01") },
new Student { FirstMidName = "Yan", LastName = "Li", EnrollmentDate = DateTime.Parse("2002-09-01") },
new Student { FirstMidName = "Peggy", LastName = "Justice", EnrollmentDate = DateTime.Parse("2001-09-01") },
new Student { FirstMidName = "Laura", LastName = "Norman", EnrollmentDate = DateTime.Parse("2003-09-01") },
new Student { FirstMidName = "Nino", LastName = "Olivetto", EnrollmentDate = DateTime.Parse("2005-09-01") }
};
students.ForEach(s => context.Students.Add(s));
context.SaveChanges();

var instructors = new List<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") }
};
instructors.ForEach(s => context.Instructors.Add(s));
context.SaveChanges();

var departments = new List<Department>
{
new Department { Name = "English", Budget = 350000, StartDate = DateTime.Parse("2007-09-01"), InstructorID = 1 },
new Department { Name = "Mathematics", Budget = 100000, StartDate = DateTime.Parse("2007-09-01"), InstructorID = 2 },
new Department { Name = "Engineering", Budget = 350000, StartDate = DateTime.Parse("2007-09-01"), InstructorID = 3 },
new Department { Name = "Economics", Budget = 100000, StartDate = DateTime.Parse("2007-09-01"), InstructorID = 4 }
};
departments.ForEach(s => context.Departments.Add(s));
context.SaveChanges();

var courses = new List<Course>
{
new Course { CourseID = 1050, Title = "Chemistry", Credits = 3, DepartmentID = 3, Instructors = new List<Instructor>() },
new Course { CourseID = 4022, Title = "Microeconomics", Credits = 3, DepartmentID = 4, Instructors = new List<Instructor>() },
new Course { CourseID = 4041, Title = "Macroeconomics", Credits = 3, DepartmentID = 4, Instructors = new List<Instructor>() },
new Course { CourseID = 1045, Title = "Calculus", Credits = 4, DepartmentID = 2, Instructors = new List<Instructor>() },
new Course { CourseID = 3141, Title = "Trigonometry", Credits = 4, DepartmentID = 2, Instructors = new List<Instructor>() },
new Course { CourseID = 2021, Title = "Composition", Credits = 3, DepartmentID = 1, Instructors = new List<Instructor>() },
new Course { CourseID = 2042, Title = "Literature", Credits = 4, DepartmentID = 1, Instructors = new List<Instructor>() }
};
courses.ForEach(s => context.Courses.Add(s));
context.SaveChanges();

courses[0].Instructors.Add(instructors[0]);
courses[0].Instructors.Add(instructors[1]);
courses[1].Instructors.Add(instructors[2]);
courses[2].Instructors.Add(instructors[2]);
courses[3].Instructors.Add(instructors[3]);
courses[4].Instructors.Add(instructors[3]);
courses[5].Instructors.Add(instructors[3]);
courses[6].Instructors.Add(instructors[3]);
context.SaveChanges();

var enrollments = new List<Enrollment>
{
new Enrollment { StudentID = 1, CourseID = 1050, Grade = 1 },
new Enrollment { StudentID = 1, CourseID = 4022, Grade = 3 },
new Enrollment { StudentID = 1, CourseID = 4041, Grade = 1 },
new Enrollment { StudentID = 2, CourseID = 1045, Grade = 2 },
new Enrollment { StudentID = 2, CourseID = 3141, Grade = 4 },
new Enrollment { StudentID = 2, CourseID = 2021, Grade = 4 },
new Enrollment { StudentID = 3, CourseID = 1050 },
new Enrollment { StudentID = 4, CourseID = 1050, },
new Enrollment { StudentID = 4, CourseID = 4022, Grade = 4 },
new Enrollment { StudentID = 5, CourseID = 4041, Grade = 3 },
new Enrollment { StudentID = 6, CourseID = 1045 },
new Enrollment { StudentID = 7, CourseID = 3141, Grade = 2 },
};
enrollments.ForEach(s => context.Enrollments.Add(s));
context.SaveChanges();

var officeAssignments = new List<OfficeAssignment>
{
new OfficeAssignment { InstructorID = 1, Location = "Smith 17" },
new OfficeAssignment { InstructorID = 2, Location = "Gowan 27" },
new OfficeAssignment { InstructorID = 3, Location = "Thompson 304" },
};
officeAssignments.ForEach(s => context.OfficeAssignments.Add(s));
context.SaveChanges();
}
}
}

像在前面一样，大多数的代码是简单地创建实体对象，通过必须的属性加载简单的测试数据，注意 Course 实体，它和 Instructor 实体之间存在多对多的关联。

var courses = new List
{
new Course { CourseID = 1050, Title = "Chemistry", Credits = 3, DepartmentID = 3, Instructors = new List() },
...
};
courses.ForEach(s => context.Courses.Add(s));
context.SaveChanges();

courses[0].Instructors.Add(instructors[0]);
...
context.SaveChanges();

当创建 Course 对象的时候，通过创建空的集合初始化了 Instructor 导航属性，使用代码 Instructors = new List()。这使得为课程相关的教师可以通过 Instructors.Add 方法加入，如果没有创建空的集合列表，你就不能增加这些关系，因为 Instructors 属性为 null，不能调用 Add 方法。

注意：记住，在发布应用到 Web 服务器上的时候，你必须删除所有的在数据库中的种子数据。

4-11 删除和重建数据库

重新运行，选择 Student 页面。

页面像从前一样，但是底层的数据库已经被重建了。

如果你没有看到学生页面，而是看到一个错误页面，提示说 School.sdf 文件正在被使用 ( 见下图 )，你需要重新打开服务器资源管理器，然后关闭与数据库的连接，然后重试一下。

在查看学生页面之后，重新打开服务器资源管理器，展开表，可以看到新创建的所有表。

另外，EdmMetadata 表不是我们创建的，还有 CourseInstructor，如前所述，这是在 Instructor 和 Course 实体之间的链接表。

鼠标右击 CourseInstructor 表，选择显示数据，可以看到通过课程 Course.Instructors 导航属性增加的教师实体。

现在你已经获得了一个更加复杂的数据模型以及关联的数据库，在后继的课程中，你可以学到通过不同的途径访问关联数据。

本文链接

翻译：Contoso 大学 - 3 - 排序、过滤及分页

2012-04-08T14:48:00Z

Contoso 大学 - 使用 EF Code First 创建 MVC 应用

原文地址：http://www.asp.net/mvc/tutorials/getting-started-with-ef-using-mvc/sorting-filtering-and-paging-with-the-entity-framework-in-an-asp-net-mvc-application

在上一个课程中，我们已经学习了如何使用 EF 对 Student 实体进行增、删、改、查处理。这次的课程我们将对学生的 Index 页面加入排序、过滤以及分页的功能。还要创建一个页面完成简单的分组。

下面的截图展示了完成之后的页面，列的标题作为链接支持用户通过点击完成排序，点击标题可以在升序和降序之间进行切换。

3-1 在 Students 的 Index 页面增加列标题链接

为 Index 页面增加排序的功能，我们需要修改 Student 控制器的 Index 方法，还需要为 Student 视图增加代码。

3-1-1 为 Index 方法增加排序功能

打开 Controllers\StudentController.cs，将 Index 方法替换为如下的代码。

public ViewResult Index(string sortOrder)
{
ViewBag.NameSortParm = String.IsNullOrEmpty(sortOrder) ? "Name desc" : "";
ViewBag.DateSortParm = sortOrder == "Date" ? "Date desc" : "Date";
var students = from s in db.Students
select s;
switch (sortOrder)
{
case "Name desc":
students = students.OrderByDescending(s => s.LastName);
break;
case "Date":
students = students.OrderBy(s => s.EnrollmentDate);
break;
case "Date desc":
students = students.OrderByDescending(s => s.EnrollmentDate);
break;
default:
students = students.OrderBy(s => s.LastName);
break;
}
return View(students.ToList());
}

这段代码从 URL 中接收名为 sortOrder 的参数，这个参数由 ASP.NET MVC 作为参数传递给 Action 方法。这个参数可以是 “Name” 或者 “Date”，可能还有一个空格隔开的 desc 来指定降序。

当第一次请求 Index 的时候，没有参数，学生使用 LastName 的升序顺序显示。这是通过 switch 的 default 代码段指定的，当用户点击一个列的标题链接的时候，合适的 sortOrder 值需要通过查询字符串传递进来。

两个 ViewBag 变量用来为视图提供合适的查询字符串链接值。

ViewBag.NameSortParm = String.IsNullOrEmpty(sortOrder) ? "Name desc" : "";
ViewBag.DateSortParm = sortOrder == "Date" ? "Date desc" : "Date";

这里使用了条件语句，第一个用来指定当 sortOrder 参数为 null 或者空串的时候， ViewBag.NameSortParm 应用被设置为 Name desc，其他情况下，应该被设置为空串。

这里有四种可能，依赖于当前的排序情况：

如果当前的排序规则为 LastName 升序，那么，LastName 链接应该设置为降序，Enrollment Date 链接必须被设置为按日期升序。
如果当前的排序规则为 LastName 降序，那么，LastName 链接应该设置为升序，排序串应该为空串，日期为升序。
如果当前排序的规则为 Date 升序，那么，链接应该为 LastName 升序和日期升序。
如果当前的排序规则为 Date 降序，那么，链接应该为 LastName 升序和日期降序。

方法中使用 LINQ to Entities 来指定排序，在 switch 之前，代码首先创建一个 IQueryable 变量，在 switch 语句中修改这个查询表达式，最后调用 ToList 方法。在创建和修改查询表达式 IQueryable 的时候，并没有将查询发送到数据库中执行，查询直到将 IQueryable 对象驼工调用类似 ToList 方法转换到集合对象的时候才会执行，因此，代码中查询直到最后的 return View 才会被执行。

3-2-2 为 Index 视图增加列标题链接

在 Views\Student\Index.cshtml，使用如下的代码替换标题行中的 <tr> 和 <th> 元素。

<tr>
<th></th>
<th>
@Html.ActionLink("Last Name", "Index", new { sortOrder=ViewBag.NameSortParm })
</th>
<th>
First Name
</th>
<th>
@Html.ActionLink("Enrollment Date", "Index", new { sortOrder=ViewBag.DateSortParm })
</th>
</tr>

这段代码使用 ViewBag 属性来设置超级链接中包含适当的查询字符串。

运行页面，点击列标题，来验证排序是否正常。

3-2 为 Index 页面增加搜索框

为 Index 页面增加过滤功能，需要增加一个文本框和一个提交按钮，然后，对 Index 方法进行一些修改，文本框允许你输入一个搜索字符串，用来在 FirstName 和 LastName 中进行搜索。

3-2-1 为 Index 方法增加过滤功能

打开 Controllers\StudentController.cs 文件，使用下面的代码替换 Index 方法。

public ViewResult Index(string sortOrder, string searchString)
{
ViewBag.NameSortParm = String.IsNullOrEmpty(sortOrder) ? "Name desc" : "";
ViewBag.DateSortParm = sortOrder == "Date" ? "Date desc" : "Date";
var students = from s in db.Students
select s;
if (!String.IsNullOrEmpty(searchString))
{
students = students.Where(s => s.LastName.ToUpper().Contains(searchString.ToUpper())
|| s.FirstMidName.ToUpper().Contains(searchString.ToUpper()));
}
switch (sortOrder)
{
case "Name desc":
students = students.OrderByDescending(s => s.LastName);
break;
case "Date":
students = students.OrderBy(s => s.EnrollmentDate);
break;
case "Date desc":
students = students.OrderByDescending(s => s.EnrollmentDate);
break;
default:
students = students.OrderBy(s => s.LastName);
break;
}

return View(students.ToList());
}

现在，为 Index 方法增加了一个参数 searchString ，LINQ 语句中也增加了一个 where 子句，用来选择在 FirstName 或者 LastName 中包含过滤字符串的学生。搜索串来自文本框的输入，后面需要你在视图中加入它。增加的 where 条件子句仅仅在提供了搜索串的情况下才会被处理。

if (!String.IsNullOrEmpty(searchString))
{
students = students.Where(s => s.LastName.ToUpper().Contains(searchString.ToUpper())
|| s.FirstMidName.ToUpper().Contains(searchString.ToUpper()));
}

注意：在传递一个空串的时候，.NET 实现的 Contains 方法将会返回所有的数据行，但是 EF Provider for SQL Server Compact 4.0 对于空串不返回任何行。因此，代码中增加了一个 if 判断语句，以确保对于所有的 SQL Server 都有一致的处理结果。另外，.NET 实现的 Contains 默认进行区分大小写的字符串比较，因此，通过调用 ToUpper 方法显式转换字符串为大写，

以确保在转换到使用资源库模式的时候不需要修改代码。那个时候将会返回一个 IEnumerable 集合而不是 IQueryable 对象 ( 在调用 IEnumerable 集合上的 Contains 方法的时候，使用 .NET 实现的方法，在调用 IQueryable 对象上的 Contains 方法的时候，使用数据库 Provider 提供的实现 )。

3-2-2 在 Student 视图上加入搜索框

在视图 Views\Student\Index.cshtml 上，table 开始标记之前，增加一个标题，一个文本框，以及一个 Search 按钮。

@using (Html.BeginForm())
{
<p>
Find by name: @Html.TextBox("SearchString")
<input type="submit" value="Search" /></p>
}

运行程序，输入一个搜索串，然后点击 Search 按钮来查看过滤的效果。

3-3 在 Student 的 Index 视图上增加分页

为了支持分页，你需要通过 NuGet 包管理器安装 PagedList ，然后，需要在 Index 方法中增加一些代码，在视图中增加分页的链接，下面的截图展示了分页的链接。

3-3-1 安装 PagedList 包

NuGet 中的 PagedList 包将会增加一种类型：PagedList，当将查询结果传入到 PagedList 中后，它提供的一系列属性和方法使得排序更加简单。

在 Visual Studio 中，确信选中了当前的项目，而不是解决方案。在 Tools 菜单中，选择 Library Package Manager，然后选择 Add Library Package Reference。

在 Add Library Package Reference 对话框中，点击左边的 Online 窗格，然后在搜索框中输入 pagedlist ，在看到 PagedList 包之后，点击 Install。

3-3-2 为 Index 方法增加分页功能

打开 Controllers\StudentController.cs，在代码的前面为 PagedList 命名空间增加 using 语句.

using PagedList;

将 Index 方法替换成如下的代码。

public ViewResult Index(string sortOrder, string currentFilter, string searchString, int? page)
{
ViewBag.CurrentSort = sortOrder;
ViewBag.NameSortParm = String.IsNullOrEmpty(sortOrder) ? "Name desc" : "";
ViewBag.DateSortParm = sortOrder == "Date" ? "Date desc" : "Date";

if (Request.HttpMethod == "GET")
{
searchString = currentFilter;
}
else
{
page = 1;
}
ViewBag.CurrentFilter = searchString;

var students = from s in db.Students
select s;
if (!String.IsNullOrEmpty(searchString))
{
students = students.Where(s => s.LastName.ToUpper().Contains(searchString.ToUpper())
|| s.FirstMidName.ToUpper().Contains(searchString.ToUpper()));
}
switch (sortOrder)
{
case "Name desc":
students = students.OrderByDescending(s => s.LastName);
break;
case "Date":
students = students.OrderBy(s => s.EnrollmentDate);
break;
case "Date desc":
students = students.OrderByDescending(s => s.EnrollmentDate);
break;
default:
students = students.OrderBy(s => s.LastName);
break;
}

int pageSize = 3;
int pageNumber = (page ?? 1);
return View(students.ToPagedList(pageNumber, pageSize));
}

方法又增加了一个 page 参数，方法的签名如下所示。

public ViewResult Index(string sortOrder, string currentFilter, string searchString, int? page)

当第一次显式这个页面的时候，或者用户没有点击分页链接的时候，page 参数将会是 null。如果分页链接被点击了，page 参数将会包含需要显示的页码。

ViewBag 中的 CurrentSort 属性用来提供当前的排序顺序，它必须被包含到当前的分页链接中，以便在分页处理过程中保持当前的排序规则。

ViewBag.CurrentSort = sortOrder;

其它的 ViewBag 属性为视图提供当前的过滤串，因为这个过滤串在页面被重新显示的时候，必须重新回到文本框中，另外，这个串也必须包含在分页链接中，以便在分页过程中，保持过滤效果。最后，如果在分页的过程中修改了过滤串，那么页码将会回到第一页，因为新的过滤规则返回了不同的数据，很可能原来的页码在这时候已经不再存在了。

if (Request.HttpMethod == "GET")
{
searchString = currentFilter;
}
else
{
page = 1;
}
ViewBag.CurrentFilter = searchString;

在方法的最后，查询学生的表达式被转换为 PagedList ，而不再是通常的 List，这样传递到视图中的就是支持分页的集合，代码如下：

int pageSize = 3;
int pageNumber = (page ?? 1);
return View(students.ToPagedList(pageNumber, pageSize));

ToPagedList 方法需要一个页码值，两个问号用来为可空的页码提供一个默认值，表达式 ( page ?? 1 ) 意味着如果 page 有值得话返回这个值，如果是 null 的话，返回 1。

3-3-3 为视图增加分页链接

在 Views\Student\Index.cshtml中，使用下面的代码替换原有代码。

@model PagedList.IPagedList<ContosoUniversity.Models.Student>

@{
ViewBag.Title = "Students";
}

<h2>Students</h2>

<p>
@Html.ActionLink("Create New", "Create")
</p>
@using (Html.BeginForm())
{
<p>
Find by name: @Html.TextBox("SearchString", ViewBag.CurrentFilter as string)
<input type="submit" value="Search" /></p>
}
<table>
<tr>
<th></th>
<th>
@Html.ActionLink("Last Name", "Index", new { sortOrder=ViewBag.NameSortParm, currentFilter=ViewBag.CurrentFilter })
</th>
<th>
First Name
</th>
<th>
@Html.ActionLink("Enrollment Date", "Index", new { sortOrder = ViewBag.DateSortParm, currentFilter = ViewBag.CurrentFilter })
</th>
</tr>

@foreach (var item in Model) {
<tr>
<td>
@Html.ActionLink("Edit", "Edit", new { id=item.StudentID }) |
@Html.ActionLink("Details", "Details", new { id=item.StudentID }) |
@Html.ActionLink("Delete", "Delete", new { id=item.StudentID })
</td>
<td>
@Html.DisplayFor(modelItem => item.LastName)
</td>
<td>
@Html.DisplayFor(modelItem => item.FirstMidName)
</td>
<td>
@Html.DisplayFor(modelItem => item.EnrollmentDate)
</td>
</tr>
}

</table>

<div>
Page @(Model.PageCount < Model.PageNumber ? 0 : Model.PageNumber)
of @Model.PageCount

@if (Model.HasPreviousPage)
{
@Html.ActionLink("<<", "Index", new { page = 1, sortOrder = ViewBag.CurrentSort, currentFilter=ViewBag.CurrentFilter })
@Html.Raw(" ");
@Html.ActionLink("< Prev", "Index", new { page = Model.PageNumber - 1, sortOrder = ViewBag.CurrentSort, currentFilter=ViewBag.CurrentFilter })
}
else
{
@:<<
@Html.Raw(" ");
@:< Prev
}

@if (Model.HasNextPage)
{
@Html.ActionLink("Next >", "Index", new { page = Model.PageNumber + 1, sortOrder = ViewBag.CurrentSort, currentFilter=ViewBag.CurrentFilter })
@Html.Raw(" ");
@Html.ActionLink(">>", "Index", new { page = Model.PageCount, sortOrder = ViewBag.CurrentSort, currentFilter=ViewBag.CurrentFilter })
}
else
{
@:Next >
@Html.Raw(" ")
@:>>
}
</div>

视图最前面的 @model 语句指定现在传递到视图的不再是 List 而是 PagedList 。

文本框使用当前的搜索串进行初始化，以便在分页的时候不会丢失搜索串。

Find by name: @Html.TextBox("SearchString", ViewBag.CurrentFilter as string)

列的标题链接使用查询串来传递当前的搜索串，以便传递给控制器当前的搜索和排序。

@Html.ActionLink("Last Name", "Index", new { sortOrder=ViewBag.NameSortParm, currentFilter=ViewBag.CurrentFilter })

在当前页面的最后，通过一行来显示分页的导航 UI。

Page [current page number] of [total number of pages] << < Prev Next > >>

<< 符号连接到第一页， < Prev 链接到上一页，等等。如果用户当前就在第一页，那么，链接到第一页的链接就会被禁用，类似地，如果用户当前在最后一页，导航到最后一页就会被禁用，每一个分页链接传递页码以及当前的排序串和搜索串到控制器，这使得可以在分页的同时维护排序和过滤规则。

如果没有页可以显示，将会显示 “Page 0 of 0 “，在这种情况下，页面数字就会大于页数，因为 Model.PageNumber 是 1，但是 Model.PageCount 为 0。

运行页面。

在不同的排序规则下，点击分页链接，确认分页在正常工作。然后输入一个过滤串，再次点击分页的链接，确认在排序和过滤的同时，分页可以正常工作。

3-4 创建 About 页面显示学生的统计情况

在 Contoso 大学网站的 About 页面，我们希望能够显示每个注册日有多少学生注册。这需要进行分组，然后在每个组上进行简单地计算，需要完成下列工作：

创建用于传递数据到视图的 ViewModel
修改 Home 控制器中的 About 方法
修改 About 视图

3-4-1 创建 ViewModel

创建 ViewModels 文件夹，在文件夹中，创建 EnrollmentDateGroup.cs 类文件，将代码替换为如下代码：

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace ContosoUniversity.ViewModels
{
public class EnrollmentDateGroup
{
[DisplayFormat(DataFormatString = "{0:d}")]
public DateTime? EnrollmentDate { get; set; }

public int StudentCount { get; set; }
}
}

3-4-2 修改 Home 控制器

增加如下的 using 语句。

using ContosoUniversity.DAL;
using ContosoUniversity.Models;
using ContosoUniversity.ViewModels;

增加一个数据库上下文变量。

private SchoolContext db = new SchoolContext();

使用如下的代码替换 About 方法。

public ActionResult About()
{
var data = from student in db.Students
group student by student.EnrollmentDate into dateGroup
select new EnrollmentDateGroup()
{
EnrollmentDate = dateGroup.Key,
StudentCount = dateGroup.Count()
};
return View(data);
}

LINQ 语句通过注册日期对学生进行分组，计算每一组中的实体数量，最后将查询结果保存为 EnrollmentDateGroup 对象。

3-4-3 增加 Dispose 方法

protected override void Dispose(bool disposing)
{
db.Dispose();
base.Dispose(disposing);
}

3-4-4 修改 About 视图

打开 Views\Home\About.cshtml ，替换为如下代码。

@model IEnumerable<ContosoUniversity.ViewModels.EnrollmentDateGroup>

@{
ViewBag.Title = "Student Body Statistics";
}

<h2>Student Body Statistics</h2>

<table>
<tr>
<th>
Enrollment Date
</th>
<th>
Students
</th>
</tr>

@foreach (var item in Model) {
<tr>
<td>
@String.Format("{0:d}", item.EnrollmentDate)
</td>
<td>
@item.StudentCount
</td>
</tr>
}
</table>

运行页面，每个注册日注册学生的数量显示在表格中。

现在，你已经看到了如何创建数据模型，以及实现基本的增、删、改、查处理，排序、过滤、分页和分组功能。下一次，我们将会扩展数据模型开始更加高级的内容。

本文链接

Contoso 大学 - 2 – 实现基本的增删改查

2012-04-07T09:11:00Z

Contoso 大学 - 使用 EF Code First 创建 MVC 应用

原文地址：http://www.asp.net/mvc/tutorials/getting-started-with-ef-using-mvc/implementing-basic-crud-functionality-with-the-entity-framework-in-asp-net-mvc-application

在上一个课程中，你已经创建了 MVC 应用，使用 EF 和 SQL Server Compact 保存和显示数据。在这个课程中，你将要复习并定制 MVC 脚手架为你的控制器和视图自动创建的 CRUD （创建、读取、更新和删除）代码。注意：为了在你的控制器和数据访问层之间进行抽象，通常的做法是实现仓储模式。为了保持这个课程的简洁，在这个系列的最后课程之前，我们不会实现仓储模式。

在这个课程中，你将要创建如下的页面。

2-1 创建详细页

脚手架创建的代码遗留下了学生注册属性没有处理，因为这个属性是集合属性。在详细页面中，你将要在 HTML 表格中显示这个集合的内容。

在 Controllers\StudentController.cs 中，详细页面的 Action 方法类似如下的代码：

public ViewResult Details(int id)
{
Student student = db.Students.Find(id);
return View(student);
}

代码使用 Find 方法来获取单个的 Student 实体，使用传递给方法的 id 关键字。Id 来自 Index 页面中的超级链接提供的查询字符串。

打开 Views\Student\Details.cshtml。每个字段使用 DisplayFor 助手方法进行显示，类似如下所示：

<div class="display-label">LastName</div>
<div class="display-field">
@Html.DisplayFor(model => model.LastName)
</div>

为了显示注册课程列表，在注册日期 EnrollmentDate 字段之后，fieldset 结束标记之前，增加如下的代码。

<div class="display-label">
@Html.LabelFor(model => model.Enrollments)
</div>
<div class="display-field">
<table>
<tr>
<th>Course Title</th>
<th>Grade</th>
</tr>
@foreach (var item in Model.Enrollments)
{
<tr>
<td>
@Html.DisplayFor(modelItem => item.Course.Title)
</td>
<td>
@Html.DisplayFor(modelItem => item.Grade)
</td>
</tr>
}
</table>
</div>

代码遍历导航属性 Enrollments 中所有的实体，对于这个属性中的每一个 Enrollment 实体，将显示其中的课程和年级。课程标题通过 Enrollments 导航属性保存的 Course 实体来获得。在需要的时候，所有的数据从数据库中获取。( 从另外一个角度说，在这里使用了延迟加载，你没有为 Courses 导航属性指定饿汉模式加载，所以，在你第一次试图访问这个属性的时候，将会向数据库发出一次查询来获取数据，你可以在这个系列后面的读取相关数据部分获取更加详细的说明 )

运行这个页面，选择 Students 选项卡，然后点击 Details 超级链接，你就可以看到课程的列表。

2-2 建立创建页面

在 Controllers\StudentController.cs，使用下面的代码替换HttpPostCreate 这个 Action 方法，为脚手架创建的代码增加 try-catch 块。

[HttpPost]
public ActionResult Create(Student student)
{
try
{
if (ModelState.IsValid)
{
db.Students.Add(student);
db.SaveChanges();
return RedirectToAction("Index");
}
}
catch (DataException)
{
//Log the error (add a variable name after DataException)
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists see your system administrator.");
}
return View(student);
}

这些代码将通过 ASP.NET MVC 模型绑定创建的实体对象加入到 Students 集合中，然后保存修改到数据库中。( 模型绑定是 ASP.NET MVC 的一个功能用于简化你获取通过表单提交的数据，模型绑定转换提交的表单数据到 .NET 中的数据类型，通过 Action 方法的参数传递进来，在这里，模型绑定通过表单数据为你实例化了一个 Student 的实体对象实例 )

这里的 try-catch 块是这些代码区别于脚手架创建的代码的唯一不同之处，在保存数据的时候，如果派生自DataException 的异常被抛出，错误信息将会被显示出来，这类错误典型的是由于一些内部错误，而不是程序错误，所以建议用户再重新试一次。在 Views\Student\Create.cshtml 中的代码与 Details.cshtml 中类似，除了将每个字段的 DisplayFor 代替为EditorFor 和 ValidationMessageFor 助手方法.下面的示例演示了相关的代码。

<div class="editor-label">
@Html.LabelFor(model => model.LastName)
</div>
<div class="editor-field">
@Html.EditorFor(model => model.LastName)
@Html.ValidationMessageFor(model => model.LastName)
</div>

在 Create.cshtml. 中不需要进行修改。

重新运行页面，选择 Students选项卡，点击 Create New。

默认会进行数据验证，输入名字和一个错误的日期，然后点击 Create，查看一下错误提示。

现在，你会看到通过 JavaScript 实现的客户端验证，但是，服务器端的验证也已经实现了。即使客户端验证失败了，坏的数据也会被捕获到，在服务器端会抛出一个异常。

将日期修改为一个正确的日期，例如：9/1/2005，然后点击 Create，会看到一个新的学生出现在 Index页面上。

2-3 创建一个编辑页面

在 Controllers\StudentController.cs 中，Http Edit 方法 ( 其中没有使用 HttpPost标签的那一个 ) 使用 Find 方法来获取选中的学生实体，像你在 Details 方法中看到的一样，不需要修改这个方法。

实际上，需要修改 HttpPost Edit 方法，使用下面的代码为它增加 try-catch处理。

[HttpPost]
public ActionResult Edit(Student student)
{
try
{
if (ModelState.IsValid)
{
db.Entry(student).State = EntityState.Modified;
db.SaveChanges();
return RedirectToAction("Index");
}
}
catch (DataException)
{
//Log the error (add a variable name after DataException)
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists see your system administrator.");
}
return View(student);
}

这段代码非常类似在 Create 中的代码，实际上，除了将通过模型绑定创建的对象添加到实体集中，这段代码还设置了实体的标志来表示这个实体已经被修改过了。当 SaveChanges方法被调用的时候，数据库中行的所有字段都将会更新。包括用户没有修改过的字段，并发冲突被忽略掉 ( 你将会在这个系列的后面学习如何处理并发问题 )。

实体的状态，连接以及 SaveChanges 方法

数据库上下文对象维护内存中的对象与数据库中数据行之间的同步。这些信息在调用 SaveChanges方法被调用的时候使用。例如，当使用 Add 方法传递一个新的实体对象时，实体的状态被设置为 Added，在调用 SaveChanges方法的时候，数据库上下文使用 SQL 命令 Insert来插入数据。

实体的状态可能为如下之一：

Added. 实体在数据库中不存在。SaveChanges 方法必须执行 Insert 命令

Unchanged. 在调用 SaveChanges 的时候不需要做任何事情，当从数据库读取数据的时候，实体处于此状态。

Modified. 某些或者全部的实体属性被修改过. SaveChanges方法需要执行 Update 命令。

Deleted. 实体标记为已删除，SaveChanges 方法必须执行 Delete 命令。

Detached. 实体的状态没有被数据库上下文管理。

在桌面应用中，实体的状态改变典型地自动完成。在这种类型的应用中，你读取一个实体，然后修改某些属性的值，这使得实体的状态被自动修改为 Modified。然后，在调用 SaveChanged 的时候，实体框架生成 Update 命令进行更新，只有你修改的实际属性被更新。

但是，在 Web 应用程序中，这个处理序列不是连续的。因为数据库上下文读取的实体对象实例在页面被呈现之后被丢弃了。当 HttpPost Edit 方法被调用的时候，导致一个新的请求和一个新的数据库上下文对象被生成，所以，你必须手工设置实体的状态为 Modified。然后调用 SaveChanges 方法，实体框架更新数据库中数据行的所有列，因为数据库上下文没有办法知道你修改了哪些属性。

如果你希望 Update 语句仅仅更新你实际上修改的字段。你可以通过某种途径保存原有的数据值 ( 例如通过隐藏域 )，以便在 HttpPost Edit 方法被调用的时候这些值存在。然后，可以使用原始的数据来创建一个 Student 实体，使用 Attach 方法调用连接含有原始值的实体对象，然后，使用新的值来更新实体对象，最后再调用 SaveChanges 方法，更多的详细内容，可以查看 EF 团队的博客： Add/Attach and Entity States和Local Data。

在 Views\Student\Edit.cshtml中的代码类似于 Create.cshtml ，不需要修改。

运行页面，选择 Students 选项卡，然后点击 Edit 超级链接。

修改一些数据，然后点击 Save，可以在 Index 页面看到修改后的数据。

2-4 创建删除页面

在 Controllers\StudentController.cs, 模板生成的 HttpGet Delete 方法使用 Find 方法来获取 Student 实体，像在Details 和 Edit 方法中一样。实际上，为了实现在调用 SaveChanges 方法失败的时候使用的错误页面，你需要为这个方法和相应的视图增加一些功能。

像在更新和创建操作中一样，删除操作也需要两个方法。GET 方法用于显示一个视图，使用户可以允许或者取消删除操作，如果用户允许删除操作，那么，将会发出一个 Post 请求，HttpPost Delete 方法将会被调用，然后执行实际的删除操作。

你需要为 HttpPost Delete 方法增加一个 try-catch 块来捕获数据库更新过程中的任何异常。如果错误出现，HttpPost Delete 方法调用 HttpGet Delete 方法，传递一个参数表示错误发生了。HttpGet Delete 方法就会根据错误信息重新显示确认页面，使用户可以取消或者重试。

使用下面的代码替换 HttpGet Delete 方法中的代码，这里会管理错误报告。

public ActionResult Delete(int id, bool? saveChangesError)
{
if (saveChangesError.GetValueOrDefault())
{
ViewBag.ErrorMessage = "Unable to save changes. Try again, and if the problem persists see your system administrator.";
}
return View(db.Students.Find(id));
}

这段代码接收一个可选的 bool 类型参数，这个参数用来表示是在更新失败之后调用这个方法。在页面请求中被调用的时候，这个参数为 null ( false )，当通过 HttpPost Delete 方法更新数据库失败后，被调用的时候，参数被设置为 true，错误信息被传递到视图中。

将 HttpPost Delete 方法 ( 名为 DeleteConfirmed 方法 )的代码替换成下面的代码，这将会执行实际的删除操作，并捕获任何数据库更新错误。

[HttpPost, ActionName("Delete")]
public ActionResult DeleteConfirmed(int id)
{
try
{
Student student = db.Students.Find(id);
db.Students.Remove(student);
db.SaveChanges();
}
catch (DataException)
{
//Log the error (add a variable name after DataException)
return RedirectToAction("Delete",
new System.Web.Routing.RouteValueDictionary {
{ "id", id },
{ "saveChangesError", true } });
}
return RedirectToAction("Index");
}

这段代码获取选中的实体，然后调用 Remove 方法将实体的状态设置为 Deleted。当调用 SaveChanged 的时候，SQL 命令 Delete 被生成并执行。

如果性能是应用的高优先级目标，你可以省略掉不需要的 SQL 查询处理，使用下面的代码行调用 Find 和 Remove 方法。

Student studentToDelete = new Student() { StudentID = id };
db.Entry(studentToDelete).State = EntityState.Deleted;

这段代码实例化了一个 Student 实体，仅仅设置了主键的值，然后将实体的状态设置为 Deleted。EF 删除实体仅仅需要这些信息。

需要注意的是，HttpGet Delete 方法并不真正删除数据，在 GET 请求处理中进行删除存在着安全风险 ( 同样在进行编辑，创建，或者任何修改数据的处理中 )，更多的资料，参见：ASP.NET MVC Tip #46 — Don't use Delete Links because they create Security Holes

在 Views\Student\Delete.cshtml 中，在 h2 和 h3 之间增加下面的代码：

<p class="error">@ViewBag.ErrorMessage</p>

运行页面，选择 Students 选项卡，点击 Delete 超级链接。

点击 Delete，Index 页面中就不会再显示被删除的学生了。( 在处理并发的部分可以看到错误处理 )

2-5 确认数据库连接没有忘记关闭

为了确认数据库连接被正确关闭，以及资源被正确释放，你需要释放数据库上下文，这就是为什么在 StudentController 代码的最后会看到 Dispose 方法的原因，在 StudentController.cs, 如下所示：

protected override void Dispose(bool disposing)
{
db.Dispose();
base.Dispose(disposing);
}

基类 Controller 已经实现了接口 IDisposable，所以这段代码简单地重写了 Dispose ( bool ) 方法来显式释放上下文对象。

你现在已经有了一套完整的页面对 Student 进行增、删、改、查处理。在下一课程中，将会为 Index 页面增加排序和分页功能。

本文链接