Curriculum planned

Stage 02 · Relational Databases

Entity Framework Core

A complete Entity Framework Core path from DbContext and model mapping through LINQ translation, change tracking, migrations, concurrency, transactions, provider-specific behavior, diagnostics, testing, security, multi-tenancy, performance, and production architecture.

Browse planned curriculum Back to all courses

25planned chapters

125reserved lesson paths

Intermediate → Advancedlearning level

Plannedcourse state

Coverage baselineEF Core 10 LTS on .NET 10, with relational provider portability

Course brief

Turn an ORM into a predictable data-access layer, not a black box.

This syllabus deliberately separates foundations, data modeling, query behavior, internals, reliability, security, performance, operations, and production design so advanced material is not compressed into generic catch-all chapters.

By the end

You will be able to

Design precise EF Core models using conventions, Fluent API, relationships, complex types, conversions, inheritance, and provider-aware mappings
Write LINQ that translates predictably, choose loading and tracking strategies deliberately, and diagnose generated SQL
Manage schema evolution with migrations, reverse engineering, seeding, deployment scripts, and compatibility controls
Handle concurrency, transactions, retries, multi-tenancy, security, testing, and observability without hiding database semantics
Tune and operate EF Core in production using projections, batching, pooling, compiled artifacts, interceptors, provider-specific features, and evidence-based performance work

Complete planned syllabus

25 chapters · 125 lesson paths.

Every lesson path is reserved now but intentionally not linked until its lesson HTML is actually published. The sequence moves from foundations through advanced implementation, architecture, operations, reliability, security, tuning, and a production capstone.

Chapter 1

EF Core Foundations, .NET Integration, Providers, and the First Lab

5 lessons

Where EF Core Fits: ORM Responsibilities, Relational Boundaries, and When Direct SQL Still MattersPlanned lesson · reserved path Chapter01/Lesson1.html

Planned02

EF Core 10 and .NET 10: LTS Baseline, Package Compatibility, and Upgrade DisciplinePlanned lesson · reserved path Chapter01/Lesson2.html

Planned03

Install the CLI and Packages, Choose a Database Provider, and Verify the ToolchainPlanned lesson · reserved path Chapter01/Lesson3.html

Planned04

Create the First DbContext, Entity, Database Connection, and End-to-End QueryPlanned lesson · reserved path Chapter01/Lesson4.html

Planned05

Build a Reproducible Course Lab with Logging, Sample Data, Configuration, and Safe SecretsPlanned lesson · reserved path Chapter01/Lesson5.html

Planned

Chapter 2

DbContext Lifecycle, Configuration, Dependency Injection, Factories, and Pooling

5 lessons

DbContext as Unit of Work: Lifetime, Thread-Safety, Disposal, and Async BoundariesPlanned lesson · reserved path Chapter02/Lesson1.html

Planned02

Configure Providers with DbContextOptions, OnConfiguring, and External ConfigurationPlanned lesson · reserved path Chapter02/Lesson2.html

Planned03

AddDbContext, Scoped Lifetimes, Dependency Injection, and Request-Oriented ApplicationsPlanned lesson · reserved path Chapter02/Lesson3.html

Planned04

IDbContextFactory, Design-Time Factories, Background Workers, and Blazor-Style LifetimesPlanned lesson · reserved path Chapter02/Lesson4.html

Planned05

DbContext Pooling: State Reset, Tenant-Sensitive State, Benchmarks, and When Pooling BackfiresPlanned lesson · reserved path Chapter02/Lesson5.html

Planned

Chapter 3

Model Building: Conventions, Data Annotations, Fluent API, and Metadata

5 lessons

How EF Builds the Model: Conventions, Discovery, Finalization, and Model MetadataPlanned lesson · reserved path Chapter03/Lesson1.html

Planned02

Configure Entity Types, Properties, Tables, Schemas, Columns, and Facets with Fluent APIPlanned lesson · reserved path Chapter03/Lesson2.html

Planned03

Data Annotations vs Fluent Configuration: Precedence, Maintainability, and Team ConventionsPlanned lesson · reserved path Chapter03/Lesson3.html

Planned04

Ignore Types and Properties, Configure Backing Fields, and Control Property Access ModesPlanned lesson · reserved path Chapter03/Lesson4.html

Planned05

