专家之声：Entity Framework 4.0深入解析

4星 · 超过85%的资源需积分: 10 11 浏览量更新于2024-07-25 收藏 18.86MB PDF 举报

"Pro Entity Framework 4.0.pdf" 《Pro Entity Framework 4.0》是Scott Klein撰写的一本深入探讨.NET编程中数据访问技术的专业书籍，尤其关注于微软的ORM框架——Entity Framework 4.0。这本书由Apress出版，是.NET开发者的专家之声系列之一。 Entity Framework是微软推出的一种对象关系映射（ORM）工具，它允许开发者使用面向对象的编程方式来操作数据库，而无需过多关注底层SQL语句。在.NET Framework 4.0版本中，Entity Framework进行了多项改进和增强，包括： 1. **Code First**：这一新特性使得开发者可以通过编写C#或VB.NET代码定义实体类和数据库架构，而不是先创建数据库。这提供了更灵活的开发流程，使模型驱动的开发变得更加直观。 2. **Entity SQL**：Entity Framework 4.0引入了Entity SQL，这是一种独立于任何特定数据库的查询语言，允许开发者编写针对实体模型的查询，而非直接针对SQL Server。 3. **ObjectContext API**：在4.0版本中，ObjectContext是主要的上下文类，用于与数据库交互，它包含EntitySet<T>对象，允许对实体进行添加、删除、修改和查询操作。 4. **Poco支持**：支持Plain Old CLR Objects（Poco），即不带任何特殊属性或接口的简单.NET类，这增强了框架的灵活性，使得模型可以更容易地脱离框架。 5. **改变跟踪（Change Tracking）**：Entity Framework自动跟踪实体的变化，这样当调用SaveChanges()方法时，只有发生更改的实体才会被提交到数据库，提高了性能。 6. **延迟加载（Lazy Loading）**：如果启用，关联的实体会在需要时自动加载，而不是在查询时一次性加载所有数据，有助于减少内存占用和提高效率。 7. **复杂类型**：允许创建不映射到数据库表的复杂类型，用于封装相关属性，简化模型设计。 8. **自定义SQL查询**：开发者可以使用StoreGeneratedPattern属性指定某些属性的值由数据库生成，或者使用Entity Framework的ExecuteStoreQuery方法执行自定义SQL查询。 9. **模型和映射的版本控制**：支持在不同的开发阶段和团队成员间管理模型和映射文件。 10. **性能优化**：Entity Framework 4.0对性能进行了大量改进，包括更高效的缓存策略、更少的数据库往返以及更好的查询编译。该书详细讲解了如何利用Entity Framework 4.0进行数据库操作，包括实体模型的设计、数据库上下文的使用、查询优化、事务处理、分页、聚合功能以及与WCF和ASP.NET MVC的集成等。同时，它还涵盖了最佳实践和可能遇到的问题，对于想要深入理解和应用Entity Framework的.NET开发者来说是一本宝贵的参考资料。

C H A P T E R 1

■ ■ ■

Introducing the ADO.NET 4.0

Entity Framework

In July 2008 Microsoft released the first version of the ADO.NET Entity Framework as part of the Visual

Studio 2008 Service Pack 1 as well as the .NET Framework 3.5 Service Pack 1. At the time, Microsoft LINQ

(Language Integrated Query) and LINQ to SQL had been out for a while and were gaining a lot of

attention. Both the Entity Framework and LINQ to SQL showed that Microsoft was very serious about

improving developer productivity, by providing an infrastructure for managing relational data as objects

and programming against a conceptual model instead of directly against a storage schema. While

Microsoft did its best to tout the Entity Framework, it went somewhat unnoticed out of the gate,

primarily due to the rise in popularity of LINQ to SQL and the misunderstanding from the public of what

the Entity Framework really was.

By the time this book hits the shelves, Visual Studio 2010 with the .NET Framework 4.0 and

ADO.NET Entity Framework will have just been released or will be very shortly. Yet, I still get questions

from people wondering what the Entity Framework is or how it differs from LINQ to SQL.

Thus, the reason for this book is twofold; first, it will answer the question of what the Entity

Framework is and why Microsoft is dedicating a lot of resources and energy to its development,

advancement, and developer acceptance. Second, it will discuss all the new features and enhancements

that will be available in ADO.NET 4.0, which will be released with Visual Studio 2010.

This book is intended to address two types of developers: those who have never worked with the

Entity Framework before, and those who have but are looking at what the ADO.NET 4.0 Entity

Framework has to offer. As such, it will cover all aspects of the Entity Framework and, where

