Programming Entity Framework

Spis treści ebooka

• Programming Entity Framework
  • SPECIAL OFFER: Upgrade this ebook with OReilly
  • A Note Regarding Supplemental Files
  • Foreword
  • Preface
    • Who This Book Is For
    • How This Book Is Organized
    • What You Need to Use This Book
    • This Books Website
    • Conventions Used in This Book
    • Using Code Examples
    • Safari Books Online
    • Comments and Questions
    • Acknowledgments
  • 1. Introducing the ADO.NET Entity Framework
    • Programming Against a Model, Not Against the Database
    • The Entity Data Model: A Client-Side Data Model
    • The Entity in Entity Framework
    • Choosing Your Backend
      • Available Providers
      • Access and ODBC
    • Entity Framework Features
      • The Entity Data Model
      • Entity Data Model Design Tools
        • The Entity Data Model Wizard
      • Managing Objects with Object Services
      • Change Tracking
      • Relationship Management
      • Data Binding
      • EntityClient
    • The Entity Framework in Web Services
    • What About ADO.NET DataSets and LINQ to SQL?
      • DataSets
      • LINQ to SQL
    • Entity Framework Pain Points
      • The Entity Framework Designer
        • Stored procedures
        • Unsupported EDM types
        • Generating a database from the model
        • A host of little things
      • Challenges with Change Tracking Distributed Applications
      • Domain-Driven Development
      • Unit Testing
    • Programming the Entity Framework
  • 2. Exploring the Entity Data Model
    • Why Use an Entity Data Model?
    • The EDM Within the Entity Framework
    • Your First EDM
    • The EDM in the Designer Window
    • Entity Properties
      • Editing the Entity Set and Navigation Property Names
    • The Naked Model: Inspecting the Models XML
    • A Less Daunting Model View
    • The Three Parts of the Model
    • CSDL: The Conceptual Schema
      • Schema
      • EntityContainer
      • EntitySet
      • EntityType
        • The Key element
        • The Property elements
        • The navigation properties
      • Associations
      • AssociationSet
      • NavigationProperty
      • Navigation Properties That Return Collections
      • Where Are the Foreign Keys?
    • SSDL: The Store Schema
      • Association and AssociationSet
        • ReferentialConstraint
    • MSL: The Mappings
      • The MSL Elements
        • Mapping
        • EntityContainerMapping
        • EntitySetMapping
          • EntityTypeMapping
          • MappingFragment
          • ScalarProperty
        • AssociationSetMapping
    • Database Views in the EDM
    • Code Generation from EDM to Classes
    • Summary
  • 3. Querying Entity Data Models
    • Query the Model, Not the Database
    • Your First EDM Query
      • A More Query-Like Query
      • Where Did the Context and Classes Come from?
        • The ObjectContext class, ProgrammingEFDB1Entities
        • The entity classes
    • LINQ to Entities Queries
      • ObjectQuery and LINQ to Entities
    • Entity SQL Queries That Return Objects
      • Why Another Way to Query?
      • Entity SQL
        • Entity SQL canonical functions
      • The Parameterized ObjectQuery
    • Method-Based Syntax Queries for LINQ and Entity SQL
      • LINQ Method-Based Queries
        • Chaining methods
      • ObjectQuerys Query Builder Methods
        • Specifying the control variable
    • The Shortest Query
    • EntityClient: The Lowest-Level Method for Returning Streamed Data Through EDM Queries
      • EntityConnection and the Connection String
      • EntityCommand
      • ExecuteReader
      • Forward-Only Access to the Fields
    • Translation to Database Queries
      • Pay Attention to the .NET Methods Impact on Generated SQL
    • Avoid Inadvertent Query Execution
    • Summary
  • 4. Exploring EDM Queries in Greater Depth
    • Same Model, Friendlier Name
    • Projections in Queries
      • Projections in LINQ to Entities
        • VB and C# syntax differences
      • LINQ Projections and New Language Features
        • Anonymous types
        • Implicitly typed local variables
        • Implicit and explicit anonymous type creation
      • Projections with LINQ Query Methods
    • Projections in Entity SQL
      • DbDataRecords and Nonscalar Properties
      • Projecting with Query Builder Methods
    • Querying Across Associations
      • Navigation 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 Entity SQL
      • Entity SQL SET Operators
      • Aggregates in LINQ Methods and Query Builder 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
        • Nested queries in Entity SQL
    • Grouping
      • Naming Properties When Grouping
      • Chaining Aggregates
      • Filtering on Group Conditions
      • Grouping in Entity SQL
        • Returning entities from an Entity SQL GROUP BY query
        • Filtering based on group properties
    • Shaped Data Returned by Queries
      • Shaped Data from Entity SQL
    • Deferred Loading and Eager Loading Queries
      • Deferred Loading Entity Collections with Load
        • Performance considerations with deferred loading
        • Loading the EntityReference
      • Using the Include Method to Eager-Load
        • How is the data shaped with Include?
        • Accessing properties from an Include in the query
      • Using Include with an ObjectQuery
      • Pros and Cons of Load and Include
    • Retrieving a Single Entity
    • Retrieving a Single Entity with GetObjectByKey
    • Entity SQLs Wrapped and Unwrapped Results
      • Entity SQL Rules for Wrapped and Unwrapped Results
      • Digging a Little Deeper into EntityClients Results
    • Summary
  • 5. Modifying Entities and Saving Changes
    • How ObjectContext Manages Entities
      • Remembering Original Values and Keeping Track of Changes
    • The SaveChanges Method
      • From Entity Framework Command to Native Command
    • Adding New Entities
      • Breaking Down the Native Insert Command
    • Inserting New Parents and Children
    • Deleting Entities
    • Summary
  • 6. Using Stored Procedures with the EDM
    • Adding the Stored Procedures into the Model
    • Working with Functions
      • Function Attributes
    • Implementing Functions
      • Rules for Mapping Functions to Entities
      • Wiring Up Insert, Update, and Delete Functions to an Entity
        • The Use Original Value option
      • Inspecting the Mappings in the XML
      • Using These Mapped Functions
        • What about the read stored procedure?
    • The EDM Designers Model Browser
    • Mapping the Last of the Four Functions: CustomersbyState
      • Using the CustomersbyState Function
      • Using Functions in a Query
    • More About the Update Model Wizard
      • A Frequently Asked Question About Deleting Entities from the Model
    • Summary
  • 7. Tuning Up a Model
    • The BreakAway Geek Adventures Business Model
    • Creating a Class Library Project to Host an EDM
    • Inspecting and Cleaning Up a New Model
      • Modifying the Names of Entities
      • Collisions Between Property Names and Entity Names
    • Cleaning Up Navigation Property Names
      • Entities with Multiple Relationships to a Single Entity
      • Determining Which Navigation Property Is Mapped to Which Foreign Key Field
    • Mapping a Few Stored Procedures
      • Mapping the Insert Function
      • Mapping the Update Function
        • Using the Use Original Value checkbox
        • The DeleteFunction mapping and an awkward stored procedure parameter
    • Working with Many-to-Many Relationships
    • Building the BreakAwayModel Project
      • Dont Overlook the Assembly and Model Names
        • BAGA assembly namespace
        • Entity container name
        • Model namespace
      • The Impact of Compiling a Project on an EDMX File
        • Splitting out the schema files
        • Moving the schema files
    • Summary
  • 8. Data Binding with Windows Forms and WPF Applications
    • Data Binding with Windows Forms Applications
      • Creating a Windows Forms Application
      • Using Windows Forms Data Sources to Help with Data Binding
      • Creating an Object Data Source for a Customer Entity
      • Getting the Entitys Details onto the Form
      • Adding Code to Perform the EDM Query
      • Testing the Sample
      • Entities, BindingSources, and a Very Important Rule
      • Adding the Related EntityCollection to the Form
        • Displaying the properties of reference properties in the grid
        • Testing the new version of the sample
      • Allowing the User to Edit the Data
        • Enabling the Save button
        • Changing the scope of the ObjectContext
        • Adding the save logic to the Save button
        • Test editing a customer
      • Editing the Navigation Properties (and Trimming Down the Query)
        • Reorganizing data retrieval
        • Replacing the navigation property TextBoxes with ComboBoxes
        • Testing the sample again
      • Adding New Customers
        • From toolbar to BindingSource to context
        • Adding the code to ensure that new customers are created properly
        • Testing the forms add functionality
    • Data Binding with WPF Applications
      • Creating the WPF Form
      • Creating the New Project
      • Adding Code to Query the Entities That Drive the Form
      • XAMLs Role in Data Binding
      • Binding with the ListBox
      • Testing the Example
      • Selecting an Entity and Seeing Its Details
        • Binding the TextBox controls to the ListBox
        • Binding the ComboBox controls to the ListBox and to the data
        • Testing the sample
      • Adding Another EntityCollection to the Mix: Activities
        • The *:* relationship between trips and activities
        • 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 Trip Entities and Their Related Data
        • What if the user changes the destination?
      • 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
        • Validating the new trip before saving
        • Testing the final version of the WPF demo
    • Summary
  • 9. Working with Object Services
    • Where Does Object Services Fit into the Framework?
    • Query Processing
      • From Query to Command Tree to SQL
        • From a LINQ to Entities query to a command tree
        • From Entity SQL and query builder methods to a command tree
        • How EntityClient turns command trees into store commands
      • A Better Understanding of Query Builder Methods
        • Query builder methods and EntitySets
        • From query builder methods to Entity SQL expressions
        • Combining LINQ methods and query builder methods
      • Breaking Apart the ObjectQuery
        • ToTraceString
        • ObjectQuery.CommandText
        • ObjectQuery.Parameters
        • ObjectQuery.Context
      • Query Execution with the ToList or ToArray Method
      • Query Execution with the Execute Method
      • ObjectContext.Connection
        • Why does the context need the EntityConnection?
      • Handling Command Execution with EntityClient
    • Object Materialization
    • The ObjectContext
      • ObjectContext Is a Cache for In-Memory Objects
        • Objects are not required to be in the ObjectContext cache
      • Entity Objects
      • EntityKey and EntityState
        • The EntityState enums
      • Merging Results into the Cache
    • State Management and ObjectStateEntry
      • Change Tracking
    • Relationship Management
      • Attaching and Detaching Objects from the ObjectContext
        • ObjectContext.Add
        • ObjectContext.Attach
        • ObjectContext.AttachTo
        • Creating an EntityKey on the fly
      • ObjectContext.ApplyPropertyChanges: A Handy Method for Updating Entities
    • Sending Changes Back to the Database
      • ObjectContext.SaveChanges
      • SaveChanges Returns an Integer
      • Data Validation with the SavingChanges Event
      • Concurrency Management
        • Optimistic concurrency
        • ConcurrencyMode
        • OptimisticConcurrencyException
      • Transaction Support
    • Additional Features
      • 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
      • Object Services Supports Custom Classes
        • IEntityWithChangeTracker
        • IEntityWithKey
        • IEntityWithRelationships
    • Summary
  • 10. Customizing Entities
    • Partial Classes
    • Customizable Methods
      • The OnContextCreated Method
        • Implementing OnContextCreated
      • The On[Property]Changed and On[Property]Changing Methods
        • Implementing the property-level PropertyChanged and PropertyChanging methods
      • Using PropertyChanged to Calculate Database-Computed Columns Locally
    • Customizable Event Handlers
      • The ObjectContext.SavingChanges Event
        • Implementing SavingChanges
      • The EntityObject.PropertyChanging and EntityObject.PropertyChanged Events
        • The order of the Changing/Changed events
        • Event parameters
        • Implementing the class-level PropertyChanging and PropertyChanged events
      • The AssociationChanged Event
        • Event arguments
    • Other Opportunities for Customization
      • Custom Properties
      • Custom Properties That Perform Calculations on Child Collections
      • Overloading Context and Entity Methods
      • Partial Classes Are for More Than Just Overriding Existing Methods and Events
      • Custom Code Generation
      • Creating Common Methods or Properties for All Entities
    • Summary
  • 11. Using the ASP.NET EntityDataSource Control
    • Getting to First Base with the EntityDataSource Control and Flat Data
      • Creating the Hello Entities Project
      • Creating a GridView and an EntityDataSource Concurrently
      • Configuring an EntityDataSource Through Its Wizard
      • Formatting the GridView
      • Testing the Web Application
    • Understanding How the EntityDataSource Is Able to Retrieve and Update Your Data
      • EntityDataSource and Its Query
        • Other EntityDataSource properties that impact the query
      • EntityDataSource and Its ObjectContext
        • Using your own context
      • EntityDataSource Context Events
      • EntityDataSource and ViewState
    • 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
        • Coding the EntityDataSources Selected event to populate a control with navigation property details
      • 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
    • Browsing Through the EntityDataSource Events
      • EntityDataSource Events and Page Events
    • Summary
  • 12. Customizing Entity Data Models
    • Designer Support for Mappings
    • Mapping Table per Type Inheritance for Tables That Describe Derived Types
      • Mapping TPT Inheritance
      • Fixing the Impact of the New Inheritance on the Customers Associations with Other Entities
      • Handling Properties with the Same Name
      • Querying Inherited Types
      • Creating a Project to Test the New Mappings
      • Testing the TPT Inheritance
      • 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
    • Using Entity Splitting to Map a Single Entity to More Than One Table
      • Merging Multiple Entities into One
      • Testing Entity Splitting
    • Using Conditional Mapping to Filter Entity Mappings
      • Creating a Conditional Mapping for the Activity Entity
        • The Is Null/Not Null conditions
      • Testing the Conditional Mapping
        • 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 Value on the Table Schema
      • Testing the TPH Mapping
      • Abstract Entity Types
      • Which of These Mappings Is Better?
    • Implementing Customizations That Are Not Supported by the EDM Designer
    • Mapping Table per Concrete (TPC) Type Inheritance for Tables with Overlapping Fields
    • Creating Complex Types to Encapsulate Sets of Properties
      • Complex Types and the EDM Designer
      • Defining a Complex Type
      • Replacing Properties with a Complex Type
      • Mapping Entities with Complex Types
      • Complex Types Are Not EntityObjects
      • Using Complex Types
      • Complex Types in Data-Binding Scenarios
        • ASP.NET EntityDataSource
      • Data Binding Complex Types in ASP.NET Without the EntityDataSource
        • Complex types with ASP.NET binding controls
          • List controls
          • Data-bound controls
          • Templated controls
      • Windows Forms DataSource and Complex Types
      • Removing the Complex Types from the Model
    • Using QueryView to Create Read-Only Entities and Other Specialized Mappings
      • Creating a Simple QueryView
      • Testing the QueryView
      • Deconstructing the QueryView
      • QueryView with Inherited Types
        • When will the Entity Framework use the QueryView for the derived type?
        • The default QueryView needs to account for derived types
      • Testing the New QueryView
    • Additional Customization Options
      • Mapping Stored Procedures
      • Multiple Entity Sets per Type
      • Self-Referencing Associations
    • Summary
  • 13. Working with Stored Procedures When Function Mapping Wont Do
    • Does the Procedure Line Up with an Entity?
    • Overview of Procedures, UDFs, and TVFs in the EDM
    • Composing Queries Against Functions
    • Mapping and Executing Query Stored Procedures
      • Using Functions That Match an Entity Whose Property Names Have Been Changed
        • How can you get around this problem?
      • Query Stored Procedures and Inherited Types
      • Queries That Return Randomly Shaped Results
      • Replacing Stored Procedures with Views
      • Queries That Return Multiple Resultsets
      • Queries That Return Primitive Types
    • Adding Native Queries to the Model
    • Adding Native Views to the Model
      • DefiningQuery Is Already in Your Model
      • Using DefiningQuery to Create Your Own Views
      • Implementing a DefiningQuery
        • Creating an association from the new entity
        • Testing the DefiningQuery
      • Using DefiningQuery to Solve More Complex Problems
    • Using Commands That Affect the Persisted Database
      • DML Functions That Return Entities
      • Insert, Update, and Delete Functions That Dont Return an Entity
        • Returning a scalar value
        • Returning nothing
    • Defining Insert, Update, and Delete Stored Procedures Directly in the Model
      • What Do the Functions Look Like?
    • 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
  • 14. Using Entities with Web and WCF Services
    • Building a Client That Is Ignorant of the Entity Framework
      • Pros and Cons of an Entity Framework-Agnostic Consumer
    • Using the Entity Framework with ASMX Web Services
      • Building the ASMX Service
        • Creating the web service
        • The GetCustomers method
        • Testing the GetCustomers service operation
        • Adding a method to return a single customer
        • Testing the new method
        • What about interoperability?
        • The insert and update web methods
        • The path of least resistance
      • Building the Client Application
        • Setting up the client project and the proxy to the service
        • Adding methods to interact with the web service
        • Designing the form
        • Adding the New and Save buttons
        • Testing your application
        • The client-side Customer versus the server-side Customer
    • Using the Entity Framework with WCF Services
      • Building the WCF Service
        • Creating the service application
        • Defining the operations the service will provide
        • Defining the DataContract classes the service will use
        • Enabling the models partial class properties for Trip and Reservation to participate in the service
        • Implementing the service interface
        • Adding graphs to ObjectContext
        • Deleting objects
        • Updating the ObjectGraph
        • Client rules for identifying changes in an EntityCollection
        • The UpdateCustomer method
        • Why call ApplyPropertyChanges if there were no changes?
        • Handling existing reservations
        • Dealing with new reservations
        • Deleting reservations
        • Wrapping up the UpdateCustomer method with SaveChanges
      • Building the Client to Consume the WCF Service
        • Editing the configuration for the web service client
        • Testing the form again
        • Adding functionality to view the reservations
        • Testing the form so far
        • Finishing the form
        • Adding and deleting the reservations
        • Running the application and saving your changes
        • Peeking under the covers
    • Summary
  • 15. Working with Relationships and Associations
    • Deconstructing Relationships in the Entity Data Model
      • How Did the Entity Data Model Wizard Create the Association?
      • Additional Items Created in the Model
      • Navigation Properties Are Not Required
      • Understanding How Associations Impact the Native Query
    • Deconstructing Relationships Between Instantiated EntityObjects
      • Relationships Are First-Class Citizens
      • The Platinum Rule About Related Entities That Are Attached or Detached from the ObjectContext
      • The Relationship Manager and the IRelatedEnd Interface
        • The Relationship Manager provides related objects through late binding
      • Experimenting with Relationship Span
      • Understanding Navigation Properties in Entity Objects
        • EntityReference properties
          • EntityReference.Value
          • What if there is no EntityReference
        • EntityCollection properties
      • Referential Integrity and Constraints
        • Constraints that are not checked until they hit the database
        • Constraints that the Entity Framework checks when SaveChanges is called
      • Deletes and Cascading Deletes
        • Cascading deletes in the database
        • Cascading deletes in the EDM
        • Recommendation: Cascade in both the model and the database, or in neither
    • Defining Relationships Between Entities
      • The CLR Way: Setting a Navigation Property
      • Setting an EntityReference Using an EntityKey
      • Loading, Adding, and Attaching Navigation Properties
        • Rules, rules, rules
      • EntityReference.Load and EntityCollection.Load
        • Load provides behind-the-scenes query creation and execution
        • Understanding why Load cannot be called on Added entities
      • EntityCollection.Add
        • Adding new entities that are detached
        • Adding new or existing entities that are attached
        • Adding entities to the EntityCollection of a detached object
      • Attach and Remove
        • Use Attach only when a relationship exists in the data store
      • Attach Versus Add
      • 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
    • Summary
  • 16. Making It Real: Connections, Transactions, Performance, and More
    • EntityConnection and Database Connections in the Entity Framework
      • EntityConnection Versus Database Connection
      • Programming EntityConnection Strings
      • Using the EntityConnectionStringBuilder Class
        • Dynamic EntityConnections
      • Opening and Closing Entity and Database Connections
        • Manually opening and closing connections
        • Default behavior 1: Many calls on a single connection
          • Default behavior 2: Multiple connections
          • Forcing an explicit connection
          • Connection versus Connection.StoreConnection
      • Taking Control of How Store Connections Are Disposed
      • What About Connection Pooling?
    • The Entity Framework and Transactions
      • Why Use Your Own Transaction?
      • Understanding the Entity Frameworks Default: Implicit Transactions
        • Where did the transaction come from?
        • Controlling AcceptAllChanges in a transaction
      • Specifying Your Own Transaction
      • Reading Queries Using System.Transaction or EntityTransaction
      • Can You Use Transactions Within ObjectContext?
    • The Entity Framework and Security
      • SQL Injection
        • Youre safe with LINQ, but be careful with Entity SQL
        • Entity SQL injection
      • Protecting Data from Connection Piggybacks
    • The Entity Framework and Performance
      • A Few Backyard Benchmarks
        • Interpreting the tests
      • Reducing the Cost of Query Compilation
      • The EDM Generator for Precompiled Views (and More)
        • Whats in a precompiled view code file?
        • Precompiling views against an existing project
      • Precompiled LINQ to Entities Queries
        • LINQ to Entities compiled queries
      • Query Plan Caching for Entity SQL
        • Entity SQL querying with EntityClient versus Object Services
      • What About Database Updates and Performance?
    • Entities in Multithreaded Applications
      • Forcing an ObjectContext to Use Its Own Thread
      • Another Spin on Threading: Concurrent Processing
    • Summary
  • 17. Controlling Objects with ObjectStateManager and MetadataWorkspace
    • Managing ObjectStateEntry Objects with ObjectStateManager
      • An ObjectStateEntry Refresher
    • Getting an ObjectStateManager and Its Entries
      • Getting Groups of Entries with GetObjectStateEntries
        • Overloading GetObjectStateEntries using extension methods
      • Getting a Single Entry with GetObjectStateEntry and TryGetObjectStateEntry
      • Digging Through ObjectStateEntry
    • CurrentValues and OriginalValues
      • CurrentValueRecord.DataRecordInfo
    • Building the ObjectStateEntry Visualizer
      • Setting Up the Project and Code File
      • Retrieving an ObjectStateEntry Using an EntityKey
      • Reading the OriginalValues and CurrentValues of an ObjectStateEntry
      • Determining Whether a Property Has Been Modified
      • Displaying the ObjectStateEntrys State and Entity Type
      • Getting ComplexType Properties Out of ObjectStateEntry
      • Modifying Values with ObjectStateManager
      • Working with Relationships in ObjectStateManager
        • RelationshipEntry EntityState
        • Inspecting the RelationshipEntries
        • Locating relationships for an entity
        • Building graphs directly with the RelationshipManager
    • ObjectStateManager and SavingChanges
      • The FieldMetadata Hierarchy
    • The MetadataWorkspace API
      • Loading the MetadataWorkspace
        • Creating a MetadataWorkspace without an EntityConnection
      • Clearing the MetadataWorkspace from Memory
      • The MetadataWorkspace ItemCollections
      • ItemCollections Are Loaded as Needed with EntityCollection
        • GetItemCollection/TryGetItemCollection
      • Reading Metadata from the MetadataWorkspace
        • GetItems/TryGetItems
        • GetItem/TryGetItem
        • GetFunctions/TryGetFunctions
      • Querying the Items
      • Building Entity SQL Queries Dynamically Using Metadata
      • Reading the Results of a Dynamically Created Query
      • Dynamic Entity SQL and Generics for Reference Lists
    • Creating EntityObjects Without Entity Classes
      • Creating a New Entity with CreateInstance
        • Getting a reference to an assembly
        • Creating an entity from the assembly
      • Using System.Type to Inspect the EntityType
    • Creating Entities and Graphs Dynamically
      • Calling the AddChildtoParentObject Method
    • Summary
  • 18. Handling Entity Framework Exceptions
    • Preparing for Exceptions in Entity Framework Code
    • EntityConnectionString Exceptions
      • Connection String Cant Be Found or Is Improperly Configured: System.ArgumentException
      • Metadata Files Cannot Be Found: System.Data.MetadataException
      • Handling Connection String Exceptions
    • Query Compilation Exceptions
      • Invalid LINQ to Entities Query Expressions: System.NotSupportedException
      • Invalid Entity SQL Query Expressions: EntitySQLException
      • Store Provider Issues: EntityCommandCompilationException
    • Creating a Common Wrapper to Handle Query Execution Exceptions
    • SaveChanges Command Execution Exceptions
      • Model and Mapping Constraints Are Broken: UpdateException
      • Exceptions Thrown by Broken Constraints in the Database
      • Automatically Rolling Back SaveChanges When an UpdateException Occurs
    • ObjectStateEntries Returned by Object Services Exceptions
      • General Entity Exceptions That May Occur When Executing Queries or Commands
    • InvalidOperationExceptions
    • Exceptions When Multiple Parties Edit Data Concurrently
      • Handling Concurrency Conflicts
    • Understanding Optimistic Concurrency Options in the Entity Framework
      • Ignoring Concurrency Conflicts
      • Forcing the Users Data to the Server (ClientWins)
      • Refreshing the Users Data with Server Data (StoreWins)
      • Determining the Scope of Changes
      • Using rowversion 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 ClientWins Refresh
      • Using StoreWins Refresh
      • Refreshing Collections of Entities
      • Refreshing Related Entities in a Graph
      • Rewinding and Starting Again, and Maybe Again After That
      • What If a Relationship, But No Scalar Properties, Changes?
      • Reporting an Exception
    • Handling Concurrency Exceptions at a Lower Level
      • Handling Granular Exceptions Without User Intervention
      • Handling Multiple Conflicts
        • Separating the good from the bad
    • Handling Exceptions When Transactions Are Your Own
    • Summary
  • 19. Using Your Own Custom Classes
    • Mapping Classes to the Entity Data Model
      • Mapping Rules for Custom Classes and Their Properties
      • Inheriting from EntityObject
      • Metadata Attributes
      • Entity Classes
      • Scalar Properties
      • Navigation Properties
        • EntityCollection navigation properties
        • EntityReference navigation properties
      • Mapping the Remaining Entities in the Model
      • Mapping the EntityContainer
      • Resolving Conflicts Between Custom Classes and Designer-Generated Classes
      • Querying Using the Custom Classes
    • Implementing the IPOCO Interfaces
      • The IEntityWithKey Interface
      • The IEntityWithChangeTracker Interface
        • An EntityState property
      • The IEntityWithRelationships Interface
      • Working with the IPOCO-Enabled Objects
    • Custom Class Assemblies and Entity Data Model Files
      • Accessing the Model Files When They Are Not in a Referenced Assembly
    • Summary
  • 20. Using the Entity Framework in n-Tier Client-Side Applications
    • Thinking in Layers
      • Organizing Your Layers
    • Finding Your Motivation: A Master/Detail Data Entry Form That Will Use the DataBridge Class
    • Preventing Non-UI Logic from Leaking into the UI
    • Implementing Logic That Fits Best in the Entity Partial Classes
      • Creating an IsDirty Property for the ObjectContext
    • Building the CommandExecutor Class
    • Building the DataBridge Class
      • Using a Long-Running ObjectContext
      • Implementing the Primary Elements of the DataBridge Class
      • Creating a Class for Lightweight Objects to Be Used in UI Pick Lists
      • Creating the Main Entity Pick List: For Customer Names
      • Using MergeOptions to Cache or Refresh a Pick List
      • Building a Frequently Used Entity Graph for the UI
        • Precompiling a frequently used query
        • Some decisions that drove the design of the GetCustomerwithRelatedData method
        • Converting a noncustomer to a customer
      • Supplying Additional Lists for UI Drop-Downs
        • Choosing between complete entities and narrower types for lists
      • Saving Changes
      • Rolling Back User Changes
        • Considering in-memory rollbacks
        • Keeping it simple: Rolling back from the database if you can
    • Using the DataBridge Class for Data Binding in a Master/Detail Form
      • Using BindingSourceControls with the DataBridge
      • Instantiating the DataBridge Class in the Form
      • Populating the Form with an Entity and Its Related Data
      • Consuming the Pick Lists in the Form
      • Deleting from Grids When EntityCollections and Referential Constraints Are Involved
        • Deleting children from a grid is easier when the child has a composite key
        • Deleting child entities in a grid when no referential constraint exists in the CSDL
    • Allowing Users to Roll Back Their Edits
    • Helping the User Who Forgets to Save Changes
    • Summary
  • 21. Using the Entity Framework in n-Tier ASP.NET Applications
    • Understanding How an ObjectContext Fits into the Web Page Life Cycle
      • Using EntityObjects in Read-Only Web Pages
      • Exploring Options for Updating Entities in an ASP.NET Application
        • Single or batch updates?
        • Persist entities or use independent values?
      • Evaluating ASP.NETs State Solutions Against the Entity Framework
        • View State
        • Application cache and session state
    • Introducing ASP.NETs ObjectDataSource Control
      • Why ObjectDataSource?
      • ObjectDataSource Enforces Its Rules on Your Objects
      • How the ObjectDataSource Gets Data into and out of the Data-Binding Controls
    • Designing Object Provider Classes to Be Used with an ObjectDataSource
      • Creating the CustomerProvider Class
      • Creating the AddressProvider Class
      • Creating the ReservationsProvider Class
      • Providing Reusable, Cached Reference Lists
    • Wiring Up the Provider Classes to ObjectDataSource Controls
      • Using the ObjectDataSource Wizard to Perform the Initial Wiring to the Provider Classes
      • Tweaking ObjectDataSource Properties to Work with Entities
        • Getting the object to the entity provider
        • Providing original and current values for updates
      • Using ObjectDataSource Events to Solve Problems That Are Particular to Entities
        • Inserting and updating entities that contain EntityReferences
        • Editing EntityReference navigation properties
        • Updating EntityReference navigation properties
        • Inserting records with EntityReference properties
    • Understanding Why We Didnt Use Object Graphs in This Business Layer
      • Database Hits Versus Very Busy Memory
    • Summary
  • 22. Implementing a Smarter WCF Service for Working with Entities
    • Will Your Client Agree to Your Data Contract?
    • Shipping DTOs, Not EntityObjects
      • Building a Data Transfer Object to Take the Place of an Entity Object
        • Replacing EntityReference navigation properties
        • Replacing EntityCollection navigation properties
    • Creating EntityState Properties That Do Not Rely on ObjectContext
      • The EntityStateLocal Enums and Interface
      • Implementing the IEntityStateLocal Interface in the DTO Classes
      • Implementing the IEntityStateLocal Interface in the Entity Classes
    • Designing the Service Interface
    • Implementing the Service Operations
      • Returning CustomerList as ShortCustomers with GetCustomerList
      • Returning Additional Reference Lists
      • Returning a Single Entity Graph for Editing with GetCustomer
      • Building Methods to Create DTOs from Entity Objects
      • Initializing the DTO Children
      • Saving Edits Sent Back from the Client with SaveCustomer
      • Building the Main Method for Updating the Graph: SaveCustomer
      • UpdateChildren
    • Implementing the Client That Will Use the WCF Service
      • Rules for the Client to Follow
      • Building a Business Layer Between the UI and the Services
      • Whats in These Business Classes?
        • The class constructor
        • The property changed event
        • The Initialize method
      • Calling the Service Operations from the Business Layer
    • Testing It All with a Simple Console Application
    • Summary
  • 23. The Entity Framework, Today and Tomorrow
    • What About Building Reports with the Entity Framework?
      • Major Differences Between the Entity Framework and LINQ to SQL
        • The future of LINQ to SQL
        • Migrating LINQ to SQL to the Entity Framework
    • Extensions, Samples, and Solutions from Microsoft
      • Extensions and APIs
        • EFExtensions
        • POCO Adapter for version 1
        • Entity Framework Lazy Loading
        • eSqlBlast
      • Samples
        • Entity Framework Query Samples
        • Sample EDMX Code Generator
        • Entity Framework Sample Provider
      • Learning Tools
    • Entity Framework v.Next
      • The Transparent Design Process for the Next Version
    • Blogs, Forums, and Other Resources
  • A. Entity Framework Assemblies and Namespaces
    • Unpacking the Entity Framework Files
    • Exploring the Namespaces
      • Existing Namespaces That Have New Classes and Functionality
      • New Namespaces
  • Index
  • About the Author
  • Colophon
  • SPECIAL OFFER: Upgrade this ebook with OReilly

pokaż cały spis treści

ukryj recenzje