Programming Entity Framework 翻译(2)-目录2-章节

How This Book Is Organized

本书组织结构

Programming Entity Framework, Second Edition, focuses on two ways for you to learn.

If you learn best by example, you’ll find many walkthroughs and code samples throughout

the book; if you’re always looking for the big picture, you’ll also find chapters that

dive deep into conceptual information. I have tried to balance the walkthroughs and

conceptual information I provide so that you will never get too much of one at a time.

The first half of the book is introductory, and the second half digs much deeper. Followingis a brief description of each chapter:

Programming Entity Framework 第二版，你可以从两个方面来学习，如果你偏好从实例开始，你将会找到许多演练和代码案例贯穿于本书，如果你喜欢看书，你也将看到有些章节在概念层的深入讲解。我尽量平衡实例演练和概念信息。第一部分主要是介绍性的，第二部分则更加深入。下面是每个章节的简要介绍。

Chapter 1, Introducing the ADO.NET Entity Framework

This chapter provides an overview of the ADO.NET Entity Framework—where it

came from, what problems it attempts to solve, and the classic “10,000-foot view”

of what it looks like. The chapter also addresses the most frequently asked

questions about the Entity Framework, such as how it fits into the .NET Framework,

what databases it works with, what types of applications you can write with

it, how it differs from object relational models, and how it works with the rest of

ADO.NET.

第1章：介绍 ado.net entity framework

本章是ado.net entity framework概述，介绍一下其来源，解决什么问题，和以很高高度来看看EF是什么。本节还会解答一些常见的关于EF的疑问，比如EF在.NET Framework中的地位，他能使用什么数据库， EF适合什么样的程序，EF和ORM有何不同，他如何跟最新的ADO.NET结合。

Chapter 2, Exploring the Entity Data Model

The Entity Data Model (EDM) lies at the core of the Entity Framework. This chapter

explains what the EDM is, and teaches you how to create one using the EDM

Wizard and then manipulate your model using the Designer. You will also get a

walkthrough of the various parts of the EDM, viewing it through the Designer or

through its raw XML.

第2章，探究EDM(实体数据模型)

EDM中EF和核心，本章节解释EDM是什么，并且教会你如何使用EDM向导去创建一个EDM和使用设计器如何去控制你的Model。演示一下EDM的各个组成部分，使用设计器或者规则XML来查看EDM

Chapter 3, Querying Entity Data Models

The Entity Framework provides a number of methods for querying against the

EDM—LINQ to Entities, Entity SQL with ObjectQuery, EntityClient, and a few

more. Each method has its own benefits. In this chapter, you will learn the basics

for leveraging the various query modes by requesting the same data using each

mechanism. You will also learn the pros and cons for choosing one method over

another, as well as gain an understanding of what happens behind the scenes in

between query execution and the creation of objects from the data that results.

第3章，查询实体数据模型

EF提供了许多查询edm的方法，比如linq to entities，基于ObjectQuery 的entity sql，entityClient，等方法。每种方法都有其利弊，通过基础原理的学习能够获取查询背后的方方面面，以便灵活掌控各种查询方法的使用。

Chapter 4, Exploring LINQ to Entities in Greater Depth

With the query basics in hand, you can now learn how to perform different types

of tricks with querying: projection, filtering, aggregates, and so forth. Because the

objects you are querying are related, you can also query across these relationships.

This chapter will walk you through a great variety of queries focusing on LINQ to

Entities. This is by no means an exhaustive depiction of every type of query you

can perform, but it will give you a huge head start.

第4章，深入探究 linq to entities

掌握查询基础后，可以开始学习如何执行各种不同技巧的查询，投影转换，过滤，聚合等等，对待查询的对象是有关系的，可以使用它们的关系进行查询。本节将引领你使用各种linq toentitys的查询技巧，虽然不是所有的查询技巧都能够讲解到位，但是至少是个非常好的开始。

Chapter 5, Exploring Entity SQL in Greater Depth

This chapter revisits the LINQ to Entities queries from Chapter 4 and shows how

to express the same types of queries using Entity SQL. You’ll also learn some specific

tips about working with Entity SQL in this chapter.

第5章，深入探究 entity sql

