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

ASP.NET.4

1星需积分: 15 81 浏览量更新于2024-07-27 收藏 18.87MB PDF 举报

"Pro.ASP.NET.4.in.C.Sharp.2010.Fourth.Edition" 是一本关于ASP.NET 4.0开发的专业书籍，作者是Scott Klein，该书以C#语言为主要编程语言进行讲解。同时，该书提到了"Entity Framework 4.0"，这是微软提供的一种面向对象的数据访问框架，用于简化.NET应用程序中的数据访问操作。在ASP.NET 4.0中，开发者可以利用C#的强大特性和更新来构建高性能、可扩展的Web应用。这一版本带来了许多改进和新特性，包括更精细的控制权、增强的性能、更强大的动态数据支持以及对HTML5的初步支持等。C# 2010也引入了新的语言特性，如自动属性、匿名类型、LINQ的进一步集成以及动态类型等，这些都使得代码编写更加简洁高效。 Entity Framework 4.0作为数据访问层的重要组成部分，允许开发者通过使用对象关系映射（ORM）技术，将业务实体与数据库表进行抽象，从而减少对SQL语句的直接操作。它支持Code First、Database First和Model First三种开发模式，为开发者提供了灵活的选择。在EF 4.0中，还包括了Poco支持、改进的性能、延迟加载以及更强大的LINQ支持等特性，使得开发人员可以更加专注于业务逻辑而不是数据访问细节。书中可能涵盖了以下主题： 1. ASP.NET 4.0基础：解释ASP.NET 4.0的核心概念，包括页面生命周期、控件、路由和页面状态管理。 2. C# 2010语言特性：深入解析C# 2010的新特性及其在ASP.NET开发中的应用。 3. 数据访问：详细阐述Entity Framework 4.0的使用，包括实体模型设计、数据上下文、查询和操作数据的方法。 4. LINQ to Entities：介绍如何使用LINQ查询数据库，以及如何创建复杂的查询表达式。 5. ADO.NET Entity Data Model工具：演示如何通过Visual Studio工具生成和编辑实体模型。 6. 性能优化：讨论如何优化Entity Framework的性能，包括批处理操作、减少内存占用和提高查询效率。 7. 部署与安全：涵盖应用程序部署策略以及ASP.NET的安全特性，如身份验证和授权。 8. 扩展与自定义：介绍如何根据需求扩展和定制Entity Framework，包括创建自定义上下文、拦截器和存储过程映射。 "Pro.ASP.NET.4.in.C.Sharp.2010.Fourth.Edition"是针对ASP.NET 4.0和Entity Framework 4.0的高级指南，旨在帮助开发者掌握这些技术，提升Web应用程序的开发效率和质量。书中不仅提供了理论知识，还包含丰富的实践示例，有助于读者深入理解和应用这些技术。

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.

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

feishi_001

粉丝: 0
资源: 1

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

C#与.NET.3.5高级程序设计(第4版)].Pro.C#.2008.and.the.NET.3.5.Platform.Fourth.Edition.part2.rar

[C#与.NET.3.5高级程序设计(第4版)].Pro.C#.2008.and.the.NET.3.5.Platform.Fourth.Edition.part1.rar

[C#与.NET.3.5高级程序设计(第4版)].Pro.C#.2008.and.the.NET.3.5.Platform.Fourth.Edition.rar

Apress.Pro.C.Sharp.2008.and.the.dot.NET.3.5.Platform.4th.Edition.Nov.2007.part2

Pro ASP.NET 4 in C# 2010, Fourth Edition

Pro ASP.NET 4 in C# 2010, Fourth Edition(asp.net高级程序设计第四版)

Pro ASP.NET 4 in C# 2010, Fourth Edition-part1

Pro ASP.NET 4 in C# 2010, Fourth Edition-part2

C#.2010.for.Programmers.Fourth.Edition

Windows.Internals.Fourth.Edition.Dec.2004.internal.Fixed.

最新资源