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

SECOND EDITION Programming Entity Framework Julia Lerman Beijing • Cambridge • Farnham • Köln • Sebastopol • Taipei • Tokyo

Programming Entity Framework, Second Edition by Julia Lerman Copyright © 2010 Julia Lerman. All rights reserved. Printed in the United States of America. Published by O’Reilly Media, Inc., 1005 Gravenstein Highway North, Sebastopol, CA 95472. O’Reilly books may be purchased for educational, business, or sales promotional use. Online editions are also available for most titles (http://my.safaribooksonline.com). For more information, contact our corporate/institutional sales department: 800-998-9938 or corporate@oreilly.com. Editors: Mike Hendrickson and Laurel Ruma Production Editor: Loranah Dimant Copyeditor: Audrey Doyle Proofreader: Sada Preisch Indexer: Ellen Troutman Zaig Cover Designer: Karen Montgomery Interior Designer: David Futato Illustrator: Robert Romano Printing History: February 2009: First Edition. August 2010: Second Edition. Nutshell Handbook, the Nutshell Handbook logo, and the O’Reilly logo are registered trademarks of O’Reilly Media, Inc. Programming Entity Framework, the image of a Seychelles blue pigeon, and related trade dress are trademarks of O’Reilly Media, Inc. Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations appear in this book, and O’Reilly Media, Inc., was aware of a trademark claim, the designations have been printed in caps or initial caps. .NET is a registered trademark of Microsoft Corporation. While every precaution has been taken in the preparation of this book, the publisher and author assume no responsibility for errors or omissions, or for damages resulting from the use of the information con- tained herein. ISBN: 978-0-596-80726-9 [SB] 1281106344

Table of Contents Foreword . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxi Preface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxiii 1. Introducing the ADO.NET Entity Framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 The Entity Relationship Model: Programming Against a Model, Not the Database 2 The Entity Data Model: A Client-Side Data Model 3 Entities: Blueprints for Business Classes 6 The Backend Database: Your Choice 7 Database Providers 8 Access and ODBC 9 Entity Framework Features: APIs and Tools 9 Metadata 10 Entity Data Model Design Tools 10 Object Services 11 POCO Support 12 Change Tracking 12 Relationship Management and Foreign Keys 13 Data Binding 13 n-Tier Development 14 EntityClient 14 The Entity Framework and WCF Services 15 What About ADO.NET DataSets and LINQ to SQL? 15 DataSets 15 LINQ to SQL 16 Entity Framework Pain Points Are Fading Away 16 Programming the Entity Framework 17 2. Exploring the Entity Data Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 Why Use an Entity Data Model? 19 iii

The EDM Within the Entity Framework 20 Walkthrough: Building Your First EDM 21 Inspecting the EDM in the Designer Window 24 Entity Container Properties 26 Entity Properties 26 Entity Property Properties 27 The Model’s Supporting Metadata 29 Viewing the Model in the Model Browser 31 Viewing the Model’s Raw XML 31 CSDL: The Conceptual Schema 33 EntityContainer 34 EntitySet 35 EntityType 36 Associations 38 Navigation Property 41 Navigation Properties That Return Collections 42 SSDL: The Store Schema 43 MSL: The Mappings 45 Database Views in the EDM 46 Summary 47 3. Querying Entity Data Models . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 Query the Model, Not the Database 49 Your First EDM Query 50 Where Did the Context and Classes Come From? 51 Querying with LINQ to Entities 55 Writing Your First LINQ to Entities Query 55 Querying with Object Services and Entity SQL 57 Why Another Way to Query? 57 Entity SQL 58 The Parameterized ObjectQuery 60 Querying with Methods 61 Querying with LINQ Methods 61 Querying with Query Builder Methods and Entity SQL 64 The Shortest Query 66 ObjectQuery, ObjectSet, and LINQ to Entities 66 Querying with EntityClient to Return Streamed Data 68 EntityConnection and the Connection String 70 EntityCommand 71 ExecuteReader 71 Forward-Only Access to the Fields 71 Translating Entity Queries to Database Queries 71 Pay Attention to the .NET Method’s Impact on Generated SQL 72 iv | Table of Contents

Avoiding Inadvertent Query Execution 74 Summary 75 4. Exploring LINQ to Entities in Greater Depth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 Getting Ready with Some New Lingo 78 Projections in Queries 78 Projections in LINQ to Entities 79 VB and C# Syntax Differences 79 LINQ Projections and Special Language Features 80 Projections with LINQ Query Methods 84 Using Navigations in Queries 84 Navigating to an EntityReference 84 Filtering and Sorting with an EntityReference 86 Navigating to Entity Collections 86 Projecting Properties from EntityCollection Entities 87 Filtering and Sorting with EntityCollections 88 Aggregates with EntityCollections 88 Aggregates in LINQ Methods 89 Joins and Nested Queries 90 Joins 90 Nested Queries 91 Grouping 93 Naming Properties When Grouping 94 Chaining Aggregates 95 Filtering on Group Conditions 95 Shaping Data Returned by Queries 97 Limiting Which Related Data Is Returned 99 Loading Related Data 100 Controlling Lazy Loading 101 Explicitly Loading Entity Collections and Entity References 101 Using the Include Method to Eager-Load 103 Pros and Cons of Load and Include 106 Retrieving a Single Entity 107 Retrieving a Single Entity with GetObjectByKey 108 Finding More Query Samples 109 Summary 109 5. Exploring Entity SQL in Greater Depth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 Literals in Entity SQL 111 Expressing a DateTime Literal 112 Expressing a Decimal Literal 112 Using Additional Literal Types 112 Projecting in Entity SQL 113 Table of Contents | v

DbDataRecords and Nonscalar Properties 114 Projecting with Query Builder Methods 115 Using Navigation in Entity SQL Queries 115 Navigating to an EntityReference 115 Filtering and Sorting with an EntityReference 116 Filtering and Sorting with EntityCollections 116 Aggregating with EntityCollections 117 Using Entity SQL SET Operators 117 Aggregating with Query Builder Methods 118 Using Joins 118 Nesting Queries 119 Grouping in Entity SQL 120 Returning Entities from an Entity SQL GROUP BY Query 121 Filtering Based on Group Properties 121 Shaping Data with Entity SQL 122 Using Include with an ObjectQuery and Entity SQL 123 Understanding Entity SQL’s Wrapped and Unwrapped Results 124 Entity SQL Rules for Wrapped and Unwrapped Results 126 Digging a Little Deeper into EntityClient’s Results 126 Summary 127 6. Modifying Entities and Saving Changes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129 Keeping Track of Entities 129 Managing an Entity’s State 130 Saving Changes Back to the Database 131 Inserting New Objects 134 Inserting New Parents and Children 135 Deleting Entities 137 Summary 139 7. Using Stored Procedures with the EDM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141 Updating the Model from a Database 142 Working with Functions 143 Function Attributes 144 Mapping Functions to Entities 146 Mapping Insert, Update, and Delete Functions to an Entity 148 Inspecting Mappings in XML 152 Using Mapped Functions 153 Using the EDM Designer Model Browser to Import Additional Functions into Your Model 155 Mapping the First of the Read Stored Procedures: ContactsbyState 156 Using Imported Functions 158 Avoiding Inadvertent Client-Side Processing 159 vi | Table of Contents

Mapping a Function to a Scalar Type 159 Mapping a Function to a Complex Type 160 Summary 163 8. Implementing a More Real-World Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165 Introducing the BreakAway Geek Adventures Business Model and Legacy Database 166 Creating a Separate Project for an EDM 168 Inspecting and Cleaning Up a New EDM 168 Modifying the Names of Entities and Properties 170 Resolving Collisions Between Property Names and Entity Names 172 Cleaning Up Navigation Property Names 172 Setting Default Values 174 Mapping Stored Procedures 175 Using the Use Original Value Checkbox in Update Mappings 176 Working with Many-to-Many Relationships 178 Inspecting the Completed BreakAway Model 181 Building the BreakAway Model Assembly 182 Looking at the Compiled Assembly 183 Splitting Out the Model’s Metadata Files 184 Summary 185 9. Data Binding with Windows Forms and WPF Applications . . . . . . . . . . . . . . . . . . . 187 Data Binding with Windows Forms Applications 187 Creating a Windows Forms Application 188 Using Windows Forms Data Sources 189 Creating an Object Data Source for a Customer Entity 190 Getting an Entity’s Details onto a Form 191 Adding Code to Query an EDM When a Form Loads 194 Binding Without a BindingSource 196 Adding an EntityCollection to the Form 198 Displaying the Properties of Related Data in the Grid 199 Allowing Users to Edit Data 201 Editing Navigation Properties (and Shrinking the Query) 202 Replacing the Navigation Property TextBoxes with ComboBoxes 204 Adding New Customers 208 Deleting Reservations 211 Data Binding with WPF Applications 213 Creating the WPF Form 213 Creating the WPF Project 214 Adding the Necessary Data Source Objects 215 Inspecting the XAML and Code Generated by the Automated Data Binding 215 Table of Contents | vii

Adding Code to Query the EDM When the Window Loads 216 Customizing the Display of the Controls 218 Selecting an Entity and Viewing Its Details 219 Adding Another EntityCollection to the Mix 222 Editing Entities and Their Related Data 224 Using SortDescriptions to Keep Sorting in Sync with Data Modifica- tions 225 Adding Items to the Child EntityCollection 226 The Last Task: Adding New Trips to the Catalog 227 Summary 230 10. Working with Object Services . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231 Where Does Object Services Fit into the Framework? 231 Processing Queries 233 Parsing Queries: From Query to Command Tree to SQL 234 Understanding Query Builder Methods 235 Analyzing a Query with ObjectQuery Methods and Properties 238 Executing Queries with ToList, ToArray, First or Single 241 Executing Queries with the Execute Method 242 Overriding a Default Connection with ObjectContext.Connection 242 Handling Command Execution with EntityClient 244 Materializing Objects 244 Managing Object State 246 Using EntityKey to Manage Objects 246 Merging Results into the Cache with MergeOptions 247 Inspecting ObjectStateEntry 248 Maintaining EntityState 249 Managing Relationships 252 Attaching and Detaching Objects from the ObjectContext 253 Taking Control of ObjectState 257 ObjectStateManager Methods 257 ObjectStateEntry State Methods for Managing State 258 ObjectSet State Methods 259 Sending Changes Back to the Database 259 ObjectContext.SaveChanges 259 Affecting SaveChanges Default Behavior 260 Overriding SaveChanges Completely 261 Data Validation with the SavingChanges Event 261 Concurrency Management 261 Transaction Support 262 Implementing Serialization, Data Binding, and More 263 Object Services Supports XML and Binary Serialization 263 Object Services Supports Data Binding 265 viii | Table of Contents

Summary 266 11. Customizing Entities . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267 Partial Classes 267 Using Partial Methods 269 The OnContextCreated Method 269 The On[Property]Changed and On[Property]Changing Methods 271 Using PropertyChanged to Calculate Database-Computed Columns Locally 273 Subscribing to Event Handlers 274 The ObjectContext.ObjectMaterialized Event 275 The ObjectContext.SavingChanges Event 276 The EntityObject.PropertyChanging and EntityObject.PropertyChanged Events 280 The AssociationChanged Event 282 Creating Your Own Partial Methods and Properties 284 Overriding the Object Constructor 284 Overriding ObjectContext.SaveChanges 285 Creating Custom Properties 286 Overloading Entity Creation Methods 289 Using Partial Classes for More Than Just Overriding Methods and Events 290 Overriding Default Code Generation 291 Switching to a Template 292 Reading the Template 292 Modifying the Template 293 Customizing a Template for Major Class Modifications 295 Switching Between the Default Template and a Custom Template 295 Summary 296 12. Data Binding with RAD ASP.NET Applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297 Using the EntityDataSource Control to Access Flat Data 298 Creating the Hello Entities Project 298 Creating a GridView and an EntityDataSource Concurrently 299 Configuring an EntityDataSource with Its Wizard 299 Formatting the GridView 301 Testing the Web Application 303 Understanding How the EntityDataSource Retrieves and Updates Your Data 304 EntityDataSource and Its Query 304 EntityDataSource and Its ObjectContext 305 EntityDataSource Context Events 306 EntityDataSource and ViewState 306 Table of Contents | ix

Accessing Foreign Keys When There Is No Foreign Key Property 308 Working with Related EntityReference Data 309 Using EntityDataSource.Include to Get Related Data 309 Displaying Data That Comes from EntityReference Navigation Properties 310 Using a New EntityDataSource Control to Enable Editing of EntityReference Navigation Properties 312 Editing EntityReferences That Cannot Be Satisfied with a Drop-Down List 313 Binding an EntityDataSource to Another Control with WhereParameters 314 Editing Related Data Concurrently with Multiple EntityDataSource Controls 316 Working with Hierarchical Data in a Master/Detail Form 317 Setting Up the Web Application 317 Specifying Your Own Entity SQL Query Expression for an EntityDataSource 318 Binding a DropDownList to an EntityDataSource Control 319 Creating a Parent EntityDataSource That Is Controlled by the DropDownList and Provides Data to a DetailsView 320 Using the EntityDataSource.Where Property to Filter Query Results 321 Displaying Read-Only Child Data Through the Parent EntityDataSource 321 Using a New EntityDataSource to Add a Third Level of Hierarchical Data to the Master/Detail Form 323 Using the EntityDataSource.Inserting Event to Help with Newly Added Entities 325 Testing the Application 326 Exploring EntityDataSource Events 327 Building Dynamic Data Websites 329 Summary 332 13. Creating and Using POCO Entities . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335 Creating POCO Classes 336 Creating an ObjectContext Class to Manage the POCOs 339 Change Tracking with POCOs 341 Understanding the Importance of DetectChanges 341 Loading Related Data with POCOs 341 Loading from the Context 342 Lazy Loading from a Dynamic Proxy 342 Exploring and Correcting POCOs’ Impact on Two-Way Relationships 342 Using the DetectChanges Method to Fix Relationships 343 Enabling Classes to Fix Their Own Relationships 344 x | Table of Contents

Using Proxies to Enable Change Notification, Lazy Loading, and Relationship Fix-Up 345 Change Notification by Proxy 346 Lazy Loading by Proxy 346 Exploring the Proxy Classes 347 Synchronizing Relationships by Proxy 348 Using T4 to Generate POCO Classes 350 Modifying the POCO Template 354 Creating a Model That Works with Preexisting Classes 358 Code First: Using Entity Framework with No Model at All 359 Summary 359 14. Customizing Entity Data Models Using the EDM Designer . . . . . . . . . . . . . . . . . . . . 361 Mapping Table per Type Inheritance for Tables That Describe Derived Types 362 Mapping TPT Inheritance 363 Querying Inherited Types 365 POCO Classes and Inherited Objects 366 Inserting TPT Inherited Types 366 Specifying or Excluding Derived Types in Queries 368 Creating New Derived Entities When the Base Entity Already Exists 370 TPT with Abstract Types 371 Mapping Unique Foreign Keys 373 Mapping an Entity to More Than One Table 375 Merging Multiple Entities into One 376 Querying, Editing, and Saving a Split Entity 378 Mapping Stored Procedures to Split Tables and More 380 Splitting a Single Table into Multiple Entities 381 Filtering Entities with Conditional Mapping 383 Creating a Conditional Mapping for the Activity Entity 385 Querying, Inserting, and Saving with Conditional Mappings 385 Filtering on Other Types of Conditions 387 Removing the Conditional Mapping from Activity and Re-creating the Category Property 388 Implementing Table per Hierarchy Inheritance for Tables That Contain Multiple Types 389 Creating the Resort Derived Type 390 Setting a Default (Computed) Value on the Table Schema 391 Testing the TPH Mapping 392 Choosing to Turn a Base Class into an Abstract Class 393 Creating Complex Types to Encapsulate Sets of Properties 393 Defining a Complex Type 394 Reusing Complex Types 396 Table of Contents | xi

Querying, Creating, and Saving Entities That Contain Complex Types 397 Removing the Complex Types from the Model 398 Using Additional Customization Options 399 Using GUIDs for EntityKeys 399 Mapping Stored Procedures 399 Mapping Multiple Entity Sets per Type 399 Mapping Self-Referencing Associations 400 Summary 401 15. Defining EDM Mappings That Are Not Supported by the Designer . . . . . . . . . . . . . 403 Using Model-Defined Functions 403 Using Model-Defined Functions to Return More Complex Results 407 Consuming the Complex Results 408 Reading the Results from a Complex Function 408 Mapping Table per Concrete (TPC) Type Inheritance for Tables with Overlapping Fields 409 Using QueryView to Create Read-Only Entities and Other Specialized Mappings 411 Finding a Common Use Case for QueryView 413 Creating a CustomerNameAndID Entity 413 Creating a QueryView Mapping for CustomerNameAndID 414 Testing the QueryView 416 Deconstructing the QueryView 416 Summary 417 16. Gaining Additional Stored Procedure and View Support in the Raw XML . . . . . . . 419 Reviewing Procedures, Views, and UDFs in the EDM 419 Working with Stored Procedures That Return Data 420 Using Functions That Match an Entity Whose Property Names Have Been Changed 420 Query Stored Procedures and Inherited Types 421 Composing Queries Against Functions 423 Replacing Stored Procedures with Views for Composability 423 Queries That Return Multiple Result Sets 424 Executing Queries on Demand with ExecuteStoreQuery 424 Querying to a Class That Is Not an Entity 424 Querying into an Entity 425 Adding Native Queries to the Model 426 Defining a Complex Type in the Model Browser 427 Adding Native Views to the Model 429 DefiningQuery Is Already in Your Model 429 Using DefiningQuery to Create Your Own Views 431 Implementing a DefiningQuery 433 xii | Table of Contents

Creating Associations with the New Entity 437 Using DefiningQuery to Solve More Complex Problems 438 Using Commands That Affect the Database 440 Executing SQL on the Fly with ExecuteStoreCommand 440 Using Functions to Manipulate Data in the Database 441 Mapping Insert/Update/Delete to Types Within an Inheritance Structure 444 What If Stored Procedures Affect Multiple Entities in an Inheritance Structure? 445 Implementing and Querying with User-Defined Functions (UDFs) 445 Summary 447 17. Using EntityObjects in WCF Services . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 449 Planning for an Entity Framework–Agnostic Client 450 Assessing the Pros and Cons of an Entity Framework–Agnostic Consumer 451 Building a Simple WCF Service with EntityObjects 452 Creating the Service 453 Defining the Service Operations 454 Defining Extra Service Classes 455 Exposing Custom Properties 456 Implementing the Service Interface 457 Adding Graphs to ObjectContext 460 Deleting Objects 461 Updating the Object Graph 463 Client Rules for Identifying Changes in an EntityCollection 463 The UpdateCustomer Method 463 Handling New and Existing Reservations 465 Deleting Reservations 466 Building a Simple Console App to Consume an EntityObject Service 467 Enabling the Client Application to Receive Large Messages from the Service 468 Creating Methods to Test the Service Operations 469 Analyzing the GetAndUpdateCustomer Method 473 Testing Out the Other Service Operations 474 Creating WCF Data Services with Entities 474 Putting WCF Data Services in Perspective 475 Creating a WCF Data Service 475 Filtering at the Service Level Using QueryInterceptor 480 Anticipating Exceptions 481 Exposing Related Data Through the Service 481 Preparing for WCF Data Services’ Limitations 483 Modifying Data Through a Service 484 Learning More About Creating and Consuming WCF Data Services 485 Table of Contents | xiii

Understanding How WCF RIA Services Relates to the Entity Framework 485 Summary 487 18. Using POCOs and Self-Tracking Entities in WCF Services . . . . . . . . . . . . . . . . . . . . . . 489 Creating WCF-Friendly POCO Classes 490 Updating the POCO Classes Based on the Current BreakAway Model 490 Isolating the POCO Entities in Their Own Project 491 Adding Custom Logic to the POCO Entities with a Base Class 493 Following WCF Collection Rules 495 Preventing Properties from Being Marked As Virtual 496 Building a WCF Service That Uses POCO Classes 497 Implementing the Interface 498 Using the Service 500 Using the Self-Tracking Entities Template for WCF Services 503 Creating and Exploring the Self-Tracking Entities 503 Putting the Change-Tracking Logic Where It’s Needed 505 Creating a WCF Service That Uses Self-Tracking Entities 506 Watching Self-Tracking Entities Under the Covers 507 Inspecting the Generated Context Class and Extensions 513 Using POCO Entities with WCF Data and RIA Services 515 Preparing for WCF Data Services 515 Using POCO Entities in WCF RIA Services 517 Sorting Out the Many Options for Creating Services 519 Summary 520 19. Working with Relationships and Associations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 521 Deconstructing Relationships in the Entity Data Model 522 Understanding How the Entity Data Model Wizard Creates the Association 523 Understanding Additional Relationship Items 525 Handling Nonessential Navigation Properties 526 Understanding the Major Differences Between Foreign Key Associations and Independent Associations 527 Defining Associations in Metadata 528 Detecting Associations at Runtime 528 Deconstructing Relationships Between Instantiated Entities 529 Understanding Relationship Manager and the IRelatedEnd Interface 530 Late-Binding Relationships 530 Taking a Peek Under the Covers: How Entity Framework Manages Relationships 531 Understanding Navigation Properties 534 Understanding Referential Integrity and Constraints 537 Implementing Deletes and Cascading Deletes 540 xiv | Table of Contents

Defining Relationships Between Entities 542 The CLR Way: Setting a Navigation Property to an Entity 543 Setting a Foreign Key Property 544 Setting an EntityReference Using an EntityKey 544 Loading, Adding, and Attaching Navigation Properties 545 Lazy Loading 545 EntityReference.Load and EntityCollection.Load 547 Loading from Detached Entities: Lazy and Explicit 547 Using EntityCollection.Add 548 Using Attach and Remove 549 Moving an Entity to a New Graph 550 Learning a Few Last Tricks to Make You a Relationship Pro 551 Using CreateSourceQuery to Enhance Deferred Loading 551 Getting a Foreign Key Value in an Independent Association 552 Summary 553 20. Real World Apps: Connections, Transactions, Performance, and More . . . . . . . . . . 555 Entity Framework and Connections 555 Overriding EntityConnection Defaults 556 Working with Connection Strings Programmatically 557 Opening and Closing Connections 560 Getting the Store Connection from EntityConnection 562 Disposing Connections 562 Pooling Connections 563 Fine-Tuning Transactions 564 Why Use Your Own Transaction? 564 Understanding Implicit Entity Framework Transactions 565 Specifying Your Own Read/Write Transactions 566 Specifying Your Own Read-Only Transactions 569 Rolling Back Transactions 570 Understanding Security 571 Guarding Against SQL Injection 571 Guarding Against Connection Piggybacks 573 Fine-Tuning Performance 574 Measuring Query Performance 575 Measuring Startup Performance 579 Reducing the Cost of Query Compilation 580 Caching for Entity SQL Queries 580 Precompiling Views for Performance 582 Precompiling LINQ to Entities Queries for Performance 585 Fine-Tuning Updates for Performance? 589 Lacking Support for Full Text Searches 590 Exploiting Multithreaded Applications 591 Table of Contents | xv

Forcing an ObjectContext to Use Its Own Thread 591 Implementing Concurrent Thread Processing 593 Exploiting .NET 4 Parallel Computing 596 Summary 596 21. Manipulating Entities with ObjectStateManager and MetadataWorkspace . . . . . 597 Manipulating Entities and Their State with ObjectStateManager 598 Refreshing Your High-Level Understanding of ObjectStateEntry 599 Getting an ObjectStateManager and Its Entries 599 Building Extension Methods to Overload GetObjectStateEntries 600 Building a Method to Return Managed Entities 602 Using GetObjectStateEntry and TryGetObjectStateEntry 603 Mining Entity Details from ObjectStateEntry 604 Leveraging the ObjectStateManager During Saves 609 Using ObjectStateManager to Build an EntityState Visualizer 611 Retrieving an ObjectStateEntry Using an EntityKey 612 Reading the OriginalValues and CurrentValues of an ObjectStateEntry 613 Determining Whether a Property Has Been Modified 614 Displaying the State and Entity Type 614 Getting ComplexType Properties Out of ObjectStateEntry 615 Modifying Values with ObjectStateManager 619 Working with Relationships in ObjectStateManager 620 Using the MetadataWorkspace 622 Loading the MetadataWorkspace 622 Clearing the MetadataWorkspace from Memory 623 Understanding the MetadataWorkspace ItemCollections 624 Retrieving Metadata from the MetadataWorkspace 625 Querying the Metadata with LINQ to Objects 628 Building Dynamic Queries and Reading Results 629 Building Entity SQL Queries Dynamically Using Metadata 629 Creating Queries on the Fly with CreateObjectSet and Query Builder Methods 632 Reading the Results of a Dynamically Created Query 634 Creating and Manipulating Entities Dynamically 637 Creating EntityObjects Without Entity Classes 637 Creating Entities and Graphs Dynamically 640 Summary 643 22. Handling Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 645 Preparing for Exceptions 645 Handling EntityConnectionString Exceptions 647 xvi | Table of Contents

Connection String Can’t Be Found or Is Improperly Configured: System.ArgumentException 648 Metadata Files Cannot Be Found: System.Data.MetadataException 648 Handling Connection String Exceptions 649 Handling Query Compilation Exceptions 649 Invalid LINQ to Entities Query Expressions: System.NotSupportedException 649 Invalid Entity SQL Query Expressions: EntitySqlException 650 EntityCommandCompilationException Thrown by the Store Provider 652 Creating a Common Wrapper to Handle Query Execution Exceptions 652 Handling Exceptions Thrown During SaveChanges Command Execution 654 UpdateException: Thrown When Independent Association Mapping Constraints Are Broken 654 UpdateException: Thrown by Broken Constraints in the Database 655 Relying on Entity Framework to Automatically Roll Back When an UpdateException Occurs 656 Gleaning Details from UpdateException 656 Planning for Other Exceptions Related to the Entity Framework 657 Handling Concurrency Exceptions 658 Summary 658 23. Planning for Concurrency Problems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 659 Understanding Database Concurrency Conflicts 660 Understanding Optimistic Concurrency Options in the Entity Frame- work 660 Ignoring Concurrency Conflicts 661 Forcing the User’s Data to the Server (ClientWins) 661 Refreshing the User’s Data with Server Data (StoreWins) 661 Determining the Scope of Changes 662 Using rowversion (a.k.a. timestamp) for Concurrency Checks 662 Implementing Optimistic Concurrency with the Entity Framework 663 Flagging a Property for Concurrency Checking 664 How the Entity Framework Uses the ConcurrencyMode Property 665 Concurrency Checking Without a rowversion Field 666 Concurrency Checking on a Checksum in the Data Store 666 Concurrency Checks for EntityReference Navigation Properties 667 Concurrency Checks and Inherited Types 667 Concurrency Checks and Stored Procedures 668 Handling OptimisticConcurrencyExceptions 670 Using ObjectContext.Refresh 671 Using Refresh with ClientWins 671 Using Refresh with StoreWins 673 Table of Contents | xvii

Refreshing Collections of Entities 673 Refreshing Related Entities in a Graph 675 Rewinding and Starting Again, and Maybe Again After That 676 Reporting an Exception 678 Handling Concurrency Exceptions at a Lower Level 678 Handling Exceptions in a Granular Way Without User Intervention 678 Handling Multiple Conflicts 680 Handling Exceptions When Transactions Are Your Own 682 Summary 683 24. Building Persistent Ignorant, Testable Applications . . . . . . . . . . . . . . . . . . . . . . . . 685 Testing the BreakAway Application Components 686 Getting Started with Testing 687 Writing an Integration Test That Hits the Database 687 Inspecting a Failed Test 689 Writing a Unit Test That Focuses on Custom Logic 689 Creating Persistent Ignorant Entities 693 Planning the Project Structure 695 Starting with the Model and Its POCO Entities 697 Building an Interface to Represent a Context 698 Modifying the BAEntities ObjectContext Class to Implement the New Interface 699 Creating the IEntityRepository Interface 702 Creating the Repository Classes 703 Testing GetReservationsForCustomer Against the Database 706 Creating a Fake Context 708 Creating a FakeObjectSet Class 710 Completing the Fake Context 712 Building Tests That Do Not Hit the Database 714 Adding Validation Logic to the POCO Class 714 Adding Validation Logic to the Context 716 Providing ManagedEntities in the FakeContext 716 Hiding the Context from the Lower Layers with Unit of Work 718 Testing UnitOfWork Against the Database 720 Enabling Eager Loading in IContext 721 Leveraging Precompiled Queries in Your Repositories 722 Using the New Infrastructure in Your Application 723 Adding a UI Layer That Calls the Repository 723 Application Architecture Benefits from Designing Testable Code 724 Considering Mocking Frameworks? 725 Summary 725 xviii | Table of Contents