book

Entity Framework Core in Action, Second Edition

Name: Entity Framework Core in Action, Second Edition
Author: Jon Smith
ISBN: 9781617298363

by Jon Smith

June 2021

Intermediate to advanced

624 pages

20h 35m

English

Manning Publications

Read now

Unlock full access

Entity Framework Core in Action
Copyright
Praise for the first edition
contents
front matter
forewordprefaceacknowledgmentsabout this bookWho should read this book?How this book is organizedAbout the codeCode conventionsliveBook discussion forumOnline resourcesabout the authorabout the cover illustration
Part 1 Getting started
1 Introduction to Entity Framework Core
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 application1.8.1 The classes that map to the database: Book and Author1.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 The stages of development of EF Core1.11 Should you use EF Core in your next project?1.11.1 .NET is the future software platform, and it’s fast!1.11.2 Open source and open communication1.11.3 Multiplatform applications and development1.11.4 Rapid development and good features1.11.5 Well supported1.11.6 Always high-performance1.12 When should you not use EF Core?Summary
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 database showing all the tables2.1.4 The classes that EF Core maps to the database2.2 Creating the application’s DbContext2.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.3.4 The two types of database queries2.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.4.4 Lazy loading: Loading relationships as required2.5 Using client vs. server evaluation: Adapting data at the last stage of a query2.6 Building complex queries2.7 Introducing the architecture of the Book App2.8 Adding sorting, filtering, and paging2.8.1 Sorting books by price, publication date, and customer ratings2.8.2 Filtering books by publication year, categories, and customer ratings2.8.3 Other filtering options: Searching text for a specific string2.8.4 Paging the books in the list2.9 Putting it all together: Combining Query ObjectsSummary
3 Changing the database content
3.1 Introducing EF Core’s entity State3.2 Creating new rows in a table3.2.1 Creating a single entity on its own3.2.2 Creating a book with a review3.3 Updating database rows3.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 a many-to-many relationship3.4.5 Advanced feature: Updating relationships via foreign keys3.5 Deleting entities3.5.1 Soft-delete approach: Using a global query filter to hide entities3.5.2 Deleting a dependent-only entity with no relationships3.5.3 Deleting a principal entity that has relationships3.5.4 Deleting a book with its dependent relationshipsSummary
4 Using EF Core in business logic
4.1 The questions to ask and the decisions you need to make before you start coding4.1.1 The three levels of complexity of your business logic code4.2 Complex business logic example: Processing an order for books4.3 Using a design pattern to implement complex 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 that 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 SaveChanges4.4.6 Putting it all together: Calling the order-processing business logic4.4.7 Placing an order in the Book App4.4.8 The pros and cons of the complex business logic pattern4.5 Simple business logic example: ChangePriceOfferService4.5.1 My design approach for simple business logic4.5.2 Writing the ChangePriceOfferService code4.5.3 The pros and cons of this business logic pattern4.6 Validation business logic example: Adding review to a book, with checks4.6.1 The pros and cons of this business logic pattern4.7 Adding extra features to your business logic handling4.7.1 Validating the data that you write to the database4.7.2 Using transactions to daisy-chain a sequence of business logic code4.7.3 Using the RunnerTransact2WriteDb classSummary

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.3.4 Special considerations for Blazor Server applications5.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.4.3 Registering a DbContext Factory with the DI provider5.5 Calling your database access code from ASP.NET Core5.5.1 A summary of how ASP.NET Core MVC 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.6.1 Injecting an instance of the application’s DbContext via DI5.6.2 Using the DbContext Factory to create an instance of a DbContext5.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 database5.8.1 Knowing where the database is on the web server5.8.2 Creating and migrating the database5.9 Using EF Core’s migration feature to change the database’s structure5.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 Obtaining an instance of your application’s DbContext to run in parallel5.11.2 Running a background service in ASP.NET Core5.11.3 Other ways of obtaining a new instance of the application’s DbContextSummary
6 Tips and techniques for reading and writing with EF Core
6.1 Reading from the database6.1.1 Exploring the relational fixup stage in a query6.1.2 Understanding what AsNoTracking and its variant do6.1.3 Reading in hierarchical data efficiently6.1.4 Understanding how the Include method works6.1.5 Making loading navigational collections fail-safe6.1.6 Using Global Query Filters in real-world situations6.1.7 Considering LINQ commands that need special attention6.1.8 Using AutoMapper to automate building Select queries6.1.9 Evaluating how EF Core creates an entity class when reading data in6.2 Writing to the database with EF Core6.2.1 Evaluating how EF Core writes entities/relationships to the database6.2.2 Evaluating how DbContext handles writing out entities/relationships6.2.3 A quick way to copy data with relationships6.2.4 A quick way to delete an entitySummary
Part 2 Entity Framework in depth
7 Configuring nonrelational properties
7.1 Three ways of configuring EF Core7.2 A worked example of configuring EF Core7.3 Configuring by convention7.3.1 Conventions for entity classes7.3.2 Conventions for parameters in an entity class7.3.3 Conventions for name, type, and size7.3.4 By convention, the nullability of a property is based on .NET type7.3.5 An EF Core naming convention identifies primary keys7.4 Configuring via Data Annotations7.4.1 Using annotations from System.ComponentModel.DataAnnotations7.4.2 Using annotations from System.ComponentModel.DataAnnotations.Schema7.5 Configuring via the Fluent API7.6 Excluding properties and classes from the database7.6.1 Excluding a class or property via Data Annotations7.6.2 Excluding a class or property via the Fluent API7.7 Setting database column type, size, and nullability7.8 Value conversions: Changing data to/from the database7.9 The different ways of configuring the primary key7.9.1 Configuring a primary key via Data Annotations7.9.2 Configuring a primary key via the Fluent API7.9.3 Configuring an entity as read-only7.10 Adding indexes to database columns7.11 Configuring the naming on the database side7.11.1 Configuring table names7.11.2 Configuring the schema name and schema groupings7.11.3 Configuring the database column names in a table7.12 Configuring Global Query Filters7.13 Applying Fluent API commands based on the database provider type7.14 Shadow properties: Hiding column data inside EF Core7.14.1 Configuring shadow properties7.14.2 Accessing shadow properties7.15 Backing fields: Controlling access to data in an entity class7.15.1 Creating a simple backing field accessed by a read/write property7.15.2 Creating a read-only column7.15.3 Concealing a person’s date of birth: Hiding data inside a class7.15.4 Configuring backing fields7.16 Recommendations for using EF Core’s configuration7.16.1 Use By Convention configuration first7.16.2 Use validation Data Annotations wherever possible7.16.3 Use the Fluent API for anything else7.16.4 Automate adding Fluent API commands by class/property signaturesSummary
8 Configuring relationships
8.1 Defining some relationship terms8.2 What navigational properties do you need?8.3 Configuring relationships8.4 Configuring relationships By Convention8.4.1 What makes a class an entity class?8.4.2 An example of an entity class with navigational properties8.4.3 How EF Core finds foreign keys By Convention8.4.4 Nullability of foreign keys: Required or optional dependent relationships8.4.5 Foreign keys: What happens if you leave them out?8.4.6 When does By Convention configuration not work?8.5 Configuring relationships by using Data Annotations8.5.1 The ForeignKey Data Annotation8.5.2 The InverseProperty Data Annotation8.6 Fluent API relationship configuration commands8.6.1 Creating a one-to-one relationship8.6.2 Creating a one-to-many relationship8.6.3 Creating a many-to-many relationship8.7 Controlling updates to collection navigational properties8.8 Additional methods available in Fluent API relationships8.8.1 OnDelete: Changing the delete action of a dependent entity8.8.2 IsRequired: Defining the nullability of the foreign key8.8.3 HasPrincipalKey: Using an alternate unique key8.8.4 Less-used options in Fluent API relationships8.9 Alternative ways of mapping entities to database tables8.9.1 Owned types: Adding a normal class into an entity class8.9.2 Table per hierarchy (TPH): Placing inherited classes into one table8.9.3 Table per Type (TPT): Each class has its own table8.9.4 Table splitting: Mapping multiple entity classes to the same table8.9.5 Property bag: Using a dictionary as an entity classSummary
9 Handling database migrations
9.1 How this chapter is organized9.2 Understanding the complexities of changing your application’s database9.2.1 A view of what databases need updating9.2.2 Handling a migration that can lose data9.3 Part 1: Introducing the three approaches to creating a migration9.4 Creating a migration by using EF Core’s add migration command9.4.1 Requirements before running any EF Core migration command9.4.2 Running the add migration command9.4.3 Seeding your database via an EF Core migration9.4.4 Handling EF Core migrations with multiple developers9.4.5 Using a custom migration table to allow multiple DbContexts to one database9.5 Editing an EF Core migration to handle complex situations9.5.1 Adding and removing MigrationBuilder methods inside the migration class9.5.2 Adding SQL commands to a migration9.5.3 Adding your own custom migration commands9.5.4 Altering a migration to work for multiple database types9.6 Using SQL scripts to build migrations9.6.1 Using SQL database comparison tools to produce migration9.6.2 Handcoding SQL change scripts to migrate the database9.6.3 Checking that your SQL change scripts matches EF Core’s database model9.7 Using EF Core’s reverse-engineering tool9.7.1 Running EF Core’s reverse-engineering command9.7.2 Installing and running EF Core Power Tools reverse-engineering command9.7.3 Updating your entity classes and DbContext when the database changes9.8 Part 2: Applying your migrations to a database9.8.1 Calling EF Core’s Database.Migrate method from your main application9.8.2 Executing EF Core’s Database.Migrate method from a standalone application9.8.3 Applying an EF Core’s migration via an SQL change script9.8.4 Applying SQL change scripts by using a migration tool9.9 Migrating a database while the application is running9.9.1 Handling a migration that doesn’t contain an application-breaking change9.9.2 Handling application-breaking changes when you can’t stop the appSummary
10 Configuring advanced features and handling concurrency conflicts
10.1 DbFunction: Using user-defined functions (UDFs) with EF Core10.1.1 Configuring a scalar-valued UDF10.1.2 Configuring a table-valued UDF10.1.3 Adding your UDF code to the database10.1.4 Using a registered UDF in your database queries10.2 Computed column: A dynamically calculated column value10.3 Setting a default value for a database column10.3.1 Using the HasDefaultValue method to add a constant value for a column10.3.2 Using the HasDefaultValueSql method to add an SQL command for a column10.3.3 Using the HasValueGenerator method to assign a value generator to a property10.4 Sequences: Providing numbers in a strict order10.5 Marking database-generated properties10.5.1 Marking a column that’s generated on an addition or update10.5.2 Marking a column’s value as set on insert of a new row10.5.3 Marking a column/property as “normal”10.6 Handling simultaneous updates: Concurrency conflicts10.6.1 Why do concurrency conflicts matter?10.6.2 EF Core’s concurrency conflict-handling features10.6.3 Handling a DbUpdateConcurrencyException10.6.4 The disconnected concurrent update issueSummary
11 Going deeper into the DbContext
11.1 Overview of the DbContext class’s properties11.2 Understanding how EF Core tracks changes11.3 Looking at commands that change an entity’s State11.3.1 The Add command: Inserting a new row into the database11.3.2 The Remove method: Deleting a row from the database11.3.3 Modifying an entity class by changing the data in that entity class11.3.4 Modifying an entity class by calling the Update method11.3.5 The Attach method: Start tracking an existing untracked entity class11.3.6 Setting the State of an entity directly11.3.7 TrackGraph: Handling disconnected updates with relationships11.4 SaveChanges and its use of ChangeTracker.DetectChanges11.4.1 How SaveChanges finds all the State changes11.4.2 What to do if ChangeTracker.DetectChanges is taking too long11.4.3 Using the entities’ State within the SaveChanges method11.4.4 Catching entity class’s State changes via events11.4.5 Triggering events when SaveChanges/SaveChangesAsync is called11.4.6 EF Core interceptors11.5 Using SQL commands in an EF Core application11.5.1 FromSqlRaw/FromSqlInterpolated: Using SQL in an EF Core query11.5.2 ExecuteSqlRaw/ExecuteSqlInterpolated: Executing a nonquery command11.5.3 AsSqlQuery Fluent API method: Mapping entity classes to queries11.5.4 Reload: Used after ExecuteSql commands11.5.5 GetDbConnection: Running your own SQL commands11.6 Accessing information about the entity classes and database tables11.6.1 Using context.Entry(entity).Metadata to reset primary keys11.6.2 Using context.Model to get database information11.7 Dynamically changing the DbContext’s connection string11.8 Handling database connection problems11.8.1 Handling database transactions with EF Core’s execution strategy11.8.2 Altering or writing your own execution strategySummary
Part 3 Using Entity Framework Core in real-world applications
12 Using entity events to solve business problems
12.1 Using events to solve business problems12.1.1 Example of using domain events12.1.2 Example of integration events12.2 Defining where domain events and integration events are useful12.3 Where might you use events with EF Core?12.3.1 Pro: Follows the SoC design principle12.3.2 Pro: Makes database updates robust12.3.3 Con: Makes your application more complex12.3.4 Con: Makes following the flow of the code more difficult12.4 Implementing a domain event system with EF Core12.4.1 Create some domain events classes to be triggered12.4.2 Add code to the entity classes to hold the domain events12.4.3 Alter the entity class to detect a change to trigger an event on12.4.4 Create event handlers that are matched to the domain events12.4.5 Build an Event Runner that finds and runs the correct event handler12.4.6 Override SaveChanges and insert the Event Runner before SaveChanges is called12.4.7 Register the Event Runner and all the event handlers12.5 Implementing an integration event system with EF Core12.5.1 Building a service that communicates with the warehouse12.5.2 Overriding SaveChanges to handle the integration event12.6 Improving the domain event and integration event implementations12.6.1 Generalizing events: Running before, during, and after the call to SaveChanges12.6.2 Adding support for async event handlers12.6.3 Handling multiple event handers for the same event12.6.4 Handling event sagas in which one event kicks off another eventSummary
13 Domain-Driven Design and other architectural approaches
13.1 A good software architecture makes it easier to build and maintain your application13.2 The Book App’s evolving architecture13.2.1 Building a modular monolith to enforce the SoC principles13.2.2 Using DDD principles both architecturally and on the entity classes13.2.3 Applying a clean architecture as described by Robert C. Martin13.3 Introduction to DDD at the entity class level13.4 Altering the Book App entities to follow the DDD approach13.4.1 Changing the properties in the Book entity to read-only13.4.2 Updating the Book entity properties via methods in the entity class13.4.3 Controlling how the Book entity is created13.4.4 Understanding the differences between an entity and a value object13.4.5 Minimizing the relationships between entity classes13.4.6 Grouping entity classes13.4.7 Deciding when the business logic shouldn’t be run inside an entity13.4.8 Applying DDD’s bounded context to your application’s DbContext13.5 Using your DDD-styled entity classes in your application13.5.1 Calling the AddPromotion access method via a repository pattern13.5.2 Calling the AddPromotion access method via a class-to-method-call library13.5.3 Adding a Review to the Book entity class via a repository pattern13.5.4 Adding a Review to the Book entity class via a class-to-method-call library13.6 The downside of DDD entities: Too many access methods13.7 Getting around performance issues in DDD-styled entities13.7.1 Allow database code into your entity classes13.7.2 Make the Review constructor public and write nonentity code to add a Review13.7.3 Use domain events to ask an event handler to add a review to the database13.8 Three architectural approaches: Did they work?13.8.1 A modular monolith approach that enforces SoC by using projects13.8.2 DDD principles, both architecturally and on the entity classes13.8.3 Clean architecture as described by Robert C. MartinSummary
14 EF Core performance tuning
14.1 Part 1: Deciding which performance issues to fix14.1.1 “Don’t performance-tune too early” doesn’t mean you stop thinking14.1.2 How do you decide what’s slow and needs performance tuning?14.1.3 The cost of finding and fixing performance issues14.2 Part 2: Techniques for diagnosing a performance issue14.2.1 Stage 1: Get a good overview, measuring the user’s experience14.2.2 Stage 2: Find all the database code involved in the feature you’re tuning14.2.3 Stage 3: Inspect the SQL code to find poor performance14.3 Part 3: Techniques for fixing performance issues14.4 Using good patterns makes your application perform well14.4.1 Using Select loading to load only the columns you need14.4.2 Using paging and/or filtering of searches to reduce the rows you load14.4.3 Warning: Lazy loading will affect database performance14.4.4 Always adding the AsNoTracking method to read-only queries14.4.5 Using the async version of EF Core commands to improve scalability14.4.6 Ensuring that your database access code is isolated/decoupled14.5 Performance antipatterns: Database queries14.5.1 Antipattern: Not minimizing the number of calls to the database14.5.2 Antipattern: Missing indexes from a property that you want to search on14.5.3 Antipattern: Not using the fastest way to load a single entity14.5.4 Antipattern: Allowing too much of a data query to be moved into the software side14.5.5 Antipattern: Not moving calculations into the database14.5.6 Antipattern: Not replacing suboptimal SQL in a LINQ query14.5.7 Antipattern: Not precompiling frequently used queries14.6 Performance antipatterns: Writes14.6.1 Antipattern: Calling SaveChanges multiple times14.6.2 Antipattern: Making DetectChanges work too hard14.6.3 Antipattern: Not using HashSet<T> for navigational collection properties14.6.4 Antipattern: Using the Update method when you want to change only part of the entity14.6.5 Antipattern: Startup issue—Using one large DbContext14.7 Performance patterns: Scalability of database accesses14.7.1 Using pooling to reduce the cost of a new application’s DbContext14.7.2 Adding scalability with little effect on overall speed14.7.3 Helping your database scalability by making your queries simple14.7.4 Scaling up the database server14.7.5 Picking the right architecture for applications that need high scalabilitySummary
15 Master class on performance-tuning database queries
15.1 The test setup and a summary of the four performance approaches15.2 Good LINQ approach: Using an EF Core Select query15.3 LINQ+UDFs approach: Adding some SQL to your LINQ code15.4 SQL+Dapper: Creating your own SQL15.5 LINQ+caching approach: Precalculating costly query parts15.5.1 Adding a way to detect changes that affect the cached values15.5.2 Adding code to update the cached values15.5.3 Adding cache properties to the Book entity with concurrency handling15.5.4 Adding a checking/healing system to your event system15.6 Comparing the four performance approaches with development effort15.7 Improving database scalabilitySummary
16 Cosmos DB, CQRS, and other database types
16.1 The differences between relational and NoSQL databases16.2 Introduction to Cosmos DB and its EF Core provider16.3 Building a Command and Query Responsibility Segregation (CQRS) system using Cosmos DB16.4 The design of a two-database CQRS architecture application16.4.1 Creating an event to trigger when the SQL Book entity changes16.4.2 Adding events to the Book entity send integration events16.4.3 Using the EfCore.GenericEventRunner to override your BookDbContext16.4.4 Creating the Cosmos entity classes and DbContext16.4.5 Creating the Cosmos event handlers16.5 Understanding the structure and data of a Cosmos DB account16.5.1 The Cosmos DB structure as seen from EF Core16.5.2 How the CosmosClass is stored in Cosmos DB16.6 Displaying books via Cosmos DB16.6.1 Cosmos DB differences from relational databases16.6.2 Cosmos DB/EF Core difference: Migrating a Cosmos database16.6.3 EF Core 5 Cosmos DB database provider limitations16.7 Was using Cosmos DB worth the effort? Yes!16.7.1 Evaluating the performance of the two-database CQRS in the Book App16.7.2 Fixing the features that EF Core 5 Cosmos DB database provider couldn’t handle16.7.3 How difficult would it be to use this two-database CQRS design in your application?16.8 Differences in other database typesSummary
17 Unit testing EF Core applications
17.1 An introduction to the unit test setup17.1.1 The test environment: xUnit unit test library17.1.2 A library I created to help with unit testing EF Core applications17.2 Getting your application’s DbContext ready for unit testing17.2.1 The application’s DbContext options are provided via its constructor17.2.2 Setting an application’s DbContext options via OnConfiguring17.3 Three ways to simulate the database when testing EF Core applications17.4 Choosing between a production-type database and an SQLite in-memory database17.5 Using a production-type database in your unit tests17.5.1 Providing a connection string to the database to use for the unit test17.5.2 Providing a database per test class to allow xUnit to run tests in parallel17.5.3 Making sure that the database’s schema is up to date and the database is empty17.5.4 Mimicking the database setup that EF Core migration would deliver17.6 Using an SQLite in-memory database for unit testing17.7 Stubbing or mocking an EF Core database17.8 Unit testing a Cosmos DB database17.9 Seeding a database with test data to test your code correctly17.10 Solving the problem of one database access breaking another stage of your test17.10.1 Test code using ChangeTracker.Clear in a disconnected state17.10.2 Test code by using multiple DbContext instances in a disconnected state17.11 Capturing the database commands sent to a database17.11.1 Using the LogTo option extension to filter and capture EF Core logging17.11.2 Using the ToQueryString method to show the SQL generated from a LINQ querySummary
Appendix. 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 LINQ
index

