《编程实体框架：代码优先》精华解读

5星 · 超过95%的资源需积分: 10 90 浏览量更新于2024-07-25 收藏 5.94MB PDF 举报

"《Programming Entity Framework: Code First》是一本由Julia Lerman和Rowan Miller合著的关于Entity Framework Code First技术的专业书籍，由O'Reilly Media, Inc.出版。该书详细介绍了如何在.NET环境中使用Entity Framework进行代码优先开发。" Entity Framework是微软推出的一款对象关系映射（ORM）框架，它允许开发人员使用面向对象的编程方式来操作数据库，而无需关心底层的SQL语句。Code First是Entity Framework提供的一个开发模式，它提倡从编写C#或VB.NET类库开始构建数据库，从而简化了数据库应用程序的开发流程。在这本书中，作者Julia Lerman和Rowan Miller深入探讨了Code First开发模式的各个方面。他们涵盖了以下关键知识点： 1. **基础概念**：解释了Entity Framework的基本架构，包括Context、Entities、DbContext、Data Models以及Migrations等核心概念。 2. **数据模型设计**：详细介绍了如何通过定义POCO（Plain Old CLR Objects）类来创建数据模型，包括属性、关系、数据注解和 Fluent API 的使用。 3. **自动迁移**：阐述了Code First中的自动数据库迁移机制，如何在代码更改后自动更新数据库结构。 4. **仓储与单元工作**：讨论了仓储模式的实现和单元工作（Unit Of Work）模式的应用，以确保数据一致性。 5. **查询与 LINQ**：讲解了如何使用LINQ查询数据库，包括投影、过滤、排序和分组等操作，以及延迟加载和Eager Loading的概念。 6. **性能优化**：提供了提高Entity Framework性能的策略，如批处理操作、减少数据库往返、缓存策略等。 7. **扩展性与自定义**：介绍如何通过继承和重写基类方法来自定义Entity Framework的行为，如拦截器、上下文工厂等。 8. **异步编程**：讲解如何在ASP.NET或Windows服务等环境中利用异步编程特性提高并发性能。 9. **测试与持续集成**：探讨如何编写可测试的代码，并与持续集成工具配合使用。 10. **最佳实践与案例研究**：提供了实际项目中使用Code First的最佳实践和示例，帮助读者将理论知识应用于实际开发。通过这本书，读者不仅可以学习到Entity Framework Code First的基础知识，还能掌握如何在实际项目中有效应用这些技术，提升开发效率和代码质量。无论是初学者还是经验丰富的开发者，都能从中受益。

Another critical change came in EF4. In .NET 3.5, the only way Entity Framework was

able to manage in-memory objects was by requiring classes to inherit from Entity

Framework’s EntityObject. The EntityObject communicates its changes to Entity

Framework, which in turns keeps track of changes and eventually is able to persist them

back to the database. In addition to this functionality, .NET 4 introduced POCO (Plain

Old CLR Object) support to enable the Entity Framework to track changes to simpler

classes without needing the EntityObject to be involved. This freed up developers to

use their own classes, independent of Entity Framework. The EF runtime had a way of

being aware of the classes and keeping track of them while in memory.

Inception of Code First

Building upon the pieces that were introduced in EF4, Microsoft was able to create one

more path to modeling, which many developers have been requesting since EF’s in-

ception. This new type of modeling is called Code First. Code First lets you define your

domain model with code rather than using an XML-based EDMX file. Even though

Model First and Database First use code generation to provide classes for you to work

with, many developers simply did not want to work with a designer nor have their

classes generated for them. They just wanted to write code.

In Code First you begin by defining your domain model using POCO classes, which

have no dependency on Entity Framework. Code First can infer a lot of information

about your model purely from the shape of your classes. You can also provide additional

configuration to further describe your model or override what Code First inferred. This

configuration is also defined in code: no XML files or designers.

EF4 also has support for POCO classes when working with the designer.

The EF team provided a POCO template that would allow POCO

classes to be generated for you. These generated classes would be au-

tomatically updated as you made changes in the designer. You could

also use your own POCO classes rather than having them generated for

you. But if you decided to take this approach, you were responsible for

keeping your classes and the EDMX file in sync. This meant that any

changes had to be made in two places—once in the designer and again

in your classes. One of the big advantages of Code First is that your

classes become the model. This means any changes to the model only

need to be made in one place—your POCO classes.

Code First, Database First, and Model First are all just ways of building an Entity Data

