Interacting with Related

Data

Julie Lerman
EF Core Expert and Software Coach

@julielerman | thedatafarm.com
 Focus on the one-to-many authors & books
Module
Inserting related data
Overview
Eager loading queries and shaping results
with projections
Loading related data for objects in memory
Filtering queries with related data
Update and delete related data
Insights into persisting untracked graphs
Bette Davis in “All About Eve”

"Fasten your seat belts, it's

gonna be a bumpy night."
Bette Davis in “All About Eve”

"Fasten your seat belts, it's

gonna be a bumpy night."
ing modu le
in te r e st
an
Adding Related Data
 +
Add New Parent and New Child
Together
Let’s add new authors and their new books
 One-to-Many in the Database

The relationship Constraints of this relationship

Views from SQL Server Management Studio

Object Graph
A connected set of related objects
Any Object Can Be the Head of a Graph

Author Graph Book Graph

An author with some A book with an author and
books in memory its book jacket in memory
 +
Add a New Child to an Existing Parent
Our authors keep writing new books.
Let’s get those books into the database
Change Tracker Response
to New Child of Existing Parent

As child’s key value is Child’s FK value to parent

not set, state will (e.g. Book.AuthorId)
automatically be “Added” is set to parent’s key
Reminder: DbContext/DbSet Tracking Methods

Add Update Remove Attach

Change Tracker Response
to New Child of Existing Parent

Set foreign key

Add child to child Add existing
property in child
collection of tracked parent to
class to parent’s
existing tracked ref property of
key value.
parent. child.
Add &
SaveChanges SaveChanges
SaveChanges
Beware accidental
inserts!
Passing a pre-existing entity into its
DbSet Add will cause EF Core to try to
insert it into the database!
EF Core’s Default Entity State of Graph Data

Has Key Value No Key Value

Add(graph) Added Added

Update(graph)

Attach(graph)
EF Core’s Default Entity State of Graph Data

Has Key Value No Key Value

Add(graph) Added* Added

Update(graph) *Database will throw an exception

unless IDENTITY INSERT is explicitly
enabled and the key doesn’t already
exist
Attach(graph)
Understand
how your tools work!
 “Foreign keys? NEVER!
They will make my classes dirty!”

“Foreign keys in my classes

make my life so much simpler!”
Some of this change
tracking behavior is
different in disconnected
scenarios.
Eager Loading Related Data in Queries
Means to Get Related Data from the Database

Query Projections
Eager Loading
Define the shape of query
Include related objects in query
results

Lazy Loading Explicit Loading

Explicitly request related data
On-the-fly retrieval of data for
related to objects in memory objects in memory
*Arrived with EF Core 2.1
Query Workflow

Receives Materializes
tabular results results as objects
Authors Books for
those Adds tracking
Authors details to
DbContext
instance
DbContext
connects the
relationships
Filtering & Sorting the Included Data

Long requested
By default, the You can filter and
feature that finally
entire collection is sort the related
arrived in
retrieved data
EF Core 5!
Composing Include with Other LINQ Methods

_context.Authors.Where(a=>a.LastName.StartsWith("L"))
.Include(a=>a.Books).ToList()

_context.Authors.Where(a => a.LastName == "Lerman")

.Include(a => a.Books).FirstOrDefault()

_context.Authors.Where(a => a.LastName == "Lerman")

.FirstOrDefault().Include(a => a.Books)

_context.Authors.Find(1).Include(a=>a.Books)
_context.Authors.Include(a=>a.Books).Find(1)
Remember, Find is not a LINQ method
Using Include for Multiple Layers of Relationships
_context.Authors
.Include(a => a.Books) t Get books for each author
.ThenInclude(b=>b.BookJackets) t Then get the jackets for each book
.ToList();

_context.Authors
t Get books for each author
.Include(a => a.Books)
.Include(a=>a.ContactInfo) t Also get the contact info each author
.ToList();

t Get the jackets for each author’s books

_context.Authors
.Include(a=>a.Books.BookJackets) (But don’t get the books)
.ToList();
Performance Considerations with Include

Composing many Includes in one Include defaults to a single SQL

query could create performance command. Use AsSplitQuery() to
issues. Monitor your queries! send multiple SQL commands
instead.
SQL Generated from Includes

Query is broken up
Single query
into multiple queries sent
with LEFT JOIN(s)
in a single command

Default With AsSplitQuery()

Projecting Related Data in Queries
Means to Get Related Data from the Database

Query Projections
Eager Loading
Define the shape of query
Include related objects in query
results

Lazy Loading Explicit Loading

Explicitly request related data
On-the-fly retrieval of data for
related to objects in memory objects in memory
var someType=_context.Authors
.Select(properties into a new type)
.ToList()

