Programming Entity Framework

Name: Programming Entity Framework | Building Data Centric Apps with the ADO.NET Entity Framework
Brand: O'Reilly
Price: 52.79 EUR
Availability: OnlineOnly

Building Data Centric Apps with the ADO.NET Entity Framework

Julia Lerman(Autor*in)

O'Reilly (Verlag)

1. Auflage

Erschienen am 9. August 2010

920 Seiten

E-Book

PDF mit Adobe-DRM

Systemvoraussetzungen

978-1-4493-9947-4 (ISBN)

52,79 €inkl. 7% MwSt.

Systemvoraussetzungen

für PDF mit Adobe-DRM

E-Book Einzellizenz

Als Download verfügbar

Beschreibung

Weitere Details

Weitere Ausgaben

Inhalt

Intro
Table of Contents
Foreword
Preface
Who This Book Is For
How This Book Is Organized
What You Need to Use This Book
This Book's Website
Conventions Used in This Book
Using Code Examples
Safari® Books Online
Comments and Questions
Acknowledgments
Author Note for Third Printing, August 2011
Entity Framework 4.1 (Code First and DbContext) Has Released
Entity Framework June 2011 CTP
Chapter 1. Introducing the ADO.NET Entity Framework
The Entity Relationship Model: Programming Against a Model, Not the Database
The Entity Data Model: A Client-Side Data Model
Entities: Blueprints for Business Classes
The Backend Database: Your Choice
Database Providers
Access and ODBC
Entity Framework Features: APIs and Tools
Metadata
Entity Data Model Design Tools
Database-first design
Model-first design
Code generation
Object Services
POCO Support
Change Tracking
Relationship Management and Foreign Keys
Data Binding
n-Tier Development
EntityClient
The Entity Framework and WCF Services
What About ADO.NET DataSets and LINQ to SQL?
DataSets
LINQ to SQL
Entity Framework Pain Points Are Fading Away
Programming the Entity Framework
Chapter 2. Exploring the Entity Data Model
Why Use an Entity Data Model?
The EDM Within the Entity Framework
Walkthrough: Building Your First EDM
Inspecting the EDM in the Designer Window
Entity Container Properties
Entity Properties
Entity Property Properties
The Model's Supporting Metadata
Viewing the Model in the Model Browser
Viewing the Model's Raw XML
CSDL: The Conceptual Schema
EntityContainer
EntitySet
EntityType
The Key element
The Property elements
The navigation properties
Associations
Navigation Property
Navigation Properties That Return Collections
SSDL: The Store Schema
MSL: The Mappings
Database Views in the EDM
Summary
Chapter 3. Querying Entity Data Models
Query the Model, Not the Database
Your First EDM Query
Where Did the Context and Classes Come From?
The ObjectContext class, SampleEntities
The entity classes
Querying with LINQ to Entities
Writing Your First LINQ to Entities Query
Querying with Object Services and Entity SQL
Why Another Way to Query?
Entity SQL
Entity SQL canonical functions
The Parameterized ObjectQuery
Querying with Methods
Querying with LINQ Methods
Chaining methods
Querying with Query Builder Methods and Entity SQL
Specifying the control variable
The Shortest Query
ObjectQuery, ObjectSet, and LINQ to Entities
Querying with EntityClient to Return Streamed Data
EntityConnection and the Connection String
EntityCommand
ExecuteReader
Forward-Only Access to the Fields
Translating Entity Queries to Database Queries
Pay Attention to the .NET Method's Impact on Generated SQL
Avoiding Inadvertent Query Execution
Summary
Chapter 4. Exploring LINQ to Entities in Greater Depth
Getting Ready with Some New Lingo
Projections in Queries
Projections in LINQ to Entities
VB and C# Syntax Differences
LINQ Projections and Special Language Features
Anonymous types
Implicitly typed local variables
Implicit and explicit anonymous type creation
Projections with LINQ Query Methods
Using Navigations in Queries
Navigating to an EntityReference
Filtering and Sorting with an EntityReference
Navigating to Entity Collections
Projecting Properties from EntityCollection Entities
Shaped results
Flattened results
Filtering and Sorting with EntityCollections
Aggregates with EntityCollections
Aggregates in LINQ to Entities
Aggregates in LINQ Methods
Joins and Nested Queries
Joins
Nested Queries
Using a nested LINQ query as a projection
Using a nested LINQ query as the collection to be queried
Grouping
Naming Properties When Grouping
Chaining Aggregates
Filtering on Group Conditions
Shaping Data Returned by Queries
Limiting Which Related Data Is Returned
Loading Related Data
Controlling Lazy Loading
Disabling and enabling lazy loading programmatically
Changing the default behavior for lazy loading
Explicitly Loading Entity Collections and Entity References
Loading the EntityReference
Performance considerations with deferred loading
Using the Include Method to Eager-Load
How is the data shaped with Include?
Accessing properties from an Include in the query
Pros and Cons of Load and Include
Retrieving a Single Entity
Retrieving a Single Entity with GetObjectByKey
Finding More Query Samples
Summary
Chapter 5. Exploring Entity SQL in Greater Depth
Literals in Entity SQL
Expressing a DateTime Literal
Expressing a Decimal Literal
Using Additional Literal Types
Projecting in Entity SQL
DbDataRecords and Nonscalar Properties
Projecting with Query Builder Methods
Using Navigation in Entity SQL Queries
Navigating to an EntityReference
Filtering and Sorting with an EntityReference
Filtering and Sorting with EntityCollections
Aggregating with EntityCollections
Using Entity SQL SET Operators
Aggregating with Query Builder Methods
Using Joins
Nesting Queries
Grouping in Entity SQL
Returning Entities from an Entity SQL GROUP BY Query
Filtering Based on Group Properties
Shaping Data with Entity SQL
Using Include with an ObjectQuery and Entity SQL
Understanding Entity SQL's Wrapped and Unwrapped Results
Entity SQL Rules for Wrapped and Unwrapped Results
Digging a Little Deeper into EntityClient's Results
Summary
Chapter 6. Modifying Entities and Saving Changes
Keeping Track of Entities
Managing an Entity's State
Saving Changes Back to the Database
Inserting New Objects
Inserting New Parents and Children
Deleting Entities
Summary
Chapter 7. Using Stored Procedures with the EDM
Updating the Model from a Database
Working with Functions
Function Attributes
Mapping Functions to Entities
Mapping Insert, Update, and Delete Functions to an Entity
Concurrency checking with Use Original Value and Rows Affected Parameter options
Inspecting Mappings in XML
Using Mapped Functions
Using the EDM Designer Model Browser to Import Additional Functions into Your Model
Mapping the First of the Read Stored Procedures: ContactsbyState
Using Imported Functions
Avoiding Inadvertent Client-Side Processing
Mapping a Function to a Scalar Type
Mapping a Function to a Complex Type
Summary
Chapter 8. Implementing a More Real-World Model
Introducing the BreakAway Geek Adventures Business Model and Legacy Database
Creating a Separate Project for an EDM
Inspecting and Cleaning Up a New EDM
Modifying the Names of Entities and Properties
Resolving Collisions Between Property Names and Entity Names
Cleaning Up Navigation Property Names
Setting Default Values
Mapping Stored Procedures
Using the Use Original Value Checkbox in Update Mappings
Working with Many-to-Many Relationships
Inspecting the Completed BreakAway Model
Building the BreakAway Model Assembly
Looking at the Compiled Assembly
Splitting Out the Model's Metadata Files
Moving the schema files
Summary
Chapter 9. Data Binding with Windows Forms and WPF Applications
Data Binding with Windows Forms Applications
Creating a Windows Forms Application
Using Windows Forms Data Sources
Creating an Object Data Source for a Customer Entity
Getting an Entity's Details onto a Form
Adding Code to Query an EDM When a Form Loads
Binding Without a BindingSource
Adding an EntityCollection to the Form
Displaying the Properties of Related Data in the Grid
Allowing Users to Edit Data
Editing Navigation Properties (and Shrinking the Query)
Replacing the Navigation Property TextBoxes with ComboBoxes
Adding New Customers
Deleting Reservations
Data Binding with WPF Applications
Creating the WPF Form
Creating the WPF Project
Adding the Necessary Data Source Objects
Inspecting the XAML and Code Generated by the Automated Data Binding
XAML data-binding elements
Adding Code to Query the EDM When the Window Loads
Customizing the Display of the Controls
Selecting an Entity and Viewing Its Details
Adding Another EntityCollection to the Mix
Working with a many-to-many relationship
Modifying the code to eager-load the related activities
Adding the Activities ListBox and binding it to the Trips ListBox
Testing the application again
Editing Entities and Their Related Data
Using SortDescriptions to Keep Sorting in Sync with Data Modifications
Adding Items to the Child EntityCollection
Testing the new feature for adding activities
The Last Task: Adding New Trips to the Catalog
A few WPF tricks for a more interactive ListBox
Coding the Add New Trip feature
Testing the final version of the WPF demo
Summary
Chapter 10. Working with Object Services
Where Does Object Services Fit into the Framework?
Processing Queries
Parsing Queries: From Query to Command Tree to SQL
Understanding Query Builder Methods
Query builder methods and EntitySets
From query builder methods to Entity SQL expressions
Combining LINQ methods and query builder methods
Analyzing a Query with ObjectQuery Methods and Properties
ObjectQuery.ToTraceString
ObjectQuery.CommandText
ObjectQuery.Parameters
ObjectQuery.Context
Executing Queries with ToList, ToArray, First or Single
Executing Queries with the Execute Method
Overriding a Default Connection with ObjectContext.Connection
Handling Command Execution with EntityClient
Materializing Objects
Managing Object State
Using EntityKey to Manage Objects
Merging Results into the Cache with MergeOptions
Inspecting ObjectStateEntry
Maintaining EntityState
Managing Relationships
Attaching and Detaching Objects from the ObjectContext
ObjectContext.AddObject and ObjectSet.AddObject
ObjectContext.Attach and ObjectSet.Attach
ObjectContext.AttachTo
Taking Control of ObjectState
ObjectContext Methods
ObjectStateManager Methods
ObjectStateEntry State Methods for Managing State
ObjectSet State Methods
Sending Changes Back to the Database
ObjectContext.SaveChanges
SaveChanges returns an integer
SaveChanges refreshes the state of tracked entities
Affecting SaveChanges Default Behavior
Overriding SaveChanges Completely
Data Validation with the SavingChanges Event
Concurrency Management
Optimistic concurrency
ConcurrencyMode
OptimisticConcurrencyException
Transaction Support
Implementing Serialization, Data Binding, and More
Object Services Supports XML and Binary Serialization
ObjectContext, ObjectStateManager, and ObjectStateEntry are not serializable
Automatic serialization
XML and DataContract serialization
Binary serialization
Serialization and object state
Explicit serialization
Object Services Supports Data Binding
Summary
Chapter 11. Customizing Entities
Partial Classes
Using Partial Methods
The OnContextCreated Method
The On[Property]Changed and On[Property]Changing Methods
Using PropertyChanged to Calculate Database-Computed Columns Locally
Subscribing to Event Handlers
The ObjectContext.ObjectMaterialized Event
The ObjectContext.SavingChanges Event
GetObjectStateEntries: A critical method when validating entities from the context
Implementing SavingChanges
Setting default foreign keys in SavingChanges when no foreign key scalar property exists
The EntityObject.PropertyChanging and EntityObject.PropertyChanged Events
The order of the Changing/Changed events
Event parameters
Subscribing to the class-level PropertyChanging and PropertyChanged events
The AssociationChanged Event
Event arguments
Creating Your Own Partial Methods and Properties
Overriding the Object Constructor
Overriding ObjectContext.SaveChanges
Creating Custom Properties
Using custom properties to perform calculations on child collections
Overloading Entity Creation Methods
Using Partial Classes for More Than Just Overriding Methods and Events
Overriding Default Code Generation
Switching to a Template
Reading the Template
Modifying the Template
Inserting the Managed partial method in each entity class
Other ways to create common methods or properties for all entities
Customizing a Template for Major Class Modifications
Switching Between the Default Template and a Custom Template
Summary
Chapter 12. Data Binding with RAD ASP.NET Applications
Using the EntityDataSource Control to Access Flat Data
Creating the Hello Entities Project
Creating a GridView and an EntityDataSource Concurrently
Configuring an EntityDataSource with Its Wizard
Formatting the GridView
Testing the Web Application
Understanding How the EntityDataSource Retrieves and Updates Your Data
EntityDataSource and Its Query
EntityDataSource and Its ObjectContext
Using your own context
EntityDataSource Context Events
EntityDataSource and ViewState
Accessing Foreign Keys When There Is No Foreign Key Property
Working with Related EntityReference Data
Using EntityDataSource.Include to Get Related Data
Displaying Data That Comes from EntityReference Navigation Properties
Using a New EntityDataSource Control to Enable Editing of EntityReference Navigation Properties
Editing EntityReferences That Cannot Be Satisfied with a Drop-Down List
Binding an EntityDataSource to Another Control with WhereParameters
Editing Related Data Concurrently with Multiple EntityDataSource Controls
Working with Hierarchical Data in a Master/Detail Form
Setting Up the Web Application
Specifying Your Own Entity SQL Query Expression for an EntityDataSource
Binding a DropDownList to an EntityDataSource Control
Creating a Parent EntityDataSource That Is Controlled by the DropDownList and Provides Data to a DetailsView
Using the EntityDataSource.Where Property to Filter Query Results
Displaying Read-Only Child Data Through the Parent EntityDataSource
Using a New EntityDataSource to Add a Third Level of Hierarchical Data to the Master/Detail Form
Using the EntityDataSource.Inserting Event to Help with Newly Added Entities
Testing the Application
Exploring EntityDataSource Events
Building Dynamic Data Websites
Summary
Chapter 13. Creating and Using POCO Entities
Creating POCO Classes
Creating an ObjectContext Class to Manage the POCOs
Verifying the POCOs with a query
Change Tracking with POCOs
Understanding the Importance of DetectChanges
Loading Related Data with POCOs
Loading from the Context
Lazy Loading from a Dynamic Proxy
Exploring and Correcting POCOs' Impact on Two-Way Relationships
Using the DetectChanges Method to Fix Relationships
Enabling Classes to Fix Their Own Relationships
Using Proxies to Enable Change Notification, Lazy Loading, and Relationship Fix-Up
Change Notification by Proxy
Lazy Loading by Proxy
Exploring the Proxy Classes
Synchronizing Relationships by Proxy
Using T4 to Generate POCO Classes
Modifying the POCO Template
Creating a Model That Works with Preexisting Classes
Code First: Using Entity Framework with No Model at All
Summary
Chapter 14. Customizing Entity Data Models Using the EDM Designer
Mapping Table per Type Inheritance for Tables That Describe Derived Types
Mapping TPT Inheritance
Handling duplicate names and concurrency properties in an inheritance hierarchy
Fixing a potential constraint problem
Querying Inherited Types
POCO Classes and Inherited Objects
Inserting TPT Inherited Types
SaveChanges and newly added derived types
Specifying or Excluding Derived Types in Queries
Creating New Derived Entities When the Base Entity Already Exists
TPT with Abstract Types
Mapping Unique Foreign Keys
Mapping an Entity to More Than One Table
Merging Multiple Entities into One
Querying, Editing, and Saving a Split Entity
Mapping Stored Procedures to Split Tables and More
Splitting a Single Table into Multiple Entities
Filtering Entities with Conditional Mapping
Creating a Conditional Mapping for the Activity Entity
Querying, Inserting, and Saving with Conditional Mappings
Filtering on Other Types of Conditions
Removing the Conditional Mapping from Activity and Re-creating the Category Property
Implementing Table per Hierarchy Inheritance for Tables That Contain Multiple Types
Creating the Resort Derived Type
Setting a Default (Computed) Value on the Table Schema
Testing the TPH Mapping
Choosing to Turn a Base Class into an Abstract Class
Creating Complex Types to Encapsulate Sets of Properties
Defining a Complex Type
Reusing Complex Types
Querying, Creating, and Saving Entities That Contain Complex Types
Removing the Complex Types from the Model
Using Additional Customization Options
Using GUIDs for EntityKeys
Mapping Stored Procedures
Mapping Multiple Entity Sets per Type
Mapping Self-Referencing Associations
Summary
Chapter 15. Defining EDM Mappings That Are Not Supported by the Designer
Using Model-Defined Functions
Using Model-Defined Functions to Return More Complex Results
Consuming the Complex Results
Reading the Results from a Complex Function
Mapping Table per Concrete (TPC) Type Inheritance for Tables with Overlapping Fields
Using QueryView to Create Read-Only Entities and Other Specialized Mappings
Finding a Common Use Case for QueryView
Creating a CustomerNameAndID Entity
Creating a QueryView Mapping for CustomerNameAndID
Testing the QueryView
Deconstructing the QueryView
Summary
Chapter 16. Gaining Additional Stored Procedure and View Support in the Raw XML
Reviewing Procedures, Views, and UDFs in the EDM
Working with Stored Procedures That Return Data
Using Functions That Match an Entity Whose Property Names Have Been Changed
Query Stored Procedures and Inherited Types
Composing Queries Against Functions
Replacing Stored Procedures with Views for Composability
Queries That Return Multiple Result Sets
Executing Queries on Demand with ExecuteStoreQuery
Querying to a Class That Is Not an Entity
Querying into an Entity
Adding Native Queries to the Model
Defining a Complex Type in the Model Browser
Adding Native Views to the Model
DefiningQuery Is Already in Your Model
Using DefiningQuery to Create Your Own Views
Implementing a DefiningQuery
Creating Associations with the New Entity
Testing the DefiningQuery in an association
Using DefiningQuery to Solve More Complex Problems
Using Commands That Affect the Database
Executing SQL on the Fly with ExecuteStoreCommand
Using Functions to Manipulate Data in the Database
Changing from one derived type to another
Mapping Insert/Update/Delete to Types Within an Inheritance Structure
What If Stored Procedures Affect Multiple Entities in an Inheritance Structure?
Implementing and Querying with User-Defined Functions (UDFs)
Summary
Chapter 17. Using EntityObjects in WCF Services
Planning for an Entity Framework-Agnostic Client
Assessing the Pros and Cons of an Entity Framework-Agnostic Consumer
Building a Simple WCF Service with EntityObjects
Creating the Service
Defining the Service Operations
Defining Extra Service Classes
Exposing Custom Properties
Implementing the Service Interface
Adding Graphs to ObjectContext
Deleting Objects
Updating the Object Graph
Client Rules for Identifying Changes in an EntityCollection
The UpdateCustomer Method
Handling New and Existing Reservations
Deleting Reservations
Building a Simple Console App to Consume an EntityObject Service
Enabling the Client Application to Receive Large Messages from the Service
Creating Methods to Test the Service Operations
Analyzing the GetAndUpdateCustomer Method
Testing Out the Other Service Operations
Creating WCF Data Services with Entities
Putting WCF Data Services in Perspective
Creating a WCF Data Service
Filtering at the Service Level Using QueryInterceptor
Anticipating Exceptions
Exposing Related Data Through the Service
Preparing for WCF Data Services' Limitations
Modifying Data Through a Service
Learning More About Creating and Consuming WCF Data Services
Understanding How WCF RIA Services Relates to the Entity Framework
Summary
Chapter 18. Using POCOs and Self-Tracking Entities in WCF Services
Creating WCF-Friendly POCO Classes
Updating the POCO Classes Based on the Current BreakAway Model
Isolating the POCO Entities in Their Own Project
Directing a template back to a model
Specifying the namespace of entity classes
Providing the ObjectContext with a reference to the entities
Adding Custom Logic to the POCO Entities with a Base Class
Modifying the template to apply the inheritance
Following WCF Collection Rules
Preventing Properties from Being Marked As Virtual
Building a WCF Service That Uses POCO Classes
Implementing the Interface
Using the Service
Using the Self-Tracking Entities Template for WCF Services
Creating and Exploring the Self-Tracking Entities
Putting the Change-Tracking Logic Where It's Needed
Creating a WCF Service That Uses Self-Tracking Entities
Watching Self-Tracking Entities Under the Covers
Debugging the client application
Debugging the SaveCustomer service method
Inspecting the Generated Context Class and Extensions
Using POCO Entities with WCF Data and RIA Services
Preparing for WCF Data Services
Dealing with entities that live in a separate assembly
Avoiding problems caused by dynamic proxies
Using POCO Entities in WCF RIA Services
Sorting Out the Many Options for Creating Services
Summary
Chapter 19. Working with Relationships and Associations
Deconstructing Relationships in the Entity Data Model
Understanding How the Entity Data Model Wizard Creates the Association
Understanding Additional Relationship Items
Handling Nonessential Navigation Properties
Understanding the Major Differences Between Foreign Key Associations and Independent Associations
Defining Associations in Metadata
Detecting Associations at Runtime
Deconstructing Relationships Between Instantiated Entities
Understanding Relationship Manager and the IRelatedEnd Interface
Late-Binding Relationships
Taking a Peek Under the Covers: How Entity Framework Manages Relationships
Understanding Navigation Properties
EntityReference properties
EntityReference.Value
What if there is no EntityReference
EntityCollection properties
Understanding Referential Integrity and Constraints
Constraints that are not checked until they hit the database
Checking for missing entity references with and without foreign keys
Implementing Deletes and Cascading Deletes
Cascading deletes in the database
Recommendation: Cascade in both the model and the database, or in neither
Defining Relationships Between Entities
The CLR Way: Setting a Navigation Property to an Entity
Setting a Foreign Key Property
Setting an EntityReference Using an EntityKey
Loading, Adding, and Attaching Navigation Properties
Lazy Loading
EntityReference.Load and EntityCollection.Load
Loading from Detached Entities: Lazy and Explicit
Using EntityCollection.Add
Adding new entities that are detached
Adding existing entities that are detached
Adding new or existing entities that are attached
Adding entities to the EntityCollection of a detached object
Using Attach and Remove
Moving an Entity to a New Graph
Learning a Few Last Tricks to Make You a Relationship Pro
Using CreateSourceQuery to Enhance Deferred Loading
Getting a Foreign Key Value in an Independent Association
Summary
Chapter 20. Real World Apps: Connections, Transactions, Performance, and More
Entity Framework and Connections
Overriding EntityConnection Defaults
Working with Connection Strings Programmatically
Constructing connection strings on the fly with the EntityConnectionStringBuilder class
Choosing and loading a model programmatically
Opening and Closing Connections
Understanding the default connection usage
Default behavior 1: Many calls on a single connection
Default behavior 2: Multiple connections
Forcing an explicit connection
Getting the Store Connection from EntityConnection
Disposing Connections
Pooling Connections
Fine-Tuning Transactions
Why Use Your Own Transaction?
Understanding Implicit Entity Framework Transactions
Understanding SaveOptions and AcceptAllChanges in a transaction
Specifying Your Own Read/Write Transactions
Specifying Your Own Read-Only Transactions
Rolling Back Transactions
Understanding Security
Guarding Against SQL Injection
Taking precautions with dynamic queries
Entity SQL injection
Guarding Against Connection Piggybacks
Fine-Tuning Performance
Measuring Query Performance
Measuring Startup Performance
Reducing the Cost of Query Compilation
Caching for Entity SQL Queries
Comparing EntityClient to Object Services
Precompiling Views for Performance
Pregenerating views for performance
Pregenerating views into an existing project
Precompiling LINQ to Entities Queries for Performance
Fine-Tuning Updates for Performance?
Lacking Support for Full Text Searches
Exploiting Multithreaded Applications
Forcing an ObjectContext to Use Its Own Thread
Implementing Concurrent Thread Processing
Exploiting .NET 4 Parallel Computing
Summary
Chapter 21. Manipulating Entities with ObjectStateManager and MetadataWorkspace
Manipulating Entities and Their State with ObjectStateManager
Refreshing Your High-Level Understanding of ObjectStateEntry
Getting an ObjectStateManager and Its Entries
Getting groups of entries with GetObjectStateEntries
Building Extension Methods to Overload GetObjectStateEntries
Building a Method to Return Managed Entities
Using GetObjectStateEntry and TryGetObjectStateEntry
Mining Entity Details from ObjectStateEntry
Reading and writing values
Accessing object metadata with CurrentValueRecord.DataRecordInfo
Getting started with the FieldMetadata hierarchy
Leveraging the ObjectStateManager During Saves
Using ObjectStateManager to Build an EntityState Visualizer
Retrieving an ObjectStateEntry Using an EntityKey
Reading the OriginalValues and CurrentValues of an ObjectStateEntry
Determining Whether a Property Has Been Modified
Displaying the State and Entity Type
Getting ComplexType Properties Out of ObjectStateEntry
Modifying Values with ObjectStateManager
Working with Relationships in ObjectStateManager
Building graphs directly with the RelationshipManager
Using the MetadataWorkspace
Loading the MetadataWorkspace
Creating a MetadataWorkspace without an EntityConnection
Clearing the MetadataWorkspace from Memory
Understanding the MetadataWorkspace ItemCollections
Determining whether an ItemCollection has been loaded
Retrieving Metadata from the MetadataWorkspace
Retrieving sets of items from the metadata with GetItems and TryGetItem
Retrieving specific items from the metadata with GetItem and TryGetItem
Retrieving functions from the metadata with GetFunctions and TryGetFunctions
Querying the Metadata with LINQ to Objects
Building Dynamic Queries and Reading Results
Building Entity SQL Queries Dynamically Using Metadata
Creating Queries on the Fly with CreateObjectSet and Query Builder Methods
Leveraging CreateObjectSet to return Entity SQL, not just a query
Reading the Results of a Dynamically Created Query
Creating and Manipulating Entities Dynamically
Creating EntityObjects Without Entity Classes
Creating a new entity with CreateInstance
Using System.Type to inspect the EntityType
Getting a reference to an assembly
Creating an entity from the assembly
Creating Entities and Graphs Dynamically
Custom extension methods used by AddChildToParentObject
Calling the AddChildToParentObject method
Summary
Chapter 22. Handling Exceptions
Preparing for Exceptions
Handling EntityConnectionString Exceptions
Connection String Can't Be Found or Is Improperly Configured: System.ArgumentException
Metadata Files Cannot Be Found: System.Data.MetadataException
Handling Connection String Exceptions
Handling Query Compilation Exceptions
Invalid LINQ to Entities Query Expressions: System.NotSupportedException
Invalid Entity SQL Query Expressions: EntitySqlException
Handling an EntitySqlException
EntityCommandCompilationException Thrown by the Store Provider
Creating a Common Wrapper to Handle Query Execution Exceptions
Handling Exceptions Thrown During SaveChanges Command Execution
UpdateException: Thrown When Independent Association Mapping Constraints Are Broken
UpdateException: Thrown by Broken Constraints in the Database
Relying on Entity Framework to Automatically Roll Back When an UpdateException Occurs
Gleaning Details from UpdateException
Planning for Other Exceptions Related to the Entity Framework
Handling Concurrency Exceptions
Summary
Chapter 23. Planning for Concurrency Problems
Understanding Database Concurrency Conflicts
Understanding Optimistic Concurrency Options in the Entity Framework
Ignoring Concurrency Conflicts
Forcing the User's Data to the Server (ClientWins)
Refreshing the User's Data with Server Data (StoreWins)
Determining the Scope of Changes
Using rowversion (a.k.a. timestamp) for Concurrency Checks
Implementing Optimistic Concurrency with the Entity Framework
Flagging a Property for Concurrency Checking
How the Entity Framework Uses the ConcurrencyMode Property
Concurrency Checking Without a rowversion Field
Concurrency Checking on a Checksum in the Data Store
Concurrency Checks for EntityReference Navigation Properties
Concurrency Checks and Inherited Types
Concurrency Checks and Stored Procedures
Defining a stored procedure to perform concurrency checking
Handling OptimisticConcurrencyExceptions
Using ObjectContext.Refresh
Using Refresh with ClientWins
Using Refresh with StoreWins
Refreshing Collections of Entities
Refreshing Related Entities in a Graph
Rewinding and Starting Again, and Maybe Again After That
Reporting an Exception
Handling Concurrency Exceptions at a Lower Level
Handling Exceptions in a Granular Way Without User Intervention
Handling Multiple Conflicts
Separating the good from the bad and the ugly
Handling Exceptions When Transactions Are Your Own
Summary
Chapter 24. Building Persistent Ignorant, Testable Applications
Testing the BreakAway Application Components
Getting Started with Testing
Writing an Integration Test That Hits the Database
Inspecting a Failed Test
Writing a Unit Test That Focuses on Custom Logic
Creating Persistent Ignorant Entities
Planning the Project Structure
Starting with the Model and Its POCO Entities
Building an Interface to Represent a Context
Modifying the BAEntities ObjectContext Class to Implement the New Interface
Disconnecting the context class from the T4 template
Implementing the IContext interface
Implementing the remaining interface members
Creating the IEntityRepository Interface
Creating the Repository Classes
Testing GetReservationsForCustomer Against the Database
Creating a Fake Context
Creating a FakeObjectSet Class
Completing the Fake Context
Modify the tests to use the fake repository
Rerun the tests
Building Tests That Do Not Hit the Database
Adding Validation Logic to the POCO Class
Adding Validation Logic to the Context
Providing ManagedEntities in the FakeContext
Hiding the Context from the Lower Layers with Unit of Work
Testing UnitOfWork Against the Database
Enabling Eager Loading in IContext
Eager loading with a fake context
Leveraging Precompiled Queries in Your Repositories
Using the New Infrastructure in Your Application
Adding a UI Layer That Calls the Repository
Application Architecture Benefits from Designing Testable Code
Considering Mocking Frameworks?
Summary
Chapter 25. Domain-Centric Modeling
Creating a Model and Database Using Model First
Creating a Conceptual Model in the Designer
Creating the Entities
Setting attributes of the entity's properties
Creating Association and Inheritance Hierarchies
Creating a one-to-many relationship
Creating a many-to-many relationship
Creating an inheritance hierarchy
Generating Database Schema from the Model
Exploring the generated DDL
Looking at the result of the inheritance
Noting the result of the many-to-many relationship
Exploring the constraints
Completing the generation of the DDL
Creating the Database and Its Schema
Overriding the DDL Generation
Using the Feature CTP Code-First Add-On
Understanding Code-First Design
Installing the Feature CTP
Exploring Some Configuration Examples
Testing the Code-First Application and Database
Using SQL Server Modeling's "M" Language
Using M Metadata in Entity Framework Applications
Summary
Chapter 26. Using Entities in Layered Client-Side Applications
Isolating the ObjectContext
Freeing Entities from Change Tracking
Enabling Change Tracking Across Tiers
Moving Other ObjectContext-Dependent Logic to the DataBridge
Ensuring That Lazy Loading Doesn't Negatively Impact the Layered Application
Noting Additional Benefits of the Layered Application
Separating Entity-Specific Logic from ObjectContext Logic
Working with POCO Entities
Providing EntityState
Providing Logic in Place of Other EntityObject Behavior
Summary
Chapter 27. Building Layered Web Applications
Understanding How ObjectContext Fits into the Web Page Life Cycle
Return Results, Not Queries, from the DataBridge Class
Using Entities in Read-Only Web Pages
Exploring Options for Updating Entities in an ASP.NET Web Forms Application
Single or batch updates?
Persist entities or use independent values?
Comparing ASP.NET's State Solutions to the Needs of the Entity Framework
View state
Application cache and session state
Building an N-Tier Web Forms Application
Designing the Application
Using the Existing Repositories
Building an Entity Manager to Act As a DataBridge
Retrieving Data for Display and for Future Updates
Making the Related Data Accessible to the Client
Getting Data from the Manager to the Client
Adding Lists for User Selection Controls
Allowing a User to Modify Related Data
Building an ASP.NET MVC Application
Replacing the Context with Repositories
Editing Entities and Graphs on an MVC Application
Creating a Repository for Payments
Interacting with the ReservationController
Summary
Appendix A. Entity Framework Assemblies and Namespaces
Unpacking the Entity Framework Files
Exploring the Namespaces
Existing Namespaces That Include Entity Framework Classes and Functionality
Entity Framework-Specific Namespaces
Appendix B. Data-Binding with Complex Types
Using Complex Types with ASP.NET EntityDataSource
Identifying Unexpected Behavior When Binding Complex Types
Successfully Using Binding to Complex Types in ASP.NET Without Data Source Controls
List controls
Data-bound controls
Templated controls
Windows Forms DataSource and Complex Types
Appendix C. Additional Details About Entity Data Model Metadata
Seeing EDMX Schema Validation in Action
Additional Conceptual Model Details
Schema
XML Representation of an Association
AssociationSet
Additional SSDL Metadata Details
SSDL Association and AssociationSet Elements
ReferentialConstraint
Additional MSL Metadata Details
The MSL Elements
Mapping
EntityContainerMapping
EntitySetMapping
EntityTypeMapping
MappingFragment
AssociationSetMapping
ScalarProperty
Index

Systemvoraussetzungen

Als PDF speichern Als Link merken