Organize Large Models with IEntityTypeConfiguration, Assembly Scanning, and ValidationPlanned lesson · reserved path Chapter03/Lesson5.html

Planned

Chapter 4

Keys, Indexes, Property Semantics, Value Generation, and Shadow State

5 lessons

Primary, Alternate, Composite, and Foreign Keys: Identity and Relationship SemanticsPlanned lesson · reserved path Chapter04/Lesson1.html

Planned02

Configure Indexes, Uniqueness, Sort Order, Filters, Included Columns, and Provider DifferencesPlanned lesson · reserved path Chapter04/Lesson2.html

Planned03

Generated Values, Identity/Sequences, Default Values, Computed Columns, and Temporary KeysPlanned lesson · reserved path Chapter04/Lesson3.html

Planned04

Shadow Properties, Indexer Properties, Property Bags, and Infrastructure MetadataPlanned lesson · reserved path Chapter04/Lesson4.html

Planned05

Concurrency Tokens, Store-Generated Values, and Mapping Decisions that Affect UpdatesPlanned lesson · reserved path Chapter04/Lesson5.html

Planned

Chapter 5

Relationships, Navigations, Cascade Behavior, and Many-to-Many Modeling

5 lessons

One-to-Many Relationships: Principal/Dependent Roles, Requiredness, and Foreign KeysPlanned lesson · reserved path Chapter05/Lesson1.html

Planned02

One-to-One Relationships: Uniqueness, Shared Keys, and Ambiguous Relationship ResolutionPlanned lesson · reserved path Chapter05/Lesson2.html

Planned03

Many-to-Many Relationships: Skip Navigations, Join Entities, Payload Columns, and OrderingPlanned lesson · reserved path Chapter05/Lesson3.html

Planned04

Cascade Delete, ClientCascade, Restrict/NoAction, Orphans, and Database Constraint BehaviorPlanned lesson · reserved path Chapter05/Lesson4.html

Planned05

Navigation Fixup, Relationship State Changes, Disconnected Graphs, and Modeling PitfallsPlanned lesson · reserved path Chapter05/Lesson5.html

Planned

Chapter 6

Complex Types, Owned Types, JSON Mapping, Conversions, Comparers, and Encapsulation

5 lessons

Complex Types vs Entity Types: Value-Object Semantics and EF Core 10 Modeling ChoicesPlanned lesson · reserved path Chapter06/Lesson1.html

Planned02

Owned Entity Types and Aggregate Boundaries: OwnsOne, OwnsMany, and Table MappingPlanned lesson · reserved path Chapter06/Lesson2.html

Planned03

Map Structured Data to Relational JSON Columns and Reason About Partial UpdatesPlanned lesson · reserved path Chapter06/Lesson3.html

Planned04

Value Converters and Value Comparers for Domain Types, Enums, Strong IDs, and CollectionsPlanned lesson · reserved path Chapter06/Lesson4.html

Planned05

Encapsulated Models with Constructors, Private Setters, Fields, and Domain-Friendly PersistencePlanned lesson · reserved path Chapter06/Lesson5.html

Planned

Chapter 7

Inheritance, Table Splitting, Entity Splitting, and Advanced Relational Mapping

5 lessons

TPH Inheritance: Discriminators, Completeness, Query Shape, and Index DesignPlanned lesson · reserved path Chapter07/Lesson1.html

Planned02

TPT Inheritance: Join Costs, Schema Clarity, and Workload TradeoffsPlanned lesson · reserved path Chapter07/Lesson2.html

Planned03

TPC Inheritance: Duplicated Columns, Key Generation, and Query PerformancePlanned lesson · reserved path Chapter07/Lesson3.html

Planned04

Table Splitting and Entity Splitting for Legacy Schemas and Bounded Object ModelsPlanned lesson · reserved path Chapter07/Lesson4.html

Planned05

Choose Mapping Strategies with Measured SQL Plans Instead of Object-Oriented PreferencePlanned lesson · reserved path Chapter07/Lesson5.html

Planned

Chapter 8

LINQ Query Fundamentals and the EF Translation Pipeline

5 lessons

IQueryable, Deferred Execution, Expression Trees, and Where Database Work Actually HappensPlanned lesson · reserved path Chapter08/Lesson1.html

Planned02