本章回顾第4章的linq to entities 查询，并展示如果使用entity sql来实现同类的查询。当然你也能学到一些entity sql特别的查询技巧

Chapter 6, Modifying Entities and Saving Changes

This chapter presents a high-level view of how the Entity Framework tracks

changes to entities, processes updates, and builds the final queries that are executed

at the database. By having a better understanding of the Entity Framework’s default

functionality, you will be better prepared to address common concerns regarding

security and performance. Additionally, understanding the default process will

make the following chapter on stored procedures much more meaningful.

第6章，修改实体并保存修改

本节以高视角来看EF如果跟踪实体变化，处理更新和建立最终在数据库中执行的查询。离了接EF的默认功能后，准备涉及普遍关注的安全和性能方面的问题，此外，理解默认处理对后续章节的学习理解非常有意义。

Chapter 7, Using Stored Procedures with the EDM

This chapter is the first of two to dig into using stored procedures in the Entity

Framework. The EDM Designer provides support for one set of scenarios, and that

is what is covered in this chapter. Chapter 16 covers the set of scenarios that require

more effort.

第7章，EDM中使用存储过程

深入EF中的存储过程的使用分两部分。本章是第一部分，讲解 EDM设计器中提供的对场景集的支持，第16章讲解关于场景集更有难度的东西。

Chapter 8, Implementing a More Real-World Model

Up to this point in the book, you will have been working with a very simplistic

database and model so that you can focus on all of the new tools. This chapter

introduces a larger model and database that support the fictitious travel adventure

company BreakAway Geek Adventures and which you will use throughout the rest

of the book. With this model, you will get a better understanding of building and

customizing a model. Chapters 14 and 15 will go even further into customizing the

model with advanced modeling and mappings.

第 8章, 实现一个更真实的模型

至此在这本书中，你会一直与非常简单数据库和模式打交道，这样你可以专注于所有的新工具。这一章介绍了一种更大的模型和数据库就是虚拟旅游探险公司极客冒险的商业模式，在本书其余部分中你将用到，使用此模型，你会更好地理解建立和自定义模型。14 和 15 章会更进一步到自定义具有先进的建模和映射模型。

Chapter 9, Data Binding with Windows Forms and WPF Applications

This chapter provides two walkthroughs for using the Entity Framework to perform

data binding in Windows Forms and Windows Presentation Foundation

(WPF). In the course of these walkthroughs, you’ll learn a lot of tips and tricks that

are specific to doing data binding with Entity Framework objects, as well as expand

your knowledge of the Entity Framework along the way.

第9章 在windows forms 和wpf应用程序中使用数据绑定

本章提供windows forms 和wpf应用程序中使用数据绑定的2个演示。在这些演示过程中,你会学到许多针对EF数据绑定的技巧.

Chapter 10, Working with Object Services

The Entity Framework’s Object Services API provides all of the functionality behind

working with the objects that are realized from the data shaped by your Entity

Data Model. Although the most critical of Object Services’ features is its ability to

keep track of changes to entity objects and manage relationships between them, it

offers many additional features as well. This chapter provides an overview of all of

Object Services’ responsibilities, how it impacts most of the work you do with the

Entity Framework, and how you can use these features directly to impact how the

Entity Framework operates. Later chapters focus even more deeply on particular

areas within Object Services.

Chapter 11, Customizing Entities

So far, the objects you will have been working with are based on the default classes

that the Entity Framework generates directly from the model, but you don’t need

to be limited to what’s in the objects. There are plenty of opportunities for customizing

the code-generated classes. This chapter walks you through how to take

advantage of these extensibility points. It is also possible to completely avoid the

generated classes and use your own custom classes, an option we will cover in

Chapter 13.

Chapter 12, Data Binding with RAD ASP.NET Applications

It’s time to create another application with the Entity Framework. There are a lot

of hurdles to overcome when using the Entity Framework in an ASP.NET application

that allows users to edit data. The EntityDataSource control is part of the

family of ASP.NET DataSource controls that you can configure in the UI and that

will automate data access and updating for you. This chapter will show you how

to use this control. You’ll also get a chance to use ASP.NET Dynamic Data Controls

in this chapter. Later chapters will teach you what you need to know to overcome

these hurdles yourself, and Chapter 27 leverages this knowledge to address building

layered ASP.NET applications rather than putting the logic in the UI.

Preface | xxvii

Download from Library of Wow! eBook <www.wowebook.com>

Chapter 13, Creating and Using POCO Entities

A critical advancement to Entity Framework in .NET 4 is its support for Plain Old

CLR Objects (POCOs). The POCO support means that entity classes are not

required to inherit from Entity Framework’s EntityObject class. Building POCOs

opens the door for a more agile architecture, unit testing, repositories, and persistence

ignorance, all while continuing to benefit from the Entity Framework. This

chapter provides an introduction to Entity Framework’s POCO support. Later

chapters will leverage POCOs to show alternative patterns, build repositories and

tests, and consume the POCOs in a variety of application types.

Chapter 14, Customizing Entity Data Models Using the EDM Designer

One of the most important features of the Entity Data Model is the ability to customize

it to shape your data structure in a way that is more useful than working

directly against the database schema. This chapter walks through many of the ways

you can achieve this with the Designer, demonstrating how to implement a variety

of inheritance mappings, create an entity that maps to multiple tables, build complex

types, and more. If you are following along with the walkthroughs, most of

the modifications you make to the sample model in this chapter you will use for

applications you’ll build in later chapters.

Chapter 15, Defining EDM Mappings That Are Not Supported by the Designer

The Entity Framework model supports even more ways to map back to the database

but, unfortunately, not all are supported by the Designer. In this chapter,

you’ll learn about the most common types of mappings that you might want to use

but will have to open up the raw XML to implement. Among these are

DefiningQuery, QueryView, and even nonexistent database views and stored procedures

that you can define directly in the Entity Framework metadata.

Chapter 16, Gaining Additional Stored Procedure and View Support in the Raw XML

Chapter 7 covers the stored procedure scenarios that the Designer supports, but

you can achieve much more if you are willing to crack open the model’s raw XML

and perform additional customizations. This chapter will walk you through adding

“virtual” store queries and stored procedures into the model, and taking advantage

of other features that will make the model work for you, rather than being constrained

by the Designer.

Chapter 17, Using EntityObjects in WCF Services

Like ASP.NET, using the Entity Framework in web and WCF services provides a

number of challenges. In this chapter, you will learn how to build and consume a

WCF service that interacts solely with EntityObjects. If you have never created

services before, have no fear. The walkthroughs will help you with step-by-step

instructions. You will also create a WCF Data Service and get a quick look at WCF

RIA Services. This chapter is the first of two that address building services.

Chapter 18, Using POCOs and Self-Tracking Entities in WCF Services

The new POCO support in Entity Framework 4 makes building WCF Services a

lot simpler. This chapter enhances the POCO entities you built in Chapter 13 and

xxviii | Preface

Download from Library of Wow! eBook <www.wowebook.com>

uses them in a revised implementation of the WCF Services you created in Chapter

17. You’ll also learn about some of the differences when building WCF Data

Services and WCF RIA Services with POCOs.

The preceding chapters will have provided you with a solid base of understanding for

working with the Entity Framework. Starting with Chapter 19, you will learn about the

Entity Framework’s advanced topics:

Chapter 19, Working with Relationships and Associations

The Entity Data Model is based on Entity Relationship Modeling, which is about

entities and relationships. Relationships are a critical part of the model and how

the Entity Framework performs its functions. To really understand and control the

Entity Framework and avoid hurting your head when the relationships don’t behave

the way you might expect, you will benefit from a deep comprehension of

how relationships work in the model and your Entity Framework code. This chapter

will provide you with that understanding.

Chapter 20, Real World Apps: Connections, Transactions, Performance, and More

Up to this point, you have seen bits and pieces of code out of the context of realworld

applications. But how does the Entity Framework fit in with the everyday

concerns of software developers? This chapter will address some of the many questions

developers ask after learning the basics about the Entity Framework. How

do you control connections? Is there any connection pooling? Are database calls

transactional? What about security? How’s the performance?

Chapter 21, Manipulating Entities with ObjectStateManager and MetadataWorkspace

This is another chapter where you get to dig even further into the APIs to interact

with your objects in the same way that many of the internal functions do. With the

two classes featured in this chapter, you can write code to generically work with

entities or raw data whether you want to create reusable code for your apps or write

utilities. There are some hefty samples in this chapter.

Chapter 22, Handling Exceptions

Hard as we try to write perfect code, things can still go wrong in our applications,

which is why we need exception handling. The Entity Framework provides a set

of its own exceptions to help you deal with the unique problems that may occur

when working with entities—poorly written queries, entities that are missing required

related objects, or even a problem in the database.

Chapter 23, Planning for Concurrency Problems

This chapter follows up what you learned about exception handling in Chapter

22 with details on a particular type of exception: the OptimisticConcurrencyEx

ception. In addition to typical coding problems, data access highlights another

arena of issues regarding concurrency: when multiple people are editing and updating

data. The Entity Framework supports optimistic concurrency and uses this

exception to detect these problems. The chapter will show you how to prepare for

concurrency issues and take advantage of this exception.

Preface | xxix

Download from Library of Wow! eBook <www.wowebook.com>

Chapter 24, Building Persistent Ignorant, Testable Applications

Chapter 13 introduced you to Entity Framework’s POCO support. Chapter 24

shows you where the POCO support really shines. Here you’ll get a chance to use

a pattern that leverages POCO support. You will create repositories and a Unit of

Work and build unit tests against your Entity Framework code. You’ll get to use

the repository in some applications in later chapters.

Chapter 25, Domain-Centric Modeling

You’ll find more new .NET 4 and Visual Studio 2010 goodness in this chapter as

well as a look to the future. You are no longer required to build database-first

models. The EDM Designer in Visual Studio 2010 supports model-first design.

Build your model in the Designer and then automatically create a database schema

from the model. In this chapter, you’ll learn a lot more about working with the

Designer. This chapter also takes a look at two not-yet-released technologies: Entity

Framework’s code first and SQL Modeling’s “M.” Both of these technologies

let you use Entity Framework without depending on a physical XML-based model.

At this point in the book, you will have learned quite a lot about how the Entity Framework

functions and how to work with the objects and the model in a granular way. The

final two chapters focus on challenges and solutions for using the Entity Framework

in enterprise applications. The book concludes with three appendixes: one that serves

as a guide to the assemblies and namespaces of the Entity Framework, another that

highlights unexpected behaviors when data-binding complex types, and a third that

looks more deeply into the XML of the model’s metadata.

Chapter 26, Using Entities in Layered Client-Side Applications

The earlier client application walkthroughs (Windows Forms and WPF) focused

on simple architectures to get you started with data binding. Most medium to large

applications are not written in this way, but rather separate their logic and data

layers from the UI. This chapter will look at some of the specific features you can

take advantage of and challenges you might face when architecting Windows and

WPF applications to keep the data access and business logic out of the user interface.

The chapter focuses on a sample WPF application using the repositories from

Chapter 24.

Chapter 27, Building Layered Web Applications

Chapter 12 focused on building RAD ASP.NET apps using the EntityDataSource

control to avoid some of the issues with change tracking across tiers in the Entity

Framework. Now that you have learned much more about working with entities,

it is time to address these challenges head-on and learn how you can build ASP.NET

application layers. This chapter begins by addressing the specific issues that the

ASP.NET Page life cycle poses for entities, and then walks through two solutions

that leverage the repositories from Chapter 24. The first is an ASP.NET Web Forms

application that is built without the support of data source controls. The second

is an ASP.NET MVC application that focuses on keeping data access code out of

xxx | Preface

Download from Library of Wow! eBook <www.wowebook.com>

the controller. The samples in this chapter provide a first step toward concepts that

will help you architect applications to fit your own domain model.

Appendix A, Entity Framework Assemblies and Namespaces

This appendix is a guide to the physical files that are part of the Entity Framework

and each namespace in the programming model.

Appendix B, Data-Binding with Complex Types

In Chapter 14, you learn how to create complex types in the model. Complex types

have some interesting (and often unexpected) behavior in data-binding scenarios.

This appendix will prepare you for what to expect.

Appendix C, Additional Details About Entity Data Model Metadata

Chapter 2 goes into plenty of detail about the model’s metadata, but if you are

hardcore and want to dig a little further into the raw XML, this appendix should

satisfy your cravings.