Tenny / Hirani Entity Framework 4.0 Recipes

A Problem-Solution Approach
1. ed
ISBN: 978-1-4302-2704-5
Verlag: Apress
Format: PDF
Kopierschutz: 1 - PDF Watermark

E-Book, Englisch, 648 Seiten

Entity Framework 4.0 Recipes provides an exhaustive collection of ready-to-use code solutions for Entity Framework, Microsoft's vision for the future of data access. Entity Framework is a model-centric data access platform with an ocean of new concepts and patterns for developers to learn. With this book, you will learn the core concepts of Entity Framework through a broad range of clear and concise solutions to everyday data access tasks. Armed with this experience, you will be ready to dive deep into Entity Framework, experiment with new approaches, and develop ways to solve even the most difficult data access challenges. If you are a developer who likes to learn by example, then this is the right book for you. Gives ready-to-use, real-world recipes to help you with everyday tasks Provides guideposts for learning core concepts Maps out key landmarks for experimenting with your own solutions

Larry Tenny has more than 20 years experience developing applications using a broad range of development tools primarily targeting the Microsoft platform. He has extensive .NET development experience. He has a Ph.D. in computer science from Indiana University.

Autoren/Hrsg.

Tenny, Larry

Hirani, Zeeshan

Inhaltsverzeichnis