appropriate, point out the new features and enhancements found in the EF 4.0.

The Entity Framework does not, nor is intended to, replace existing ADO.NET data access

technologies; rather, it is an enhancement to ADO.NET, providing developers an augmented approach

to accessing data, letting them work with a conceptual model, and thus enabling developers to deal with

data as objects and properties, a concept already familiar to them.

The Need for an Entity Framework

To really understand what the Entity Framework is and why it is so important, we need to take a step

back and look at some of the existing data access technologies. Microsoft has put a lot of time and effort

into ADO.NET over the past many years. Prior to that, it was RDO, and prior to that it was DAO. Heaven

forbid we look prior to DAO. With ADO.NET, developers were finally sensing that Microsoft had settled

on a data access strategy and technology. With the improvements and enhancements that were being

made to ADO.NET with each .NET release, it was the “go-to” technology for data access.

Developers’ data access technologies of choice have primarily been the DataReader and the DataSet,

and these have been serving developers well for many years. Yet with all of the improvements being

made to ADO.NET, there was still a disconnect between the application and the back-end database.

www.wowebook.com

CHAPTER 1

■

INTRODUCING THE ADO.NET 4.0 ENTITY FRAMEWORK

Developers were spending far too much time trying to keep up with changes being made to the

database. Any schema change to a table or stored procedure, for example, could potentially break an

application.

Take the following code snippet, for example, which runs against Microsoft’s standard

AdventureWorks example database. Take a good look at this code sample and then ask yourself two

questions:

1. Will it compile?

2. Assuming it compiles, when it runs, will you get the “yep, we have rows”

message?

try

