book

Programming Entity Framework, 2nd Edition

Name: Programming Entity Framework, 2nd Edition
Author: Julia Lerman
ISBN: 9781449399658

by Julia Lerman

August 2010

Beginner to intermediate

920 pages

28h 49m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Programming Entity Framework
Foreword
Preface
Who This Book Is ForHow This Book Is OrganizedWhat You Need to Use This BookThis Book’s WebsiteConventions Used in This BookUsing Code ExamplesSafari® Books OnlineComments and QuestionsAcknowledgments
Author Note for Third Printing, August 2011
Entity Framework 4.1 (Code First and DbContext) Has ReleasedEntity Framework June 2011 CTP
1. Introducing the ADO.NET Entity Framework
The Entity Relationship Model: Programming Against a Model, Not the DatabaseThe Entity Data Model: A Client-Side Data ModelEntities: Blueprints for Business ClassesThe Backend Database: Your ChoiceDatabase ProvidersAccess and ODBCEntity Framework Features: APIs and ToolsMetadataEntity Data Model Design ToolsDatabase-first designModel-first designCode generationObject ServicesPOCO SupportChange TrackingRelationship Management and Foreign KeysData Bindingn-Tier DevelopmentEntityClientThe Entity Framework and WCF ServicesWhat About ADO.NET DataSets and LINQ to SQL?DataSetsLINQ to SQLEntity Framework Pain Points Are Fading AwayProgramming the Entity Framework
2. Exploring the Entity Data Model
Why Use an Entity Data Model?The EDM Within the Entity FrameworkWalkthrough: Building Your First EDMInspecting the EDM in the Designer WindowEntity Container PropertiesEntity PropertiesEntity Property PropertiesThe Model’s Supporting MetadataViewing the Model in the Model BrowserViewing the Model’s Raw XMLCSDL: The Conceptual SchemaEntityContainerEntitySetEntityTypeThe Key elementThe Property elementsThe navigation propertiesAssociationsNavigation PropertyNavigation Properties That Return CollectionsSSDL: The Store SchemaMSL: The MappingsDatabase Views in the EDMSummary
3. Querying Entity Data Models
Query the Model, Not the DatabaseYour First EDM QueryWhere Did the Context and Classes Come From?The ObjectContext class, SampleEntitiesThe entity classesQuerying with LINQ to EntitiesWriting Your First LINQ to Entities QueryQuerying with Object Services and Entity SQLWhy Another Way to Query?Entity SQLEntity SQL canonical functionsThe Parameterized ObjectQueryQuerying with MethodsQuerying with LINQ MethodsChaining methodsQuerying with Query Builder Methods and Entity SQLSpecifying the control variableThe Shortest QueryObjectQuery, ObjectSet, and LINQ to EntitiesQuerying with EntityClient to Return Streamed DataEntityConnection and the Connection StringEntityCommandExecuteReaderForward-Only Access to the FieldsTranslating Entity Queries to Database QueriesPay Attention to the .NET Method’s Impact on Generated SQLAvoiding Inadvertent Query ExecutionSummary
4. Exploring LINQ to Entities in Greater Depth
Getting Ready with Some New LingoProjections in QueriesProjections in LINQ to EntitiesVB and C# Syntax DifferencesLINQ Projections and Special Language FeaturesAnonymous typesImplicitly typed local variablesImplicit and explicit anonymous type creationProjections with LINQ Query MethodsUsing Navigations in QueriesNavigating to an EntityReferenceFiltering and Sorting with an EntityReferenceNavigating to Entity CollectionsProjecting Properties from EntityCollection EntitiesShaped resultsFlattened resultsFiltering and Sorting with EntityCollectionsAggregates with EntityCollectionsAggregates in LINQ to EntitiesAggregates in LINQ MethodsJoins and Nested QueriesJoinsNested QueriesUsing a nested LINQ query as a projectionUsing a nested LINQ query as the collection to be queriedGroupingNaming Properties When GroupingChaining AggregatesFiltering on Group ConditionsShaping Data Returned by QueriesLimiting Which Related Data Is ReturnedLoading Related DataControlling Lazy LoadingDisabling and enabling lazy loading programmaticallyChanging the default behavior for lazy loadingExplicitly Loading Entity Collections and Entity ReferencesLoading the EntityReferencePerformance considerations with deferred loadingUsing the Include Method to Eager-LoadHow is the data shaped with Include?Accessing properties from an Include in the queryPros and Cons of Load and IncludeRetrieving a Single EntityRetrieving a Single Entity with GetObjectByKeyFinding More Query SamplesSummary
5. Exploring Entity SQL in Greater Depth
Literals in Entity SQLExpressing a DateTime LiteralExpressing a Decimal LiteralUsing Additional Literal TypesProjecting in Entity SQLDbDataRecords and Nonscalar PropertiesProjecting with Query Builder MethodsUsing Navigation in Entity SQL QueriesNavigating to an EntityReferenceFiltering and Sorting with an EntityReferenceFiltering and Sorting with EntityCollectionsAggregating with EntityCollectionsUsing Entity SQL SET OperatorsAggregating with Query Builder MethodsUsing JoinsNesting QueriesGrouping in Entity SQLReturning Entities from an Entity SQL GROUP BY QueryFiltering Based on Group PropertiesShaping Data with Entity SQLUsing Include with an ObjectQuery and Entity SQLUnderstanding Entity SQL’s Wrapped and Unwrapped ResultsEntity SQL Rules for Wrapped and Unwrapped ResultsDigging a Little Deeper into EntityClient’s ResultsSummary
6. Modifying Entities and Saving Changes
Keeping Track of EntitiesManaging an Entity’s StateSaving Changes Back to the DatabaseInserting New ObjectsInserting New Parents and ChildrenDeleting EntitiesSummary