1;Title Page;1
2;Copyright Page;2
3;Contents at a Glance;4
4;Table of Contents;5
5;About the Authors;30
6;About the Technical Reviewers;31
7;Acknowledgments;32
8;Preface;33
8.1;Who This Book Is For;33
8.2;What’s in This Book;34
8.3;About the Recipes;35
8.4;Stuff You Need to Get Started;36
8.5;Code Examples;36
8.6;The Database;36
8.7;Apress Website;37
9;CHAPTER 1 Getting Started With Entity Framework;38
9.1;A Brief Tour of the Entity Framework World;39
9.1.1;Models;39
9.1.2;Terminology;40
9.1.3;Code;41
9.1.4;Visual Studio 2010;41
9.2;Using Entity Framework;42
10;CHAPTER 2 Entity Data Modeling Fundamentals;46
10.1;2-1. Creating a Simple Model;46
10.1.1;Problem;46
10.1.2;Solution;46
10.1.3;How It Works;51
10.2;2-2. Creating a Model from an Existing Database;53
10.2.1;Problem;53
10.2.2;Solution;53
10.2.3;How It Works;56
10.3;2-3. Modeling a Many-to-Many Relationship with No Payload;59
10.3.1;Problem;59
10.3.2;Solution;59
10.3.3;How It Works;60
10.4;2-4. Modeling a Many-to-Many Relationship with a Payload;63
10.4.1;Problem;63
10.4.2;Solution;63
10.4.3;How It Works;64
10.5;2-5. Modeling a Self-Referencing Relationship;66
10.5.1;Problem;66
10.5.2;Solution;66
10.5.3;How It Works;67
10.6;2-6. Splitting an Entity Across Multiple Tables;70
10.6.1;Problem;70
10.6.2;Solution;70
10.6.3;How It Works;72
10.7;2-7. Splitting a Table Across Multiple Entities;74
10.7.1;Problem;74
10.7.2;Solution;74
10.7.3;How It Works;77
10.8;2-8. Modeling Table per Type Inheritance;79
10.8.1;Problem;79
10.8.2;Solution;79
10.8.3;How It Works;81
10.9;2-9. Using Conditions to Filter an ObjectSet;83
10.9.1;Problem;83
10.9.2;Solution;83
10.9.3;How It Works;85
10.10;2-10. Modeling Table per Hierarchy Inheritance;86
10.10.1;Problem;86
10.10.2;Solution;86
10.10.3;How It Works;89
10.11;2-11. Modeling Is-a and Has-a Relationships Between Two Entities;91
10.11.1;Problem;91
10.11.2;Solution;92
10.11.3;How It Works;93
10.12;2-12. Creating, Modifying, and Mapping Complex Types;94
10.12.1;Problem;94
10.12.2;Solution;95
10.12.3;How It Works;96
11;CHAPTER 3 Querying an Entity Data Model;99
11.1;3-1. Executing an SQL Statement;99
11.1.1;Problem;99
11.1.2;Solution;99
11.1.3;How It Works;101
11.2;3-2. Returning Objects from a SQL Statement;102
11.2.1;Problem;102
11.2.2;Solution;102
11.2.3;How It Works;103
11.3;3-3. Returning Objects from an Entity SQL Statement;104
11.3.1;Problem;104
11.3.2;Solution;104
11.3.3;How It Works;106
11.4;3-4. Specifying Fully Qualified Names in Entity SQL;108
11.4.1;Problem;108
11.4.2;Solution;108
11.4.3;How It Works;110
11.5;3-5. Finding a Master that Has Detail in a Master-Detail Relationship;110
11.5.1;Problem;110
11.5.2;Solution;110
11.5.3;How It Works;112
11.6;3-6. Setting Default Values in a Query;113
11.6.1;Problem;113
11.6.2;Solution;113
11.6.3;How It Works;115
11.7;3-7. Returning Multiple Result Sets From a Stored Procedure;116
11.7.1;Problem;116
11.7.2;Solution;116
11.7.3;How It Works;117
11.8;3-8. Comparing Against a List of Values;118
11.8.1;Problem;118
11.8.2;Solution;118
11.8.3;How It Works;120
11.9;3-9. Building and Executing a Query Against an ObjectSet;121
11.9.1;Problem;121
11.9.2;Solution;121
11.9.3;How It Works;123
11.10;3-10. Returning a Primitive Type From a Query;123
11.10.1;Problem;123
11.10.2;Solution;123
11.10.3;How It Works;125
11.11;3-11. Filtering Related Entities;125
11.11.1;Problem;125
11.11.2;Solution;125
11.11.3;How It Works;128
11.12;3-12. Applying a Left Outer Join;129
11.12.1;Problem;129
11.12.2;Solution;129
11.12.3;How It Works;131
11.13;3-13. Ordering by Derived Types;132
11.13.1;Problem;132
11.13.2;Solution;132
11.13.3;How It Works;133
11.14;3-14. Paging and Filtering;134
11.14.1;Problem;134
11.14.2;Solution;134
11.14.3;How It Works;136
11.15;3-15. Grouping by Date;137
11.15.1;Problem;137
11.15.2;Solution;137
11.15.3;How It Works;138
11.16;3-16. Flattening Query Results;139
11.16.1;Problem;139
11.16.2;Solution;139
11.16.3;How It Works;141
11.17;3-17. Grouping by Multiple Properties;141
11.17.1;Problem;141
11.17.2;Solution;142
11.17.3;How It Works;144
11.18;3-18. Using Bitwise Operators in a Filter;144
11.18.1;Problem;144
11.18.2;Solution;144
11.18.3;How It Works;147
11.19;3-19. Joining on Multiple Columns;147
11.19.1;Problem;147
11.19.2;Solution;147
11.19.3;How It Works;149
12;CHAPTER 4 Using Entity Framework in ASP.NET;150
12.1;4-1. Building a Search Query;150
12.1.1;Problem;150
12.1.2;Solution;150
12.1.3;How It Works;153
12.2;4.2. Building CRUD Operations in an ASP.NET Web Page;154
12.2.1;Problem;154
12.2.2;Solution;154
12.2.3;How It Works;159
12.3;4-3. Executing Business Logic When Changes Are Saved;159
12.3.1;Problem;159
12.3.2;Solution;159
12.3.3;How It Works;161
12.4;4-4. Loading Related Entities;162
12.4.1;Problem;162
12.4.2;Solution;162
12.4.3;How It Works;164
12.5;4-5. Searching with QueryExtender;164
12.5.1;Problem;164
12.5.2;Solution;164
12.5.3;How It Works;170
12.6;4-6. Retrieving a Derived Type Using an EntityDataSource Control;171
12.6.1;Problem;171
12.6.2;Solution;171
12.6.3;How It Works;174
12.7;4-7. Filtering with ASP.NET’s URL Routing;174
12.7.1;Problem;174
12.7.2;Solution;174
12.7.3;How It Works;177
12.8;4-8. Building CRUD Operations with an ObjectDataSource Control;178
12.8.1;Problem;178
12.8.2;Solution;178
12.8.3;How It Works;183
12.9;4-9. Using Entity Framework With MVC;184
12.9.1;Problem;184
12.9.2;Solution;184
12.9.3;How It Works;189
13;CHAPTER 5 Loading Entities and Navigation Properties;190
13.1;5-1. Loading Related Entities;190
13.1.1;Problem;190
13.1.2;Solution;190
13.1.3;How It Works;193
13.2;5-2. Loading a Complete Object Graph;195
13.2.1;Problem;195
13.2.2;Solution;195
13.2.3;How It Works;197
13.3;5-3. Loading Navigation Properties on Derived Types;197
13.3.1;Problem;197
13.3.2;Solution;198
13.3.3;How It Works;199
13.4;5-4. Using Include() with Other LINQ Query Operators;200
13.4.1;Problem;200
13.4.2;Solution;200
13.4.3;How It Works;201
13.5;5-5. Deferred Loading of Related Entities;202
13.5.1;Problem;202
13.5.2;Solution;202
13.5.3;How It Works;204
13.6;5-6. Filtering and Ordering Related Entities;204
13.6.1;Problem;204
13.6.2;Solution;205
13.6.3;How It Works;206
13.7;5-7. Executing Aggregate Operations on Related Entities;207
13.7.1;Problem;207
13.7.2;Solution;207
13.7.3;How It Works;209
13.8;5-8. Testing Whether an Entity Reference or Entity Collection Is Loaded;209
13.8.1;Problem;209
13.8.2;Solution;209
13.8.3;How It Works;211
13.9;5-9. Loading Related Entities Explicitly;211
13.9.1;Problem;211
13.9.2;Solution;211
13.9.3;How It Works;213
13.10;5-10. Filtering an Eagerly Loaded Entity Collection;215
13.10.1;Problem;215
13.10.2;Solution;215
13.10.3;How It Works;216
13.11;5-11. Using Relationship Span;217
13.11.1;Problem;217
13.11.2;Solution;217
13.11.3;How It Works;219
13.12;5-12. Modifying Foreign Key Associations;219
13.12.1;Problem;219
13.12.2;Solution;219
13.12.3;How It Works;222
14;CHAPTER 6 Beyond the Basics with Modeling and Inheritance;224
14.1;6-1. Retrieving the Link Table in a Many-to-Many Association;224
14.1.1;Problem;224
14.1.2;Solution;224
14.1.3;How It Works;226
14.2;6-2. Exposing a Link Table as an Entity;227
14.2.1;Problem;227
14.2.2;Solution;227
14.2.3;How It Works;230
14.3;6-3. Modeling a Many-to-Many, Self-Referencing Relationship;231
14.3.1;Problem;231
14.3.2;Solution;231
14.3.3;How It Works;232
14.4;6-4. Modeling a Self-Referencing Relationship Using Table per Hierarchy Inheritance;235
14.4.1;Problem;235
14.4.2;Solution;235
14.4.3;How It Works;237
14.5;6-5. Modeling a Self-Referencing Relationship and Retrieving a Complete Hierarchy;239
14.5.1;Problem;239
14.5.2;Solution;239
14.5.3;How It Works;242
14.6;6-6. Mapping Null Conditions in Derived Entities;243
14.6.1;Problem;243
14.6.2;Solution;243
14.6.3;How It Works;244
14.7;6-7. Modeling Table per Type Inheritance Using a Non-Primary Key Column;246
14.7.1;Problem;246
14.7.2;Solution;246
14.7.3;How It Works;250
14.8;6-8. Modeling Nested Table per Hierarchy Inheritance;251
14.8.1;Problem;251
14.8.2;Solution;251
14.8.3;How It Works;253
14.9;6-9. Limiting the Values Assigned to a Foreign Key;255
14.9.1;Problem;255
14.9.2;Solution;255
14.9.3;How It Works;257
14.10;6-10. Applying Conditions in Table per Type Inheritance;259
14.10.1;Problem;259
14.10.2;Solution;259
14.10.3;How It Works;261
14.11;6-11. Creating a Filter on Multiple Criteria;262
14.11.1;Problem;262
14.11.2;Solution;262
14.11.3;How It Works;264
14.12;6-12. Using Complex Conditions with Table per Hierarchy Inheritance;267
14.12.1;Problem;267
14.12.2;Solution;268
14.12.3;How It Works;270
14.13;6-13. Modeling Table per Concrete Type Inheritance;273
14.13.1;Problem;273
14.13.2;Solution;273
14.13.3;How It Works;275
14.14;6-14. Applying Conditions on a Base Entity;277
14.14.1;Problem;277
14.14.2;Solution;277
14.14.3;How It Works;279
14.15;6-15. Creating Independent and Foreign Key Associations;281
14.15.1;Problem;281
14.15.2;Solution;281
14.15.3;How It Works;282
14.16;6-16. Changing an Independent Association into a Foreign Key Association;282
14.16.1;Problem;282
14.16.2;Solution;283
14.16.3;How It Works;284
15;CHAPTER 7 Working with Object Services;286
15.1;7-1. Dynamically Building a Connection String;286
15.1.1;Problem;286
15.1.2;Solution;286
15.1.3;How It Works;287
15.2;7-2. Reading a Model from a Database;288
15.2.1;Problem;288
15.2.2;Solution;288
15.2.3;How It Works;291
15.3;7-3. Deploying a Model;292
15.3.1;Problem;292
15.3.2;Solution;292
15.3.3;How It Works;292
15.4;7-4. Using the Pluralization Service;293
15.4.1;Problem;293
15.4.2;Solution;293
15.4.3;How It Works;295
15.5;7-5. Retrieving Entities from the Object State Manager;296
15.5.1;Problem;296
15.5.2;Solution;296
15.5.3;How It Works;298
15.6;7-6. Generating a Model from the Command Line;298
15.6.1;Problem;298
15.6.2;Solution;298
15.6.3;How It Works;299
15.7;7-7. Working with Dependent Entities in an Identifying Relationship;299
15.7.1;Problem;299
15.7.2;Solution;299
15.7.3;How It Works;302
15.8;7-8. Inserting Entities Using an Object Context;302
15.8.1;Problem;302
15.8.2;Solution;302
15.8.3;How It Works;304
16;CHAPTER 8 Plain Old CLR Objects;305
16.1;8-1. Using POCO;305
16.1.1;Problem;305
16.1.2;Solution;305
16.1.3;How It Works;310
16.2;8-2. Loading Related Entities With POCO;310
16.2.1;Problem;310
16.2.2;Solution;310
16.2.3;How It Works;313
16.3;8-3. Lazy Loading With POCO;313
16.3.1;Problem;313
16.3.2;Solution;314
16.3.3;How It Works;316
16.4;8-4. POCO With Complex Type Properties;317
16.4.1;Problem;317
16.4.2;Solution;317
16.4.3;How It Works;319
16.5;8-5. Notifying Entity Framework About Object Changes;320
16.5.1;Problem;320
16.5.2;Solution;320
16.5.3;How It Works;322
16.6;8-6. Retrieving the Original (POCO) Object;323
16.6.1;Problem;323
16.6.2;Solution;323
16.6.3;How It Works;325
16.7;8-7. Manually Synchronizing the Object Graph and the Object State Manager;326
16.7.1;Problem;326
16.7.2;Solution;326
16.7.3;How It Works;329
16.8;8-8. Testing Domain Objects;330
16.8.1;Problem;330
16.8.2;Solution;330
16.8.3;How It Works;338
16.9;8-9. Testing a Repository Against a Database;339
16.9.1;Problem;339
16.9.2;Solution;339
16.9.3;How It Works;342
17;CHAPTER 9 Using the Entity Framework in N-Tier Applications;344
17.1;9-1. Deleting an Entity When Disconnected;344
17.1.1;Problem;344
17.1.2;Solution;344
17.1.3;How It Works;347
17.2;9-2. Managing Concurrency When Disconnected;348
17.2.1;Problem;348
17.2.2;Solution;348
17.2.3;How It Works;351
17.3;9-3. Finding Out What Has Changed;352
17.3.1;Problem;352
17.3.2;Solution;352
17.3.3;How It Works;355
17.4;9-4. Using POCO With WCF;356
17.4.1;Problem;356
17.4.2;Solution;356
17.4.3;How It Works;361
17.5;9-5. Using Self-Tracking Entities With WCF;362
17.5.1;Problem;362
17.5.2;Solution;362
17.5.3;How It Works;366
17.6;9-6. Validating Self-Tracking Entities;367
17.6.1;Problem;367
17.6.2;Solution;367
17.6.3;How It Works;371
17.7;9-7. Using Self-Tracking Entities on the Server Side;371
17.7.1;Problem;371
17.7.2;Solution;371
17.7.3;How It Works;377
17.8;9-8. Serializing Proxies in a WCF Service;378
17.8.1;Problem;378
17.8.2;Solution;378
17.8.3;How It Works;382
17.9;9-9. Serializing Self-Tracking Entities in the ViewState;382
17.9.1;Problem;382
17.9.2;Solution;382
17.9.3;How It Works;386
17.10;9-10. Fixing Duplicate References on a WCF Client;387
17.10.1;Problem;387
17.10.2;Solution;387
17.10.3;How It Works;390
18;CHAPTER 10 Stored Procedures;392
18.1;10-1. Returning an Entity Collection;392
18.1.1;Problem;392
18.1.2;Solution;392
18.1.3;How It Works;394
18.2;10-2. Returning Output Parameters;395
18.2.1;Problem;395
18.2.2;Solution;395
18.2.3;How It Works;398
18.3;10-3. Returning a Scalar Value Result Set;398
18.3.1;Problem;398
18.3.2;Solution;398
18.3.3;How It Works;400
18.4;10-4. Returning a Complex Type from a Stored Procedure;400
18.4.1;Problem;400
18.4.2;Solution;400
18.4.3;How It Works;402
18.5;10-5. Defining a Custom Function in the Storage Model;403
18.5.1;Problem;403
18.5.2;Solution;403
18.5.3;How It Works;405
18.6;10-6. Populating Entities in a Table per Type Inheritance Model;406
18.6.1;Problem;406
18.6.2;Solution;406
18.6.3;How It Works;408
18.7;10-7. Populating Entities in a Table per Hierarchy Inheritance Model;409
18.7.1;Problem;409
18.7.2;Solution;409
18.7.3;How It Works;411
18.8;10-8. Mapping the Insert, Update, and Delete Actions to Stored Procedures;412
18.8.1;Problem;412
18.8.2;Solution;412
18.8.3;How It Works;414
18.9;10-9. Using Stored Procedures for the Insert and Delete Actions in a Many-to-Many Association;415
18.9.1;Problem;415
18.9.2;Solution;416
18.9.3;How It Works;420
18.10;10-10. Mapping the Insert, Update, and Delete Actions to Stored Procedures for Table per Hierarchy Inheritance;420
18.10.1;Problems;420
18.10.2;Solution;420
18.10.3;How It Works;424
19;CHAPTER 11 Functions;426
19.1;11-1. Returning a Scalar Value from a Model Defined Function;426
19.1.1;Problem;426
19.1.2;Solution;426
19.1.3;How It Works;429
19.2;11-2. Filtering an Entity Collection Using a Model Defined Function;430
19.2.1;Problem;430
19.2.2;Solution;430
19.2.3;How It Works;433
19.3;11-3. Returning a Computed Column from a Model Defined Function;434
19.3.1;Problem;434
19.3.2;Solution;434
19.3.3;How It Works;437
19.4;11-4. Calling a Model Defined Function from a Model Defined Function;437
19.4.1;Problem;437
19.4.2;Solution;437
19.4.3;How It Works;441
19.5;11-5. Returning an Anonymous Type From a Model Difined Function;441
19.5.1;Problem;441
19.5.2;Solution;441
19.5.3;How It Works;444
19.6;11-6. Returning a Complex Type From a Model Defined Function;445
19.6.1;Problem;445
19.6.2;Solution;445
19.6.3;How It Works;448
19.7;11-7. Returning a Collection of Entity References From a Model Defined Function;448
19.7.1;Problem;448
19.7.2;Solution;448
19.7.3;How It Works;450
19.8;11-8. Using Canonical Functions in eSQL;451
19.8.1;Problem;451
19.8.2;Solution;451
19.8.3;How It Works;452
19.9;11-9. Using Canonical Functions in LINQ;452
19.9.1;Problem;452
19.9.2;Solution;452
19.9.3;How It Works;454
19.10;11-10. Calling Database Functions in eSQL;455
19.10.1;Problem;455
19.10.2;Solution;455
19.10.3;How It Works;457
19.11;11-11. Calling Database Functions in LINQ;457
19.11.1;Problem;457
19.11.2;Solution;457
19.11.3;How It Works;458
19.12;11-12. Defining Built-in Functions;458
19.12.1;Problem;458
19.12.2;Solution;459
19.12.3;How It Works;461
20;CHAPTER 12 Customizing Entity Framework Objects;462
20.1;12-1. Executing Code When SaveChanges() Is Called;462
20.1.1;Problem;462
20.1.2;Solution;462
20.1.3;How It Works;464
20.2;12-2. Validating Property Changes;465
20.2.1;Problem;465
20.2.2;Solution;465
20.2.3;How It Works;467
20.3;12-3. Logging Database Connections;468
20.3.1;Problem;468
20.3.2;Solution;468
20.3.3;How It Works;470
20.4;12-4. Recalculating a Property Value When an Entity Collection Changes;470
20.4.1;Problem;470
20.4.2;Solution;470
20.4.3;How It Works;472
20.5;12-5. Automatically Deleting Related Entities;473
20.5.1;Problem;473
20.5.2;Solution;473
20.5.3;How It Works;476
20.6;12-6. Deleting All Related Entities;476
20.6.1;Problem;476
20.6.2;Solution;477
20.6.3;How It Works;480
20.7;12-7. Assigning Default Values;480
20.7.1;Problem;480
20.7.2;Solution;480
20.7.3;How It Works;483
20.8;12-8. Retrieving the Original Value of a Property;484
20.8.1;Problem;484
20.8.2;Solution;484
20.8.3;How It Works;486
20.9;12-9. Retrieving the Original Association for Independent Associations;487
20.9.1;Problem;487
20.9.2;Solution;487
20.9.3;How It Works;490
20.10;12-10. Retrieving XML;490
20.10.1;Problem;490
20.10.2;Solution;490
20.10.3;How It Works;493
20.11;12-11. Applying Server-Generated Values to Properties;493
20.11.1;Problem;493
20.11.2;Solution;493
20.11.3;How It Works;497
20.12;12-12. Validating Entities on SavingChanges;497
20.12.1;Problem;497
20.12.2;Solution;497
20.12.3;How It Works;502
21;CHAPTER 13 Improving Performance;504
21.1;13-1. Optimizing Queries in a Table per Type Inheritance Model;504
21.1.1;Problem;504
21.1.2;Solution;504
21.1.3;How It Works;505
21.2;13-2. Retrieving a Single Entity Using an Entity Key;506
21.2.1;Problem;506
21.2.2;Solution;506
21.2.3;How It Works;507
21.3;13-3. Retrieving Entities for Read Only;508
21.3.1;Problem;508
21.3.2;Solution;508
21.3.3;How It Works;509
21.4;13-4. Improving the Startup Time;510
21.4.1;Problem;510
21.4.2;Solution;510
21.4.3;How It Works;511
21.5;13-5. Efficiently Building a Search Query;512
21.5.1;Problem;512
21.5.2;Solution;513
21.5.3;How It Works;514
21.6;13-6. Making Change Tracking with POCO Faster;515
21.6.1;Problem;515
21.6.2;Solution;515
21.6.3;How It Works;518
21.7;13-7. Compiling LINQ Queries;518
21.7.1;Problem;518
21.7.2;Solution;518
21.7.3;How It Works;521
21.8;13-8. Returning Partially Filled Entities;522
21.8.1;Problem;522
21.8.2;Solution;522
21.8.3;How It Works;524
21.9;13-9. Moving an Expensive Property to Another Entity;524
21.9.1;Problem;524
21.9.2;Solution;524
21.9.3;How It Works;527
21.10;13-10. Avoiding Include;528
21.10.1;Problem;528
21.10.2;Solution;528
21.10.3;How It Works;530
21.11;13-11. Improving QueryView Performance;530
21.11.1;Problem;530
21.11.2;Solution;530
21.11.3;How It Works;532
21.12;13-12. Generating Proxies Explicitly;533
21.12.1;Problem;533
21.12.2;Solution;533
21.12.3;How It Works;535
21.13;13-13. Preventing the Update of All Columns in Self-Tracking Entities;536
21.13.1;Problem;536
21.13.2;Solution;536
21.13.3;How It Works;540
22;CHAPTER 14 Concurrency;541
22.1;14-1. Applying Optimistic Concurrency;541
22.1.1;Problem;541
22.1.2;Solution;541
22.1.3;How It Works;543
22.2;14-2. Managing Concurrency When Using Stored Procedures;544
22.2.1;Problem;544
22.2.2;Solution;544
22.2.3;How It Works;548
22.3;14-3. Reading Uncommitted Data;548
22.3.1;Problem;548
22.3.2;Solution;548
22.3.3;How It Works;550
22.4;14-4. Implementing the “Last Record Wins” Strategy;550
22.4.1;Problem;550
22.4.2;Solution;550
22.4.3;How It Works;552
22.5;14-5. Getting Affected Rows from a Stored Procedure;552
22.5.1;Problem;552
22.5.2;Solution;553
22.5.3;How It Works;556
22.6;14-6. Optimistic Concurrency with Table Per Type Inheritance;556
22.6.1;Problem;556
22.6.2;Solution;556
22.6.3;How It Works;559
22.7;14-7. Generating a Timestamp Column with Model First;559
22.7.1;Problem;559
22.7.2;Solution;559
22.7.3;How It Works;560
23;CHAPTER 15 Advanced Modeling;561
23.1;15-1. Creating an Association on a Derived Entity;561
23.1.1;Problem;561
23.1.2;Solution;561
23.1.3;How It Works;563
23.2;15-2. Mapping an Entity to Customized Parts of One or More Tables;564
23.2.1;Problem;564
23.2.2;Solution;564
23.2.3;How It Works;566
23.3;15-3. Creating Conditional Associations;568
23.3.1;Problem;568
23.3.2;Solution;568
23.3.3;How It Works;573
23.4;15-4. Fabricating Additional Inheritance Hierarchies;574
23.4.1;Problem;574
23.4.2;Solution;574
23.4.3;How It Works;577
23.5;15-5. Sharing Audit Fields Across Multiple Entities;579
23.5.1;Problem;579
23.5.2;Solution;579
23.5.3;How It Works;583
23.6;15-6. Modeling a Many-to-Many Relationship with Payload;585
23.6.1;Problem;585
23.6.2;Solution;585
23.6.3;How It Works;587
23.7;15-7. Mapping a Foreign Key Column to Multiple Associations;588
23.7.1;Problem;588
23.7.2;Solution;589
23.7.3;How It Works;594
23.8;15-8. Using Inheritance to Map a Foreign Key Column to Multiple Associations;596
23.8.1;Problem;596
23.8.2;Solution;596
23.8.3;How It Works;599
23.9;15-9. Creating Read-only and Computed Properties;600
23.9.1;Problem;600
23.9.2;Solution;600
23.9.3;How It Works;606
23.10;15-10. Mapping an Entity to Multiple Tables;608
23.10.1;Problem;608
23.10.2;Solution;608
23.10.3;How It Works;609
23.11;15-11. Mapping an Entity to Multiple Entity Sets (MEST);610
23.11.1;Problem;610
23.11.2;Solution;610
23.11.3;How It Works;615
23.12;15-12. Extending Table per Type with Table per Hierarchy;617
23.12.1;Problem;617
23.12.2;Solution;617
23.12.3;How It Works;620
24;Index;622