►
From YouTube: Deep Dive into Many-to-Many: A Tour of EF Core 5.0 pt. 2
Description
In this episode, Arthur Vickers returns to chat some more with Jeremy about some of the new features in Entity Framework Core 5. In particular, they’ll be diving deep into the building blocks of many-to-many. You’ll see how they can be configured to allow flexible mapping and access to the underlying join table.
[01:46] - Reviewing the debug views for many-to-many
[08:00] - Under the covers of the change tracker
[10:38] - Configuring shared-type entities
[12:30] - Explicit many-to-many configuration
What's New in EF Core 5.0
https://docs.microsoft.com/ef/core/what-is-new/ef-core-5.0/whatsnew?WT.mc_id=dotnet-00000-cephilli
Persist and retrieve relational data with Entity Framework Core
https://docs.microsoft.com/learn/modules/persist-data-ef-core/?WT.mc_id=dotnet-00000-cephilli
Announcing the Release of EF Core 5.0
https://devblogs.microsoft.com/dotnet/announcing-the-release-of-ef-core-5-0/?WT.mc_id=dotnet-00000-cephilli
A
A
A
B
Thanks,
jeremy
yeah,
so
last
time
we
went
through
a
whirlwind
tour
of
lots
of
different
features
without
going
deep
into
any
of
them,
but
some
of
those
features
that
we
saw
were
were
the
debug
views
that
we've
introduced
and
enhanced
in
the
f
core
five,
and
also,
of
course,
I
think
everyone
is
well
aware.
We've
introduced
many
to
many
in
ef
core
five.
B
What
I'm
gonna
show
today
is
what
goes
on
on
under
the
covers
when
you
do
many
to
many
in
the
f
core
five,
because
on
the
surface
it
looks
like
there's
a
lot
of
magic
going
on
and
there
is
we're
doing
a
lot
of
things
for
you.
But
one
of
the
philosophies
of
vf
core
is
that
when
we
do
things
for
you
by
magic
or
by
convention,
then
we
also
provide
a
mechanism
where
you
can
provide
configuration
to
override
that
convention
and
change
the
things
that
you
don't
like
about
it.
B
Users
are
going
to
have
groups
and
groups
going
to
have
users,
but
before
I
add
many
to
me
to
that,
I
just
want
to
show
you
what's
happening
in
the
debug
views
before
we
do
that.
So
I'm
running
this
in
the
debugger
again
I
have
output
from
logging,
as
you
can
see,
but
we're
not
going
to
look
at
that
too
much.
Instead,
I'm
going
to
go
directly
into
the
context
here
and
I'm
going
to
look
at
the
debug
view
for
the
model,
so
I'm
going
to
go
context,
model
debug
view
and
then
short
view.
B
The
short
view,
as
I
said
before,
doesn't
have
the
annotations
and
is
therefore
a
lot
easier
to
read
I'll
put
it
here.
So
we
can
see
it
so
yeah
we've
got
an
editorial
group.
We've
got
an
entity
called
user.
It's
got
primary
keys
as
expected
all
the
normal
kind
of
stuff
that
you
would
expect
there.
So
this
is
kind
of
what
we
saw
last
time.
B
Likewise,
we
can
go
and
look
at
the
debug
view
for
the
change
tracker.
So
I'm
going
to
go
in
here.
Change
tracker,
expand
it.
You
can
see
debug
view
expand
that
and
I'm
going
to
just
look
at
the
short
view.
We
looked
at
the
long
view
last
time,
but
this
time
we're
going
to
use
a
short
view
because
it
makes
things
clearer.
B
B
B
B
Just
add
all
the
users
onto
the
so
for
each
group
add
all
the
users
that
are
associated
and
there
we
have
it
and
then
I'll
put
a
little
bit
of
code
in
after
here
just
so,
we
can
see
that
things
are
actually
working
in
the
database
so
stuff
out
like
we
did
before
there
we
go.
So
you
know
I'll
show
you
the
console
screen
here
and
we've
inserted
stuff
into
the
database
we've
selected
thumbs
and
we
have
users
and
groups
all
related
together
in
a
management.
B
So
that's
how
easy
it
is
to
get
many
too
working,
there's
really
nothing
to
it.
The
interesting
thing
is:
if
we
now
go,
look
what's
happened
to
the
debug
views
underneath.
So
if
I
go
into
context
model
debug
view
and
go
into
short
view
here
and
copy
that
over,
you
can
see,
there's
a
lot
more
in
here
than
all
we
did
was
add
two
navigation
properties,
and
now
we've
got
loads
of
magical
stuff.
B
B
We
added
a
user's
navigation
property
from
group
to
users
and
we
added
a
groups,
navigation,
property
from
user
to
groups,
and
these
are
inverses
of
each
other,
so
you
can
see
that
they're
detected
as
inverses.
So
this
is
all
we
added,
and
this
is
what
ef
has
created
underneath
the
covers.
So
basically
it's
created
a
new
entity
type.
This
is
what
we
call
a
join
entity.
This
allows
you
to
join
groups
and
users
together,
and
this
is
what
it
gets
will
result
in
creating
a
joint
table
in
the
database.
B
Now
this
entity
type
is
actually
of
type
dictionary
string
to
object.
So
it's
the
even
though
we
had
a
clr
type
group
here
and
we
have
a
clr
type
user
here
in
this
case,
ef
is
showing
us
that
this
is
actually
different.
It's
not
a
cls,
simple,
clr
type.
It's
actually
a
dictionary
string
to
object.
I'm
not
sure
why
we
showed
this
twice
here,
I'm
going
to
follow
up
on
that,
but
anyway,
just
extra
information.
B
So
when
you're
storing
things
as
a
dictionary
or
string
to
object
any
entity,
any
entity
type
can
use
this.
It's
what
we
call
a
shared
type
entity
type,
so
dictionary
string
object
is
just
something
that
ships
with
the
bco
right
and
it
doesn't
have
any
specific
properties
for
id
or
name
or
anything.
Instead,
it
just
has
an
indexer,
so
you
can
do
square
brackets
in
c
sharp
and
say
here's
my
property
name
id,
what's
the
value
of
it.
B
B
We
see
down
here,
foreign
key
to
group,
and
then
we've
got
a
property
user's
id
which
is
acting
as
the
foreign
key
to
user,
and
these
are
index
of
property,
meaning
in
the
dictionary
we
expect
a
property,
a
value
or
with
name
group
id
to
have
the
value
of
the
the
field.
The
the
foreign
key
for
group
and
the
other
index
property
to
have
the
foreign
key
for
the
user
and
we've
created
a
composite
key
of
these
things,
which
is
useful
in
the
database
for
ensuring
that
everything
is
created
consistently.
B
So
don't
worry
if
some
of
that
didn't
make
sense
like
go,
read
up
about
index
or
properties,
read
up
about
shared
type
into
types
in
the
documentation.
There's
lots
of
information
about
those,
but
let's,
let's
move
on
and
see
also
what's
happening
in
the
change
tracker
now
and
we're
going
to
come
back
to
the
model
in
a
minute.
B
So
in
the
change
tracker
I
can
expand
the
debug
view
of
that
by
going
change,
tracker,
debug
view
and
we're
going
to
look
at
the
short
view.
Again,
it's
looking
pretty
crazy
this
time,
but
it's
actually
not
very
bad.
All
they're
saying
is
now
I've
created
groups
like
before
and
users
before,
but
I've
got
all
of
these
entities,
so
these
are
entities
of
my
join
entity.
B
So
this
says
it's
a
dictionary
string
to
object
right,
that's
the
type
remember
of
the
entity
and
it's
got
values
in
it
for
the
group
id
and
the
user's
id,
and
these
are
the
same
temporary
values
that
have
been
assigned
by
ef
here.
So
these
are
the
things
that
says:
okay,
this
is
related
to
this.
This
is
related
to
this.
This
user
is
related
to
this
group.
This
user
is
related
to
this
group.
B
These
entities
are
what
show
that,
under
the
covers,
if
we
step
over
this,
you
can
see
that
what
ef
does
and
I'm
going
to
just
bring
up
the
the
output.
Here,
it's
inserted
a
bunch
of
values,
let's
step
back,
so
what
we've
first
done
is:
we've
inserted
groups
and
users
and
we've
selected
back
the
ids
for
all
of
those
things.
So
this
is
how
ef
has
got
back
the
generated
ids,
because
they're
identity
columns
in
the
sql
server
database.
B
This
is
how
af
has
got
those
ids
back
now
when
it
inserts
into
the
the
join
table.
It's
actually
inserting
all
of
the
all
of
these
values
that
are
now
the
correct
values.
So
what
af
has
done?
It's
recognized
that
the
temporary
value
has
now
been
replaced
in
the
database
by
an
actual
key
value.
It's
taken
those
propagated
those
to
my
join
entity,
types
set
them
to
the
correct
values,
and
now
it's
doing
another
insert
into
the
database
to
insert
all
of
those
values.
B
So
a
lot
of
stuff
is
actually
going
on
under
the
covers
there.
The
end
result
is
in
this
debug
view.
Again.
Sorry,
no,
that's
the
wrong
one
yeah.
What?
Yes?
That's
the
right
one!
Okay!
So
now
after
we
save
changes
instead
of
having
all
of
those
temporary
values,
they've
all
been
replaced
here
with
the
with
the
real
values.
So
that's
all
happened.
You
don't
have
to
with
ef4.
B
Okay,
so
now
I'm
going
to
show
you
how
remember
I
said
that
all
of
this
magic
is.
Am
I
still
running
the
depot.
Let
me
stop
debugging
here
so
yeah
that
helps
okay.
So
all
of
this
magic
is
stuff
that
you
can
replace
with
your
own
with
your
own
configuration.
So,
for
example,
you
remember,
I
said
that
ef
created
this
shared
type
entity
type,
which
is
using
dictionary
or
string
to
object
to
act
as
the
group
user
table.
B
So
I
can
say,
oh
explicitly,
this
is
what
I
want,
and
actually
what
will
happen
in
this
is
that
ef
will
see
this
thing,
you've
explicitly
configured
and
say:
hey,
that's
the
same
thing
I
was
going
to
configure,
so
I'm
going
to
use
yours
instead
and
that's
kind
of
how
the
conventions
and
the
explicit
cover
configuration
work
together
they
integrate
with
each
other.
It's
like
you,
add
a
bit
of
explicit
configuration.
B
We
take
the
rest
of
the
conventions
and
we
combine
it
with
that
explicit
configuration
to
get
what
you
actually
ask
for.
In
this
case,
I
haven't
asked
for
anything
different,
but
if
I
run
this,
actually
I
run
it
not.
In
the
debugger,
which
is
not
what
I
wanted
to
do
so
we'll
let
it
finish
and
then
I'll
run
it
again
in
the
debugger.
B
B
So
after
having
done
that,
let's
let's
see,
let's
go
a
bit
further,
let's
actually
configure
that
many-to-many
relationship
explicitly
so
again.
What
I'm
going
to
do
here
is
I'm
going
to
come
here
and
say
actually,
even
though
we
have
discovered
this
by
convention,
I'm
explicitly
now
going
to
say
this:
is
a
user
entity
has
many
groups
with
many
users,
so
this
is
how
it's
recently
configured
many
too
many.
B
So
if
you
have
things
that
don't
match
conventions
or
where
you
have
multiple
relationships
between
the
same
entities
and
af
can't
figure
out,
oh
this,
these
two
navigations
fit
together
and
make
it
many
too
many.
This
is
what
you
have.
This
is
all
you
have
to
do
right.
You
don't
have
to
specify
any
of
the
other
stuff
that
will
still
be
built
by
convention.
B
So
all
of
the
other
things
are
still
put
by
convention,
and
I
did
it
again
where
I
run
it
instead
of
debugging
it,
but
I
will
just
show
you
again
really
quickly.
It
gets
boring
because
nothing
changed
again,
but
it's
useful
to
see
that
so
context,
model
diva
view
short
view
and
let's
go
back
over
here.
B
Everything
is
still
the
same,
even
though
we've
explicitly
configured
this
many
to
many,
because
it
matches
what
we
would
do
by
convention.
It
didn't
change
anything
okay.
So
now
I'm
going
to
go
another
step
further
on
this
and
say
actually,
let's
configure
more
about
it,
let's,
let's
do
the
whole
thing
now.
This
is
a
big
leap
and
we
actually
have
an
issue
on
the
backlog
for
6-0
all
right.
It's
not
on
the
backlog,
it's
triage
for
6-0,
which
says
make
this
step
a
bit
a
bit
easier,
because
this
is
where
you
have
to
go
now.
B
I
could
put
in
a
regular
entity
type
just
as
it
was
before
ef
core5
in
there,
and
you
can
see
that
in
many
of
the
other
demos
of
many
too
many
in
this
case,
I'm
using
a
shared
entity
type
just
like
with
little
bit
default
and
I'm
giving
it
the
same
name,
and
then
I'm
just
telling
it
in
here
that
this
is
set
up
underneath
by
a
one-to-many
and
a
one-to-many
on
either
side,
because
that's
basically
what
a
many-to-many
relationship
is.
It's
a
view
over
a
two
one-to-many
relationships
to
the
joint
table.
B
B
B
B
However,
in
a
simple
case
like
this,
you
probably
want
this
to
be
called
group
id
and
user
id.
So
I
could
run
this
all
this
code.
Again,
we
get
exactly
the
same
model,
but
now
I've
got
to
the
point
where
I
can
say.
Actually
I
don't
want
the
signal.
What
I
want
is
these
columns,
these
properties
to
be
called
group
id
and
user
id,
and
I
don't
want
this
to
be
called
group
user.
I
want
this
to
be
called
memberships,
because
the
table
in
my
database
should
be
memberships
between
users
and
groups.
B
B
What
I
did
wrong
is
that
I
forgot
a
step
in
my
demo
in
my
demo.
I
was
good.
What
I
should
have
done
is
before
we
run
this
step.
I
should
have
said
you
don't
need
this
anymore
like
this
is
actually
being
set
up.
This
here
has
everything
you
need,
but
by
leaving
this
in,
what
I
said
is
I
actually
want
a
shared
entity,
type
group
user,
and
I
want
to
share
them
together
for
memberships,
and
so
it
created
both.
B
You
know,
because
now
the
one
I
take
it
above
is
different
from
the
one
that
I'm
configuring.
So
now
I
say,
oh
you
want
two
of
those.
So
if
I
do
what
I'm
supposed
to
do
and
remove
that
and
then
run
this
again
in
the
debugger,
which
I
I
have
to
start
it
again
here
we
go
it's
going
to
pop
up
now.
Hopefully
we
get
the
right
one
mont
context,
model
debug
view
short
view.
B
Let's
bring
it
over
here,
yes,
now
we're
back
to
the
same
model.
So
this
is
exactly
the
same
thing.
We
started
it
except
my
entity.
Type
for
the
join
is
now
called
memberships,
and
the
table
will
likewise
be
called
membership,
which
is
what
I
want
it's
it's
closer
to.
What
I
was
hoping
for
and
the
keys
are
now
group
id
user
id
instead
of
groups
id
and
user
id,
but
everything
else
is
exactly
the
same.
B
A
That
was
great,
so
the
takeaway
that
I
got
from
this
is
that
entity
framework
is
pretty
smart
and
is
going
to
figure
out
a
lot
about
your
models,
but
those
conventions
aren't
something
that
you're
stuck
with.
You
can
override
them,
configure
them
tweak
them
change
them
and
I'll.
Tell
you
what
that
debug
view
is
an
awesome
way
to
stay
on
top
of
what's
happening.
I
I
I
knew
about
it.
I've
used
it
for
queries,
but
I
haven't
dug
into
the
change
tracker
and
the
the
model
piece
and
that's
that's
pretty
huge.
B
Yeah,
so
we
had
the
we
had
the
model
debug
view
in
previous
versions
of
ef
core
we've
enhanced
it
with
the
short
view,
which
makes
it
easier
to
read
in
the
f45
and
the
change
tracker
debug
view
is
new
in
ef
core5
and
when
I'm
debugging
issues
that
people
file
and
trying
to
reproduce
things,
I
use
it
all
the
time
and
I
think
other
people
will
similarly
find
it
super
useful.
So
I
hope
you
love
it
as
much
as
we
do.