Entity Framework Core in Action, Second Edition, Video Edition

Table of contents

1. Part 1. Getting started
2. Chapter 1. Introduction to Entity Framework Core
3. Chapter 1. My “lightbulb moment” with Entity Framework
4. Chapter 1. Some words for existing EF6.x developers
5. Chapter 1. An overview of EF Core
6. Chapter 1. What about NoSQL?
7. Chapter 1. Your first EF Core application
8. Chapter 1. The database that MyFirstEfCoreApp will access
9. Chapter 1. Setting up the MyFirstEfCoreApp application
10. Chapter 1. Looking under the hood of EF Core
11. Chapter 1. The stages of development of EF Core
12. Chapter 1. Should you use EF Core in your next project?
13. Chapter 1. When should you not use EF Core?
14. Chapter 1. Summary
15. Chapter 2. Querying the database
16. Chapter 2. Creating the application’s DbContext
17. Chapter 2. Understanding database queries
18. Chapter 2. Loading related data
19. Chapter 2. Using client vs. server evaluation: Adapting data at the last stage of a query
20. Chapter 2. Building complex queries
21. Chapter 2. Introducing the architecture of the Book App
22. Chapter 2. Adding sorting, filtering, and paging
23. Chapter 2. Putting it all together: Combining Query Objects
24. Chapter 2. Summary
25. Chapter 3. Changing the database content
26. Chapter 3. Creating new rows in a table
27. Chapter 3. Updating database rows
28. Chapter 3. Handling relationships in updates
29. Chapter 3. Deleting entities
30. Chapter 3. Summary
31. Chapter 4. Using EF Core in business logic
32. Chapter 4. Complex business logic example: Processing an order for books
33. Chapter 4. Using a design pattern to implement complex business logic
34. Chapter 4. Implementing the business logic for processing an order
35. Chapter 4. Simple business logic example: ChangePriceOfferService
36. Chapter 4. Validation business logic example: Adding review to a book, with checks
37. Chapter 4. Adding extra features to your business logic handling
38. Chapter 4. Summary
39. Chapter 5. Using EF Core in ASP.NET Core web applications
40. Chapter 5. Understanding the architecture of the Book App
41. Chapter 5. Understanding dependency injection
42. Chapter 5. Making the application’s DbContext available via DI
43. Chapter 5. Calling your database access code from ASP.NET Core
44. Chapter 5. Implementing the book list query page
45. Chapter 5. Implementing your database methods as a DI service
46. Chapter 5. Deploying an ASP.NET Core application with a database
47. Chapter 5. Using EF Core’s migration feature to change the database’s structure
48. Chapter 5. Using async/await for better scalability
49. Chapter 5. Running parallel tasks: How to provide the DbContext
50. Chapter 5. Summary
51. Chapter 6. Tips and techniques for reading and writing with EF Core
52. Chapter 6. Writing to the database with EF Core
53. Chapter 6. Summary
54. Part 2. Entity Framework in depth
55. Chapter 7. Configuring nonrelational properties
56. Chapter 7. A worked example of configuring EF Core
57. Chapter 7. Configuring by convention
58. Chapter 7. Configuring via Data Annotations
59. Chapter 7. Configuring via the Fluent API
60. Chapter 7. Excluding properties and classes from the database
61. Chapter 7. Setting database column type, size, and nullability
62. Chapter 7. Value conversions: Changing data to/from the database
63. Chapter 7. The different ways of configuring the primary key
64. Chapter 7. Adding indexes to database columns
65. Chapter 7. Configuring the naming on the database side
66. Chapter 7. Configuring Global Query Filters
67. Chapter 7. Applying Fluent API commands based on the database provider type
68. Chapter 7. Shadow properties: Hiding column data inside EF Core
69. Chapter 7. Backing fields: Controlling access to data in an entity class
70. Chapter 7. Recommendations for using EF Core’s configuration
71. Chapter 7. Summary
72. Chapter 8. Configuring relationships
73. Chapter 8. What navigational properties do you need?
74. Chapter 8. Configuring relationships
75. Chapter 8. Configuring relationships By Convention
76. Chapter 8. Configuring relationships by using Data Annotations
77. Chapter 8. Fluent API relationship configuration commands
78. Chapter 8. Controlling updates to collection navigational properties
79. Chapter 8. Additional methods available in Fluent API relationships
80. Chapter 8. Alternative ways of mapping entities to database tables
81. Chapter 8. Summary
82. Chapter 9. Handling database migrations
83. Chapter 9. Understanding the complexities of changing your application’s database
84. Chapter 9. Part 1: Introducing the three approaches to creating a migration
85. Chapter 9. Creating a migration by using EF Core’s add migration command
86. Chapter 9. Editing an EF Core migration to handle complex situations
87. Chapter 9. Using SQL scripts to build migrations
88. Chapter 9. Using EF Core’s reverse-engineering tool
89. Chapter 9. Part 2: Applying your migrations to a database
90. Chapter 9. Migrating a database while the application is running
91. Chapter 9. Summary
92. Chapter 10. Configuring advanced features and handling concurrency conflicts
93. Chapter 10. Computed column: A dynamically calculated column value
94. Chapter 10. Setting a default value for a database column
95. Chapter 10. Sequences: Providing numbers in a strict order
96. Chapter 10. Marking database-generated properties
97. Chapter 10. Handling simultaneous updates: Concurrency conflicts
98. Chapter 10. Summary
99. Chapter 11. Going deeper into the DbContext
100. Chapter 11. Understanding how EF Core tracks changes
101. Chapter 11. Looking at commands that change an entity’s State
102. Chapter 11. SaveChanges and its use of ChangeTracker.DetectChanges
103. Chapter 11. Using SQL commands in an EF Core application
104. Chapter 11. Accessing information about the entity classes and database tables
105. Chapter 11. Dynamically changing the DbContext’s connection string
106. Chapter 11. Handling database connection problems
107. Chapter 11. Summary
108. Part 3. Using Entity Framework Core in real-world applications
109. Chapter 12. Using entity events to solve business problems
110. Chapter 12. Defining where domain events and integration events are useful
111. Chapter 12. Where might you use events with EF Core?
112. Chapter 12. Implementing a domain event system with EF Core
113. Chapter 12. Implementing an integration event system with EF Core
114. Chapter 12. Improving the domain event and integration event implementations
115. Chapter 12. Summary
116. Chapter 13. Domain-Driven Design and other architectural approaches
117. Chapter 13. The Book App’s evolving architecture
118. Chapter 13. Introduction to DDD at the entity class level
119. Chapter 13. Altering the Book App entities to follow the DDD approach
120. Chapter 13. Using your DDD-styled entity classes in your application
121. Chapter 13. The downside of DDD entities: Too many access methods
122. Chapter 13. Getting around performance issues in DDD-styled entities
123. Chapter 13. Three architectural approaches: Did they work?
124. Chapter 13. Summary
125. Chapter 14. EF Core performance tuning
126. Chapter 14. Part 2: Techniques for diagnosing a performance issue
127. Chapter 14. Part 3: Techniques for fixing performance issues
128. Chapter 14. Using good patterns makes your application perform well
129. Chapter 14. Performance antipatterns: Database queries
130. Chapter 14. Performance antipatterns: Writes
131. Chapter 14. Performance patterns: Scalability of database accesses
132. Chapter 14. Summary
133. Chapter 15. Master class on performance-tuning database queries
134. Chapter 15. Good LINQ approach: Using an EF Core Select query
135. Chapter 15. LINQ+UDFs approach: Adding some SQL to your LINQ code
136. Chapter 15. SQL+Dapper: Creating your own SQL
137. Chapter 15. LINQ+caching approach: Precalculating costly query parts
138. Chapter 15. Comparing the four performance approaches with development effort
139. Chapter 15. Improving database scalability
140. Chapter 15. Summary
141. Chapter 16. Cosmos DB, CQRS, and other database types
142. Chapter 16. Introduction to Cosmos DB and its EF Core provider
143. Chapter 16. Building a Command and Query Responsibility Segregation (CQRS) system using Cosmos DB
144. Chapter 16. The design of a two-database CQRS architecture application
145. Chapter 16. Understanding the structure and data of a Cosmos DB account
146. Chapter 16. Displaying books via Cosmos DB
147. Chapter 16. Was using Cosmos DB worth the effort? Yes!
148. Chapter 16. Differences in other database types
149. Chapter 16. Summary
150. Chapter 17. Unit testing EF Core applications
151. Chapter 17. Getting your application’s DbContext ready for unit testing
152. Chapter 17. Three ways to simulate the database when testing EF Core applications
153. Chapter 17. Choosing between a production-type database and an SQLite in-memory database
154. Chapter 17. Using a production-type database in your unit tests
155. Chapter 17. Using an SQLite in-memory database for unit testing
156. Chapter 17. Stubbing or mocking an EF Core database
157. Chapter 17. Unit testing a Cosmos DB database
158. Chapter 17. Seeding a database with test data to test your code correctly
159. Chapter 17. Solving the problem of one database access breaking another stage of your test
160. Chapter 17. Capturing the database commands sent to a database
161. Chapter 17. Summary
162. Appendix. A brief introduction to LINQ
163. Appendix. Introduction to IQueryable type, and why it’s useful
     1. Appendix. Querying an EF Core database by using LINQ