Projection, Filtering, Ordering, Pagination, Distinctness, and NULL SemanticsPlanned lesson · reserved path Chapter08/Lesson2.html

Planned03

Parameterization, Query Compilation, Server Evaluation, and Unsupported ExpressionsPlanned lesson · reserved path Chapter08/Lesson3.html

Planned04

Async Query Execution, Streaming vs Buffering, Cancellation, and Connection LifetimesPlanned lesson · reserved path Chapter08/Lesson4.html

Planned05

Read Generated SQL with ToQueryString and Verify Translation Before Performance TuningPlanned lesson · reserved path Chapter08/Lesson5.html

Planned

Chapter 9

Advanced LINQ: Joins, Grouping, Subqueries, Set Operations, and Raw SQL Composition

5 lessons

Inner, Left, Right, Cross, and Correlated Joins with Cardinality-Aware LINQPlanned lesson · reserved path Chapter09/Lesson1.html

Planned02

GroupBy Translation, Aggregates, HAVING-Like Filters, and Common Translation BoundariesPlanned lesson · reserved path Chapter09/Lesson2.html

Planned03

EXISTS, Any, All, Contains, Correlated Subqueries, and Efficient Membership TestsPlanned lesson · reserved path Chapter09/Lesson3.html

Planned04

Union, Concat, Intersect, Except, Distinct, and Shape Compatibility Across Set OperationsPlanned lesson · reserved path Chapter09/Lesson4.html

Planned05

FromSql, SqlQuery, Stored Procedures, Composability, and Safe Escape Hatches for Handwritten SQLPlanned lesson · reserved path Chapter09/Lesson5.html

Planned

Chapter 10

Loading Related Data: Eager, Explicit, Lazy, Filtered Include, and Split Queries

5 lessons

Include and ThenInclude: Loading Graphs Without Losing Sight of Result CardinalityPlanned lesson · reserved path Chapter10/Lesson1.html

Planned02

Filtered Include, Navigation Fixup, Tracking Side Effects, and Predictable Result ShapesPlanned lesson · reserved path Chapter10/Lesson2.html

Planned03

Single vs Split Queries: Cartesian Explosion, Round Trips, Ordering, and Consistency TradeoffsPlanned lesson · reserved path Chapter10/Lesson3.html

Planned04

Explicit Loading and Targeted Relationship Queries for Conditional WorkflowsPlanned lesson · reserved path Chapter10/Lesson4.html

Planned05

Lazy Loading Proxies and ILazyLoader: N+1 Risk, Serialization Problems, and When to Avoid ThemPlanned lesson · reserved path Chapter10/Lesson5.html

Planned

Chapter 11

Change Tracking, Entity States, Identity Resolution, and Disconnected Graphs

5 lessons

Unchanged, Added, Modified, Deleted, and Detached: The Entity-State MachinePlanned lesson · reserved path Chapter11/Lesson1.html

Planned02

Snapshot Change Detection, DetectChanges, AutoDetectChangesEnabled, and Cost ControlPlanned lesson · reserved path Chapter11/Lesson2.html

Planned03

Identity Resolution, Tracking vs No-Tracking, and AsNoTrackingWithIdentityResolutionPlanned lesson · reserved path Chapter11/Lesson3.html

Planned04

Attach, Update, Entry, TrackGraph, and Selective Changes in Disconnected ApplicationsPlanned lesson · reserved path Chapter11/Lesson4.html

Planned05

Original/Current/Database Values, DebugView, and Diagnosing Unexpected UpdatesPlanned lesson · reserved path Chapter11/Lesson5.html

Planned

Chapter 12

Saving Data: Insert, Update, Delete, Batching, ExecuteUpdate, and ExecuteDelete

5 lessons

SaveChanges Pipeline, Command Ordering, Generated Keys, AcceptAllChanges, and Failure SemanticsPlanned lesson · reserved path Chapter12/Lesson1.html

Planned02

Batching Inserts and Updates, Parameter Limits, Round Trips, and Provider ThresholdsPlanned lesson · reserved path Chapter12/Lesson2.html

Planned03

ExecuteUpdate and ExecuteDelete: Set-Based DML Without Loading or Tracking EntitiesPlanned lesson · reserved path Chapter12/Lesson3.html

Planned04

Bulk-Operation Boundaries: EF APIs, Third-Party Libraries, COPY/BulkCopy, and CorrectnessPlanned lesson · reserved path Chapter12/Lesson4.html

