Programming Entity Framework: DbContext. Querying, Changing, and Validating Your Data with Entity Framework Julia Lerman, Rowan Miller

Spis treści książki

• Programming Entity Framework: DbContext
• Preface
  • Audience
  • Contents of This Book
  • Conventions Used in This Book
  • Using Code Examples
  • Safari Books Online
  • How to Contact Us
  • Acknowledgments
• 1. Introducing the DbContext API
  • Getting the DbContext API into Your Project
  • Looking at Some Highlights of the DbContext API
    • Reducing and Simplifying Ways to Work with a Set
    • Retrieving an Entity Using ID with DbSet.Find
    • Avoiding Trolling Around the Guts of Entity Framework
  • Working with the BreakAway Model
    • Getting the Sample Solution
    • Getting DbContext from an EDMX Model
  • Ensuring DbContext Instances Get Disposed
• 2. Querying with DbContext
  • Writing Queries with LINQ to Entities
  • Querying All the Data from a Set
  • Using LINQ for Sorting, Filtering, and More
  • Finding a Single Object
  • Querying Local Data
    • Using the Load Method to Bring Data into Memory
    • Running LINQ Queries Against Local
    • Working with the ObservableCollection Returned by Local
  • Loading Related Data
    • Lazy Loading
      • Understanding the downsides of lazy loading
    • Eager Loading
      • Understanding the downsides of eager loading
      • Using Include in LINQ queries
    • Explicit Loading
    • Checking If a Navigation Property Has Been Loaded
  • Querying Contents of a Collection Navigation Property
    • Explicit Loading a Subset of the Contents of a Navigation Property
• 3. Adding, Changing, and Deleting Entities
  • Working with Single Entities
    • Adding New Entities
    • Changing Existing Entities
    • Deleting Existing Entities
      • Deleting without loading from the database
      • Deleting an object with related data
    • Multiple Changes at Once
    • The Find or Add Pattern
  • Working with Relationships
    • Adding a Relationship Between Objects
    • Changing a Relationship Between Objects
    • Removing a Relationship Between Objects
  • Working with Change Tracking
  • Using Snapshot Change Tracking
    • Understanding When Automatic Change Detection Occurs
    • Controlling When DetectChanges Is Called
    • Using DetectChanges to Trigger Relationship Fix-up
  • Enabling and Working with Change Tracking Proxies
    • Ensuring the New Instances Get Proxies
    • Creating Proxy Instances for Derived Types
  • Fetching Entities Without Change Tracking
• 4. Working with Disconnected Entities Including N-Tier Applications
  • A Simple Operation on a Disconnected Graph
  • Exploring the Challenges of N-Tier
    • Using Existing N-Tier Frameworks That Support Graph Modification
    • Using Explicit Operations on the Server Side
    • Replaying Changes on the Server
  • Understanding How DbContext Responds to Setting the State of a Single Entity
    • Marking a New Entity as Added
    • Marking an Existing Entity as Unchanged
    • Marking an Existing Entity as Modified
    • Registering an Existing Entity for Deletion
      • Using a stub entity to mark for deletion
    • Working with Relationships with and Without Foreign Keys
      • Benefiting from foreign key properties
      • Using navigation properties to define relationships
  • Setting the State for Multiple Entities in an Entity Graph
    • Getting the Graph into the Context
    • Setting the State of Entities in a Graph
  • Building a Generic Approach to Track State Locally
    • Creating a Generic Method That Can Apply State Through Any Graph
    • Concurrency Implications
  • Tracking Individually Modified Properties
    • Recording Modified Property Names
      • Concurrency implications
    • Recording Original Values
      • Concurrency implications
    • Querying and Applying Changes
      • Concurrency implications
• 5. Change Tracker API
  • Change Tracking Information and Operations for a Single Entity
  • Working with the State Property
  • Working with Current, Original, and Database Values
    • Working with DbPropertyValues for Complex Types
    • Copying the Values from DbPropertyValues into an Entity
    • Changing Values in a DbPropertyValues
      • Using the SetValues method
  • Working with Individual Properties
    • Working with Scalar Properties
    • Working with Complex Properties
    • Working with Navigation Properties
      • Modifying the value of a navigation property
      • Modifying navigation properties with the change tracker
      • Working with collection navigation properties
  • Refreshing an Entity from the Database
  • Change Tracking Information and Operations for Multiple Entities
  • Using the Change Tracker API in Application Scenarios
    • Resolving Concurrency Conflicts
    • Logging During Save Changes
• 6. Validating with the Validation API
  • Defining and Triggering Validation: An Overview
  • Validating a Single Object on Demand with GetValidationResult
  • Specifying Property Rules with ValidationAttribute Data Annotations
    • Validating Facets Configured with the Fluent API
    • Validating Unmapped or Transient Properties
    • Validating Complex Types
    • Using Data Annotations with an EDMX Model
  • Inspecting Validation Result Details
    • Inspecting Individual Validation Errors
  • Exploring More ValidationAttributes
    • Using CustomValidationAttributes
  • Validating Individual Properties on Demand
  • Specifying Type-Level Validation Rules
    • Using IValidatableObject for Type Validation
    • Validating Multiple Rules in IValidatableObject
    • Using CustomValidationAttributes for Type Validation
  • Understanding How EF Combines Validations
  • Validating Multiple Objects
  • Validating When Saving Changes
    • Reviewing ObjectContext. SaveChanges Workflow
    • Understanding DbContext.SaveChanges Workflow
    • Disabling Validate Before Save
• 7. Customizing Validations
  • Overriding ValidateEntity in the DbContext
  • Considering Different Ways to Leverage ValidateEntity
  • Updating Data During SaveChanges
  • Overriding SaveChanges When Validation Occurs
    • Comparing ValidateEntity to SaveChanges for Custom Logic
  • Using the IDictionary Parameter of ValidateEntity
  • Controlling Which Entities Are Validated in ValidateEntity
• 8. Using DbContext in Advanced Scenarios
  • Moving Between ObjectContext and DbContext
    • Accessing ObjectContext Features from a DbContext
    • Adding DbContext into Existing .NET 4 Applications
  • Leveraging SQL Server Operators Exposed in SqlFunctions
  • Querying Derived Types with DbSet
  • Understanding the Interface Property Limitation
  • Considering Automated Testing with DbContext
    • Testing with DbSet
    • Exploring a Scenario That Unnecessarily Queries the Database
  • Reducing Database Hits in Testing with IDbSet
    • Creating an IDbSet Implementation
    • Abstracting BreakAwayContext for Tests
    • Reviewing the Implementation
    • Supplying Data to a FakeDbSet
  • Accessing the Database Directly from DbContext
    • Executing Queries with Database.SqlQuery and DbSet.SqlQuery
    • Tracking Results of SqlQuery
    • Executing Commands from the Database Class
  • Providing Multiple Targeted Contexts in Your Application
    • Reusing Classes, Configurations, and Validation Across Multiple Contexts
    • Ensuring That All DbContexts Use a Single Database
    • Validating Relationship Constraints and Other Validations with Multiple Contexts
    • Getting Code First to Create Full BreakAwayContext Database
• 9. Whats Coming Next for Entity Framework
  • Understanding Entity Frameworks Version Numbers
  • Entity Framework 5.0
    • Enums
    • Spatial Data
    • Performance Improvements
    • Multiple Result Sets from Stored Procedures
    • Table Value Functions
• About the Authors
• Copyright

pokaż cały spis treści

ukryj recenzje