7. Using Stored Procedures with the EDM
Updating the Model from a DatabaseWorking with FunctionsFunction AttributesMapping Functions to EntitiesMapping Insert, Update, and Delete Functions to an EntityConcurrency checking with Use Original Value and Rows Affected Parameter optionsInspecting Mappings in XMLUsing Mapped FunctionsUsing the EDM Designer Model Browser to Import Additional Functions into Your ModelMapping the First of the Read Stored Procedures: ContactsbyStateUsing Imported FunctionsAvoiding Inadvertent Client-Side ProcessingMapping a Function to a Scalar TypeMapping a Function to a Complex TypeSummary
8. Implementing a More Real-World Model
Introducing the BreakAway Geek Adventures Business Model and Legacy DatabaseCreating a Separate Project for an EDMInspecting and Cleaning Up a New EDMModifying the Names of Entities and PropertiesResolving Collisions Between Property Names and Entity NamesCleaning Up Navigation Property NamesSetting Default ValuesMapping Stored ProceduresUsing the Use Original Value Checkbox in Update MappingsWorking with Many-to-Many RelationshipsInspecting the Completed BreakAway ModelBuilding the BreakAway Model AssemblyLooking at the Compiled AssemblySplitting Out the Model’s Metadata FilesMoving the schema filesSummary
9. Data Binding with Windows Forms and WPF Applications
Data Binding with Windows Forms ApplicationsCreating a Windows Forms ApplicationUsing Windows Forms Data SourcesCreating an Object Data Source for a Customer EntityGetting an Entity’s Details onto a FormAdding Code to Query an EDM When a Form LoadsBinding Without a BindingSourceAdding an EntityCollection to the FormDisplaying the Properties of Related Data in the GridAllowing Users to Edit DataEditing Navigation Properties (and Shrinking the Query)Replacing the Navigation Property TextBoxes with ComboBoxesAdding New CustomersDeleting ReservationsData Binding with WPF ApplicationsCreating the WPF FormCreating the WPF ProjectAdding the Necessary Data Source ObjectsInspecting the XAML and Code Generated by the Automated Data BindingXAML data-binding elementsAdding Code to Query the EDM When the Window LoadsCustomizing the Display of the ControlsSelecting an Entity and Viewing Its DetailsAdding Another EntityCollection to the MixWorking with a many-to-many relationshipModifying the code to eager-load the related activitiesAdding the Activities ListBox and binding it to the Trips ListBoxTesting the application againEditing Entities and Their Related DataUsing SortDescriptions to Keep Sorting in Sync with Data ModificationsAdding Items to the Child EntityCollectionTesting the new feature for adding activitiesThe Last Task: Adding New Trips to the CatalogA few WPF tricks for a more interactive ListBoxCoding the Add New Trip featureTesting the final version of the WPF demoSummary
10. Working with Object Services
Where Does Object Services Fit into the Framework?Processing QueriesParsing Queries: From Query to Command Tree to SQLUnderstanding Query Builder MethodsQuery builder methods and EntitySetsFrom query builder methods to Entity SQL expressionsCombining LINQ methods and query builder methodsAnalyzing a Query with ObjectQuery Methods and PropertiesObjectQuery.ToTraceStringObjectQuery.CommandTextObjectQuery.ParametersObjectQuery.ContextExecuting Queries with ToList, ToArray, First or SingleExecuting Queries with the Execute MethodOverriding a Default Connection with ObjectContext.ConnectionHandling Command Execution with EntityClientMaterializing ObjectsManaging Object StateUsing EntityKey to Manage ObjectsMerging Results into the Cache with MergeOptionsInspecting ObjectStateEntryMaintaining EntityStateManaging RelationshipsAttaching and Detaching Objects from the ObjectContextObjectContext.AddObject and ObjectSet.AddObjectObjectContext.Attach and ObjectSet.AttachObjectContext.AttachToTaking Control of ObjectStateObjectContext MethodsObjectStateManager MethodsObjectStateEntry State Methods for Managing StateObjectSet State MethodsSending Changes Back to the DatabaseObjectContext.SaveChangesSaveChanges returns an integerSaveChanges refreshes the state of tracked entitiesAffecting SaveChanges Default BehaviorOverriding SaveChanges CompletelyData Validation with the SavingChanges EventConcurrency ManagementOptimistic concurrencyConcurrencyModeOptimisticConcurrencyExceptionTransaction SupportImplementing Serialization, Data Binding, and MoreObject Services Supports XML and Binary SerializationObjectContext, ObjectStateManager, and ObjectStateEntry are not serializableAutomatic serializationXML and DataContract serializationBinary serializationSerialization and object stateExplicit serializationObject Services Supports Data BindingSummary
11. Customizing Entities
Partial ClassesUsing Partial MethodsThe OnContextCreated MethodThe On[Property]Changed and On[Property]Changing MethodsUsing PropertyChanged to Calculate Database-Computed Columns LocallySubscribing to Event HandlersThe ObjectContext.ObjectMaterialized EventThe ObjectContext.SavingChanges EventGetObjectStateEntries: A critical method when validating entities from the contextImplementing SavingChangesSetting default foreign keys in SavingChanges when no foreign key scalar property existsThe EntityObject.PropertyChanging and EntityObject.PropertyChanged EventsThe order of the Changing/Changed eventsEvent parametersSubscribing to the class-level PropertyChanging and PropertyChanged eventsThe AssociationChanged EventEvent argumentsCreating Your Own Partial Methods and PropertiesOverriding the Object ConstructorOverriding ObjectContext.SaveChangesCreating Custom PropertiesUsing custom properties to perform calculations on child collectionsOverloading Entity Creation MethodsUsing Partial Classes for More Than Just Overriding Methods and EventsOverriding Default Code GenerationSwitching to a TemplateReading the TemplateModifying the TemplateInserting the Managed partial method in each entity classOther ways to create common methods or properties for all entitiesCustomizing a Template for Major Class ModificationsSwitching Between the Default Template and a Custom TemplateSummary
12. Data Binding with RAD ASP.NET Applications
Using the EntityDataSource Control to Access Flat DataCreating the Hello Entities ProjectCreating a GridView and an EntityDataSource ConcurrentlyConfiguring an EntityDataSource with Its WizardFormatting the GridViewTesting the Web ApplicationUnderstanding How the EntityDataSource Retrieves and Updates Your DataEntityDataSource and Its QueryEntityDataSource and Its ObjectContextUsing your own contextEntityDataSource Context EventsEntityDataSource and ViewStateAccessing Foreign Keys When There Is No Foreign Key PropertyWorking with Related EntityReference DataUsing EntityDataSource.Include to Get Related DataDisplaying Data That Comes from EntityReference Navigation PropertiesUsing a New EntityDataSource Control to Enable Editing of EntityReference Navigation PropertiesEditing EntityReferences That Cannot Be Satisfied with a Drop-Down ListBinding an EntityDataSource to Another Control with WhereParametersEditing Related Data Concurrently with Multiple EntityDataSource ControlsWorking with Hierarchical Data in a Master/Detail FormSetting Up the Web ApplicationSpecifying Your Own Entity SQL Query Expression for an EntityDataSourceBinding a DropDownList to an EntityDataSource ControlCreating a Parent EntityDataSource That Is Controlled by the DropDownList and Provides Data to a DetailsViewUsing the EntityDataSource.Where Property to Filter Query ResultsDisplaying Read-Only Child Data Through the Parent EntityDataSourceUsing a New EntityDataSource to Add a Third Level of Hierarchical Data to the Master/Detail FormUsing the EntityDataSource.Inserting Event to Help with Newly Added EntitiesTesting the ApplicationExploring EntityDataSource EventsBuilding Dynamic Data WebsitesSummary
13. Creating and Using POCO Entities
Creating POCO ClassesCreating an ObjectContext Class to Manage the POCOsVerifying the POCOs with a queryChange Tracking with POCOsUnderstanding the Importance of DetectChangesLoading Related Data with POCOsLoading from the ContextLazy Loading from a Dynamic ProxyExploring and Correcting POCOs’ Impact on Two-Way RelationshipsUsing the DetectChanges Method to Fix RelationshipsEnabling Classes to Fix Their Own RelationshipsUsing Proxies to Enable Change Notification, Lazy Loading, and Relationship Fix-UpChange Notification by ProxyLazy Loading by ProxyExploring the Proxy ClassesSynchronizing Relationships by ProxyUsing T4 to Generate POCO ClassesModifying the POCO TemplateCreating a Model That Works with Preexisting ClassesCode First: Using Entity Framework with No Model at AllSummary
14. Customizing Entity Data Models Using the EDM Designer
Mapping Table per Type Inheritance for Tables That Describe Derived TypesMapping TPT InheritanceHandling duplicate names and concurrency properties in an inheritance hierarchyFixing a potential constraint problemQuerying Inherited TypesPOCO Classes and Inherited ObjectsInserting TPT Inherited TypesSaveChanges and newly added derived typesSpecifying or Excluding Derived Types in QueriesCreating New Derived Entities When the Base Entity Already ExistsTPT with Abstract TypesMapping Unique Foreign KeysMapping an Entity to More Than One TableMerging Multiple Entities into OneQuerying, Editing, and Saving a Split EntityMapping Stored Procedures to Split Tables and MoreSplitting a Single Table into Multiple EntitiesFiltering Entities with Conditional MappingCreating a Conditional Mapping for the Activity EntityQuerying, Inserting, and Saving with Conditional MappingsFiltering on Other Types of ConditionsRemoving the Conditional Mapping from Activity and Re-creating the Category PropertyImplementing Table per Hierarchy Inheritance for Tables That Contain Multiple TypesCreating the Resort Derived TypeSetting a Default (Computed) Value on the Table SchemaTesting the TPH MappingChoosing to Turn a Base Class into an Abstract ClassCreating Complex Types to Encapsulate Sets of PropertiesDefining a Complex TypeReusing Complex TypesQuerying, Creating, and Saving Entities That Contain Complex TypesRemoving the Complex Types from the ModelUsing Additional Customization OptionsUsing GUIDs for EntityKeysMapping Stored ProceduresMapping Multiple Entity Sets per TypeMapping Self-Referencing AssociationsSummary
15. Defining EDM Mappings That Are Not Supported by the Designer
Using Model-Defined FunctionsUsing Model-Defined Functions to Return More Complex ResultsConsuming the Complex ResultsReading the Results from a Complex FunctionMapping Table per Concrete (TPC) Type Inheritance for Tables with Overlapping FieldsUsing QueryView to Create Read-Only Entities and Other Specialized MappingsFinding a Common Use Case for QueryViewCreating a CustomerNameAndID EntityCreating a QueryView Mapping for CustomerNameAndIDTesting the QueryViewDeconstructing the QueryViewSummary
16. Gaining Additional Stored Procedure and View Support in the Raw XML
Reviewing Procedures, Views, and UDFs in the EDMWorking with Stored Procedures That Return DataUsing Functions That Match an Entity Whose Property Names Have Been ChangedQuery Stored Procedures and Inherited TypesComposing Queries Against FunctionsReplacing Stored Procedures with Views for ComposabilityQueries That Return Multiple Result SetsExecuting Queries on Demand with ExecuteStoreQueryQuerying to a Class That Is Not an EntityQuerying into an EntityAdding Native Queries to the ModelDefining a Complex Type in the Model BrowserAdding Native Views to the ModelDefiningQuery Is Already in Your ModelUsing DefiningQuery to Create Your Own ViewsImplementing a DefiningQueryCreating Associations with the New EntityTesting the DefiningQuery in an associationUsing DefiningQuery to Solve More Complex ProblemsUsing Commands That Affect the DatabaseExecuting SQL on the Fly with ExecuteStoreCommandUsing Functions to Manipulate Data in the DatabaseChanging from one derived type to anotherMapping Insert/Update/Delete to Types Within an Inheritance StructureWhat If Stored Procedures Affect Multiple Entities in an Inheritance Structure?Implementing and Querying with User-Defined Functions (UDFs)Summary
17. Using EntityObjects in WCF Services
Planning for an Entity Framework–Agnostic ClientAssessing the Pros and Cons of an Entity Framework–Agnostic ConsumerBuilding a Simple WCF Service with EntityObjectsCreating the ServiceDefining the Service OperationsDefining Extra Service ClassesExposing Custom PropertiesImplementing the Service InterfaceAdding Graphs to ObjectContextDeleting ObjectsUpdating the Object GraphClient Rules for Identifying Changes in an EntityCollectionThe UpdateCustomer MethodHandling New and Existing ReservationsDeleting ReservationsBuilding a Simple Console App to Consume an EntityObject ServiceEnabling the Client Application to Receive Large Messages from the ServiceCreating Methods to Test the Service OperationsAnalyzing the GetAndUpdateCustomer MethodTesting Out the Other Service OperationsCreating WCF Data Services with EntitiesPutting WCF Data Services in PerspectiveCreating a WCF Data ServiceFiltering at the Service Level Using QueryInterceptorAnticipating ExceptionsExposing Related Data Through the ServicePreparing for WCF Data Services’ LimitationsModifying Data Through a ServiceLearning More About Creating and Consuming WCF Data ServicesUnderstanding How WCF RIA Services Relates to the Entity FrameworkSummary
18. Using POCOs and Self-Tracking Entities in WCF Services
Creating WCF-Friendly POCO ClassesUpdating the POCO Classes Based on the Current BreakAway ModelIsolating the POCO Entities in Their Own ProjectDirecting a template back to a modelSpecifying the namespace of entity classesProviding the ObjectContext with a reference to the entitiesAdding Custom Logic to the POCO Entities with a Base ClassModifying the template to apply the inheritanceFollowing WCF Collection RulesPreventing Properties from Being Marked As VirtualBuilding a WCF Service That Uses POCO ClassesImplementing the InterfaceUsing the ServiceUsing the Self-Tracking Entities Template for WCF ServicesCreating and Exploring the Self-Tracking EntitiesPutting the Change-Tracking Logic Where It’s NeededCreating a WCF Service That Uses Self-Tracking EntitiesWatching Self-Tracking Entities Under the CoversDebugging the client applicationDebugging the SaveCustomer service methodInspecting the Generated Context Class and ExtensionsUsing POCO Entities with WCF Data and RIA ServicesPreparing for WCF Data ServicesDealing with entities that live in a separate assemblyAvoiding problems caused by dynamic proxiesUsing POCO Entities in WCF RIA ServicesSorting Out the Many Options for Creating ServicesSummary
19. Working with Relationships and Associations
Deconstructing Relationships in the Entity Data ModelUnderstanding How the Entity Data Model Wizard Creates the AssociationUnderstanding Additional Relationship ItemsHandling Nonessential Navigation PropertiesUnderstanding the Major Differences Between Foreign Key Associations and Independent AssociationsDefining Associations in MetadataDetecting Associations at RuntimeDeconstructing Relationships Between Instantiated EntitiesUnderstanding Relationship Manager and the IRelatedEnd InterfaceLate-Binding RelationshipsTaking a Peek Under the Covers: How Entity Framework Manages RelationshipsUnderstanding Navigation PropertiesEntityReference propertiesEntityReference.ValueWhat if there is no EntityReferenceEntityCollection propertiesUnderstanding Referential Integrity and ConstraintsConstraints that are not checked until they hit the databaseChecking for missing entity references with and without foreign keysImplementing Deletes and Cascading DeletesCascading deletes in the databaseRecommendation: Cascade in both the model and the database, or in neitherDefining Relationships Between EntitiesThe CLR Way: Setting a Navigation Property to an EntitySetting a Foreign Key PropertySetting an EntityReference Using an EntityKeyLoading, Adding, and Attaching Navigation PropertiesLazy LoadingEntityReference.Load and EntityCollection.LoadLoading from Detached Entities: Lazy and ExplicitUsing EntityCollection.AddAdding new entities that are detachedAdding existing entities that are detachedAdding new or existing entities that are attachedAdding entities to the EntityCollection of a detached objectUsing Attach and RemoveMoving an Entity to a New GraphLearning a Few Last Tricks to Make You a Relationship ProUsing CreateSourceQuery to Enhance Deferred LoadingGetting a Foreign Key Value in an Independent AssociationSummary
20. Real World Apps: Connections, Transactions, Performance, and More
Entity Framework and ConnectionsOverriding EntityConnection DefaultsWorking with Connection Strings ProgrammaticallyConstructing connection strings on the fly with the EntityConnectionStringBuilder classChoosing and loading a model programmaticallyOpening and Closing ConnectionsUnderstanding the default connection usageDefault behavior 1: Many calls on a single connectionDefault behavior 2: Multiple connectionsForcing an explicit connectionGetting the Store Connection from EntityConnectionDisposing ConnectionsPooling ConnectionsFine-Tuning TransactionsWhy Use Your Own Transaction?Understanding Implicit Entity Framework TransactionsUnderstanding SaveOptions and AcceptAllChanges in a transactionSpecifying Your Own Read/Write TransactionsSpecifying Your Own Read-Only TransactionsRolling Back TransactionsUnderstanding SecurityGuarding Against SQL InjectionTaking precautions with dynamic queriesEntity SQL injectionGuarding Against Connection PiggybacksFine-Tuning PerformanceMeasuring Query PerformanceMeasuring Startup PerformanceReducing the Cost of Query CompilationCaching for Entity SQL QueriesComparing EntityClient to Object ServicesPrecompiling Views for PerformancePregenerating views for performancePregenerating views into an existing projectPrecompiling LINQ to Entities Queries for PerformanceFine-Tuning Updates for Performance?Lacking Support for Full Text SearchesExploiting Multithreaded ApplicationsForcing an ObjectContext to Use Its Own ThreadImplementing Concurrent Thread ProcessingExploiting .NET 4 Parallel ComputingSummary
21. Manipulating Entities with ObjectStateManager and MetadataWorkspace
Manipulating Entities and Their State with ObjectStateManagerRefreshing Your High-Level Understanding of ObjectStateEntryGetting an ObjectStateManager and Its EntriesGetting groups of entries with GetObjectStateEntriesBuilding Extension Methods to Overload GetObjectStateEntriesBuilding a Method to Return Managed EntitiesUsing GetObjectStateEntry and TryGetObjectStateEntryMining Entity Details from ObjectStateEntryReading and writing valuesAccessing object metadata with CurrentValueRecord.DataRecordInfoGetting started with the FieldMetadata hierarchyLeveraging the ObjectStateManager During SavesUsing ObjectStateManager to Build an EntityState VisualizerRetrieving an ObjectStateEntry Using an EntityKeyReading the OriginalValues and CurrentValues of an ObjectStateEntryDetermining Whether a Property Has Been ModifiedDisplaying the State and Entity TypeGetting ComplexType Properties Out of ObjectStateEntryModifying Values with ObjectStateManagerWorking with Relationships in ObjectStateManagerBuilding graphs directly with the RelationshipManagerUsing the MetadataWorkspaceLoading the MetadataWorkspaceCreating a MetadataWorkspace without an EntityConnectionClearing the MetadataWorkspace from MemoryUnderstanding the MetadataWorkspace ItemCollectionsDetermining whether an ItemCollection has been loadedRetrieving Metadata from the MetadataWorkspaceRetrieving sets of items from the metadata with GetItems and TryGetItemRetrieving specific items from the metadata with GetItem and TryGetItemRetrieving functions from the metadata with GetFunctions and TryGetFunctionsQuerying the Metadata with LINQ to ObjectsBuilding Dynamic Queries and Reading ResultsBuilding Entity SQL Queries Dynamically Using MetadataCreating Queries on the Fly with CreateObjectSet and Query Builder MethodsLeveraging CreateObjectSet to return Entity SQL, not just a queryReading the Results of a Dynamically Created QueryCreating and Manipulating Entities DynamicallyCreating EntityObjects Without Entity ClassesCreating a new entity with CreateInstanceGetting a reference to an assemblyCreating an entity from the assemblyUsing System.Type to inspect the EntityTypeCreating Entities and Graphs DynamicallyCustom extension methods used by AddChildToParentObjectCalling the AddChildToParentObject methodSummary
22. Handling Exceptions
Preparing for ExceptionsHandling EntityConnectionString ExceptionsConnection String Can’t Be Found or Is Improperly Configured: System.ArgumentExceptionMetadata Files Cannot Be Found: System.Data.MetadataExceptionHandling Connection String ExceptionsHandling Query Compilation ExceptionsInvalid LINQ to Entities Query Expressions: System.NotSupportedExceptionInvalid Entity SQL Query Expressions: EntitySqlExceptionHandling an EntitySqlExceptionEntityCommandCompilationException Thrown by the Store ProviderCreating a Common Wrapper to Handle Query Execution ExceptionsHandling Exceptions Thrown During SaveChanges Command ExecutionUpdateException: Thrown When Independent Association Mapping Constraints Are BrokenUpdateException: Thrown by Broken Constraints in the DatabaseRelying on Entity Framework to Automatically Roll Back When an UpdateException OccursGleaning Details from UpdateExceptionPlanning for Other Exceptions Related to the Entity FrameworkHandling Concurrency ExceptionsSummary
23. Planning for Concurrency Problems
Understanding Database Concurrency ConflictsUnderstanding Optimistic Concurrency Options in the Entity FrameworkIgnoring Concurrency ConflictsForcing the User’s Data to the Server (ClientWins)Refreshing the User’s Data with Server Data (StoreWins)Determining the Scope of ChangesUsing rowversion (a.k.a. timestamp) for Concurrency ChecksImplementing Optimistic Concurrency with the Entity FrameworkFlagging a Property for Concurrency CheckingHow the Entity Framework Uses the ConcurrencyMode PropertyConcurrency Checking Without a rowversion FieldConcurrency Checking on a Checksum in the Data StoreConcurrency Checks for EntityReference Navigation PropertiesConcurrency Checks and Inherited TypesConcurrency Checks and Stored ProceduresDefining a stored procedure to perform concurrency checkingHandling OptimisticConcurrencyExceptionsUsing ObjectContext.RefreshUsing Refresh with ClientWinsUsing Refresh with StoreWinsRefreshing Collections of EntitiesRefreshing Related Entities in a GraphRewinding and Starting Again, and Maybe Again After ThatReporting an ExceptionHandling Concurrency Exceptions at a Lower LevelHandling Exceptions in a Granular Way Without User InterventionHandling Multiple ConflictsSeparating the good from the bad and the uglyHandling Exceptions When Transactions Are Your OwnSummary
24. Building Persistent Ignorant, Testable Applications
Testing the BreakAway Application ComponentsGetting Started with TestingWriting an Integration Test That Hits the DatabaseInspecting a Failed TestWriting a Unit Test That Focuses on Custom LogicCreating Persistent Ignorant EntitiesPlanning the Project StructureStarting with the Model and Its POCO EntitiesBuilding an Interface to Represent a ContextModifying the BAEntities ObjectContext Class to Implement the New InterfaceDisconnecting the context class from the T4 templateImplementing the IContext interfaceImplementing the remaining interface membersCreating the IEntityRepository InterfaceCreating the Repository ClassesTesting GetReservationsForCustomer Against the DatabaseCreating a Fake ContextCreating a FakeObjectSet ClassCompleting the Fake ContextModify the tests to use the fake repositoryRerun the testsBuilding Tests That Do Not Hit the DatabaseAdding Validation Logic to the POCO ClassAdding Validation Logic to the ContextProviding ManagedEntities in the FakeContextHiding the Context from the Lower Layers with Unit of WorkTesting UnitOfWork Against the DatabaseEnabling Eager Loading in IContextEager loading with a fake contextLeveraging Precompiled Queries in Your RepositoriesUsing the New Infrastructure in Your ApplicationAdding a UI Layer That Calls the RepositoryApplication Architecture Benefits from Designing Testable CodeConsidering Mocking Frameworks?Summary
25. Domain-Centric Modeling
Creating a Model and Database Using Model FirstCreating a Conceptual Model in the DesignerCreating the EntitiesSetting attributes of the entity’s propertiesCreating Association and Inheritance HierarchiesCreating a one-to-many relationshipCreating a many-to-many relationshipCreating an inheritance hierarchyGenerating Database Schema from the ModelExploring the generated DDLLooking at the result of the inheritanceNoting the result of the many-to-many relationshipExploring the constraintsCompleting the generation of the DDLCreating the Database and Its SchemaOverriding the DDL GenerationUsing the Feature CTP Code-First Add-OnUnderstanding Code-First DesignInstalling the Feature CTPExploring Some Configuration ExamplesTesting the Code-First Application and DatabaseUsing SQL Server Modeling’s “M” LanguageUsing M Metadata in Entity Framework ApplicationsSummary
26. Using Entities in Layered Client-Side Applications
Isolating the ObjectContextFreeing Entities from Change TrackingEnabling Change Tracking Across TiersMoving Other ObjectContext-Dependent Logic to the DataBridgeEnsuring That Lazy Loading Doesn’t Negatively Impact the Layered ApplicationNoting Additional Benefits of the Layered ApplicationSeparating Entity-Specific Logic from ObjectContext LogicWorking with POCO EntitiesProviding EntityStateProviding Logic in Place of Other EntityObject BehaviorSummary
27. Building Layered Web Applications
Understanding How ObjectContext Fits into the Web Page Life CycleReturn Results, Not Queries, from the DataBridge ClassUsing Entities in Read-Only Web PagesExploring Options for Updating Entities in an ASP.NET Web Forms ApplicationSingle or batch updates?Persist entities or use independent values?Comparing ASP.NET’s State Solutions to the Needs of the Entity FrameworkView stateApplication cache and session stateBuilding an N-Tier Web Forms ApplicationDesigning the ApplicationUsing the Existing RepositoriesBuilding an Entity Manager to Act As a DataBridgeRetrieving Data for Display and for Future UpdatesMaking the Related Data Accessible to the ClientGetting Data from the Manager to the ClientAdding Lists for User Selection ControlsAllowing a User to Modify Related DataBuilding an ASP.NET MVC ApplicationReplacing the Context with RepositoriesEditing Entities and Graphs on an MVC ApplicationCreating a Repository for PaymentsInteracting with the ReservationControllerSummary
A. Entity Framework Assemblies and Namespaces
Unpacking the Entity Framework FilesExploring the NamespacesExisting Namespaces That Include Entity Framework Classes and FunctionalityEntity Framework-Specific Namespaces
B. Data-Binding with Complex Types
Using Complex Types with ASP.NET EntityDataSourceIdentifying Unexpected Behavior When Binding Complex TypesSuccessfully Using Binding to Complex Types in ASP.NET Without Data Source ControlsList controlsData-bound controlsTemplated controlsWindows Forms DataSource and Complex Types
C. Additional Details About Entity Data Model Metadata
Seeing EDMX Schema Validation in ActionAdditional Conceptual Model DetailsSchemaXML Representation of an AssociationAssociationSetAdditional SSDL Metadata DetailsSSDL Association and AssociationSet ElementsReferentialConstraintAdditional MSL Metadata DetailsThe MSL ElementsMappingEntityContainerMappingEntitySetMappingEntityTypeMappingMappingFragmentScalarPropertyAssociationSetMapping
Index
About the Author
Colophon
Copyright

