001. Part 1. Getting started
002. Chapter 1. Introduction to Entity Framework Core
003. Chapter 1. My lightbulb moment with Entity Framework
004. Chapter 1. Some words for existing EF6.x developers
005. Chapter 1. An overview of EF Core
006. Chapter 1. What about NoSQL
007. Chapter 1. Your first EF Core application
008. Chapter 1. The database that MyFirstEfCoreApp will access
009. Chapter 1. Setting up the MyFirstEfCoreApp application
010. Chapter 1. Looking under the hood of EF Core
011. Chapter 1. The stages of development of EF Core
012. Chapter 1. Should you use EF Core in your next project
013. Chapter 1. When should you not use EF Core
014. Chapter 1. Summary
015. Chapter 2. Querying the database
016. Chapter 2. Creating the applications DbContext
017. Chapter 2. Understanding database queries
018. Chapter 2. Loading related data
019. Chapter 2. Using client vs. server evaluation Adapting data at the last stage of a query
020. Chapter 2. Building complex queries
021. Chapter 2. Introducing the architecture of the Book App
022. Chapter 2. Adding sorting, filtering, and paging
023. Chapter 2. Putting it all together Combining Query Objects
024. Chapter 2. Summary
025. Chapter 3. Changing the database content
026. Chapter 3. Creating new rows in a table
027. Chapter 3. Updating database rows
028. Chapter 3. Handling relationships in updates
029. Chapter 3. Deleting entities
030. Chapter 3. Summary
031. Chapter 4. Using EF Core in business logic
032. Chapter 4. Complex business logic example Processing an order for books
033. Chapter 4. Using a design pattern to implement complex business logic
034. Chapter 4. Implementing the business logic for processing an order
035. Chapter 4. Simple business logic example ChangePriceOfferService
036. Chapter 4. Validation business logic example Adding review to a book, with checks
037. Chapter 4. Adding extra features to your business logic handling
038. Chapter 4. Summary
039. Chapter 5. Using EF Core in ASP.NET Core web applications
040. Chapter 5. Understanding the architecture of the Book App
041. Chapter 5. Understanding dependency injection
042. Chapter 5. Making the applications DbContext available via DI
043. Chapter 5. Calling your database access code from ASP.NET Core
044. Chapter 5. Implementing the book list query page
045. Chapter 5. Implementing your database methods as a DI service
046. Chapter 5. Deploying an ASP.NET Core application with a database
047. Chapter 5. Using EF Cores migration feature to change the databases structure
048. Chapter 5. Using asyncawait for better scalability
049. Chapter 5. Running parallel tasks How to provide the DbContext
050. Chapter 5. Summary
051. Chapter 6. Tips and techniques for reading and writing with EF Core
052. Chapter 6. Writing to the database with EF Core
053. Chapter 6. Summary
054. Part 2. Entity Framework in depth
055. Chapter 7. Configuring nonrelational properties
056. Chapter 7. A worked example of configuring EF Core
057. Chapter 7. Configuring by convention
058. Chapter 7. Configuring via Data Annotations
059. Chapter 7. Configuring via the Fluent API
060. Chapter 7. Excluding properties and classes from the database
061. Chapter 7. Setting database column type, size, and nullability
062. Chapter 7. Value conversions Changing data tofrom the database
063. Chapter 7. The different ways of configuring the primary key
064. Chapter 7. Adding indexes to database columns
065. Chapter 7. Configuring the naming on the database side
066. Chapter 7. Configuring Global Query Filters
067. Chapter 7. Applying Fluent API commands based on the database provider type
068. Chapter 7. Shadow properties Hiding column data inside EF Core
069. Chapter 7. Backing fields Controlling access to data in an entity class
070. Chapter 7. Recommendations for using EF Cores configuration
071. Chapter 7. Summary
072. Chapter 8. Configuring relationships
073. Chapter 8. What navigational properties do you need
074. Chapter 8. Configuring relationships
075. Chapter 8. Configuring relationships By Convention
076. Chapter 8. Configuring relationships by using Data Annotations
077. Chapter 8. Fluent API relationship configuration commands
078. Chapter 8. Controlling updates to collection navigational properties
079. Chapter 8. Additional methods available in Fluent API relationships
080. Chapter 8. Alternative ways of mapping entities to database tables
081. Chapter 8. Summary
082. Chapter 9. Handling database migrations
083. Chapter 9. Understanding the complexities of changing your applications database
084. Chapter 9. Part 1 Introducing the three approaches to creating a migration
085. Chapter 9. Creating a migration by using EF Cores add migration command
086. Chapter 9. Editing an EF Core migration to handle complex situations
087. Chapter 9. Using SQL scripts to build migrations
088. Chapter 9. Using EF Cores reverse-engineering tool
089. Chapter 9. Part 2 Applying your migrations to a database
090. Chapter 9. Migrating a database while the application is running
091. Chapter 9. Summary
092. Chapter 10. Configuring advanced features and handling concurrency conflicts
093. Chapter 10. Computed column A dynamically calculated column value
094. Chapter 10. Setting a default value for a database column
095. Chapter 10. Sequences Providing numbers in a strict order
096. Chapter 10. Marking database-generated properties
097. Chapter 10. Handling simultaneous updates Concurrency conflicts
098. Chapter 10. Summary
099. 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 entitys 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 DbContexts 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 Apps 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 applications 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 IQueryableT type, and why its useful
164. Appendix. Querying an EF Core database by using LINQ