{

string connectionString = Class1.GetConnectionString();

using (SqlConnection conn = new SqlConnection(connectionString))

{

conn.Open();

using (SqlCommand cmd = new SqlCommand())

{

cmd.Connection = conn;

cmd.CommandText = "SELECT FirstName, MidleName, LastName FROM Person.Contact

WHERE ContactID = @ContactID";

SqlParameter param = new SqlParameter("@ContactID", SqlDbType.Int, 50,

"ContactID");

param.Value = 8;

cmd.Parameters.Add(param);

SqlDataReader rdr = cmd.ExecuteReader();

while (rdr.Read())

{

Console.WriteLine(String.Format("{0}, {1}",

rdr[0], rdr[1]));

}

catch (Exception ex)

{

MessageBox.Show(ex.Message);

}

If you want to try it out, open up a new instance of Visual Studio 2010 (or 2008—this example is not

specific to 2010) and create a new C# Windows Forms application. On the form, place a button on the

form and in the click event of that button enter the code as you see it above. Prior to running the project,

change the connection string username and password for your environment and add the following using

statement:

using System.Data.SqlClient;

If you don’t feel like typing, you can download the code from the Apress web site for this book. In

any case, run the project and click the button. When the project runs and the form displays, it should be

CHAPTER 1

■

INTRODUCING THE ADO.NET 4.0 ENTITY FRAMEWORK

obvious at that point that the code did compile successfully. Now click the button. Did you get the “yep,

we have rows” message?

If you typed in the code just as you see it above, you didn’t get the message indicating a successful

run. Instead you received a message that the column MidName is an invalid column name. The column

containing the middle name is actually called MiddleName. The problem is you had to run the

application to find that out. Now imagine if yours had been a larger production application and you

received a similar error. A larger application makes it much more difficult to find the offending line of

code, plus you have the greater overhead of tracking down the actual spelling of the column name.

The point is that developers spend far too much time worrying about things they shouldn’t need to

when it comes to the database side of things. Developers need to focus only on developing applications

and should not be concerned if a table, stored procedure, relationship, or some other database object

changes.

In the code example above, the error that you get illustrates an example of a table change being

made without informing the developers. When the table was originally created, it possibly could have

had a column named MidName, but someone decided to change that column’s name to MiddleName to be

consistent with the other name columns in the table. Unless that schema change is disseminated to the

appropriate people (the developers in this case), no one is going to find out about the change until run

time. Think of what could happen if for some reason the change was not picked up and somehow

slipped through QA and into the production release. Oops.

What was needed was a model where the database, application, and data move together. This is

exactly what the Entity Framework provides. The Entity Framework is a conceptual model that works

with databases and applications, eliminating the gap between data and applications (and application

languages) that developers normally have to work with when working with the DataReader object and

other data access technologies.

This Has Been Tried Before

Modeling applications exist in abundance, but each application has a specific focus such as process data

flow or describing objects. The following lists some of the modeling application types and their primary

focus.

• ERM (Entity Relationship Model): Used with databases, it is a way to represent

logical relationships of entities (objects) in order to create a database.

• UML (Unified Modeling Language): A standard modeling language that is used to

describe objects.

• ORM (Object-Relational Mapping): Method of mapping relational databases and

object-oriented programming languages.

• DFD (Data Flow Diagram): A graphical representation of the flow of data between

processes and between systems.

The problem is that each of these modeling applications is limited in scope. For example, ERM

products do logical data models really well, but struggle at UML tasks. UML excels at describing objects,

but falls short at performing ERM tasks.

And lest we forget, there are other ERM-like products in the market that have been around for a bit

and provide Entity Framework-like capabilities, such as the following:

• NHibernate: Ported from Hibernate Core for Java for the .NET Framework,

NHibernate for .NET persists plain .NET objects to and from an underlying

relational database.

CHAPTER 1

■

INTRODUCING THE ADO.NET 4.0 ENTITY FRAMEWORK

• SPRINT.net: An open-source application framework, and based on the Java

version of Spring Framework, allowing you to build components that can be

integrated into multiple tiers of your application.

While this list is by no means complete, it is provided to illustrate the necessity and need for good

ERM application development products that remove many of the complexities of working with

databases to help improve productivity.

The ADO.NET Entity Framework does not have the same limitations of other modeling products.

This is because the Entity Framework works at a conceptual level that is based on the ERM and, as such,

provides a depth and richness of functionality that many of the stand-alone ERMs and UMLs cannot

provide.

As the name suggests, the Entity Framework allows you to work directly with Entities that represent

your own schema without having to deal with the nuances of DataReader and DataSet objects. Some

developers who have worked with or have some knowledge about Entity Framework compare it to other

relational mappers and try to classify it as an object relational mapper. This comparison or thought

process is not entirely correct. The Entity Framework does have relational mapping capabilities. But the

Entity Framework is much more than just a relational mapper, and the ORM capabilities it does have are

implemented much differently than that of other ORM products.

So, What Is the Entity Framework?

The Entity Framework is a set of technologies in ADO.NET that helps fill in the space between object-

oriented development (objects) and databases. This gap is commonly known as an “impedance

mismatch” and it exists because the mapping and organization of classes does not quite match up to the

organization of relational objects. Many mapping solutions have tried to solve this problem by mapping

OO (object-oriented) classes and properties straight to tables and columns.

For example, let’s use the case of customers and products. First, in a simple mapping scenario, you

may have a product class that contains a property that references an instance of a customer class.

Second, a customer class might contain a property containing a collection of instances of the product

class. While this might seem fine, how do you represent the foreign keys between customer and product

in the first case (while in the second case you have a reference of an object-oriented collection of

product instances that has no comparable column in the customer table in the database)?

A scenario such as this one is known as the conceptual space and is accomplished by raising the

abstraction level to a point that lets developers query entities and relationships in the conceptual model,

all while letting the Entity Framework translate the query operations to data source–specific commands.

It allows applications to be written against conceptual models and not directly against the database. By

doing so, the gap between object-oriented programming and databases has been closed, letting

developers focus on the task of developing applications, without concerning themselves about the

database (structure or otherwise) or data access.

You should start to see where the gap comes into play, simply because there is no one-to-one

mapping. Relationships between relational objects are represented much differently from class

relationships. And this is where the Entity Framework takes a much different approach. The EF maps

relational objects to conceptual models. Conceptual mapping provides a number of huge benefits. For

example, it provides the needed improved flexibility in creating (defining) and enhancing the logical

model.

■ Note The Entity Framework divides the data model into three separate models: conceptual, logical, and

physical. Each of these will be discussed in detail in Chapter 3.

剩余280页未读，继续阅读

老男孩121

粉丝: 0
资源: 6

专家之声：Entity Framework 4.0深入解析

[EF] Entity Framework 4.0 高级程序设计 (英文版)

Pro Entity Framework 4.0

.NET FrameWork 4.0.30319

Apress.Pro.Entity.Framework.4.0.pdf

精通ADO.NET Entity Framework 4.0

精通Entity Framework 4.0：.NET编程的数据访问未来

Apress.Pro.CSharp.2010.and.the.dotNET.4.Platform.5th.Edition.May.2010.pdf

Pro ASP.NET 4 CMS PDF 版本

Pro C# 2010 and the .NET 4 Platform

Pro_LINQ_Language_Integrated_Query_in_C#_2010

最新资源