Model that can be used with Entity Framework to perform data access. Once the model

has been built, the Entity Framework runtime behaves the same, regardless of how you

created the model. Whether you choose to go with a designer or to use the code-based

modeling is entirely your decision. Figure 1-1 lays out the different options you have

for modeling with Entity Framework.

2 | Chapter 1: Welcome to Code First

complex to achieve with the ObjectContext. DbContext also takes care of a lot of common

tasks for you, so that you write less code to achieve the same tasks; this is particularly

true when working with Code First. Because Microsoft recommends that you use

DbContext with Code First, you will see it used throughout this book. However, a sep-

arate book, called Programming Entity Framework: DbContext, will delve more deeply

into DbContext, DbSet, Validation API, and other features that arrived alongside the

DbContext.

Figure 1-2 helps you to visualize how Code First and DbContext add functionality by

building on the core Entity Framework 4 API, rather than modifying it.

Figure 1-2. Code First and DbContext built on EF4

Flexible Release Schedule

Microsoft will continue to release new features on top of Entity Framework using Visual

Studio’s Library Package Management distribution (aka NuGet) mechanism that is

used for Entity Framework 4.2. The core EF libraries that are in .NET will evolve

with .NET releases. But features such as Code First and DbContext that rely on the

core will be distributed when they are ready by way of updates to the Entity Framework

NuGet package.

Writing the Code…First

Code First is aptly named: the code comes first, the rest follows. Let’s take a look at

the basic default functionality without worrying about all of the possible scenarios you

might need to support. The rest of the book is dedicated to that.

We don’t expect you to recreate the sample code shown in this first

chapter. The code samples are presented as part of an overview, not as

a walkthrough. Beginning with Chapter 2, you will find many walk-

throughs. They are described in a way that you can follow along in Visual

Studio and try things out yourself if you’d like.

Of course, the first thing you’ll need is some code—classes to describe a business do-

main. In this case a very small one, patients and patient visits for a veterinarian.

4 | Chapter 1: Welcome to Code First

common scenarios. If your classes happen to follow convention, Code First doesn’t

need any more information from you. Entity Framework will be able to work directly

with your classes. If they don’t follow convention, you can provide additional infor-

mation through Code First’s many configuration options to ensure that your classes

are interpreted properly by Code First.

In the case of the three classes in Example 1-1, the Id properties in each class meet the

convention for keys. We’ll let Code First work with these classes as they are without

any additional configurations.

Managing Objects with DbContext

The domain classes described above have nothing to do with the Entity Framework.

They have no knowledge of it. That’s the beauty of working with Code First. You get

to use your own classes. This is especially beneficial if you have existing domain classes

from another project.

To use Code First, you start by defining a class that inherits from DbContext. One of

the roles of this class, which we’ll refer to as a context, is to let Code First know about

the classes that make up your model. That’s how Entity Framework will be aware of

them and be able to keep track of them. This is done by exposing the domain classes

through another new class introduced along with DbContext—the DbSet. Just as DbCon

text is a simpler wrapper around the ObjectContext, DbSet is a wrapper around Entity

Framework 4’s ObjectSet, which simplifies coding tasks for which we normally use the

ObjectSet.

Example 1-2 shows what this context class might look like. Notice that there are

DbSet properties for Patients and Visits. The DbSets will allow you to query against

the types. But we don’t anticipate doing a direct query of AnimalTypes, so there’s no

need for a DbSet of AnimalTypes. Code First is smart enough to know that Patient makes

use of the AnimalType class and will therefore include it in the model.

Example 1-2. VetContext class which derives from DbContext

using System.Data.Entity;

namespace ChapterOneProject

{

class VetContext:DbContext

{

public DbSet<Patient> Patients { get; set; }

public DbSet<Visit> Visits { get; set; }

}

6 | Chapter 1: Welcome to Code First

剩余191页未读，继续阅读

frank789

粉丝: 0
资源: 2

《编程实体框架：代码优先》精华解读

Programming+Entity+Framework+Code+First

Programming Entity Framework Code First

Programming.Entity.Framework.Code.First

Programming Entity Framework: Code First

Programming Entity Framework Code First By Julia Lerman

C#-Programming Entity Framework Code First.pdf

Entity Framework Code First Usage

Programming.Entity.Framework.DbContext

Entity Framework Code First学习资料

航空公司客户满意度数据转换与预测分析Power BI案例研究

最新资源