Planned05

Interceptors and SaveChanges Overrides for Auditing, Timestamps, Domain Events, and Outbox HooksPlanned lesson · reserved path Chapter12/Lesson5.html

Planned

Chapter 13

Optimistic Concurrency and Conflict Resolution

5 lessons

Concurrency Tokens: Application-Managed Versions, rowversion, xmin, and Provider OptionsPlanned lesson · reserved path Chapter13/Lesson1.html

Planned02

How EF Detects Lost Updates and Builds Concurrency-Sensitive UPDATE/DELETE PredicatesPlanned lesson · reserved path Chapter13/Lesson2.html

Planned03

Resolve DbUpdateConcurrencyException with Client Wins, Store Wins, or Field-Level MergePlanned lesson · reserved path Chapter13/Lesson3.html

Planned04

Concurrency Across Aggregate Boundaries, APIs, Background Jobs, and Offline WorkflowsPlanned lesson · reserved path Chapter13/Lesson4.html

Planned05

Test Races Deterministically and Distinguish Concurrency Conflicts from Transient FailuresPlanned lesson · reserved path Chapter13/Lesson5.html

Planned

Chapter 14

Transactions, Savepoints, Execution Strategies, and Cross-Context Coordination

5 lessons

Default SaveChanges Transactions, Explicit Transactions, Isolation Levels, and ScopePlanned lesson · reserved path Chapter14/Lesson1.html

Planned02

Savepoints and Automatic Rollback Inside Existing TransactionsPlanned lesson · reserved path Chapter14/Lesson2.html

Planned03

Resilient Execution Strategies: Retryable Failures, Idempotency, and Transaction DelegatesPlanned lesson · reserved path Chapter14/Lesson3.html

Planned04

Share DbConnection/DbTransaction Across Contexts and Coordinate EF with ADO.NETPlanned lesson · reserved path Chapter14/Lesson4.html

Planned05

Ambient/System.Transactions Boundaries, Distributed Transactions, and Safer Architectural AlternativesPlanned lesson · reserved path Chapter14/Lesson5.html

Planned

Chapter 15

Migrations, Model Snapshots, Seeding, Scripts, Bundles, and Deployment

5 lessons

How Migrations Diff Models: Snapshot Semantics, Operations, and Migration HistoryPlanned lesson · reserved path Chapter15/Lesson1.html

Planned02

Create, Review, Rename, Reorder, and Repair Migrations Without Losing DataPlanned lesson · reserved path Chapter15/Lesson2.html

Planned03

Generate Idempotent SQL Scripts and Separate Build-Time Migration Authoring from DeploymentPlanned lesson · reserved path Chapter15/Lesson3.html

Planned04

Migration Bundles, Runtime Migration Risks, Permissions, Locking, and Multi-Instance DeploymentsPlanned lesson · reserved path Chapter15/Lesson4.html

Planned05

Deterministic Data Seeding, Environment-Specific Data, Rollback Strategy, and Zero-Downtime ThinkingPlanned lesson · reserved path Chapter15/Lesson5.html

Planned

Chapter 16

Reverse Engineering and Database-First Workflows

5 lessons

Scaffold DbContext and Entities from Existing Schemas with Provider ToolingPlanned lesson · reserved path Chapter16/Lesson1.html

Planned02

Control Tables, Schemas, Naming, Data Annotations, Connection Strings, and Generated OutputPlanned lesson · reserved path Chapter16/Lesson2.html

Planned03

Preserve Custom Code with Partial Classes, Partial Methods, Separate Configurations, and TemplatesPlanned lesson · reserved path Chapter16/Lesson3.html

Planned04

Re-Scaffolding, Schema Drift, Handwritten Changes, and Sustainable Database-First OwnershipPlanned lesson · reserved path Chapter16/Lesson4.html

Planned05

Map Stored Procedures, Views, Keyless Types, Legacy Constraints, and Imperfect Schemas PragmaticallyPlanned lesson · reserved path Chapter16/Lesson5.html

Planned

Chapter 17

Performance Engineering: Query Shape, Compiled Artifacts, Pooling, and Database Evidence

5 lessons

Project Only Needed Columns, Avoid Accidental Client Work, and Bound Result SetsPlanned lesson · reserved path Chapter17/Lesson1.html

Planned02

Compiled Queries, EF Query Cache Behavior, and When Compilation HelpsPlanned lesson · reserved path Chapter17/Lesson2.html

Planned03

Compiled Models, Startup Cost, Large Model Optimization, and NativeAOT ConsiderationsPlanned lesson · reserved path Chapter17/Lesson3.html

Planned04

DbContext Pooling, Connection Pooling, Batching, and the Difference Between ORM and Driver PoolsPlanned lesson · reserved path Chapter17/Lesson4.html

Planned05

Benchmark with Database Execution Plans, Query Tags, Realistic Data Volumes, and End-to-End LatencyPlanned lesson · reserved path Chapter17/Lesson5.html

Planned

Chapter 18

Diagnostics, Logging, Interceptors, Metrics, and Observability

5 lessons

Configure Structured Logging, Sensitive-Data Logging, Detailed Errors, and Environment SafetyPlanned lesson · reserved path Chapter18/Lesson1.html

Planned02

DiagnosticSource, EventCounters, Activity/OpenTelemetry Integration, and CorrelationPlanned lesson · reserved path Chapter18/Lesson2.html

Planned03

Command, Connection, Transaction, SaveChanges, and Materialization InterceptorsPlanned lesson · reserved path Chapter18/Lesson3.html

Planned04

Query Tags, Command Timeouts, Slow-Query Correlation, and Mapping ORM Events to Database PlansPlanned lesson · reserved path Chapter18/Lesson4.html

Planned05

Build an EF Core Production Dashboard with Error Rates, Latency, Pool Pressure, and Migration StatePlanned lesson · reserved path Chapter18/Lesson5.html

Planned

Chapter 19

SQL Server and Azure SQL Provider Deep Dive

5 lessons

Identity, Sequences, rowversion, Computed Columns, Collations, and SQL Server Type MappingPlanned lesson · reserved path Chapter19/Lesson1.html

Planned02

Temporal Tables, JSON Columns, Sparse/Provider Features, and Query TranslationPlanned lesson · reserved path Chapter19/Lesson2.html

Planned03

Execution Strategies, Connection Resiliency, Azure SQL Transient Faults, and Retry SemanticsPlanned lesson · reserved path Chapter19/Lesson3.html

Planned04

Indexes, Include Properties, Filtered Indexes, Migrations, and SQL Server DDL BehaviorPlanned lesson · reserved path Chapter19/Lesson4.html

Planned05

Provider-Specific SQL Inspection: When EF Abstractions Leak and How to Keep Them IntentionalPlanned lesson · reserved path Chapter19/Lesson5.html

Planned

Chapter 20

SQLite Provider Deep Dive and Embedded-Database Constraints

5 lessons

SQLite Type Affinity vs CLR Types: Mappings, Conversions, Precision, and Unsupported OperationsPlanned lesson · reserved path Chapter20/Lesson1.html

Planned02

SQLite Migrations and Table Rebuilds: DDL Limitations, Idempotency Boundaries, and TestingPlanned lesson · reserved path Chapter20/Lesson2.html

Planned03

Concurrency Without rowversion: Application Tokens, Locking Behavior, WAL Awareness, and RetriesPlanned lesson · reserved path Chapter20/Lesson3.html

Planned04

JSON, Date/Time, Decimal, Collation, Foreign Key, and Function Translation DifferencesPlanned lesson · reserved path Chapter20/Lesson4.html

Planned05

Use SQLite for Production Embedded Workloads vs Using It Only as a Test SubstitutePlanned lesson · reserved path Chapter20/Lesson5.html

Planned

Chapter 21

PostgreSQL, MySQL, and Cross-Provider Portability

5 lessons

Provider Ecosystem Awareness: Npgsql, MySQL/MariaDB Providers, Versions, and Compatibility ContractsPlanned lesson · reserved path Chapter21/Lesson1.html

Planned02

Identity/Sequence Strategies, Case Sensitivity, Types, JSON, Arrays, and Database-Specific ExtensionsPlanned lesson · reserved path Chapter21/Lesson2.html

Planned03

LINQ Translation Differences, Function Mapping, Generated SQL, and Provider Test MatricesPlanned lesson · reserved path Chapter21/Lesson3.html

Planned04

Migration Portability: Why One EF Model Does Not Guarantee One Portable SchemaPlanned lesson · reserved path Chapter21/Lesson4.html

Planned05

Design a Provider-Abstraction Boundary Without Falling into Lowest-Common-Denominator Data ModelingPlanned lesson · reserved path Chapter21/Lesson5.html

Planned

Chapter 22

Global Query Filters, Multi-Tenancy, Soft Delete, and Data Partitioning

5 lessons

Global Query Filters for Soft Delete, Tenant Scope, Active Rows, and Security-Sensitive PredicatesPlanned lesson · reserved path Chapter22/Lesson1.html

Planned02

Named Query Filters in EF Core 10: Selective Disabling and Composable Policy LayersPlanned lesson · reserved path Chapter22/Lesson2.html

Planned03

Single Database, Schema-per-Tenant, and Database-per-Tenant Tradeoffs with DbContext ConfigurationPlanned lesson · reserved path Chapter22/Lesson3.html

Planned04

Model Caching, Tenant-Specific State, DbContext Pooling, and Avoiding Cross-Tenant LeakagePlanned lesson · reserved path Chapter22/Lesson4.html

Planned05

Enforce Tenant Isolation in Tests, Database Constraints, Authorization, and Operational ToolingPlanned lesson · reserved path Chapter22/Lesson5.html

Planned

Chapter 23

Testing EF Core Correctly: Unit, Integration, Containers, and Migration Verification

5 lessons

What to Unit Test Around EF and What Requires a Real DatabasePlanned lesson · reserved path Chapter23/Lesson1.html

Planned02

Why the InMemory Provider Is Not a Relational Database and Where It Misleads TestsPlanned lesson · reserved path Chapter23/Lesson2.html

Planned03

Use SQLite Intentionally for Lightweight Tests and Understand Provider-Behavior DifferencesPlanned lesson · reserved path Chapter23/Lesson3.html

Planned04

Run Integration Tests Against Production-Like Engines with Containers and Isolated DatabasesPlanned lesson · reserved path Chapter23/Lesson4.html

Planned05

Test Migrations, Concurrency, Transactions, Failure Retries, Query Counts, and Performance RegressionsPlanned lesson · reserved path Chapter23/Lesson5.html

Planned

Chapter 24

Security, Raw SQL, Secrets, Authorization Boundaries, and Abuse Resistance

5 lessons

Parameterization by Default: LINQ Safety, FromSql Variants, SqlQuery, and Injection BoundariesPlanned lesson · reserved path Chapter24/Lesson1.html

Planned02

Dynamic SQL Identifiers, Sorting/Filtering APIs, Allow-Lists, and Query-Shape AbusePlanned lesson · reserved path Chapter24/Lesson2.html

Planned03

Protect Connection Strings and Credentials with Environment Configuration and Secret StoresPlanned lesson · reserved path Chapter24/Lesson3.html

Planned04

Least-Privilege Database Accounts, Migration Permissions, Row-Level Security, and Tenant Defense in DepthPlanned lesson · reserved path Chapter24/Lesson4.html

Planned05

Sensitive Data in Logs, Error Messages, Traces, Backups, and Development DiagnosticsPlanned lesson · reserved path Chapter24/Lesson5.html

Planned

Chapter 25

Production Architecture, DDD/CQRS Integration, Reliability, and Capstone

5 lessons

DbContext vs Repository/Unit-of-Work Abstractions: Avoid Redundant Layers and Preserve Testable BoundariesPlanned lesson · reserved path Chapter25/Lesson1.html

Planned02

Aggregate Persistence, Owned/Complex Types, Value Objects, Domain Events, and Transactional Outbox DesignPlanned lesson · reserved path Chapter25/Lesson2.html

Planned03

CQRS Read Models, Raw SQL/Dapper Interop, Bulk Workloads, and Choosing the Right Data-Access Tool per PathPlanned lesson · reserved path Chapter25/Lesson3.html

Planned04

Production Deployment: Migrations, Health Checks, Retries, Pool Sizing, Observability, and Incident RunbooksPlanned lesson · reserved path Chapter25/Lesson4.html

Planned05

Capstone: Design, Implement, Test, Tune, Secure, Deploy, and Defend a Production EF Core Data LayerPlanned lesson · reserved path Chapter25/Lesson5.html

Planned