►
From YouTube: Entity Framework: .NET Community Standup - August 5th 2020 - EF Core In Depth Video Series
Description
Join members from the .NET teams for our community standup covering great community contributions for Framework, .NET Core, Languages, CLI, MSBuild, and more.
Community Links: https://www.theurlist.com/efcore-standup-2020-08-05
A
A
And
we
are
live
and
together
for
another
edition
of
the
entity,
framework
community
stand
up,
and
so
first
thing
is
is
first
I
introduce
the
the
people
on
the
show
today.
So
I'm
kicking
things
off.
My
name
is
jeremy
likness,
I'm
a
program
manager
for
net
data
at
microsoft,
and
we
have
two
guests
with
us
today.
First
phil,
you
want
to
share
a
little
bit
about
yourself.
B
Sure
my
name's
phil
g
pixie,
I
write
a
bunch
of
books.
I
do
a
lot
of
speaking,
but
I
work
full
time
as
a
consultant
and
as
an
interim
cto
for
a
large
firm
in
chicago
and
I've
been
involved
in.net
since
the
beginning,
uh.net
core
since
the
very
beginning
and
I've
been
a
fan
of
ef,
since
it
became
a
real
product
about
mid-stream
of
the
ef
classic
cycle.
C
Robert
hey
I'm
robert
greene,
and
I
worked
at
microsoft
for
many
many
years
in
developer
tools,
marketing
and
then
also
in
various
evangelism
groups,
I
retired,
from
full-time
employment.
Last
october,
let's
stuck
around
to
keep
hosting
the
visual
studio
toolbox,
show
which
I've
been
doing
on
channel
9
since.
C
D
A
F
A
Alright,
a
few
links
for
us
today,
I'm
not
going
to
click
on
this
first
one
because
it'll
start
playing
a
video,
but
this
is
a
recent.
We
just
had
our
our.net
comp
for
microservices
and
it
was
a.
I
think
it
was
actually
like
a
full
day
of
sessions,
but
julie,
lerman
had
a
session
on
the
intersection
of
microservices
domain,
driven
design
and
entity
framework
core.
It's
about
a
30
minute
session,
highly
recommend,
taking
a
look
at
that.
The
second
link
here
is
the
github
repo
for
her
session.
A
So
it
shows
basically
how
to
take
the
patterns
that
she
talked
about
in
that
session
and
implement
them
in
a
small
project,
so
something
to
check
out
sort
of
a
real
world
entity
framework
core.
If
you
will,
I
don't
know
if
anyone
else
either
saw
her
session
or
has
looked
at
the
repo
has
any
comments
or
thoughts.
E
B
E
Have
we
have
gaps
there
too?
You
know,
I
mean
yes,
we
we
have
support.
I
think
we
took
some
missteps
in
value,
object
and
aggregates
in
the
in
the
past,
but
but
yes
in
general,
we
we
look
at
ddd
patterns
as
something
we
definitely
want
to
support.
You
know
not
because
it's
ddd
necessarily,
but
just
because
they're
useful
patterns
for
anybody
doing
this
kind
of
development.
I
think.
A
Oh,
no,
that's
what
this
is
about
discussion
and
free-flowing
conversation
about
how
to
call
stored
procedures
with
output
parameters
with
from
sql
raw
and
efcor,
which
is
pretty
much
the
blog
post.
I
think
no,
the
very
specific
title.
This
is
ericky
blogs,
quite
frequently,
tips
and
tricks
and
techniques
about
entity
framework.
Core
he's,
author
of
the
the
power
tools,
definitely
check
those
out,
but
this
is
basically
showing
you
how
to
take
this
particular
type
of
stored
procedure
and
map
it
through
entity
framework
core.
E
This
is
really
good
stuff.
Output
parameters
are
tend
to
be
tricky
because
there's
things
that
people
don't
necessarily
understand,
aren't
very
intuitive,
such
as
having
to
enumerate
the
result
set
before
the
output
parameter
is
populated.
So
some
of
these
patterns
that
eric
shows
are
really
useful
and
and
good
for
us
to
look
at
and
discuss
with
eric
in
terms
of
how
we
make
the
the
experience
better
without
having
to
do
some
of
these
things.
F
A
And
the
next
two
links
are
just
some
new
documentation,
but
we
wanted
to
highlight
that
we're
continuing
to
build
what
we're
calling
our
platforms
experience,
so
that
is
making
sure
that
we
have
the
documentation
and
the
support
you
need,
regardless
of
which
platform
you're
using
entity
framework
core
on.
So
this
is
a
new
get
getting
started
with
efcor
and
xamarin
link.
You
can
see
it's
right
here
in
the
documentation.
A
In
fact,
if
you
land
on
our
main
page,
we've
got
supported
platforms
right
down
here
and
you
can
drill
into
the
the
different
documentation
related
to
those
this
walks
through
creating
an
ef
core
and
xamarin
app.
It's
a
fairly
simple.
It's
got
blogs
and
posts,
but
it
shows
you
how
to
query
and
update
and
post
new
data,
so
definitely
check
that
out,
there's
a
sample
that
you
can
clone
for
that.
Any
thoughts
on
ef
core
on
xamarin.
A
E
Really,
it's
really
great
to
see
these
different
platforms
coming
forward
and
you
know
not
just
all
asp.net.
Obviously,
a
lot
of
people
use
asp.net
core,
but
we've
designed
ef
core
from
the
beginning
to
work
on
different
platforms.
So
it's
really
good
to
to
get
better
support
and
we
had
great
help
from
the
the
xamarin
cad
team
on
this
for
get
creating
this
contact.
We've
really
tried
to
work
with
the
with
the
other
teams
to
make
sure
we're
we're
giving
the
correct
guidance
there.
A
A
The
other
thing
I
want
to
point
to
is:
we've
had
a
issue
for
some
time
on
wpf
for
net
core,
so
we
do
have
a
example
of
wpf
on
the
dot
net
framework,
but
this
is
getting
started
with
wpf
on.net
core
and
walks
you
through
building
a
similar
application.
It's
actually
products
categories
and
and
products
example,
but
it'll
show
you
all
the
different
steps
that
you
need
to
take
and
it's
also
linked
to
a
repo.
A
And
then
we
had
a
question
in
chat
about
plans
for
winforms
equivalent,
and
the
answer
is
yes.
I
am
working
on
a
winforms
equivalent
for
this
documentation
right
now.
The
designer
for
net
core
doesn't
have
all
of
the
functionality
that
some
of
our
existing
tutorials
had
with,
for
example,
creating
and
dragging
data
sources.
That
doesn't
mean
it
won't
work
with
winforms,
there's
just
some
other
steps
involved,
and
so
I'm
working
through
the
the
best
practices
and
guidance
for
that.
But
we
will
have
win
forms
come
out.
A
We
will
also
have
guidance
for
blazer
server
applications,
and
that
will
include
a
sample
project
should
come
out
in
the
next
few
weeks
is
is
what
the
timeline
is
looking
like,
but
that
is
a
sample
project.
That's
a
pretty
in-depth
project,
and
by
in-depth
I
mean
it's
got
a
grid
that
you
can
sort
you
can
insert,
you
can
update,
you
can
delete,
so
it
should
be
a
pretty
comprehensive
list.
A
A
B
On
the
wpf
side,
we've
been
using
ef
core
with
wpf
since
1.1
since
ef
core
1.1.
It's
something
that
we
switched
over
and
we'll
talk
about
later
on.
This
show
about
the
performance
but
yeah.
So
it's
it's
been
going
great
and
then
my
latest
book,
which
I
am
no
wrong
hand,
because
it's
backwards
anyway.
My
c
sharp
eight
book
I've
got
an
entire
chapter
on
wpf
with
ef
core
is
all
3.1
using
mvvm.
So
it
fully
implements
nvvm
pattern
with
the
f.
E
That's
nice!
That's
very
cool!
It's
really
good
to
hear
that
because,
like
I
said
from
the
beginning
of
ef
core,
even
though
we
were
kind
of
going
along
with
asp
net
core
and
that's
you
know
our
main
partner
and
still
most
people
using
afko
are
using
asp
net
core.
We
tried
to
build
in
like
the
data
binding
and
the
wpf
and
the
win
forms
and
all
of
the
stuff
that
we've
learned
from
the
classic
ef
built
into
the
you
know
apis
on
the
new
ef,
but
with
you
know,
a
much
better
implementation.
E
Af45
we
have
a
community
contribution
that
implemented
change
tracking
proxies.
Now
they,
the
change
tracking
proxies,
are
not
without
their
challenges,
but
it
means
that
basically,
you
can
now
have
us
create
dynamic
proxies
which
implement.
I
notify
property
changing
and
I
notify
property
change
for
you,
so
you
don't
have
to
do
that
and
then
you
know
we
respond
to
all
those
events.
So
so
that
can
be
useful
if
you
want
those
those
things
implemented
automatically
as
well.
C
C
E
Awesome
work
there
appreciate
that.
I
think
I
think,
as
docs
is
a
never-ending
task.
We
have.
We
have
more
docs
to
do
all
the
time,
but
it's
one
of
those
things
that
you
know.
I
think
the
the
value
is
being
increasingly
recognized
within
microsoft,
which
is
which
does
not
mean
that
it
wasn't
before,
but
I
think
maybe
in
the
in
the
dot
net
core
time
frame,
some
of
the
docs
kind
of
like
behind
and
now
that's
really.
G
E
G
E
Things
you
know
we,
we
have
people
to
help
with
the
editing
and
the
grammar
and
that
kind
of
stuff,
but
we
have
to
write
the
content.
So
it's
a
great
example
of
where
we
have
to
draw
the
balance
between
okay.
We
haven't
implemented
this
feature,
but
we've
very
well
documented
these
other
things,
so
people
can
actually
use
it
and
it's
it's.
It's
a
challenge
to
get
that
balance
right,
but
but
we
do
our
best
yeah.
I'm.
A
To
or
used
the,
for
example,
with
those
getting
started
articles
you
see
all
those
code
snippets
and
highlights,
and
I
don't
even
have
to
copy
and
paste
code,
I'm
actually
referencing
the
sample
directly.
So
as
the
sample
changes,
the
code,
snippets
change
and
it's
just
little
things
like
that
that
make
it
incredible
and
that
it's
open
source.
So
anyone
listening
to
this,
who
has
a
correction
that
they
think
should
be
made.
B
E
I
could
spend
the
next
hour
answering
that
question,
but,
but
I'm
not
going
to
I,
I
would
say
that
you
know
we.
We
had
a
lot
of
very
passionate
discussions
around
how
to
support
the
equivalent
of
complex
types
in
ef6
and
and
before,
and
one
of
those
options
was
okay,
so
also
at
the
same
time,
we
know
we
want
to
support
very
good.
E
A
G
E
A
So
yeah,
you
might
have
a
a
rack
with
five
copies
of
the
same
shirt
right.
That
would
be
one
way
to
do
it.
So
this
is
the
the
entity
framework
core
in-depth
series,
and
this
is
why
we
brought
this
team
team
on
because
this
series
just
came
out
and,
as
you
can
see,
there's
multiple
parts,
there's
a
focus
on
performance
view,
models,
configuration
so
on
and
so
forth.
A
I
won't
read
all
all
of
the
parts,
but
it's
a
very
in-depth
series
and
there's
some
interesting
motivations
be
behind
why
it
was
created
and
also
just
both
of
these
gentlemen-
have
plenty
of
experience
that
they
bring
to
the
table
with
actually
using
entity
framework
core.
So
why
don't?
I
start
with
a
question
for
robert
and
phil
on.
You
know
exactly
what
was
your
motivation
behind?
A
C
C
You
know:
they're
called
developer
tools
for
a
reason
and
they're
tools,
because
you
build
things
and
if
you
think
about
visual
studio,
it's
just
this
giant
toolbox
of
various
tools
and
some
of
the
tools
are
ide.
I
view
the
language
as
the
tool
I
view
net
as
a
tool.
I
view
anything
you
do
whether
it's
a
designer
or
a
wizard
or
code.
You
write
as
a
tool
you're
using
because
at
the
end,
you're
building
an
application,
so
the
whole
show
has
always
been
about
the
tools
you
can
use
to
build
up.
C
So
some
episodes
are
about
what
you
literally
think
of
tools.
You
know
performance
tools
or
refactorings
or
whatever,
but
I've
always
we've
also
done
lots
of
episodes
on
things
like
c
sharp
or
vb
or
net
now
theon.net
show
is
also
came
around
and
so
a
lot
of
the
net
framework
e
language
type
things
are
on
that
show,
but
we
we
don't.
We
don't.
You
know
say
that
you
can
only
do
dotnet
on
on.net
show
and
you
can't
do
net
on
the
toolbox
show.
C
C
We
did
a
series
on
design
patterns,
so
we
said
we
should
do
another
series
and
we
picked
ef
core
because
we
think
there's
a
lot
of
misconceptions:
a
lot
of
knowledge,
a
lot
of
people
who
maybe
haven't
thought
about
it
in
a
while.
Maybe
they
played
with
any
framework
a
while
ago,
but
you
know
they
haven't
really
played
with
core.
C
So
we
started
out
with
an
intro
series,
a
five
part
intro
series
on
ef
core
and
then
after
that,
followed
up
with
the
in-depth
series
where
we
picked
10
specific
topics
and
again,
the
whole
idea
is
to
provide
another
way
for
people
to
learn
how
to
use
ef
core
and
then
how
to
make
the
most
out
of
it
and
phil
was.
You
know,
awesome
and
gracious
in
his
time
agreeing
to
do
what
wind
up
being
15
episodes
all
together.
B
B
You
know
why
ef
core
is
so
much
better
than
the
ef
and
why
e,
of
course,
should
be
part
of
your
toolbox
for
certain
things
right,
certainly,
if
you're
building
a
reporting,
app
ef
core,
isn't
the
right
tool,
but
if
you're
building
forms
over
data
ef
core
is
absolutely
the
right
tool
and
there's
you
know,
as
robert
said
there's
so
many
misconceptions,
you
know
I'll
be
at
a
conference.
I
do
a
lot
of
full
day
workshops
and
on
a
spin
on
core
and
ef
core
and
I'll
have
people.
You
know
ping
me
beforehand.
B
It's
like!
Oh,
you
know
you're
doing
a
morning
of
ef
core.
Can
I
just
come
for
the
afternoon
when
you
talk
about
asp.net
core
and
I'm
like
well,
no
because
you're
gonna
be
behind
and
the
hands-on
labs
require
you
to
be.
You
know
on
time
and
oh
by
the
way,
you
know
why
don't
you
want
to
come
to
ef
core?
Well,
it's
slow,
my
boss,
won't
let
me
use
it.
The
dbas
hate
it
right.
B
All
these
non-technical
well,
so
is
a
technical
reason,
but
it's
wrong,
but
all
these
non-technical
reasons
that
people
come
up
with.
I'm
like
you
know
what
you're
at
the
conference
anyway
just
spend
the
half
day,
and
invariably
people
come
up
to
me
afterwards
and
they're
like
we
had
no
idea
that
ef
core
has
come
this
far,
and
it
can
be
this
helpful
for
what
we're
trying
to
accomplish
you
know
so,
and
that's
that's
really.
You
know
that's
why
we
kicked
it
off
for
performance
right.
B
I
I
hear
all
the
time
ef
core
is
slow
or
they'll
say
ef
is
slow
and
I'll
be
like
all
right.
If
you're
talking
about
ef
classic
the
early
versions,
I'm
to
give
you
that
it
was
slow
right,
it
might
have
sped
up
parts,
your
development,
but
as
a
runtime,
it
kind
of
sucked
and
there's
reasons
for
that,
but
ef
core.
You
know
one
of
the
things
I
always
point
out
and
I'm
just
that's
why
I'm
so
thrilled
about
the
whole
net.
B
Core
ecosystem
is
prior
versions
of
of
net
asp.net
right
they
had
goals
and,
and
the
goals
didn't
really
include
performance.
Initially
they
were
trying
to
meet
an
objective.
However,
you
get,
you
know,
get
her
done
right,
and
so
they
got
it
done
and
then,
when
performance
started
to
matter,
because
now
we're
going
to
the
cloud
or
now
we're
distributed
systems
right,
if
you
think
about
early
on
everything,
was
client
server.
Nobody
cared
about
performance
because
you
had
your
entire
computer
to
do
the
processing,
and
then
you
know
eight
years
down
the
road
you're.
B
Looking
at
es6
scratching
your
head
going,
we
can't
change
it
right,
we're
locked
in.
If
we
change
this,
we
break
everybody.
So
the
decision
and
I'm
not
speaking
for
microsoft-
I'm
not
a
microsoft
employee.
These
are
my
opinions,
but
I
believe
the
decision
was
made.
You
know
what
let's
go
ahead
and
break
everybody,
which
is
what
dot
net
core
did
right,
but
but
this
is
our
brass
ring
right.
How
many
people
are
listening
to
show
right
now
go
back
and
look
at
code.
B
You
wrote
a
week
ago,
three
weeks
ago,
a
year
ago
and
go
holy
crap.
I
could
have
done
that
so
much
better
right.
This
was
the
opportunity
for
all
the
teams
in
the
efcor
team,
especially
to
go
back
and
say
what
is
our
foundation?
What
are
we
trying
to
accomplish
right?
What's
our
sprint
goal,
let's
figure
that
out
and
let's
write
code
to
match
that
as
opposed
to
some
other
random
goal,
and-
and
you
know
I
I
rejoiced
when
I
heard
that
the
designer
was
not
coming
back
into
ef4-
I
think
I
did
it.
B
I
think
I
danced
a
little
bit
because
almost
every
time
I
talk
to
somebody
who's
using
ef
classic
and
they
say
what
is
your
biggest
problem
and
they
say
performance
I
said:
are
you
using
the
designer
and
they
said?
Yes,
I'm
like
okay?
Well,
there
you
go
right,
you
can
draggy
droppy,
but
now
your
performance
is
going
to
be
out
to
crapper
right,
and
so
I
I
guess,
that's
really.
My
bait
motivation
is
to
I've
spread
the
love
right
because
he
of
course
comes
so
far.
E
E
You
know
system
that
was
the
starting
point
in
the
asp
net
core,
which
you
know
david
fowler
and
other
people
worked
on
and
and
from
the
beginning,
we
were,
you
know
in
lockstep,
with
them,
with
the
same
goals
of
high
performance.
Modern
extensible,
open
source
allow
the
community
ecosystem
to
plug
things
in.
E
We
have
brilliant
providers
for
postgres
and
my
sequel
now,
because
the
community
is
able
to
write
them
and
you
run
our
tests
and
test
them
and
ship
them,
whereas
in
af6
you
had
some
other
providers
for
them,
but
because
it
was
all
based
around
sql
server,
they
they
weren't
very
useful.
So
there
was
all
these
goals
that
aligned
with
ef
core
and
project
k,
which
all
became.net
core
and
now.net
5,
and
and
it's
awesome,
it's
reinvigorated
the
platform.
E
B
E
Well,
I
don't
have
time
yeah,
so
we
we
have
performance
tests
that
that
run
continually
on
basically
on
every
check-in
and
twice
a
week
in
our
weekly
triage
meetings.
We
look
through
all
of
the
results
and,
if
there's
any
regression,
in
fact,
if
you
follow
along
on
the
github
repo
you'll,
see
us
file,
these
issues
and
it'll
be
a
little
graph
in
there
says:
hey,
look,
we
regress
the
perf
on
this
thing
and
then
somebody
goes
and
looks
at
it
and
basically
we
put
we.
We
fix
the
perf.
E
So
obviously,
as
always,
we
need
more
of
those
tests
and
there's
so
many
different
variations,
and
you
know
in
af
core
that
you
can
do
that.
We
don't
have
enough
testing
there,
but
from
a
philosophical
and
a
process
perspective
like
we
care,
we
care
that
the
perf
doesn't
regress
and
we
care
that
we
make
it
faster
when
we
can.
B
Well
and
it's
not
just
the
perf
of
e
of
core
itself
right,
it's
the
brains
behind
the
link
to
sql
translation
engine
right.
I
remember
early
on
in
core
a
friend
of
mine,
who's,
a
hardcore
dba
right.
You
know
certified
and
stored
procedure.
Everything-
and
I
said
it
was
you
know
it
wasn't
that
early,
because
I
didn't
want
to
do
it
early.
I
think
it
was
a
2.1
time
frame.
I
said:
okay,
let's,
let's
look
at
your
database.
Let
me
write
some.
You
know.
B
E
Yeah
it
shut
them
up.
One
of
the
one
of
the
other
goals
we've
had
in
in
ef
core
is
to
write
simple,
readable
sql
to
generate
sync,
simple,
readable,
sql,
obviously
efficient
as
well,
but
not
just
efficient,
also
kind
of
where
we
can.
You
know
efficiency
trumps
this,
but
where
we
can,
we
want
to
write.
We
want
to
generate
sql
like
you
would
have
written
it
and
not
make
the
argument.
E
Oh
the
query,
compiler
and
sql
server,
or
whatever
is
going
to
just
optimize
that
also
the
same
thing
anyway,
which
may
have
been
true
and
was
true
in
a
lot
of
cases,
but
different
providers
optimize
differently
for
one
thing
and
secondly,
you
want
to
be
able
to
have
it,
like
you
say,
pass
it
to
somebody
who
knows
sql
and
say:
is
this
what
you
would
have
written
and
if
they
say
no,
then
you're
like
okay?
Well,
well,
you
know
what
should
we
do
then,
because
that's
not
ideal
if
we're
writing
different
sequels.
D
Yeah
I
have
to
interject
on
this.
Like
one
small
point
on
this,
I
remember
that
there
were
some
days
when
people
would
say.
Oh
you
know,
you're
using
an
orm.
Sql
is
basically
your
assembly
right.
It's
like
compiling
somebody
is
compiling
your
code
for
you
you're
not
supposed
to
care
about
what
comes
out
right,
you're
supposed
to
care
about
it
working,
and
I
think
so.
D
I
I
did
used
to
interact
with
ef
and
the
old
stack
and
ef6
and
so
on,
and
if
you
look
at
the
sql
that
gets
generated
there,
that
is
the
way
it
looks
like.
It
looks
like
a
bit
of
assembly
that,
if
you
know
sql
you're
not
necessarily
going
to
be
able
to
parse,
especially
if
you're
looking
at
some
of
the
more
complex
patterns
tpt
and
things
like
this
you're
not
actually
going
to
understand.
D
If
you
look
at
the
actual
sequel,
you
should
not
be
scared
to
look
at
it,
and
it
is
fine,
and,
as
anybody
who
is
using
a
database
knows
at
the
end
of
the
day,
if
performance
is
something
that
you
do
care
about,
you
should
be
looking
at
at
least
a
little
bit
at
your
sequel
at
those
queries
and
escort
makes
that
actually
possible
when
compared
to
previous
versions
of
this.
That's.
E
E
To
to
add
to
that
and
to
a
comment
on
the
on
the
chat
here
in
afcor
five
zero,
we
have
the
two
query
string.
Two
query
string
api,
so
you
can
now
you
know
hop
in
a
debug
view.
You
can
hover
over
your
iqr.
You
can
see
what
sql
we
generate.
You
know
print
it
out.
You
know,
so
it's
easier
to
see
that
information
than
it
was
even
if
we
had
logging
before
you
could
always
log
it.
But
now
you
don't
need
to
run
it.
B
B
A
really
nice
feature
that
brought
back.
That
was
something
that
was
an
ef
classic
that
finally
made
it
into
ef
core,
where
you
could
get
the
actual
query
out.
Looking
at
the
comments
going
by
and
and
somebody
is
a
fan
of
dapper
and
if
dapper
works
better
for
you
then
use
it
right.
Nobody
on
this
call
is
saying
you
have
to
use
ef
core,
I
mean
yes,
it
has
issues
right.
B
The
m
plus
one
issue
which
has
been
resolved
there
are
some
missing
features
that
honestly
made
1.1
very
difficult
to
use
in
a
non-web
world
2.1.
I
think
the
features
were
there
where
I
could
use
it.
You
know
universally
for
web
and
wpf
3.1
brought
in
even
more
features
and
five.
You
know
I'm
looking
forward
to
actually
seeing
six,
because
I'm
I'm
really
hesitant
to
use
the
current
version
versus
lts,
but
yeah
I
mean
it
keeps
getting
better.
E
I'd
like
to
actually
ask
you
about
that,
a
little
bit.
It's
interesting!
You
say
that
because,
because
more
and
more
it
feels
to
me,
like
certainly
on
the
team
and
when
people
are
interested
in
getting
the
new
ef
course
stuff
we're
pushing
people
to
use
the
daily
builds,
which
is
about
as
far
as
you
can
go
to
the
opposite
direction
of
using
the
lts
and
the
reason
we
do.
That
is
that
I
mean
essentially
this
wasn't
true
in
effort
three,
because
in
efco3
we
did
the
whole.
E
You
know
query
rewrite
so
things
were
broken
while
we
were
doing
the
previews,
but
that's
not
the
normal
case.
Normally
all
of
our
tests
run
on
every
build
that
we
do.
You
know
if
you
break
the
build
which
doesn't
happen
frequently,
then
you've
got
to
fix
it
immediately.
So,
basically,
our
daily
all
you
get
when
you
take
a
release
version,
is
we
put
a
stamp
on
one
of
those
daily
builds
essentially
and
said:
that's
the
release
version.
It's
not
it's
not
inherently
any
better.
B
B
You
would
maybe
you'd
be
surprised.
Maybe
she's
come
to
one
of
my
workshops,
one
time,
because
when
I
go
through
the
whole
licensing,
confusion,
yeah
and
the
versioning
confusion,
yes,
somebody
will
drop
the
f-bomb
when
I
talk
about
2.2
being
unsupported,
and
so
these
people
are
on
2.2
and
they're
going
I'm
like
you're
out
of
support
right,
I
mean
what
does
that
mean?
Well,
it
might
mean
nothing
to
you,
but
for
my
customers
that
is
a
checkbox
that
the
regulators
look
at.
E
B
I'm
not
going
to
five,
I
will
I
will
play
with
it.
I
will
talk
about
it,
I'll
write
about
it,
but
I'm
not
going
to
recommend
my
customers
go
to
five
for
a
couple
reasons.
If
they
go
to
five
and
microsoft
stamps
a
5.1
that
means
5.0
is
out
of
support
in
three
months
after
5.1,
right
and
so
we've
got
that
whole
dance
going
on,
whereas
I
would
rather
just
tell
my
customers
hey
stay
on
the
lts's
and
you
know
we
can
look
at
and
we
can
prototype
it
and
think
about
these.
B
E
Yeah
now
that
that
makes
sense
I'll
say,
though,
that
the
the
the
leaving
people
in
the
lurch
with
the
2-2
thing-
that's
that's
known
and
discussed
across.
You
know
not
not
the
ef
team,
but
you
know
the
wider
you
know.net
or
guys
being
something
that
we
want
to
avoid
doing
that.
You
know
what
it's
caused.
It's
caused
various
problems
for
customers
and
us
internally,
and
we
wouldn't
want
to
do
that.
E
So
hopefully
it
won't
be
quite
as
bad
as
the
the
2-2
situation,
but
but
your
points
are
valid
I'll
say
one
more
thing
on
this,
though
one
of
the
reasons
that
you
know,
people
want
to
be
on
supported
versions,
obviously
is
to
get
security
fixes
when
they
come
in.
But
since
we
already
already
always
put
security
fixes
into
you
know
the
the
main
branch
as
it
were,
basically
at
the
same
time
it
might
be
slightly
after,
but
basically
at
the
same
time
as
they
go
into
a
release.
E
It's
actually
a
very
good
way
of
getting
those
security
fixes
quickly
too
so
understanding,
there's
regulatory
things
and
you
have
to
have
supportive
software.
But
if
you,
if
you're
in
a
place
where
you
can
use
daily
bills,
I
I
would,
I
would
say
that's
something
you
should
look
at.
You
know,
depending
on
your
domain
and
everything.
E
D
Just
to
add,
like
a
very
very
small
thing,
so
one
of
the
points
with
2.2
is
mainly
that
3.0
was
such
a
big
change
and
upgrading
from
2.2
was
such
a
difficult
thing
for
our
customers,
which
I
think
is
the
the
real
source
of
the
issue
that
happened
with
tutu.
So
basically,
if
you're
saying
to
yourself,
I
might
go
to
5.0,
but
I'm
scared
about
what
happens
later.
We
are
no
longer
we're,
definitely
no
longer
intending
to
do
any
sort
of
version.
That's
going
to
be
as
difficult
to
upgrade
to
as
it
was
for
3.0.
D
So
basically,
if
you're,
okay,
with
doing
the
upgrade
to
6.0
one
year
later
after
5.0,
then
there's
no,
let's
say,
there's
much
less
of
a
risk
than
there
was
before
to
get
being
stuck
in
the
lurch
and
that's
in
in
that
sense.
Of
course,
you
still
have
to
commit.
If,
assuming
you
want
to
stay
unsupported
versions,
you
still
have
to
somewhat
commit
to
doing
that
upgrade
to
a
6.0
rather
quickly,
but
at
least
what
we
can
tell.
D
E
B
E
Yeah
I
mean
I,
I
absolutely
not
pushing
back
on
what
you're
saying
at
all
there
that,
but
there
are
first-party
services
in
microsoft
that
are
running
on
at
least
preview
it.
Sometimes
they
they
switch
to
daily,
builds
of.net
core
all
up,
and
I
don't
know
if
I'm
I'm
allowed
to
name
them.
So
I
won't
because
I
don't
want
to
you
know,
get
in
trouble
here,
but
they're,
big
things
that
everybody's
heard
about
and
they
run
on.
E
You
know,
because
if
you
can
do
that,
and
you
don't
have
the
regulatory
concerns
and
the
business
concerns
it's
it's
in
the
modern
environment
where
we
do
build,
we
do
have
continuous
integration
going.
We
do
ship
those
bills,
we
are
very
responsive
to
hey,
we
broke
you,
we
can
put
a
fix
in
there
and
get
it
out
basically
the
same
day.
You
know
it's
it's
a
path
that
I
think
people
should
consider
when
they
can.
That's
all.
B
A
A
B
B
You
know
full
framework
which
ef
core,
obviously
at
that
time
and
still
mostly
with
caveats,
can
run
on
on
the
classic,
and
so
we
had
our
ef6
project
in
there
we
had
our
ef
core
project
in
there
and
the
heavy
headers.
You
know
the
the
queries
that
were
called
most
same
models
right.
We
had
to
tweak
some
of
the
attributes
and
use
fluent
api
on
both
sides
to
make
it
work,
same
models,
ef6
or
ef,
core
1.1
queries.
We
released
that
the
performance
complaints
dropped
out
of
the
top
10.
B
wow.
So
so
that's
real
world
evidence.
What
I
have
here-
and
this
is
jeremy
you-
I
know
it's
robert-
it's
on
our
show
notes
the
link
to
the
the
code,
but
I've
got
a
a
project
here
that
all
it
does
is
call
into
two
other
projects
and
runs
a
series
of
things.
Let's
talk
about
those
things,
so
I've
got
ef,
6.1.3
6.4.4,
so
the
net
corrified
version
of
ef6
and
that's
not
truly
a
rewrite.
That's
just
core
support.
B
Yeah
and
then
I've
got
3.1.6
for
ef
core,
and
it's
going
against.
Adventure
works
on
my
machine
now.
I've
got
a
pretty
decent
machine,
32
gig
of
ram,
it's
16
cores,
so
it's
not
slow,
ssd
right,
but
no
network
latency,
no
other
things
out
about
it.
So
let
me
run
this
and
I'll
get
this
warmed
up
on
a
different
screen,
because
it's
just
a
console
app
calling
both
systems
three
times
where
I
call
you
know,
get
17
000
records.
B
I
think
it's
19
000
records
these
all
these
things
that
you
shouldn't
do
when
you're
using
an
orm
by
the
way,
I'm
doing
a
lot
of
them
just
to
show
the
magnitude
and
then
once
it's
done,
which
it's
almost
done
now,
we'll
just
go
through
the
results.
It's
going
to
bounce
a
little
bit.
So
can
you
see
my
screen?
Okay?
Is
that
font
big
enough?
I
think
it
is
okay.
A
B
B
If
you
had
10
changes
right
to
change
the
db
change,
trackers
tracking,
what
changed
right,
that's
one
of
the
beauties
of
using
it
as
a
developer.
You
don't
have
to
track
all
these
things
and
you
call
save
changes
on
the
db
contacts.
So
the
db
contacts
and
ask
the
chain
tracker
hey
what
do
I
have
to
do
and
the
change
tracker
says:
oh
you've
got
these
changes,
so
those
changes
are
then
sent
to
the
link,
translation
engine
or
the
sql
translation
engine
and
the
sql
is
generated
to
do
those
in
ef6.
B
This
code
exists.
So
let's
look
at
the
numbers,
so
I'm
querying
19
000
records
out
of
adventure
works.
This
is
ef64,
so
it
took
about
a
second
half
a
second,
for
course,
so
about
a
50
improvement.
Now,
if
you're
querying
19
000
records
from
an
orm
you're,
probably
doing
it
wrong,
so
you
might
want
to
think
about
that.
B
There
is
a
concept
in
ef
core
where
you
can
say:
I
want
it
to
be
untracked,
so
you're
telling
ef
core.
Please
don't
take
this
thing.
Put
it
in
a
in
the
you
know,
don't
have
the
db
tracker
track
it
so
just
an
entity.
That's
in
your
context-
and
this
is
great,
for
example,
if
you're
building
a
website
the
get
methods
will
never
do
an
update,
so
you
can
send
them
as
untracked
right.
B
B
B
E
E
Why
you
know
you're
just
talking
about
how
you
look
back
at
old
code,
and
you
say
I
could
do
that
better
now,
so
we
look
back
at
query
type
and
we
tried
to
figure
out
why
we
thought
that
was
a
good
idea
and
it
really
wasn't.
I
don't
think,
but
because
we've
given
it
you
and
made
it
easy,
then
taking
it
back
make
people
upset,
but
I
think
it
well.
E
Yes,
yes,
so
query
type.
I
think
just
just
to
finish
this,
though
I
think
there
this
is
a.
This
is
one
of
the
the
challenges
we
have
with
dot
net
moving
forward
and
with
dot
net
core
becoming
dot
there.
Five,
and
that
is,
if
we
stick
to
rigid
compatibility,
then
we
end
up
in
a
place
like.net
framework
where
we
can't
evolve
anymore.
It
is
what
it
is
and
anytime
you
change
it.
You
break
too
many
people
to
change
it.
E
So
that
means
you're
putting
db
career
type
back
in.
Is
that
what
I
hear?
No
it's
gone
now,
it's
too
late.
That
shift
has
sailed.
On
the
other
hand,
we
are
in
general,
not
just
for
ef,
but
across
net
core.
You
know
trying
to
sail
this
balance.
Basically
between
evolve
the
framework
where
it
needs
to
evolve,
but
not
break
people
or,
if
you
break
them,
make
it
super
super
easy
for
them
to
unbreak
themselves,
which
is
really
the
like.
Typically
people
don't
mind
if
you
say:
okay,
rebuild
your
application
and
change.
E
B
So
a
query
type
in
ef
core
is
you're
setting
it
up
from
the
beginning.
This
will
never
be
tracked.
I'm
never
going
to
do
updates,
I'm
never
going
to
do,
deletes
and
they're
going
to
do
changes
right.
I
just
need
to
read
this
data
into
an
object
model
or
into
my
object
graph,
and
you
can
see
that
the
performance
this
is
now
ef
core
versus
ef
core
and
the
query
type
typically
performs
a
little
better,
something
I
mean
it's
close
right.
B
I
mean
we're
talking
milliseconds,
so
a
complex
query.
This
is
an
interesting
one
and
I
did
not
warm
it
up
ahead
of
time.
You
can
do
some
some
pre-compilation
of
queries
and
what
I
mean
by
complex
query.
This
is
just
something
that
has
like
a
gazillion
joints
right.
So
it's
not
truly
complex
prior
to
3.1
the
numbers
weren't
as
good,
but
you
can
see
once
it's
warmed
up.
It
actually
goes
amazingly
fast.
So
that's
something
you
should
look
at
with
your
pre-compilation
features.
That's
built
in.
E
Yeah,
so
it's
interesting
on
that
because
you
know
there's
the
query:
has
multiple
phases
like
you're
saying
so,
the
the
query
compilation,
which
typically
only
happens
once
because
we
cache
it
it's
something
that
we
haven't
focused
too
much
time
on
doing
the
perf
improvements
on
yet
that
it's
not
that
we
don't
we.
We
would
like
to
do
that.
E
But
that's
probably
why
you're
seeing
the
query
compilation,
you
know
obviously
on
the
first
iteration,
be
vastly
different
from
the
other
ones
after
we've
done
the
the
caching
and
it's
it's
faster,
but
we'll
get
at
some
point
we'll
get
to
make
the
compilation
faster
at
some
point
and
also
in
some
future
version,
allow
much
better
pre-compiled
queries
potentially
using
the
roslin
code,
generators
to
pre-generate
some
stuff
as
you're
building
your
your
project
rather
than
us
dynamically
doing
it
the
first
time.
We
see
your
query,
for
example.
So
we
have
we
have.
E
B
This
demo
was
so
important.
I
wanted
to
call
it
twice
but
anyway,
so
this
is
adding
a
thousand
records
and
calling
save
changes,
and
this
shows
the
the
batching
in
you
know
in
full,
so
we've
got
19
seconds,
16,
almost
17
seconds
and
14
seconds
to
save
a
thousand
records
with
ef6
and
we're
less
than
a
second.
You
know
less
than
right
around
a
quarter
of
a
second
on
down
and
that's
you
know,
that's
kind
of
how
I
kick
off
all
my
ef
core
talks
and
I
just
realized.
B
As
well
but
yeah,
so
if
you,
if
you
are
hesitant
to
move
to
ef
core,
because
you
had
a
nasty
experience
with
ef
classic
try
ef
core
right,
that's
that's
the
the
long
and
short
of
it
and
you
probably
will
if
you're
watching
this
show,
so
I'm
preaching
to
the
choir
a
little
bit.
But
you
know
one
of
the
things
that
we
went
through
these
15
episodes
robert
and
I
and
he
had
some
exposure
if
core.
B
C
I
made
some
minor
changes
to
the
database,
then
rewrote
the
service
and
anecdotally
saw
what
I
thought
was
an
order
of
magnitude
and
improvement
and
performance
working
with
basically
the
same
data,
a
small
data
set,
but
just
demonstrably
quicker.
So
I
didn't
necessarily
do
perf
testing,
but
just
from
eyeballs
it
went
from
being.
Oh,
my
god.
This
is
slow
to.
Oh,
that's
pretty
usable.
I
wonder
how
I
can
make
it
a
little
bit
faster,
which
is
an
order
of
magnitude
improvement.
C
If
you
want
to
see
all
the
tasks
that
are
outstanding,
so
phil
showed
the
global
query
filter
where
you
could
basically
make
that
as
the
default.
Now
you
don't
have
to
edit
all
your
added
to
all
your
queries.
It's
a
really
simple
feature:
it's
very
easy
to
implement,
but
I
then
spent
for
this
particular
app
days.
C
Thinking
about
do
I
want
to
delete
the
data.
Do
I
want
it
to
stick
around?
What
are
the
use
cases?
What
are
the
questions
you
could
ask
if
you
actually
had
access
to
that
previous
data,
and
would
you
ever
actually
ask
those
questions,
so
you
know
if
it's
a
to
do
app.
I
want
to
know
what
are
the
tasks
that
are
due
to
me
and
any
tasks
that
I've
already
completed?
Well,
that's
ancient
history
right
well,
is
it
ancient
history?
C
Would
I
ever
go
back
and
say
what
percentage
of
tasks
have
been
assigned
to
me
versus
assigned
to
my
wife?
What
percentage
of
tasks?
What
percentage
of
the
hard
tasks
have
been
assigned
to
me?
What
percentage
of
the
tasks
that
were
assigned
to
me
were
delivered
late
right?
So
a
lot
of
questions
you
can
ask
if
you
actually
had
the
data,
but
would
you,
but
would
you
ask
those
questions
yeah,
or
do
you
just
want
to
insult?
C
You
just
want
to
have
insurance
because
a
year
from
now
someone's
going
to
ask
those
questions,
and
you
can't
answer
them
because
you
deleted
all
the
data,
so
it
really
forced
me
to
sit
and
think
about
the
application
itself
and
it
wound
up
being
a
really
interesting
design
exercise.
The
feature
itself
is
pretty
much
a
no-brainer
to
implement,
but
I
spent
a
lot
of
time
thinking
about
what
I
wanted
the
app
to
do.
B
Well,
in
the
good
news
that
you
know
that
whole
thinking
that
you
went
through,
that's
all
providing
additional
value
to
the
business
or
your
relationship
in
this
case
right,
so
you
can
pull
up
the
app
and
say
look
colette.
I
did
200
tests.
You
did
five
right.
It's
your
turn.
You've
met
my
wife.
You
know
the
conversation
would
never
go
like
that
yeah.
I
know
she's
wonderful
by
the
way,
certainly
the
better
half
the.
A
B
You
can
make
those
decisions
and
and
a
lot
of
that
hardness
concurrency
right,
concurrency
support
people,
don't
think
about
concurrency
right.
What?
If
robert
and
I
are
working
on
the
same
thing
and
we
want
to
save
it,
and
I
save
it
first
and
he
tries
to
save
it.
Well,
the
beauty-
and
I
don't
have
time
to
actually
run
this,
but
let
me
just
look
at
I'm
going
to
show
you
my
my
exception
here,
so
you
can
automatically
have
ef
core,
throw
a
db
update,
concurrency
exception.
B
If
somebody
tries
to
update
a
record
after
somebody
else
is
updated
and
sql
server
uses
a
row
version,
I'm
trying
to
talk
quick,
because
I
know
we
have
a
time,
but
the
good
news
is
then
it
exposes
those
entries
that
failed.
The
concurrency
check.
I
can
get
the
original
values
that
that
I
had.
When
I
pulled
this
record
from
the
database,
I
can
look
at
the
current
values.
This
is
what
I
changed
it
to.
I
can
use
all
kinds
of
link
variations
to
figure
out
what
I
modified.
B
If
I
want
to
make
another
database
call
it's
important.
I
call
this
out.
This
is
a
database
call,
but
then
I
can
get
the
current
values
from
the
database.
So
then
I
can
put
a
screen
up
saying:
well,
here's
what's
currently
in
the
database!
Here's
what
it
was
when
you
loaded
it!
Here's
what
it
is
that
you
try
to
change
it
to
and
then
you
know,
do
some
ui.
So
I
can
pick
and
choose,
or
I
can
programmatically
say
robert
tried,
you
know
changed
field
a
I
changed
field
b.
B
E
C
E
We've
had
those
discussions
about.
Does
it
really
matter
a
lot?
You
know,
especially
when
diego
was
you
know,
still
the
pm,
because
he
felt
very
strongly.
You
know
people
should
be
using
optimistic
concurrency.
I
I'm
putting
words
in
the
mouth.
I
apologie,
if
you
didn't
exactly
say
that,
but
you
know
I
felt
people
should
be
checking
for
this
kind
of
thing,
but
what
we
found
is
a
lot
of
customers
will
actually
say.
I
don't
care
like
last
one
wins,
that's
it
fine.
E
B
B
The
other
thing
that
we
turn
on
automatically
is
connection
resiliency,
because
we
get
that
for
free,
yeah,
right
and
and
that
those
are
very
seldom
do
I
say
you
have
to
do
something
or
you
should
never
do
something
or
you
will
never
do
something,
but
those
are
two
things
that
we
turn
on
now.
What
the
business
decides
to
do.
If
there's
a
concurrency
issue,
that's
a
business
problem
right,
but
ef
core
makes
it
very
simple
and
for
those
watching
who've
never
used
this.
B
But
you
know
one
two,
three
four,
let's
say
and
then
robert
comes
in
and
he
tries
to
update
it
and
it's
one
two
three
four
for
the
time
stamp,
so
he
just
says:
update
sql
server
says
there
is
no
blog
id
of
five
with
a
timestamp
of
one
two,
three
four,
so
zero
records
return,
it's
not
an
exception
on
the
sql
server
side.
It's
just
nothing
happened
right.
I
got
nothing
to
do
nothing
to
see
move
along
so
then
he
of
course
you
know
the
chain
tracker
says
hold
on
a
minute.
B
E
Well,
you
have
to
decide
how
to
handle
it.
That's
why
not
to
turn
it
on
and
if
you,
if
your
decision
of
how
to
handle
it,
is
it's
fine,
just
write
it
anyway,
then
there's
no
point
in
using
it,
but
your
point
is
very
valid.
It's
it's
certainly
a
very
useful
thing
that
you
can
just
switch
on
and
easily
use.
I
absolutely
agree.
D
I
think
optimistic
concurrency,
though,
and
also
connection
resiliency,
are
pretty
good
ideas,
pretty
good
examples
of
stuff
you
get
for
free
with
efcor,
and
it
would
be
good
if
people
would
kind
of
think
what
they
would
have
to
go
through
to
do
the
same
kind
of
thing
on
dapper,
so
where
you
get
a
much
more
low
level
thing
with
much
less
kind
of
stuff
like
implemented
for
you
for
free.
This
is
typically
the
kind
of
stuff.
D
If
you
have
to
go
dapper
and
write
your
own
sql
and
do
these
kinds
of
things
you're
going
to
end
up,
there
may
be
a
plug-in
out
there
for
dapper.
That
does
some
of
these
things.
So
I
might
be
you
know
not
totally
correct
here,
but
that's
a
good
idea
of
the
kind
of
added
value
that
you
get
in
ef
corp.
B
E
B
Remember
the
default
sounds
right:
okay,
yeah,
because
I
have
five
in
my
demo,
so
it
will
you
try
up
to
five
times
and
then,
if
it
fails
after
the
fifth
time,
you
actually
get
a
retry
limit
exceeded
exception.
So
from
a
developer
standpoint
again,
you
know:
hey
sql,
server's,
getting
hammered.
How
do
I
want
to
handle
this
as
opposed
to
just
some
random
exception
that
didn't
work?
You
can
customize
it,
but
why?
When
sql
server
team
gives
us
this
for
free.
B
A
A
Has
some
in
the
background
for
his
too
so
I've
got
the
link
to
the
show,
there's,
obviously
a
lot
more
topics
we
could
probably
spend
a
day
on
this
view
models
configuration
we
talked
about
query
filters,
resiliency,
computed
columns,
etc.
So
definitely
check
out
this
series.
It's
a
great
in-depth
series-
and
I
I
love
you
know
that
we
talked
about
this,
how
it
dispels
some
myths
about
entity
framework
core.
Thank
you,
robert
and
phil,
for
your
time
today.
I
know
that
you
have.