Overview

Entity Framework Core in Action, Second Edition is an in-depth guide to reading and writing databases with EF Core. Revised from the bestselling original edition, it’s filled with over 100 diagrams, code snippets, and examples—including building and scaling your own bookselling web application. Learn from author Jon Smith’s extensive experience working with EF Core in production, as you discover time-saving patterns and best practices for security, performance tuning, and unit testing. All of the book’s code is available on GitHub.

About the Technology
Entity Framework radically simplifies data access in .NET applications. This easy-to-use object-relational mapper (ORM) lets you write database code in pure C#. It automatically maps classes to database tables and enables queries with standard LINQ commands. It even generates SQL, so you don’t have to!

About the Book
Entity Framework Core in Action, Second Edition teaches you to write flawless database interactions for .NET applications. Following relevant examples from author Jon Smith’s extensive experience, you’ll progress quickly from EF basics to advanced techniques. In addition to the latest EF features, this book addresses performance, security, refactoring, and unit testing. This updated edition also contains new material on NoSQL databases.

What's Inside

Configuring EF to define every table and column
Updating your schema as your app grows
Integrating EF with existing C# application
Writing and testing business logic for database access
Applying a Domain-Driven Design to EF Core
Getting the best performance out of EF Core

About the Reader
For .NET developers familiar with relational databases.

About the Author
Jon P. Smith is a freelance software developer and architect with a special focus on .NET and Azure.

Quotes
The most comprehensive reference for EF Core that does—or ever will—exist.
- Stephen Byrne, Intel Corporation

The definitive guide to EF Core. Filled with real world examples, it’s the most practical way to enhance your EF Core skill set.
- Paul Brown, Diversified Services Network

I firmly believe anyone using EF Core will find something to up their game in this book.
- Anne Epstein, Headspring

Remains a go-to resource for me while working with Entity Framework.
- Foster Haines, J2 Interactive

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

Publisher Resources

ISBN: 9781617298363Publisher Support Publisher Website Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills