使用CodeFirst实现数据库通讯：Entity Framework技术解析

需积分: 9 177 浏览量更新于2024-07-27 收藏 6.05MB PDF 举报

"Entity_Framework_Code_First" Entity Framework Code First是微软提供的一个ORM（对象关系映射）框架，它允许开发人员使用.NET Framework中的类和对象直接与数据库进行交互，而无需编写大量的ADO.NET代码。这个技术使得数据库的创建和管理变得更加灵活，同时也提高了开发效率。在传统的ADO.NET开发模式中，开发者需要先设计数据库，然后创建对应的表和关系，最后编写代码来操作这些数据库对象。而在Entity Framework Code First中，开发流程反转了过来：首先编写业务逻辑层的代码，即定义实体类和数据上下文，然后框架会根据这些代码自动生成数据库结构。这种方式称为“Code First”或“Code Only”，意味着数据库的生命周期由代码控制。在《Programming Entity Framework: Code First》这本书中，作者Julia Lerman和Rowan Miller详细介绍了如何利用Code First方法进行开发。书中涵盖了以下关键知识点： 1. **实体类**：Code First的基础是实体类，它们代表数据库中的表。开发者通过定义C#类并使用特性如`[Key]`来指定主键，以及`[Required]`来指定非空字段，来描述数据库表的结构。 2. **数据上下文**：DbContext是Entity Framework的核心，它是与数据库交互的主要接口。开发者可以继承DbContext类，定义DbSet属性来表示数据库中的集合，并重写OnModelCreating方法来自定义数据库模型。 3. **自动迁移**：Code First提供了一种自动迁移机制，允许开发者在不破坏现有数据的情况下，随着代码的变化更新数据库架构。通过`Add-Migration`和`Update-Database`命令，开发者可以在Visual Studio的Package Manager Console中轻松地管理数据库迁移。 4. **数据库初始化策略**：Code First提供了多种数据库初始化策略，如DropCreateDatabaseAlways、CreateDatabaseIfNotExists等，用于控制数据库的创建和初始化。 5. **复杂类型和关系**：Code First支持复杂的对象模型，包括嵌套复杂类型、多对一、一对多和多对多关系的映射。 6. **查询和保存**：使用LINQ（Language Integrated Query）可以直接在C#代码中编写查询，同时EF还支持EF SQL，提供更底层的数据库操作。保存更改时，可以通过DbContext的SaveChanges方法将实体状态的变化持久化到数据库。 7. **性能优化**：书中也讨论了如何优化Code First应用的性能，包括延迟加载、查询优化、减少数据传输量等。 8. **扩展性**：Entity Framework允许开发者通过继承和重写来扩展其功能，例如自定义拦截器、仓储模式等。 9. **测试和部署**：书中还涵盖了如何在单元测试中使用Code First，以及在生产环境中部署和配置数据库的策略。《Programming Entity Framework: Code First》是一本深入探讨Code First开发模式的权威指南，对于想要掌握Entity Framework并利用其提高开发效率的.NET开发者来说，是一本非常有价值的参考书。

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页未读，继续阅读

msdn880918

粉丝: 0
资源: 4

使用CodeFirst实现数据库通讯：Entity Framework技术解析

Entity_Framework-Code_First

Entity_framework教程

Entity_Framework_实体框架.doc

使用CodeFirst与Entity_Framework开发

Code_First_使用Entity._Framework编程.docx

使用Entity_Framework_4进行代码优先开发.

CodeFirst使用Entity._Framework编程

EF.rar_ENTITY FRAMEWORK_Framework_ef

Entity_Framework与LINQ深度教程

Entity_Framework教程：LINQ与数据访问层设计

最新资源