Content preview from Programming Entity Framework, 2nd Edition

Chapter 23. Planning for Concurrency Problems

Concurrency issues are the bane of data access developers. In any sizable organization, it is not uncommon for multiple users or services to be processing the same sets of information. Not infrequently, different users may be updating the same piece of data concurrently, and a conflict occurs. For instance, a salesperson could be modifying a payment at the same time an accounting system is processing it. Or a scheduler might delete a calendar item while another person in a different department was in the middle of editing the same item.

These are two very different types of concurrency problems. In the first problem, you need to consider whose changes are saved. Does the accounting system rule over the salesperson, or vice versa? Do you simply take the last changes that were sent to the database, overriding the changes that were just saved moments ago? In some organizations, the focus is on a single record, whereas other organizations might get as granular as worrying about which fields in the record were updated by whom.

Another common type of concurrency problem occurs when a user tries to save changes to data that no longer exists in the database. What do you do then? You might minimally want to inform the user about the problem and give her an opportunity to take further action, if she has the proper permissions.

It is a tangled web of conundrums and decision making on the part of the application designer. Once your organization has ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Programming Entity Framework: Code First

Publisher Resources

ISBN: 9780596807276Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Programming Entity Framework, 2nd Edition

by Julia Lerman

Chapter 23. Planning for Concurrency Problems

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.