book

Entity Framework Core in Action

Name: Entity Framework Core in Action
Author: Jon Smith
ISBN: 9781617294563

by Jon Smith

August 2018

Intermediate to advanced

520 pages

15h 18m

English

Manning Publications

Read now

Unlock full access

Titlepage
Copyright
preface
acknowledgments
about this book
Who should read this book How this book is organizedAbout the codeCode conventionsBook forumOnline resources
about the author
about the cover illustration
Part 1: Getting started
Chapter 1: Introduction to Entity FrameworkCore
1.1 What you’ll learn from this book1.2 My “lightbulb moment” with Entity Framework1.3 Some words for existing EF6.x developers1.4 An overview of EF Core1.4.1 The downsides of O/RMs1.5 What about NoSQL?1.6 Your first EF Core application1.6.1 What you need to install1.6.2 Creating your own .NET Core console app with EF Core1.7 The database that MyFirstEfCoreApp will access1.8 Setting up the MyFirstEfCoreApp applicationThe classes that map to the database—Book and Author 1.8.2 The application’s DbContext1.9 Looking under the hood of EF Core1.9.1 Modeling the database1.9.2 Reading data from the database1.9.3 Updating the database1.10 Should you use EF Core in your next project?1.10.1 Latest generation1.10.2 Multiplatform and open source1.10.3 Rapid development1.10.4 Well supported1.10.5 Access to NuGet libraries1.10.6 Fully featured O/RM1.10.7 Stable library1.10.8 Always high-performance1.11 When should you not use EF Core?Summary
Chapter 2: Querying the database
2.1 Setting the scene—our book-selling site2.1.1 The book app’s relational database2.1.2 Other relationship types not covered in this chapter2.1.3 The final database showing all the tables 2.1.4 The classes that EF Core maps to the database2.2 Creating the application’s DbContext 2.2.1 Defining the application’s DbContext: EfCoreContext2.2.2 Creating an instance of the application’s DbContext2.2.3 Creating a database for your own application2.3 Understanding database queries2.3.1 Application’s DbContext property access2.3.2 A series of LINQ/EF Core commands2.3.3 The execute command2.4 Loading related data2.4.1 Eager loading: loading relationships with the primary entity class2.4.2 Explicit loading: loading relationships after the primary entity class2.4.3 Select loading: loading specific parts of primary entity class and any relationships2.5 Using client vs. server evaluation: moving part of your query into software2.5.1 Creating the display string of a book’s authors 2.5.2 Understanding the limitations of client vs. server evaluation2.6 Building complex queries2.6.1 Building the book list query by using select loading2.6.2 Introducing the architecture of the book app2.7 Adding sorting, filtering, and paging2.7.1 Sorting books by price, publication date, and customer ratings2.7.2 Filtering books by publication year and customer ratings2.7.3 Paging the books in the list2.8 Putting it all together: combining query objectsSummary

