book

Practical Entity Framework Core 10: Database Access for Enterprise Applications

Name: Practical Entity Framework Core 10: Database Access for Enterprise Applications
Author: Brian Gorman
ISBN: 9798868821233

by Brian Gorman

January 2026

Intermediate to advanced

567 pages

11h 44m

English

Apress

Read now

Unlock full access

Practical Entity Framework Core 10
Acknowledgments
Table of Contents
About the Author
About the Technical Reviewer
Part I: Getting Started
1. Introduction to Entity Framework
A Brief History of .NETThe Birth of .NETADO.NET to the RescueSomewhat Functional, Declarative ProgrammingEntity Framework Arrives and EvolvesSlow Adoption and Some IssuesCode-First DevelopmentModelsMigrationsDatabase-First DevelopmentA New Direction for .NET and EFMicrosoft Goes All in for All DevelopersA New Vision Requires a New PathJust How Many Versions of EF Are There?Entity Framework 6 (EF6)Entity Framework Core Will Become EF10The FutureActivitiesActivity 1-1: Getting Started with EF10PrerequisitesTask 1: Create a New Project and Add the EF NuGet PackagesStep 1: Create a New Console Project and SolutionStep 2: Create a New Class Library ProjectStep 3: Ensure Your Projects Are Utilizing the Correct Framework VersionStep 4: Ensure That the Console Program References the DBLibraryStep 5: Run the ProjectTask 2: Add NuGet Packages, Create a DBContext and a Migration, and Apply the MigrationStep 1: Reference NuGet Packages in Your ProjectsStep 2: Add the DBContextStep 3: Create the Configuration and Get It LoadedStep 4: Leverage the DBContextStep 5: Add and Run the Initial MigrationStep 6: Validate the Database ExistsActivity SummaryChapter SummaryImportant TakeawaysClosing Thoughts
2. Working with an Existing Database
Reverse-Engineering or Database-FirstWhy Would We Approach Entity Framework in This Manner?Reverse-Engineered SolutionsKeeping Everything in SyncInteracting with the Existing DatabaseActivity 2-1: Reverse-Engineering an Existing DatabasePrerequisitesTask 1: Restoring AdventureWorksStep 1: Download the Latest Version of AdventureWorksStep 2: Restore the AdventureWorksLT Database to Your Local SQL InstanceTask 2: Reverse-Engineering (Scaffolding) an Existing DatabaseStep 1: Get the Starter FilesStep 2: Create a Local GIT Repository (No Need to Push to GitHub)Step 3: Run the Scaffold CommandStep 4: Repeat the Scaffold Operation, but Change ParametersStep 5: Run the Original Scaffolding Operation to Get All the Files BackTask 3: Connect to the Database and Show Results in CodeStep 1: Review and Understand the CodeStep 2: Query the DataStep 3: Print the Results to the ConsoleActivity SummaryChapter SummaryImportant TakeawaysClosing Thoughts
3. Entity Framework: Code-First Database Interaction
Code First Doesn’t Always Mean Staring with CodeWhen Not to Use the Code-First ApproachWhen to Use the Code-First ApproachCode First in an Existing ProjectCode First in a New Project Against a Mature DatabaseCode First in a New Project with a New DatabaseThe Benefits of a Well-Executed Code-First Development EffortAbility to Get Up and Running QuicklyA Complete Record of Database Changes in Source ControlDisaster RecoveryMigration Planning Leads to Safe Database ModificationsAgility When Needing to Revert to a Previous StateImperative Programming from a Declarative ModelImperative Cloud ArchitectureDeclarative Cloud ArchitectureIt’s Time to See Code-First Database Programming in ActionAdditional Thoughts About the ActivitiesActivity 3-1: Creating a New Code-First Project Against an Existing Database in EF Core 10 (EF10)Use the Starter Files or Your Files from Activity 2-1Task 1: Getting Started with the ActivityStep 1: Getting the Project Started for the ActivityStep 2: Establish a Local RepositoryStep 3: Review the DatabaseTask 2: Creating and Reviewing the Initial MigrationStep 1: Create the Initial MigrationTask 3: Review and Modify the Generated Initial MigrationStep 1: Review the Initial Migration and then Comment Out the Up Method and Delete the Code in the Down MethodStep 2: Delete the Code in the Down MethodStep 3: Run the UpdateStep 4: Review the DatabaseTask 4: Add a New Migration, Review It, Remove It, and Then Add a Real MigrationStep 1: Add a New Migration Without Making Any Changes, Review It, and Remove ItStep 2: Make a Code Change, Add a Migration, Update, and Review the DatabaseStep 3: Roll Back the Changes to a Previous VersionStep 4: Remove the Migration and Remove the Code ChangeActivity 3-1: SummaryActivity 3-2: Creating a New Code-First Project in EF Core 10 (EF10)Leverage the Starter FilesTask 1: Create the Inventory Item ModelStep 1: Create the Collection Item ModelStep 2: Add the StringLength Field Constraint to the Name ColumnTask 2: Create Your Item Table MigrationStep 1: Add the Item Model to the InventoryDbContext As DbSet<Item>Step 2: Create a Migration for the Items Table in the Inventory SystemTask 3: Update and Review the DatabaseStep 1: Update the DatabaseStep 2: Review the DatabaseStep 3: Make a Code Change, Add a Migration, and Remove a MigrationStep 4: Add a Migration, Update the Database, and Roll back the ChangesTask 4: Add Code to Insert and Query a List of ItemsStep 1: Add Items to Your DatabaseStep 2: Get Items from the DatabaseActivity 3-2: SummaryChapter SummaryImportant TakeawaysClosing Thoughts
Part II: Building the Data Solution

4. Models and the Data Context (DbContext)
What Is the Database Context (DbContext), and Why Do We Need It?DbContext vs. ObjectContextWhat Is the DbContext?Constructing a New DbContextCritical Properties and Methods Available When Working with the DbContextImportant Properties on the DbContextOptionsBuilder ObjectImportant Properties on the DBContextOptions ObjectImportant Properties on the DBContext ObjectMethods Available on the DBContextMethods and Extensions on the DbSet<TEntity> ObjectWorking with ModelsTwo Immediate Benefits of Code-First ModelsBuilding a Database Entity ModelA Final Thought About ModelsActivity 4-1: Utilizing Inheritance and the Changetracker for Automatic AuditingGetting StartedOverviewTask 1: Create the Auditing HierarchyStep 1: Create the Auditing HierarchyStep 2: Create the FullAuditModel Abstract Class for Common ImplementationTask 2: Modify the Item ClassStep 1: Modify the Item ClassStep 2: Add a Migration and a Truncate Table StatementStep 4: Update and Review the DatabaseStep 5: Fix the Broken CodeTask 3: Implement Automated AuditingStep 1: Implement The Override for SaveChangesAsyncStep 2: Modify the ApplicationStep 3: Run the CodeStep 4: Add an Update MethodChapter SummaryImportant TakeawaysClosing Thoughts
5. Constraints, Keys, and Relationships
Constraining Your Data to Enhance Your SolutionsSize LimitationsValue ConstraintsDefault ValuesOther Data AnnotationsPrimary, Foreign, and Composite KeysNonunique IndexesWorking with Relational DataFirst, Second, and Third Normal FormFirst Normal Form (1NF)Second Normal Form (2NF)Third Normal Form (3NF)Types of RelationshipsOne-to-One RelationshipsOne-to-Many RelationshipsMany-to-Many RelationshipsFinal Thoughts About RelationshipsActivity 5-1: Using Keys, Constraints, and RelationshipsGetting StartedOverviewTask 1: Define and Constrain EntitiesStep 1: Create an AuditableIdentityModel and Constrain the FullAuditModel EntityStep 2: Constrain the Item EntityStep 3: Create the Genre EntityStep 4: Create the Category EntityStep 5: Create the ContributorType EnumerationStep 6: Create the Contributor EntityTask 2: Add RelationshipsStep 1: Create the One-to-Many Category to Items RelationshipStep 2: Create the Implicit Item to Genre Many-to-Many RelationshipStep 3: Create the ItemContributor Explicit Many-to-Many JoinTask 3: Add Entity DbSet<T> Mappings in the DBContextStep 1: Map the EntitiesTask 4: Add Migration and Update DatabaseStep 1: Create the MigrationTask 5: Seed DataStep 1: Review the SeedData ClassStep 2: Add Seed Data for CategoryStep 3: Add Seed Data for GenresStep 4: Add Seed Data for ContributorsStep 5: Add Seed Data for Items with Relational Data to CategoryStep 6: Add Seed Data for ItemContributorsStep 7: Add Seed Data for ItemGenresStep 8: Add a Migration to Seed the DataTask 6: Modify and Run the ProgramStep 1: Remove CallsStep 2: Run the ProgramChapter SummaryImportant TakeawaysClosing Thoughts
6. Data Access (Create, Read, Update, Delete)
An Overview of CRUD CommandsLanguage INtegrated Query (LINQ)Basic InteractionsLeveraging the DbSet<TEntity> ObjectsCreate Data (Add)Read DataUpdate DataDelete Data (Remove)Activity 6-1: Create, Read, Update, and Delete DataGetting StartedOverviewTask 1: Reading DataStep 1: Get a Single Category Using the Find MethodStep 2: Get a Single Category Using LINQStep 3: Get Items Using the Async EnumeratorStep 4: Query the Data with a Filter Using LINQStep 5: Using Include and Then IncludeTask 2: Creating DataStep 1: Create (Add) a Single EntityStep 2: Create (Add) Relational Data Using NavigationsStep 3: Create (Add) Multiple EntitiesTask 3: Update DataStep 1: Attempt to Update Untracked DataStep 2: Update Implicitly on Tracked EntityStep 3: Update Explicitly with Relational DataStep 4: Update Multiple Items with UpdateRangeTask 4: Remove DataStep 1: Remove an ItemStep 2: Remove an Item by IdChapter SummaryImportant TakeawaysClosing Thoughts
7. Stored Procedures, Views, and Functions
Understanding Stored Procedures, Views, and FunctionsStored ProceduresAdvantages of Stored ProceduresCreating a Stored ProcedureFunctionsAdvantages of FunctionsViewsAdvantages of ViewsExamples of Using ViewsSome Drawbacks and ImprovementsMigrations with Large ScriptsSome SolutionsFluent APIWhat Can You Do with the Fluent APIHow Do You Work with the Fluent APIWorking with the Database ObjectsA Final Thought Before Diving into the ActivitiesActivity Prerequisite: Use the Starter FilesActivity 7-1: Working with Stored ProceduresGetting StartedOverviewTask 1: Create a New SQL Stored ProcedureStep 1: Design the Stored ProcedureStep 2: Add the New File and Procedure CodeStep 3: Create a DTO ObjectStep 4: Use the Fluent API And DbSet to Configure the DTOStep 5: Add the Migration and Update the DatabaseStep 6: Leverage the Stored Procedure in CodeActivity 7-2: Working with FunctionsGetting StartedOverviewTask 1: Scalar-Valued FunctionsStep 1: Create the ScriptStep 2: Create and Apply the MigrationStep 3: Use the Function in CodeStep 4: Run the Program to See ResultsTask 2: Table-Valued FunctionsStep 1: Test the QueryStep 2: Create the Function FileStep 3: Create a DTO to Map ResultsStep 4: Add to the DBContextStep 5: Add a Migration and Update the DatabaseStep 6: Leverage the Function in CodeActivity 7-3: Working with ViewsGetting StartedOverviewStep 1: Create the New ViewStep 2: Add the Script FileStep 3: Create the DTOStep 4: Modify the DBContextStep 5: Add the Migration and Apply ItStep 6: Use the View in Your SolutionChapter SummaryImportant TakeawaysClosing Thoughts
8. Sorting, Filtering, and Paging
It’s Time to Learn LINQLINQ Is Generally Not the ProblemUse a Profiler or Another ToolIssues and SolutionsIssue #1: Prefetching Results, Then Iterating to Sort or FilterIssue #2: Not Disconnecting Your DataIssue #3: IEnumerable vs. IQueryableActivity 8-1: Sorting, Paging, and FilteringGetting StartedOverviewTask 1: Compare the Efficiency of OperationsStep 1: Create the Query for List Items Then Order and TakeStep 2: Create the Query for Order, Then List Items and TakeStep 3: Run the Two QueriesStep 4: Analyze the QueriesTask 2: Filter ResultsStep 1: Implement the Method to Let the User Filter ResultsStep 2: Analyze the QueryStep 3: Use the ViewTask 3: Page the Filtered ResultsStep 1: Leverage Skip and Take to Implement PagingTask 4: Disconnecting the Result SetsStep 1: Make the Query with TrackingStep 2: Update the DatabaseStep 3: Run the Code to See the ResultsStep 4: Consider Making All Queries Disconnected by DefaultChapter SummaryImportant TakeawaysClosing Thoughts
Part III: Enhancing the Data Solution
9. Efficient Queries Using LINQ and Projections
LINQ vs. Stored ProceduresComplex Data and the Code-First ApproachDTOs, View Models, or Domain ModelsDecoupling Your Business or View Logic from the DatabaseSometimes, a Predefined Object Is OverkillAnonymous Types and ProjectionsUsing an Anonymous Type with a Projection on the DatabaseUsing Anonymous Types and Projections on ListsUsing Anonymous Types and Projections to Manipulate Model-Backed Result SetsOne Tool to Rule Them AllAutoMapperActivity 9-1: Working with LINQ, Anonymous Types, Projections, and AutoMapperGetting StartedOverviewTask 1: Project Query Results to an Anonymous ClassStep 1: Implement the QueryStep 2: Review the OutputTask 2: Project Query Results to a Known TypeStep 1: Create the ProjectionStep 2: Run the CodeTask 3: Utilize AutoMapper to Map Projected Results from a Known Type to a DTO for Use in the UIStep 1: Review the AutoMapper ImplementationStep : Use AutoMapper’s ProjectTo MethodStep 3: Run the Code to See It in ActionChapter SummaryImportant TakeawaysClosing Thoughts
10. Encryption of Data
Data at Rest Is Likely EncryptedEncryption in the Past vs. Encryption TodayPasswordsASP.Net Built-in AuthenticationSalting and HashingProtecting Sensitive User InformationEncryption BasicsWhich Type Should You UseWhich Encryption Should We Use?ActivitiesActivity 10-1: Using Transparent Data EncryptionGetting StartedOverviewTask 1: Plan the Migration StrategyStep 1: Create the PlanStep 2: Determine the Columns You Want to EncryptStep 3: Backup the DatabaseStep 4: Enable TDE on the Entire DatabaseTask 2: Create Backup ColumnsStep 1: Add the Additional Columns to the ModelStep 2: Add the Migration and Update the DatabaseStep 3: Run a Script to Back Up the Data for the Target ColumnsTask 3: Keys and CertificatesStep 1: Create the Folder for the KeysStep 2: Create the Certificate and KeyTask 4: Drop Constraints and ColumnsStep 1: Drop Existing ConstraintsStep 2: Drop “To-Be-Encrypted” Existing ColumnsStep 3: Create Target Fields (Encrypted Columns)Step 4: Show Data in Its Current StateTask 5: Transform the Backup DataStep 1: Encrypt the Backup Column Data into New ColumnsStep 2: Validate the Encrypted DataTask 6: Clean UpStep 1: Remove Backup Columns from the ModelStep 2: Create the Migration and Update the DatabaseActivity 10-2: Using Always EncryptedGetting StartedOverviewTask 1: Enable Always EncryptedStep 1: Create a Backup [Optional]Step 2: Prepare the Fields for EncryptionStep 3: Encrypt the DataStep 4: Review the DataTask 2: Use the Encrypted DataStep 1: Use SSMS to see the dataStep 2: Fix the ApplicationStep 3: Run the ApplicationStep 3: If You Are Trying to JOINStep 4: If You Are Trying to Use SQL RawChapter SummaryImportant TakeawaysClosing Thoughts
11. Repository and Unit of Work Patterns
The Repository (Repo) PatternSources of Information About the Repository PatternThe Repository Pattern Abstracts the Database Plumbing Code from the ImplementationEntity Framework’s Built-in RepositoryThe Unit of Work PatternUsing a Unit of WorkCombining the Repository and the Unit of WorkThe One-Two PunchA Couple of DrawbacksIn General, Rely on EFSeparation of ConcernsLogical Separation of ConcernsFinal Benefits of Separation of ConcernsSome Drawbacks of Separation of ConcernsChapter 11 ActivitiesActivity 11-1: Create a Generic RepositoryGetting StartedOverviewTask 1: Create the RepositoryStep 1: Create the Repository InterfaceStep 2: Create the Repository ImplementationStep 3: Inherit/Extend the Implementation in Data Layer RepositoriesTask 2: Leverage the RepositoryStep 1: Adapt the Service LayerStep 2: Run the ProjectTask 3: Adapt Other RepositoriesActivity 11-2: Create a Custom Unit of WorkGetting StartedOverviewTask 1: Create the Unit of WorkStep 1: First StepStep 2: Add the TransactionStep 3: Run the CodeChapter SummaryImportant TakeawaysClosing Thoughts
12. Unit Testing, Integration Testing, and Mocking
Testing Your Code Is a Must-Have, Not a Nice-to-HaveThe Code Needs to Be ChangedThe Database Is the Lifeblood of the ApplicationTesting Saves Your Sanity and Protects the SystemTwo Different Approaches Leading to the Ability to Test ChangesUnit TestingLibraries UtilizedIntegration TestingActivity 12-1: Unit Testing with MockingGetting StartedOverviewTask 1: Set Up MocksStep 1: Create the Mock and ServiceStep 2: Set Up the Code to Mock GenericRepository ResponsesStep 3: Set Up the Code to Mock the Custom ResponsesTask 2: Test the Service LayerStep 1: Add the Unit TestsStep 2: Run the Unit TestsActivity 12-2: Integration TestingTask 1: Implement the Tests using TestContainersStep 1: Create the Tests for the Accessor (Get) OperationsStep 2: Create the Tests for the Mutation Operations (Add/Update/Delete)Step 3: Create the Special Test Without Transaction for Bulk Load RollbackTask 2: Run the TestsChapter SummaryImportant TakeawaysClosing Thoughts
Part IV: Modern Entity Framework
13. Modern Deployments
The Evolution of DeploymentManual DeploymentsManaging the InfrastructureContinuous Integration/Continuous Deployment (CI/CD)Early CI/CD ToolsCI/CD Practices EmergeCloud Platform As a Service (PaaS) HostingContainerization with DockerContainers vs. Virtual MachinesDocker Containers Are PortableInfrastructure as Code (IaC)Modern Deployment StrategiesBlue/GreenCanaryFeature FlagsRing/Blast ZoneDatabase Deployment StrategiesRoll-Forward StrategyUse NULL ColumnsUse ONLINE IndexesUPDATE STATISTICS SafelyIdempotent Migration ScriptsDropping Columns or Changing SchemaNever Assume That Just Your Code Is AffectedSchema Drift and DetectionMigrations for the Web ProjectActivity 13-1: Modern Application DeploymentGetting StartedOverviewTask 1: Review the Orchestrator PipelineStep 1: Review the Orchestration PipelineTask 2: Build the SolutionStep 1: Review the Build and Test ActionTask 3: Publish to Github Container Registry (GHCR)Step 1: Create the PATStep 2: Create the Repository SecretStep 3: Review the ActionTask 4: Deploy the SolutionStep 1: Create the UMI with Federated CredentialsStep 2: Create the GitHub SecretsStep 3: Review the ActionChapter SummaryImportant TakeawaysClosing Thoughts
14. New Features in EF Core 7/8/9/10
New FeaturesInterceptors and Logging (EF Core 6+)Practical ApplicationNamed Query Filters (EF10)Practical ApplicationBulk Updates/Deletes (EF Core 7+)Practical ApplicationImproved JSON Column Support (EF7+)Practical ApplicationSome Quick Details About the SystemUtilize the New JSON Data in CodeRaw SQL Projection to DTOs (EF Core 8+)Practical ApplicationDefault Constraint Naming (EF10)Practical ApplicationLINQ Enhancements (EF10)Practical ApplicationFully Supported Inheritance Mapping (EF Core 7+)Practical ApplicationCode Added for TPCModify the Demo Method CodeChapter SummaryImportant TakeawaysClosing Thoughts
Appendix A: Important Links, Required Tools, and Additional Resources
Software and ToolsStarter FilesDirectory.Build.propsAdditional ResourcesEF Core DocumentationWhat’s New in EF Core 10EF Core Tools and Extensions.NET BlogContact MeLinkedInX (Formerly Twitter) – Twixter
Appendix B: Command Cheat Sheet
EF Core CLI (dotnet ef)Install EF Core ToolsAdd PackagesAdd a Package with VersionMigrationsAdd MigrationApply MigrationRoll Back to a Previous MigrationRemove a MigrationList MigrationsScript MigrationsDrop DatabaseScaffold a Database (Database-First)General .NET CommandsRestore PackagesBuild ProjectRun ApplicationCreate .gitignoreGit CommandsStage ChangesUnstage ChangesDiscard All ChangesReset to RemoteCommit Staged ChangesPush to RemotePull from RemoteClone RepositoryCreating Projects (VSCode/CLI)Create a SolutionCreate a Console Project (with Main)Create a Class LibraryCreate an MVC Web Project with IdentityAdd an Existing Project to a SolutionConclusion
Index

Overview

Focus on the code-first approach to developing a database with EFCore 10. Taking the code-first approach allows the entire database to be built and maintained in code so there is never a situation in which you cannot restore the database schema. Additionally, the code-first approach creates an entirely transparent record of changes to the database that is easily tracked in your source control. Emphasis throughout the book is on leaving you well positioned to architect and lead data development efforts for your organization.

New to This Edition

Demonstrate the Object Relational Mapper (ORM) of choice for working with databases for enterprise applications using .Net Framework from the ground up. This third edition is revised to cover modern EFCore development as of EFCore 10 and includes information and examples for changes from EFCore 7, 8, 9, and 10. Throughout the book, practical examples and considerations are presented to help you understand how to create robust and efficient database solutions.

What You Will Learn

● Ability to build robust and maintainable database solutions using a code-first approach

● How to create and execute stored procedures, triggers, and functions

● Skills, tips, and tricks to analyze and optimize performance of database queries

● Confidence to architect data integrity through keys, constraints, and relationships

● Understanding of Data Annotations and the Fluent API for enhancing solutions

● Examples to leverage your learning, including information on the latest features in EFCore

Who This Book is For

This book is for .NET developers who work with enterprise-level applications and need to interact with data structures using Entity Framework. The major focus of this book is learning how to use Entity Framework in practical scenarios, with many examples for creating solutions to work through. If you like learning with a hands-on approach over theory, this book is for you.

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

Practical Entity Framework Core 6: Database Access for Enterprise Applications

Publisher Resources

ISBN: 9798868821233Purchase Link Publisher Website

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills