专家之声：Entity Framework 4.0 教程

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

"Pro.Entity.Framework.4.0 是一本关于学习Entity Framework 4.0框架的专业书籍，由Scott Klein撰写，是.NET编程领域中的专家之声系列。本书详细介绍了Entity Framework 4.0的相关内容，包括数据访问的未来、实体框架的基础和高级特性，以及实际应用中的最佳实践。" Entity Framework 4.0 (简称EF4) 是微软提供的一款对象关系映射（ORM）工具，用于简化.NET应用程序与数据库之间的交互。这本书详细探讨了以下关键知识点： 1. **ORM基础**：ORM允许开发者使用面向对象的方式来操作数据库，而无需直接编写SQL语句。EF4通过创建模型类和映射文件，将数据库表映射到这些类，实现了数据库操作的抽象。 2. **Code First开发**：在EF4中，开发者可以采用Code First的方式，从零开始构建模型类，然后由EF自动生成数据库结构。这种方式强调了代码的重要性，使得数据库设计更加灵活。 3. **Database First和Model First**：除了Code First，EF4还支持Database First（以现有数据库为基础构建模型）和Model First（先建模型再生成数据库）两种开发模式，满足不同开发场景的需求。 4. **Entity Data Model (EDM)**：这是EF4的核心，它是一个统一的数据表示，包括概念模型、存储模型和映射模型，用于描述应用程序中的数据和数据库中的数据之间的关系。 5. **LINQ支持**：Entity Framework 4.0完全支持Language Integrated Query (LINQ)，使得开发者可以用C#或VB.NET的语法进行数据库查询，提高了代码的可读性和效率。 6. **Lazy Loading和Eager Loading**：EF4提供了延迟加载和急切加载策略，用于管理关联对象的加载时机，帮助优化性能。 7. **Change Tracking**：自动跟踪对象状态变化，如新增、修改和删除，简化了数据持久化的处理。 8. **Transactions**：EF4支持事务处理，确保数据操作的一致性和完整性。 9. **Entity SQL和LINQ to Entities**：两种查询语言提供了不同的方式来查询数据库，Entity SQL更接近于SQL语法，而LINQ to Entities则是基于C#或VB.NET的查询表达式。 10. **性能优化**：书中可能会涵盖如何识别并优化EF4性能瓶颈，包括批处理、减少数据库往返、预加载关联对象等技巧。这本书的技术审查者Vidya Vrat Agarwal可能对内容进行了专业审核，确保了技术的准确性和实用性。对于想要深入理解和掌握Entity Framework 4.0的.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页未读，继续阅读

devgis

粉丝: 51
资源: 95

专家之声：Entity Framework 4.0 教程

Pro Entity Framework 4.0

Pro Entity Framework 4

Microsoft.NETFramework4.0

Apress.Pro.Entity.Framework.4.0.Mar.2010.rar

《Pro.Entity.Framework.4.0》：NET编程数据访问未来

Apress.Pro.Csharp.5.0.and.the.NET.4.5.Framework

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

ADO.NET Entity Framework 4.0 教程

精通ADO.NET Entity Framework 4.0

ASP.NET 4.0 实战：Scott Klein著 Entity Framework 4.0

最新资源