Entity Framework Core in Action [2 ed.] 1617298360, 9781617298363

Table of contents :
Entity Framework Core in Action
contents
foreword
preface
acknowledgments
about this book
Who should read this book?
How this book is organized
About the code
Code conventions
liveBook discussion forum
Online resources
about the author
about the cover illustration
Part 1—Getting started
1 Introduction to Entity Framework Core
1.1 What you’ll learn from this book
1.2 My “lightbulb moment” with Entity Framework
1.3 Some words for existing EF6.x developers
1.4 An overview of EF Core
1.4.1 The downsides of O/RMs
1.5 What about NoSQL?
1.6 Your first EF Core application
1.6.1 What you need to install
1.6.2 Creating your own .NET Core console app with EF Core
1.7 The database that MyFirstEfCoreApp will access
1.8 Setting up the MyFirstEfCoreApp application
1.8.1 The classes that map to the database: Book and Author
1.8.2 The application’s DbContext
1.9 Looking under the hood of EF Core
1.9.1 Modeling the database
1.9.2 Reading data from the database
1.9.3 Updating the database
1.10 The stages of development of EF Core
1.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 communication
1.11.3 Multiplatform applications and development
1.11.4 Rapid development and good features
1.11.5 Well supported
1.11.6 Always high-performance
1.12 When should you not use EF Core?
Summary
2 Querying the database
2.1 Setting the scene: Our book-selling site
2.1.1 The Book App’s relational database
2.1.2 Other relationship types not covered in this chapter
2.1.3 The database showing all the tables
2.1.4 The classes that EF Core maps to the database
2.2 Creating the application’s DbContext
2.2.1 Defining the application’s DbContext: EfCoreContext
2.2.2 Creating an instance of the application’s DbContext
2.2.3 Creating a database for your own application
2.3 Understanding database queries
2.3.1 Application’s DbContext property access
2.3.2 A series of LINQ/EF Core commands
2.3.3 The execute command
2.3.4 The two types of database queries
2.4 Loading related data
2.4.1 Eager loading: Loading relationships with the primary entity class
2.4.2 Explicit loading: Loading relationships after the primary entity class
2.4.3 Select loading: Loading specific parts of primary entity class and any relationships
2.4.4 Lazy loading: Loading relationships as required
2.5 Using client vs. server evaluation: Adapting data at the last stage of a query
2.6 Building complex queries
2.7 Introducing the architecture of the Book App
2.8 Adding sorting, filtering, and paging
2.8.1 Sorting books by price, publication date, and customer ratings
2.8.2 Filtering books by publication year, categories, and customer ratings
2.8.3 Other filtering options: Searching text for a specific string
2.8.4 Paging the books in the list
2.9 Putting it all together: Combining Query Objects
Summary
3 Changing the database content
3.1 Introducing EF Core’s entity State
3.2 Creating new rows in a table
3.2.1 Creating a single entity on its own
3.2.2 Creating a book with a review
3.3 Updating database rows
3.3.1 Handling disconnected updates in a web application
3.4 Handling relationships in updates
3.4.1 Principal and dependent relationships
3.4.2 Updating one-to-one relationships: Adding a PriceOffer to a book
3.4.3 Updating one-to-many relationships: Adding a review to a book
3.4.4 Updating a many-to-many relationship
3.4.5 Advanced feature: Updating relationships via foreign keys
3.5 Deleting entities
3.5.1 Soft-delete approach: Using a global query filter to hide entities
3.5.2 Deleting a dependent-only entity with no relationships
3.5.3 Deleting a principal entity that has relationships
3.5.4 Deleting a book with its dependent relationships
Summary
4 Using EF Core in business logic
4.1 The questions to ask and the decisions you need to make before you start coding
4.1.1 The three levels of complexity of your business logic code
4.2 Complex business logic example: Processing an order for books
4.3 Using a design pattern to implement complex business logic
4.3.1 Five guidelines for building business logic that uses EF Core
4.4 Implementing the business logic for processing an order
4.4.1 Guideline 1: Business logic has first call on defining the database structure
4.4.2 Guideline 2: Business logic should have no distractions
4.4.3 Guideline 3: Business logic should think that it’s working on in-memory data
4.4.4 Guideline 4: Isolate the database access code into a separate project
4.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 logic
4.4.7 Placing an order in the Book App
4.4.8 The pros and cons of the complex business logic pattern
4.5 Simple business logic example: ChangePriceOfferService
4.5.1 My design approach for simple business logic
4.5.2 Writing the ChangePriceOfferService code
4.5.3 The pros and cons of this business logic pattern
4.6 Validation business logic example: Adding review to a book, with checks
4.6.1 The pros and cons of this business logic pattern
4.7 Adding extra features to your business logic handling
4.7.1 Validating the data that you write to the database
4.7.2 Using transactions to daisy-chain a sequence of business logic code
4.7.3 Using the RunnerTransact2WriteDb class
Summary
5 Using EF Core in ASP.NET Core web applications
5.1 Introducing ASP.NET Core
5.2 Understanding the architecture of the Book App
5.3 Understanding dependency injection
5.3.1 Why you need to learn about DI in ASP.NET Core
5.3.2 A basic example of dependency injection in ASP.NET Core
5.3.3 The lifetime of a service created by DI
5.3.4 Special considerations for Blazor Server applications
5.4 Making the application’s DbContext available via DI
5.4.1 Providing information on the database’s location
5.4.2 Registering your application’s DbContext with the DI provider
5.4.3 Registering a DbContext Factory with the DI provider
5.5 Calling your database access code from ASP.NET Core
5.5.1 A summary of how ASP.NET Core MVC works and the terms it uses
5.5.2 Where does the EF Core code live in the Book App?
5.6 Implementing the book list query page
5.6.1 Injecting an instance of the application’s DbContext via DI
5.6.2 Using the DbContext Factory to create an instance of a DbContext
5.7 Implementing your database methods as a DI service
5.7.1 Registering your class as a DI service
5.7.2 Injecting ChangePubDateService into the ASP.NET action method
5.7.3 Improving registering your database access classes as services
5.8 Deploying an ASP.NET Core application with a database
5.8.1 Knowing where the database is on the web server
5.8.2 Creating and migrating the database
5.9 Using EF Core’s migration feature to change the database’s structure
5.9.1 Updating your production database
5.9.2 Having your application migrate your database on startup
5.10 Using async/await for better scalability
5.10.1 Why async/await is useful in a web application using EF Core
5.10.2 Where should you use async/await with database accesses?
5.10.3 Changing over to async/await versions of EF Core commands
5.11 Running parallel tasks: How to provide the DbContext
5.11.1 Obtaining an instance of your application’s DbContext to run in parallel
5.11.2 Running a background service in ASP.NET Core
5.11.3 Other ways of obtaining a new instance of the application’s DbContext
Summary
6 Tips and techniques for reading and writing with EF Core
6.1 Reading from the database
6.1.1 Exploring the relational fixup stage in a query
6.1.2 Understanding what AsNoTracking and its variant do
6.1.3 Reading in hierarchical data efficiently
6.1.4 Understanding how the Include method works
6.1.5 Making loading navigational collections fail-safe
6.1.6 Using Global Query Filters in real-world situations
6.1.7 Considering LINQ commands that need special attention
6.1.8 Using AutoMapper to automate building Select queries
6.1.9 Evaluating how EF Core creates an entity class when reading data in
6.2 Writing to the database with EF Core
6.2.1 Evaluating how EF Core writes entities/relationships to the database
6.2.2 Evaluating how DbContext handles writing out entities/relationships
6.2.3 A quick way to copy data with relationships
6.2.4 A quick way to delete an entity
Summary
Part 2—Entity Framework in depth
7 Configuring nonrelational properties
7.1 Three ways of configuring EF Core
7.2 A worked example of configuring EF Core
7.3 Configuring by convention
7.3.1 Conventions for entity classes
7.3.2 Conventions for parameters in an entity class
7.3.3 Conventions for name, type, and size
7.3.4 By convention, the nullability of a property is based on .NET type
7.3.5 An EF Core naming convention identifies primary keys
7.4 Configuring via Data Annotations
7.4.1 Using annotations from System.ComponentModel.DataAnnotations
7.4.2 Using annotations from System.ComponentModel.DataAnnotations.Schema
7.5 Configuring via the Fluent API
7.6 Excluding properties and classes from the database
7.6.1 Excluding a class or property via Data Annotations
7.6.2 Excluding a class or property via the Fluent API
7.7 Setting database column type, size, and nullability
7.8 Value conversions: Changing data to/from the database
7.9 The different ways of configuring the primary key
7.9.1 Configuring a primary key via Data Annotations
7.9.2 Configuring a primary key via the Fluent API
7.9.3 Configuring an entity as read-only
7.10 Adding indexes to database columns
7.11 Configuring the naming on the database side
7.11.1 Configuring table names
7.11.2 Configuring the schema name and schema groupings
7.11.3 Configuring the database column names in a table
7.12 Configuring Global Query Filters
7.13 Applying Fluent API commands based on the database provider type
7.14 Shadow properties: Hiding column data inside EF Core
7.14.1 Configuring shadow properties
7.14.2 Accessing shadow properties
7.15 Backing fields: Controlling access to data in an entity class
7.15.1 Creating a simple backing field accessed by a read/write property
7.15.2 Creating a read-only column
7.15.3 Concealing a person’s date of birth: Hiding data inside a class
7.15.4 Configuring backing fields
7.16 Recommendations for using EF Core’s configuration
7.16.1 Use By Convention configuration first
7.16.2 Use validation Data Annotations wherever possible
7.16.3 Use the Fluent API for anything else
7.16.4 Automate adding Fluent API commands by class/property signatures
Summary
8 Configuring relationships
8.1 Defining some relationship terms
8.2 What navigational properties do you need?
8.3 Configuring relationships
8.4 Configuring relationships By Convention
8.4.1 What makes a class an entity class?
8.4.2 An example of an entity class with navigational properties
8.4.3 How EF Core finds foreign keys By Convention
8.4.4 Nullability of foreign keys: Required or optional dependent relationships
8.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 Annotations
8.5.1 The ForeignKey Data Annotation
8.5.2 The InverseProperty Data Annotation
8.6 Fluent API relationship configuration commands
8.6.1 Creating a one-to-one relationship
8.6.2 Creating a one-to-many relationship
8.6.3 Creating a many-to-many relationship
8.7 Controlling updates to collection navigational properties
8.8 Additional methods available in Fluent API relationships
8.8.1 OnDelete: Changing the delete action of a dependent entity
8.8.2 IsRequired: Defining the nullability of the foreign key
8.8.3 HasPrincipalKey: Using an alternate unique key
8.8.4 Less-used options in Fluent API relationships
8.9 Alternative ways of mapping entities to database tables
8.9.1 Owned types: Adding a normal class into an entity class
8.9.2 Table per hierarchy (TPH): Placing inherited classes into one table
8.9.3 Table per Type (TPT): Each class has its own table
8.9.4 Table splitting: Mapping multiple entity classes to the same table
8.9.5 Property bag: Using a dictionary as an entity class
Summary
9 Handling database migrations
9.1 How this chapter is organized
9.2 Understanding the complexities of changing your application’s database
9.2.1 A view of what databases need updating
9.2.2 Handling a migration that can lose data
9.3 Part 1: Introducing the three approaches to creating a migration
9.4 Creating a migration by using EF Core’s add migration command
9.4.1 Requirements before running any EF Core migration command
9.4.2 Running the add migration command
9.4.3 Seeding your database via an EF Core migration
9.4.4 Handling EF Core migrations with multiple developers
9.4.5 Using a custom migration table to allow multiple DbContexts to one database
9.5 Editing an EF Core migration to handle complex situations
9.5.1 Adding and removing MigrationBuilder methods inside the migration class
9.5.2 Adding SQL commands to a migration
9.5.3 Adding your own custom migration commands
9.5.4 Altering a migration to work for multiple database types
9.6 Using SQL scripts to build migrations
9.6.1 Using SQL database comparison tools to produce migration
9.6.2 Handcoding SQL change scripts to migrate the database
9.6.3 Checking that your SQL change scripts matches EF Core’s database model
9.7 Using EF Core’s reverse-engineering tool
9.7.1 Running EF Core’s reverse-engineering command
9.7.2 Installing and running EF Core Power Tools reverse-engineering command
9.7.3 Updating your entity classes and DbContext when the database changes
9.8 Part 2: Applying your migrations to a database
9.8.1 Calling EF Core’s Database.Migrate method from your main application
9.8.2 Executing EF Core’s Database.Migrate method from a standalone application
9.8.3 Applying an EF Core’s migration via an SQL change script
9.8.4 Applying SQL change scripts by using a migration tool
9.9 Migrating a database while the application is running
9.9.1 Handling a migration that doesn’t contain an application-breaking change
9.9.2 Handling application-breaking changes when you can’t stop the app
Summary
10 Configuring advanced features and handling concurrency conflicts
10.1 DbFunction: Using user-defined functions (UDFs) with EF Core
10.1.1 Configuring a scalar-valued UDF
10.1.2 Configuring a table-valued UDF
10.1.3 Adding your UDF code to the database
10.1.4 Using a registered UDF in your database queries
10.2 Computed column: A dynamically calculated column value
10.3 Setting a default value for a database column
10.3.1 Using the HasDefaultValue method to add a constant value for a column
10.3.2 Using the HasDefaultValueSql method to add an SQL command for a column
10.3.3 Using the HasValueGenerator method to assign a value generator to a property
10.4 Sequences: Providing numbers in a strict order
10.5 Marking database-generated properties
10.5.1 Marking a column that’s generated on an addition or update
10.5.2 Marking a column’s value as set on insert of a new row
10.5.3 Marking a column/property as “normal”
10.6 Handling simultaneous updates: Concurrency conflicts
10.6.1 Why do concurrency conflicts matter?
10.6.2 EF Core’s concurrency conflict–handling features
10.6.3 Handling a DbUpdateConcurrencyException
10.6.4 The disconnected concurrent update issue
Summary
11 Going deeper into the DbContext
11.1 Overview of the DbContext class’s properties
11.2 Understanding how EF Core tracks changes
11.3 Looking at commands that change an entity’s State
11.3.1 The Add command: Inserting a new row into the database
11.3.2 The Remove method: Deleting a row from the database
11.3.3 Modifying an entity class by changing the data in that entity class
11.3.4 Modifying an entity class by calling the Update method
11.3.5 The Attach method: Start tracking an existing untracked entity class
11.3.6 Setting the State of an entity directly
11.3.7 TrackGraph: Handling disconnected updates with relationships
11.4 SaveChanges and its use of ChangeTracker.DetectChanges
11.4.1 How SaveChanges finds all the State changes
11.4.2 What to do if ChangeTracker.DetectChanges is taking too long
11.4.3 Using the entities’ State within the SaveChanges method
11.4.4 Catching entity class’s State changes via events
11.4.5 Triggering events when SaveChanges/SaveChangesAsync is called
11.4.6 EF Core interceptors
11.5 Using SQL commands in an EF Core application
11.5.1 FromSqlRaw/FromSqlInterpolated: Using SQL in an EF Core query
11.5.2 ExecuteSqlRaw/ExecuteSqlInterpolated: Executing a nonquery command
11.5.3 AsSqlQuery Fluent API method: Mapping entity classes to queries
11.5.4 Reload: Used after ExecuteSql commands
11.5.5 GetDbConnection: Running your own SQL commands
11.6 Accessing information about the entity classes and database tables
11.6.1 Using context.Entry(entity).Metadata to reset primary keys
11.6.2 Using context.Model to get database information
11.7 Dynamically changing the DbContext’s connection string
11.8 Handling database connection problems
11.8.1 Handling database transactions with EF Core’s execution strategy
11.8.2 Altering or writing your own execution strategy
Summary
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 problems
12.1.1 Example of using domain events
12.1.2 Example of integration events
12.2 Defining where domain events and integration events are useful
12.3 Where might you use events with EF Core?
12.3.1 Pro: Follows the SoC design principle
12.3.2 Pro: Makes database updates robust
12.3.3 Con: Makes your application more complex
12.3.4 Con: Makes following the flow of the code more difficult
12.4 Implementing a domain event system with EF Core
12.4.1 Create some domain events classes to be triggered
12.4.2 Add code to the entity classes to hold the domain events
12.4.3 Alter the entity class to detect a change to trigger an event on
12.4.4 Create event handlers that are matched to the domain events
12.4.5 Build an Event Runner that finds and runs the correct event handler
12.4.6 Override SaveChanges and insert the Event Runner before SaveChanges is called
12.4.7 Register the Event Runner and all the event handlers
12.5 Implementing an integration event system with EF Core
12.5.1 Building a service that communicates with the warehouse
12.5.2 Overriding SaveChanges to handle the integration event
12.6 Improving the domain event and integration event implementations
12.6.1 Generalizing events: Running before, during, and after the call to SaveChanges
12.6.2 Adding support for async event handlers
12.6.3 Handling multiple event handers for the same event
12.6.4 Handling event sagas in which one event kicks off another event
Summary
13 Domain-Driven Design and other architectural approaches
13.1 A good software architecture makes it easier to build and maintain your application
13.2 The Book App’s evolving architecture
13.2.1 Building a modular monolith to enforce the SoC principles
13.2.2 Using DDD principles both architecturally and on the entity classes
13.2.3 Applying a clean architecture as described by Robert C. Martin
13.3 Introduction to DDD at the entity class level
13.4 Altering the Book App entities to follow the DDD approach
13.4.1 Changing the properties in the Book entity to read-only
13.4.2 Updating the Book entity properties via methods in the entity class
13.4.3 Controlling how the Book entity is created
13.4.4 Understanding the differences between an entity and a value object
13.4.5 Minimizing the relationships between entity classes
13.4.6 Grouping entity classes
13.4.7 Deciding when the business logic shouldn’t be run inside an entity
13.4.8 Applying DDD’s bounded context to your application’s DbContext
13.5 Using your DDD-styled entity classes in your application
13.5.1 Calling the AddPromotion access method via a repository pattern
13.5.2 Calling the AddPromotion access method via a class-to-method-call library
13.5.3 Adding a Review to the Book entity class via a repository pattern
13.5.4 Adding a Review to the Book entity class via a class-to-method-call library
13.6 The downside of DDD entities: Too many access methods
13.7 Getting around performance issues in DDD-styled entities
13.7.1 Allow database code into your entity classes
13.7.2 Make the Review constructor public and write nonentity code to add a Review
13.7.3 Use domain events to ask an event handler to add a review to the database
13.8 Three architectural approaches: Did they work?
13.8.1 A modular monolith approach that enforces SoC by using projects
13.8.2 DDD principles, both architecturally and on the entity classes
13.8.3 Clean architecture as described by Robert C. Martin
Summary
14 EF Core performance tuning
14.1 Part 1: Deciding which performance issues to fix
14.1.1 “Don’t performance-tune too early” doesn’t mean you stop thinking
14.1.2 How do you decide what’s slow and needs performance tuning?
14.1.3 The cost of finding and fixing performance issues
14.2 Part 2: Techniques for diagnosing a performance issue
14.2.1 Stage 1: Get a good overview, measuring the user’s experience
14.2.2 Stage 2: Find all the database code involved in the feature you’re tuning
14.2.3 Stage 3: Inspect the SQL code to find poor performance
14.3 Part 3: Techniques for fixing performance issues
14.4 Using good patterns makes your application perform well
14.4.1 Using Select loading to load only the columns you need
14.4.2 Using paging and/or filtering of searches to reduce the rows you load
14.4.3 Warning: Lazy loading will affect database performance
14.4.4 Always adding the AsNoTracking method to read-only queries
14.4.5 Using the async version of EF Core commands to improve scalability
14.4.6 Ensuring that your database access code is isolated/decoupled
14.5 Performance antipatterns: Database queries
14.5.1 Antipattern: Not minimizing the number of calls to the database
14.5.2 Antipattern: Missing indexes from a property that you want to search on
14.5.3 Antipattern: Not using the fastest way to load a single entity
14.5.4 Antipattern: Allowing too much of a data query to be moved into the software side
14.5.5 Antipattern: Not moving calculations into the database
14.5.6 Antipattern: Not replacing suboptimal SQL in a LINQ query
14.5.7 Antipattern: Not precompiling frequently used queries
14.6 Performance antipatterns: Writes
14.6.1 Antipattern: Calling SaveChanges multiple times
14.6.2 Antipattern: Making DetectChanges work too hard
14.6.3 Antipattern: Not using HashSet for navigational collection properties
14.6.4 Antipattern: Using the Update method when you want to change only part of the entity
14.6.5 Antipattern: Startup issue—Using one large DbContext
14.7 Performance patterns: Scalability of database accesses
14.7.1 Using pooling to reduce the cost of a new application’s DbContext
14.7.2 Adding scalability with little effect on overall speed
14.7.3 Helping your database scalability by making your queries simple
14.7.4 Scaling up the database server
14.7.5 Picking the right architecture for applications that need high scalability
Summary
15 Master class on performance-tuning database queries
15.1 The test setup and a summary of the four performance approaches
15.2 Good LINQ approach: Using an EF Core Select query
15.3 LINQ+UDFs approach: Adding some SQL to your LINQ code
15.4 SQL+Dapper: Creating your own SQL
15.5 LINQ+caching approach: Precalculating costly query parts
15.5.1 Adding a way to detect changes that affect the cached values
15.5.2 Adding code to update the cached values
15.5.3 Adding cache properties to the Book entity with concurrency handling
15.5.4 Adding a checking/healing system to your event system
15.6 Comparing the four performance approaches with development effort
15.7 Improving database scalability
Summary
16 Cosmos DB, CQRS, and other database types
16.1 The differences between relational and NoSQL databases
16.2 Introduction to Cosmos DB and its EF Core provider
16.3 Building a Command and Query Responsibility Segregation (CQRS) system using Cosmos DB
16.4 The design of a two-database CQRS architecture application
16.4.1 Creating an event to trigger when the SQL Book entity changes
16.4.2 Adding events to the Book entity send integration events
16.4.3 Using the EfCore.GenericEventRunner to override your BookDbContext
16.4.4 Creating the Cosmos entity classes and DbContext
16.4.5 Creating the Cosmos event handlers
16.5 Understanding the structure and data of a Cosmos DB account
16.5.1 The Cosmos DB structure as seen from EF Core
16.5.2 How the CosmosClass is stored in Cosmos DB
16.6 Displaying books via Cosmos DB
16.6.1 Cosmos DB differences from relational databases
16.6.2 Cosmos DB/EF Core difference: Migrating a Cosmos database
16.6.3 EF Core 5 Cosmos DB database provider limitations
16.7 Was using Cosmos DB worth the effort? Yes!
16.7.1 Evaluating the performance of the two-database CQRS in the Book App
16.7.2 Fixing the features that EF Core 5 Cosmos DB database provider couldn’t handle
16.7.3 How difficult would it be to use this two-database CQRS design in your application?
16.8 Differences in other database types
Summary
17 Unit testing EF Core applications
17.1 An introduction to the unit test setup
17.1.1 The test environment: xUnit unit test library
17.1.2 A library I created to help with unit testing EF Core applications
17.2 Getting your application’s DbContext ready for unit testing
17.2.1 The application’s DbContext options are provided via its constructor
17.2.2 Setting an application’s DbContext options via OnConfiguring
17.3 Three ways to simulate the database when testing EF Core applications
17.4 Choosing between a production-type database and an SQLite in-memory database
17.5 Using a production-type database in your unit tests
17.5.1 Providing a connection string to the database to use for the unit test
17.5.2 Providing a database per test class to allow xUnit to run tests in parallel
17.5.3 Making sure that the database’s schema is up to date and the database is empty
17.5.4 Mimicking the database setup that EF Core migration would deliver
17.6 Using an SQLite in-memory database for unit testing
17.7 Stubbing or mocking an EF Core database
17.8 Unit testing a Cosmos DB database
17.9 Seeding a database with test data to test your code correctly
17.10 Solving the problem of one database access breaking another stage of your test
17.10.1 Test code using ChangeTracker.Clear in a disconnected state
17.10.2 Test code by using multiple DbContext instances in a disconnected state
17.11 Capturing the database commands sent to a database
17.11.1 Using the LogTo option extension to filter and capture EF Core logging
17.11.2 Using the ToQueryString method to show the SQL generated from a LINQ query
Summary
Appendix A—A brief introduction to LINQ
A.1 An introduction to the LINQ language
A.1.1 The two ways you can write LINQ queries
A.1.2 The data operations you can do with LINQ
A.2 Introduction to IQueryable type, and why it’s useful
A.2.1 Splitting up a complex LINQ query by using the IQueryable type
A.2.2 How EF Core translates IQueryable into database code
A.3 Querying an EF Core database by using LINQ
index
A
B
C
D
E
F
G
H
I
K
L
M
N
O
P
Q
R
S
T
U
V
W
X