var someType=_context.Authors
.Select(a=>new {a.FirstName, a.LastName, a.Books.Count() }
.ToList()

someType structure:
FirstName
LastName
Books

Projecting into Undefined (“Anonymous”) Types

Use LINQ’s Select method
Use a lambda expression to specify properties to retrieve
Instantiate a type to capture the resulting structure
Anonymous types are not available outside of the method
EF Core Can Only Track Entities Known by DbContext

Anonymous types Entities that are properties

of an anonymous type
are not tracked are tracked
Loading Related Data for Objects
Already in Memory
Means to Get Related Data from the Database

Query Projections
Eager Loading
Define the shape of query
Include related objects in query
results

Loading related data for objects already in memory

Means to Get Related Data from the Database

Query Projections
Eager Loading
Define the shape of query
Include related objects in query
results

Explicit Loading
Lazy Loading
Explicitly request related data
On-the-fly retrieval of data
for related to objects in memory
objects in memory
With author object already in memory, load a collection

_context.Entry(author).Collection(a => a.Books).Load();

With book object already in memory, load a reference (e.g., parent or 1:1)

_context.Entry(book).Reference(b => b.Author).Load();

Explicit Loading
Explicitly retrieve related data for objects already in memory
DbContext.Entry(object).Collection().Load()
DbContext.Entry(object).Reference().Load()
More on Explicit Loading

You can only load from a single object Profile to determine if LINQ query
would be better performance

Filter on loading using Query() method var newfBooks =

context.Entry(author)
.Collection(a => a.Books)
.Query().Where(b =>
b.Title.Contains(“Newf”)
.ToList();
Using Lazy Loading to Retrieve Related
Data
Means to Get Related Data from the Database

Query Projections
Eager Loading
Define the shape of query
Include related objects in query
results

Explicit Loading Lazy Loading

Explicitly request related data for On-the-fly retrieval of data
objects in memory related to objects in memory
Lazy loading is easy to misuse!
I recommend some advanced learning before
using it.
Lazy Loading is OFF by default
Enabling Lazy Loading

Every navigation property in every entity must be virtual

e.g., public virtual List<Book> Books { get; set; }

Reference the Microsoft.EntityFramework.Proxies package

Use the proxy logic provided by that package

optionsBuilder.UseLazyLoadingProxies()
 Some Good and Not So Good Ways to Use Lazy
Loading
Good Behavior
foreach(var b in author.Books) t One command to the db to get the books for
this one author
{
Console.WriteLine(b.Title);
}

Behavior to Avoid
var bookCount= author.Books.Count(); t Retrieves all the Book objects from the
database and materialize them and then give you
the count.
t Sends N+1 commands to the database as each
Data bind a grid to lazy-loaded data author’s book is loaded into a grid row

Lazy loading when no context in scope t No data is retrieved

Using Related Data to Filter Objects
Modifying Related Data
EF Core’s Default Entity State of Graph Data

Has Key Value No Key Value

Add(graph) Added Added

Update(graph) Modified Added

Attach(graph)
 Connected Disconnected

DbContext is aware DbContext has no clue

of all changes made to objects about history of objects
that it is tracking before they are attached
(when DetectChanges is called)
Reminder: DbContext/DbSet Tracking Methods

Add Update Remove Attach

Attach starts tracking with state set to Unchanged

EF Core’s Default Entity State of Graph Data

Has Key Value No Key Value

Add(graph) Added Added

Update(graph) Modified Added

Attach(graph) Unchanged Added

The Challenge

Edited
Book
Author

Book Book
The Challenge

Edited
Book

Author

Book Book
The Challenge

_context.Entry
( Edited
Book
)
.State

Author

Book Book
The Challenge

_context.Entry
( Edited
Book
)
.State

Author

Book Book
DbContext.Entry gives you
a lot of fine-grained control
over the change tracker.
Understanding Deleting Within Graphs
Multiple Meanings of Remove/Delete

Remove from an Set State to Deleted Delete from database

in-memory collection in Change Tracker
Cascade Delete When Dependents
Can’t Be “Orphaned”
When parent is optional, the
children will not be deleted
When parent is optional, the
children will not be deleted

This was a breaking change in EF Core 7

I will start with a focus on
required parents and
cascade delete enabled.
Foreign Key Relationship Constraint in SQL Server
void DeleteAnAuthor()
{
var author = _context.Authors.Find(2);
_context.Authors.Remove(author);
_context.SaveChanges();
}

Database Enforces Cascade Delete

Only author is in memory, tracked by EF Core & marked “Deleted”
Database’s cascade delete will take care of books when author is deleted
EF Core Enforces
Cascade Deletes
Any related data that is also tracked
will be marked as Deleted along with
the principal object
It’s running the
DELETE FROM Books
while the books are still in
the database.
var author=_context.Authors t Retrieve an author with only *some* of their
.Include(a=>a.Books books
.Where(b=>b.Title=“XYZ”)
.FirstOrDefault();

t Mark the author as deleted

_context.Authors.Remove(author);

//Entry(author).State=Deleted t Change tracker will also mark that book as

//Entry(thatbook).State=Deleted deleted

DELETE thatbook FROM BOOKS t SaveChanges sends DELETE for that book and
DELETE for the author to database
DELETE thatauthor FROM AUTHORS

//database cascade delete any other t The database will delete any remaining books
books in that database for the author
A Few Last Questions about Cascade Delete

Question Answer
Will Remove() remove everything in a No. Remove will only remove the
graph, just like Update? specific object.

What about deleting a dependent that’s You’ve actually done this. If it’s in
not in a graph? memory, DbSet.Remove works. If it’s
not, then ExecuteDelete.
Some More Points About Removing Dependents

What about .... Examples

How to move a child from one parent to • book.AuthorId=3
another (when tracked)? • newAuthor.Books.Add(book)
• book.Author=newAuthor

What about optional relationships? • book.AuthorId=null

• author.Books.Remove(book)

What about deleting relationships in This is more advanced, but you will see
disconnected scenarios? some of it in the web app module.
Impact of Optional Relationship

No Cascade Delete in the Database No Cascade Delete in

ChangeTracker
 You can eager load related data with
Include() or projections.
Lazy and explicit loading let you load after
Review the fact.
Pay attention to lazy loading behavior.
Filter the related data or use it to filter the
base data.
Adding, modifying or deleting data in
graphs has varying impacts on the related
objects.
DbContext.Entry() isolates and affects only
the object you pass in.
Up Next:

Defining and Using Many-to-Many

Relationships
Resources

Entity Framework Core on GitHub github.com/dotnet/efcore

EF Core Documentation learn.microsoft.com/ef/core

Lazy Loading With and Without Proxies

(Module from EF Core 2.1 What’s New) bit.ly/EFCoreLazy