Programming Entity Framework, Second edition (Julia Lerman) (Z Library)

# Programming Entity Framework, Second Edition — Reading Guide ## 【One-Line Pitch】 A comprehensive, hands-on guide to ADO.NET Entity Framework 4 for .NET developers who want to master Microsoft's core data-access framework—covering everything from modeling and querying to building real-world applications with WCF, MVC, and unit testing. ## 【Book Arc】 - **Opening (~0%–9%)**: Introduces EF4's architecture, the Entity Data Model (EDM), and the tooling in Visual Studio 2010, establishing the conceptual foundation—entities, associations, and the designer—before diving into code. - **Early (~9%–25%)**: Covers querying fundamentals with LINQ to Entities and Entity SQL, including navigation properties, projections, and how queries translate to database commands, with practical examples in C# and VB. - **Early–Middle (~25%–38%)**: Explores deeper query techniques—shaped results, explicit loading, Entity SQL operators, and query builder methods—then transitions into change tracking and how ObjectContext manages entity states during SaveChanges. - **Middle (~38%–47%)**: Moves into real-world modeling with complex relationships (many-to-many, self-referencing) and data binding in Windows Forms and WPF, including the Include method for eager loading and handling child data in grids. - **Late (~47%–end)**: Addresses enterprise concerns: POCOs and self-tracking entities for WCF services, layered client-side and web applications (Web Forms and MVC), repositories, unit testing, and model-first design—plus a look at future technologies like Code First and "M." ## 【Key Takeaways】 - **The Entity Data Model is the heart of EF4** (Early): Understanding the three layers—conceptual, store, and mapping—explains how EF translates your object queries into database commands, making architecture knowledge essential before writing code. - **Foreign keys in entities are new and optional in EF4** (Early): Unlike version 1, EF4 includes foreign key properties by default, which simplifies change tracking and relationship management, but you can still build models the old way for backward compatibility. - **Multiplicity defines relationship semantics** (Early): The 1, *, and 0..1 cardinality options determine how associations behave—for example, "0..1:*" means a shipper may have many orders, but an order may have zero or one shipper. - **LINQ to Entities gives you compile-time IntelliSense** (Early): Because the compiler knows entity types, you get property suggestions as you type—a major productivity win over raw SQL or Entity SQL strings. - **EntityClient requires sequential column access** (Early): When using ExecuteReader, you must read columns in the order they stream; this memory-control rule forces you to plan your data extraction carefully. - **SaveChanges is efficient because of ObjectStateEntry tracking** (Middle): The ObjectContext inspects state entries, ignores Unchanged entities, and only builds commands for Modified, Added, or Deleted ones—so you don't pay for untouched data. - **The Include method eagerly loads related data but can be wasteful** (Middle): A query with multiple Includes returns a full object graph, but as the author warns, it can produce "gasp"-inducing SQL and redundant data—use it deliberately, not as a default. - **Deleting child rows in grids doesn't delete from the database** (Middle): Removing a reservation from a grid only removes it from the collection; you need explicit handling to persist deletions—a gotcha that applies beyond EF to DataSets and custom objects. ## 【Reading Tips】 - **Skim the early architecture chapters** (~0%–9%) if you're already familiar with EF v1; focus instead on the "what's new" callouts about foreign keys and model-first design. - **Deep-read the querying chapters** (~9%–25%)—they're the foundation for everything else; pay special attention to the LINQ vs. Entity SQL comparisons and the translation-to-SQL explanations. - **Watch for the "not a best practice" warnings** (e.g., the Include-heavy query in Chapter 9); the author explicitly flags anti-patterns, which are as instructive as the recommended approaches. - **The later enterprise chapters** (~47%–end) assume you've absorbed the earlier material; if you're only building simple apps, you can skim the WCF and layered-architecture content. - **Keep the appendixes in mind**—they cover assemblies, data-binding quirks, and metadata XML, which are useful references when you hit edge cases in real projects. ## 【Coverage Limits】 This guide synthesizes the opening through middle sections (~47% of the book); the later chapters on WCF services, POCOs, layered applications, and model-first design are summarized from the preface but not detailed here. ##