Chapter 3: Changing the database content
3.1 Introducing EF Core’s entity State3.2 Creating new rows in a table 3.2.1 Creating a single entity on its own3.2.2 Creating a book with a review3.3 Updating database rows 3.3.1 Handling disconnected updates in a web application3.4 Handling relationships in updates3.4.1 Principal and dependent relationships3.4.2 Updating one-to-one relationships—adding a PriceOffer to a book3.4.3 Updating one-to-many relationships—adding a review to a book3.4.4 Updating many-to-many relationships—changing a book’s authors3.4.5 Advanced feature—updating relationships via foreign keys3.5 Deleting entities3.5.1 Using a soft delete—using model-level query filters to “hide” entities3.5.2 Deleting a dependent-only entity—no relationships3.5.3 Deleting a principal entity that has relationshipsSummary
Chapter 4: Using EF Core in business logic
4.1 Why is business logic so different from other code? 4.2 Our business need—processing an order for books 4.2.1 The business rules that you need to implement4.3 Using a design pattern to help implement business logic4.3.1 Five guidelines for building business logic that uses EF Core4.4 Implementing the business logic for processing an order4.4.1 Guideline 1: Business logic has first call on defining the database structure4.4.2 Guideline 2: Business logic should have no distractions4.4.3 Guideline 3: Business logic should think it’s working on in-memory data4.4.4 Guideline 4: Isolate the database access code into a separate project4.4.5 Guideline 5: Business logic shouldn’t call EF Core’s SaveChanges 4.4.6 Putting it all together—calling the order-processing business logic4.4.7 Any disadvantages of this business logic pattern?4.5 Placing an order on the book app4.6 Adding extra features to your business logic handling4.6.1 Validating the data that you write to the database4.6.2 Using transactions to daisy-chain a sequence of business logic codeSummary
Chapter 5: Using EF Core in ASP.NET Core web applications
5.1 Introducing ASP.NET Core5.2 Understanding the architecture of the book app5.3 Understanding dependency injection5.3.1 Why you need to learn about DI in ASP.NET Core5.3.2 A basic example of dependency injection in ASP.NET Core5.3.3 The lifetime of a service created by DI5.4 Making the application’s DbContext available via DI5.4.1 Providing information on the database’s location5.4.2 Registering your application’s DbContext with the DI provider5.5 Calling your database access code from ASP.NET Core5.5.1 A summary of how ASP.NET Core works and the terms it uses5.5.2 Where does the EF Core code live in the book app? 5.6 Implementing the book list query page5.7 Implementing your database methods as a DI service5.7.1 Registering your class as a DI service5.7.2 Injecting ChangePubDateService into the ASP.NET action method5.7.3 Improving registering your database access classes as services5.8 Deploying an ASP.NET Core application with a database 5.8.1 Knowing where the database is on the web server5.8.2 Creating and migrating the database5.9 Using EF Core’s Migrate to change the database structure 5.9.1 Updating your production database5.9.2 Having your application migrate your database on startup5.10 Using async/await for better scalability5.10.1 Why async/await is useful in a web application using EF Core5.10.2 Where should you use async/await with database accesses?5.10.3 Changing over to async/await versions of EF Core commands5.11 Running parallel tasks: how to provide the DbContext5.11.1 Other ways of obtaining a new instance of the application’s DbContextSummary
Part 2: Entity Framework in depth
Chapter 6: Configuring nonrelational properties
6.1 Three ways of configuring EF Core6.2 A worked example of configuring EF Core6.3 Configuring By Convention 6.3.1 Conventions for entity classes6.3.2 Conventions for parameters in an entity class6.3.3 Conventions for name, type, and size6.3.4 By Convention, the nullability of a property is based on .NET type6.3.5 An EF Core naming convention identifies primary keys6.4 Configuring via Data Annotations6.4.1 System.ComponentModel.DataAnnotations 6.4.2 System.ComponentModel.DataAnnotations.Schema6.5 Configuring via the Fluent API6.5.1 A better way to structure your Fluent API commands6.6 Excluding properties and classes from the database6.6.1 Excluding a class or property via Data Annotations6.6.2 Excluding a class or property via the Fluent API6.7 Configuring model-level query filters6.8 Setting database column type, size, and nullability6.9 The different ways of configuring the primary key6.9.1 Configuring a primary key via Data Annotations6.9.2 Configuring a primary key via the Fluent API6.10 Adding indexes to database columns6.11 Configuring the naming on the database side6.11.1 Configuring table names 6.11.2 Configuring the schema name, and schema groupings6.11.3 Configuring the database column names in a table6.12 Using specific database-provider Fluent API commands6.13 Recommendations for using EF Core’s configuration6.13.1 Use By Convention configuration first—its quick and easy6.13.2 Use validation Data Annotations wherever possible6.13.3 Use the Fluent API for anything else6.14 Shadow properties—hide column data inside EF Core6.14.1 Configuring shadow properties6.14.2 Accessing shadow properties6.15 Backing fields—controlling access to data in an entity class6.15.1 Creating a simple backing field accessed by a read/write property6.15.2 Configuring backing fieldsSummary
Chapter 7: Configuring relationships
7.1 Defining some relationship terms7.2 What navigational properties do you need?7.3 Configuring relationships7.4 Configuring relationships By Convention7.4.1 What makes a class an entity class?7.4.2 An example of an entity class with navigational properties7.4.3 How EF Core finds foreign keys By Convention7.4.4 Nullability of foreign keys—required or optional relationships7.4.5 Foreign keys—what happens if you leave them out?7.4.6 When does By Convention configuration not work?7.5 Configuring relationships by using Data Annotations7.5.1 The ForeignKey Data Annotation7.5.2 The InverseProperty Data Annotation7.6 Fluent API relationship configuration commands7.6.1 Creating a one-to-one relationship7.6.2 Creating a one-to-many relationship 7.6.3 Creating a many-to-many relationship 7.7 Additional methods available in Fluent API relationships7.7.1 OnDelete—changing the delete action of a dependent entity7.7.2 IsRequired—defining the nullability of the foreign key 7.7.3 HasPrincipalKey—using an alternate unique key7.7.4 Less-used options in Fluent API relationships 7.8 Alternative ways of mapping entities to database tables7.8.1 Owned types—adding a normal class into an entity class7.8.2 Table per hierarchy—placing inherited classes into one table7.8.3 Table splitting—mapping multiple entity classes to the same tableSummary
Chapter 8: Configuring advanced features and handling concurrency conflicts
8.1 Advanced feature—using backing fields with relationships8.1.1 The problem—the book app performance is too slow8.1.2 Our solution—IEnumerable<Review> property and a backing field8.2 DbFunction—using user-defined functions with EF Core8.2.1 Configuring a scalar user-defined function8.2.2 Adding your UDF code to the database8.2.3 Using a registered scalar UDF in your database queries8.3 Computed column—a dynamically calculated column value8.4 Setting a default value for a database column8.4.1 Adding a constant as a default constraint 8.4.2 Adding an SQL fragment as a default constraint8.4.3 Creating a value generator to generate a default value dynamically8.5 Sequences—providing numbers in a strict order8.6 Marking database-generated properties8.6.1 Marking a column that’s generated on an addition or update8.6.2 Marking a column’s value as set on insert of a new row8.6.3 Marking a column as “normal”8.7 Handling simultaneous updates—concurrency conflicts8.7.1 Why do concurrency conflicts matter?8.7.2 EF Core’s concurrency conflict–handling features8.7.3 Handling a DbUpdateConcurrencyException8.7.4 The disconnected concurrent update issueSummary
Chapter 9: Going deeper into the DbContext
9.1 Overview of the DbContext class’s properties9.2 Understanding how EF Core tracks changes9.3 Details on every command that changes an entity’s State9.3.1 The Add command--inserting a new row in the database 9.3.2 The Remove command—deleting a row from the database 9.3.3 Modifying a tracked entity—EF Core’s DetectChanges9.3.4 INotifyPropertyChanged entities—a different way of tracking changes9.3.5 The Update method—telling EF Core that everything has changed9.3.6 The Attach method—changing an untracked entity into a tracked entity9.3.7 Setting the State of an entity directly9.3.8 TrackGraph—handling disconnected updates with relationships9.4 Using ChangeTracker to detect changes9.5 Using raw SQL commands in EF Core9.5.1 FromSql—adding raw SQL to an EF Core query 9.5.2 ExecuteSqlCommand—executing a nonquery command9.5.3 Reload—useful after an ExecuteSqlCommand 9.5.4 GetDbConnection—calling database access commands 9.6 Using Context.Model to access EF Core’s view of the database9.6.1 Using the Model property to build a fast database wipe method9.7 Handling database connection problems9.7.1 Handling database transactions with EF Core’s execution strategy 9.7.2 Altering or writing your own execution strategySummary
Part 3: Using Entity Framework Core in real-world applications
Chapter 10: Useful software patterns for EF Core applications
10.1 Another look at the separation-of-concerns principle10.2 Using patterns to speed development of database access10.3 Speed up query development—use a LINQ mapper10.4 Domain-driven-design database repository10.4.1 Example Book DDD entity and repository10.4.2 How the DDD design changes the business logic design10.4.3 Impressions from building this DDD design10.5 Is the Repository pattern useful with Entity Framework? 10.5.1 Some forms of Repository patterns to avoid10.6 Splitting a database across multiple DbContexts10.6.1 Creating DbContexts that contain only a subset of entities/tables10.6.2 Passing data between bounded contexts10.7 Data validation and error-handling patterns10.7.1 Data validation to your entity classes makes for better error feedback10.7.2 Business logic should contain checks and return a list of all errors10.7.3 Catching database server errors and providing user-friendly feedbackSummary
Chapter 11: Handling database migrations
11.1 Part 1—EF Core methods to change the database schema11.1.1 A view of what databases need updating11.2 Code-first: using EF Core’s migrations 11.2.1 Stage 1: creating a migration—building the code for migration 11.2.2 Stage 2: applying migrations—updating a database schema11.2.3 Undoing a migration—Remove-Migration or update command11.3 Database-first: creating a DbContext from a database11.3.1 How to alter or edit the output from the scaffold command11.3.2 The limitations of the reverse-engineering feature11.4 SQL-first: using SQL change scripts to change the schema11.4.1 Using an SQL comparison tool to build an SQL change script11.4.2 Using EfSchemaCompare to check your SQL matches EF Core’s model11.5 Part 2—Issues around a database schema change11.5.1 Applying nonbreaking changes while the current app is running11.5.2 Applying breaking database changes by stopping the application11.5.3 Handling breaking database changes when you can’t stop the appSummary
Chapter 12: EF Core performance tuning
12.1 Part 1—Deciding which performance issues to fix12.1.1 “Don’t performance tune too early” doesn’t mean you stop thinking12.1.2 How do you decide what’s slow and needs performance tuning?12.1.3 The cost of finding and fixing performance issues12.2 Part 2—Techniques for diagnosing a performance issue12.2.1 Stage 1: get a good overview—measuring the user’s experience12.2.2 Stage 2: find all the database code involved in the feature you’re tuning12.2.3 Stage 3: inspecting the SQL code to find poor performance 12.2.4 Techniques for finding database scalability issues12.3 Part 3—Techniques for fixing performance issues12.4 Using good patterns makes your application perform well12.4.1 Using Select loading to load only the columns you need12.4.2 Using paging and/or filtering of searches to reduce the rows you load12.4.3 A warning that using lazy loading will affect database performance12.4.4 Always adding the AsNoTracking method to read-only queries12.4.5 Using the async version of EF Core commands to improve scalability12.4.6 Ensuring that your database access code is isolated/decoupled12.5 Performance antipatterns—database access12.5.1 Not minimizing the number of calls to the database12.5.2 Calling SaveChanges multiple times12.5.3 Allowing too much of a data query to be moved into the software side12.5.4 Not replacing suboptimal SQL translations with user-defined functions12.5.5 Not precompiling queries that are used frequently12.5.6 Expecting EF Core to build the best SQL database commands12.5.7 Not using the Find method when an entity might be already loaded12.5.8 Missing indexes from a property that you want to search on12.5.9 Mismatching column data types12.6 Performance antipatterns—software12.6.1 Making DetectChanges work too hard12.6.2 Startup issue: using one large DbContext12.7 Performance patterns—scalability of database accesses12.7.1 Using pooling to reduce the cost of a new application’s DbContext12.7.2 Async/await—adding scalability, with small effect on speed12.7.3 Helping your database scalability by making your queries simple 12.7.4 Picking the right architecture for applications that need high scalabilitySummary
Chapter 13: A worked example of performance tuning
13.1 Part 1a—Making sure a single query performs well13.1.1 Analyzing the book list query to see potential performance issues13.1.2 Turning the book’s Votes display into a client-side calculation13.2 Part 1b—Improving the query by adding a DbFunction13.2.1 Looking at the updated query13.2.2 Ensuring that the query sorting and filtering are performing well13.3 Part 2—Converting EF Core commands to SQL queries13.3.1 Introducing Dapper13.3.2 Rewriting MapBookToDto and associated EF queries using Dapper13.4 Part 3—Modifying the database to increase performance13.4.1 Creating an ActualPrice property—changing the promotion process13.4.2 Caching the book review values, and not letting them get out-of-date 13.4.3 Calculating AuthorsString when a book is first created13.4.4 Analyzing the changes—Is the performance gain worth the effort?13.5 Comparing parts 1a, 1b, 2, and 313.6 Database scalability—what can you do to improve that?Summary
Chapter 14: Different database types and EF Core services
14.1 What differences do other database server types bring?14.1.1 Creating an instance of the application’s DbContext for MySQL14.1.2 What you have to do to convert the SQL Server application to MySQL14.1.3 Looking at other database server types and differences14.1.4 Summarizing EF Core’s ability to work with multiple database types14.2 Developing a CQRS architecture application with EF Core14.2.1 Implementation of a two-database CQRS architecture application14.2.2 How the parts of the CQRS solution interact with each other 14.2.3 Finding book view changes—Part 1, finding the correct state and key14.2.4 Finding the book view changes—Part 2, building the correct State14.2.5 Why the CQRS solution is less likely to have out-of-date cached values14.2.6 Is the two-database CQRS architecture worth the effort?14.3 Accessing and changing EF Core services14.3.1 Accessing an EF Core service to help in your own application14.3.2 Replacing an EF Core service with your own modified service14.4 Accessing command-line tools from software14.4.1 How to access EF Core design-time services14.4.2 How to use design-time services to build the EfSchemaCompare toolSummary
Chapter 15: Unit testing EF Core applications
15.1 Introduction—our unit test setup15.1.1 The test environment—the xUnit unit test library15.1.2 A library I’ve created to help with unit testing EF Core applications15.2 Simulating the database when testing EF Core applications15.2.1 The options you have for simulating the database15.2.2 Choosing between an in-memory or real database for unit testing15.3 Getting your application’s DbContext ready for unit testing15.3.1 The application’s DbContext options are provided via its constructor15.3.2 Setting an application’s DbContext options via OnConfiguring 15.4 Simulating a database—using an in-memory database 15.5 Using a real database in your unit tests15.5.1 How to set up a real database for unit testing15.5.2 Running unit tests in parallel—uniquely named databases15.5.3 Tips on how to speed up the database creation stage of a unit test15.5.4 How to handle databases in which you’ve added extra SQL code15.6 Unit testing a disconnected state update properly15.7 Mocking a database repository pattern15.8 Capturing EF Core logging information in unit testing15.8.1 Using logging to help you build SQL change scripts15.9 Using the EfSchemaCompare tool in your unit tests15.9.1 Features and options for the EfSchemaCompare toolSummary
appendix A: A brief introduction to LINQ
A.1 An introduction to the LINQ languageA.1.1 The two ways you can write LINQ queriesA.1.2 The data operations you can do with LINQA.2 Introduction to IQueryable<T> type, and why it’s usefulA.2.1 Splitting up a complex LINQ query by using the IQueryable<T> typeA.2.2 How EF Core translates IQueryable<T> into database codeA.3 Querying an EF Core database by using LINQSummary
appendix B: Early information on EF Core version 2.1
B.1 What does the 2.1 in the EF Core release number mean?B.2 Brand-new featuresB.2.1 Lazy loading—loading relationships when you need themB.2.2 Parameters in entity class constructorsB.2.3 Value conversion—defining the mapping of value types to the databaseB.2.4 Data seeding—adding initial data to a new/updated databaseB.2.5 Query types—using non-entity classes in read-only queriesB.2.6 Include derived types when using table per hierarchyB.2.7 Ability to link to entity class state change eventsB.2.8 Supporting NoSQL—Cosmos NoSQL Database provider (preview)B.3 Improvements to existing featuresB.3.1 LINQ GroupBy translation to SQL GROUP BY commandB.3.2 Optimization of correlated subqueries—the N + 1 SQL query problemB.3.3 .NET Core global tools—installing design-time tools locallyB.3.4 Column ordering in database now follows entity-class property orderB.3.5 System.Transactions support B.3.6 Specifying an owned type via an attributeSummary
Index

Content preview from Entity Framework Core in Action

9 Going deeper into the DbContext

This chapter covers

How EF Core detects changes to an entity
Using change tracking to build an audit trail
Using raw SQL commands from EF Core
Inspecting EF Core’s database model
Using EF Core’s database connection resiliency

So far in this book, you’ve seen a wide range of EF Core commands available to you. This chapter digs deeper into the properties and methods available in the application’s DbContext. In some cases, I provide a more detailed explanation of commands in chapter 3, such as the Add, Update, and Delete methods. I also introduce methods that haven’t been covered, such as Attach and TrackGraph, that give you options on how to change the database data.

The EF Core’s DbContext class has a ...

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

Entity Framework Core in Action, Second Edition

Publisher Resources

ISBN: 9781617294563Publisher Support Publisher Website Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Entity Framework Core in Action

by Jon Smith

9 Going deeper into the DbContext

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.