►
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-06-24
B
I'm
here
with
Jeremy
and
also
we
have
Bryce
and
Laurence
and
submit
in
the
background,
if
we
have
any
questions,
come
up
and
other
people
on
the
team
may
join
so
welcome
to
another
PF
community
stand
up,
we're
gonna,
look
at
some
links
in
a
second
and
then
after
that
we
have
our
own
dotnet
data
p.m.
Jeremy
lick
nurse
who's
going
to
demonstrate
using
EF
core
in
blazer
apps
and
some
of
the
patterns
that
you
can
use
to
manage
your
context
and
you
know,
create
great
apps
and
blazer
so
super
exciting.
D
A
B
Okay,
okay,
so
it
seems
like
we
have
some
technical
issues.
So
if
you
heard
me
before,
then
congratulations,
if
not,
then
we're
back
again.
So
this
is
the
EF
community
stand
up
I'm
here:
I'm
Arthur
I'm,
the
engineering
manager
on
EF
and
I'm
here
with
several
people
from
the
EF
team.
I
think
we
have
shy
and
Bryce
and
Laurence,
and
somebody
else
probably
I,
don't
see
this
their
screens
anymore.
Who
will
jump
in
if
they
have
questions,
and
we
also
have
our
own
Jeremy
lick
nice
net
data
p.m.
B
who
is
going
to
take
up
most
of
the
show
demonstrating
EF
core
and
blazer.
We've
done
a
lot
of
work
recently,
looking
at
good
patterns
in
conjunction
with
the
blazer
team,
so
we're
going
to
show
how
you
can
create
some
some
great
apps
and
manage
your
context
appropriately
and
everything
before
that.
Hopefully,
you
can
see
on
my
screen.
B
We've
got
some
of
the
community
links
that
we
want
to
go
through
really
quickly,
so
the
first
one
is
a
link
to
the
court,
a
second
set
basically
of
entity
framework,
core
demos
and
tutorials
from
from
Phil,
gypsy
and
Robert.
Here
they
had
already
done
some
fairly
decent,
getting
started
on
EF
core
stuff.
That
was
that
was
great
if
you're
getting
started,
and
this
is
now
awesome,
because
this
is
like
an
in-depth
review
where
it's
going
through
performance
configurations
and
in
this
time
this
case
build
your
model.
B
Likewise,
we
have
a
link
here
from
John
P
Smith,
who
is
writing
this
book
entity
framework
or
in
action
or
in
fact
he's
written
it.
There's
a
new
edition
covering
EF
5
coming
out.
I
have
read
some
of
the
chapters
reviewed
some
of
the
chapters.
There
is
really
good
book.
It
really
goes
into
some
of
the.
Why
and
house,
and
gives
you
great
idea
of
what's
really
happening,
and
these
blog
post
is
kind
of
continue
with
that.
This
is
an
in-depth
look
at
what
happens
when
you
write
to
the
database.
B
So
when
you
call
Save
Changes,
this
goes
into
how
we
order
entities
to
deal
with
relationships,
how
we
read
values
back,
how
we
do
with
computer
columns.
All
of
that
kind
of
stuff,
so
this
is
a
great
in-depth
look
any
f
qor
if
you're
interested
in
that
just
going
over
a
few
of
the
PRS
that
we've
had
this
week
or
no
not
this
week.
But
since
the
last
community
center,
which
was
a
couple
of
weeks
ago,
we've
added
an
API
to
allow
you
to
clear
all
attract
entities
from
a
DB
context.
Instance.
B
Now
the
recommended
guidance
is
short-lived.
You've
got
EF
context
instances
you
create
one
for
a
single
unit
of
work
and
throw
it
away.
However,
sometimes
we
recognize
that
pragmatically,
it's
necessary
to
clear
an
existing,
inter
instance
of
all
its
entities
and
make
it
pristine
to
start
using
it
again,
and
this
is
what
this
API
does.
So
it
prevents
people
from
having
to
write
all
kinds
of
code
to
recursively
detach
entities
and
things
like
that.
B
The
next
one
is
a
link
to
the
implementation
for
many-to-many
in
EF,
core
five
zero.
So
the
reason
I'm
bringing
this
up
is
I.
Think
most
people
are
aware.
We've
been
doing
many
too
many
navigation
properties
in
AF
core
five
there's.
There
is
a
distinction
between
that
and
full
support
for
many
to
many.
B
However,
as
we've
been
going
along
with
the
many-to-many
work,
it's
been
going
well
and
we're
pulling
in
the
other
things
that
I
needed
now
to
do
a
full
many-to-many
sport
without
having
any
entity
take
for
the
drawing
table
at
all
and
hopefully
also
detecting
them
by
convention.
When
you
build
your
model,
so
it
will
detect
entity
with
a
collection.
Navigation
is
an
another
entity
with
the
collection,
navigation
in
the
other
direction
and
create
a
many-to-many
relationship
for
you.
So
look
for
that
coming
soon
and
Jeremy.
A
Into
that
so
yeah,
the
dotnet
5
wave
of
releases,
the
Donette
documen
patient
team,
is
reorganizing,
pretty
much
all
of
the
documentation.
So
it's
not
necessarily
a
rewrite,
but
it
is
a
new
taxonomy
and
structure
and
flow.
And
so
what
we're
looking
at
this
is
an
issue
with
a
proposed
hierarchy,
sort
of
high-level
table
of
contents,
and
this
project
is
going
to
be
completely
open
source
out
in
the
open,
we're
looking
for
community
feedback
on
this
open
issue.
A
A
Be
the
first
thing
once
we
get
that
high
level
fleshed
out,
then
we'll
create
some
sub
issues
on
what
those
categories
look
like
and
then
we're
gonna
figure
out
what
documentation
we
can
link
to
what
documentation
needs
to
be
updated
and
potentially
write
some
new
documents
to
fill
it
in.
But
it's
a
pretty
exciting
project
and
again
it's
completely
out
in
the
open.
So
if
you
go
to
that
issue,
that's
in
the
show
links
you
can
provide
your
feedback
and
participate
in
that
process.
B
So
we
probably
won't
go
this
into
this
in
detail,
but
this
is
a
super
interesting
blog
post
showing
how
to
use
the
repository
pattern
and
things
like
that,
which
are
a
little
bit
more
more
advanced
than
some
of
the
basic
uses
of
blazer,
where
you
don't
need
to
have
things
like
that,
I!
Don't
if
you
want
to
say
any
more
on
this
or
we
just
should
we
just
go
into
the
into
the
show
and
demo
stuff.
A
There
we
go,
give
it
a
little
bit
more
real
estate,
so
this
is
a
reference
application.
What
I'm
gonna
show
first
is
not
publicly
available
yet
not
because
we
don't
want
it
to
be
publicly
available,
but
because
we're
just
going
through
a
final
internal
review
before
we
publish
it,
but
this
will
be
part
of
our
official
samples
and
what
we
wanted
to
do
was
provide
some
guidance
for
using
AF
core
with
blazer.
A
Now
for
those
listening
who
aren't
familiar
with
blazer
blazer
is
a
new
way
of
building
web
applications
and
there's
two
flavors
of
blazer
there's,
what's
called
blazer
webassembly,
which
is
a
version
of
blazer
that
runs
entirely
in
the
browser.
What
is
unique
about
this
is
that
it
does
it
without
plugins.
Webassembly
is
a
feature
that
provides
think
of
it
as
a
virtual
machine.
That's
inside
the
browser
sandbox,
but
it
is
implemented
by
all
of
the
modern
browsers.
And
if
you
have
you
know
modern
phone
browser
tablets,
late
desktop
laptop
those
will
all
support
web
assembly.
A
So
what
Blazer
did
is
it
took
a
port
of
the
dotnet
framework
that
can
run
on
web
assembly
added
tooling
so
that
you
can
use
razor
templates,
which
most
developers
are
familiar
with
and
allows
you
to
build
single
page
applications
that
run
inside
the
browser
and
even
used
on
that
standard.
Libraries.
In
fact,
I
have
a
post
that
shows
using
entity
framework
core
inside
the
browser
to
talk
directly
to
a
cosmos,
TV
server
using
our
cosmos,
TV
provider.
A
A
In
fact,
the
projects
I'm
going
to
show
sure
about
95%
of
the
UI
and
code
between
blazer
server
and
blade
webassembly
blazer
server
does
all
of
the
computation
on
the
server
side,
and
then
it
uses
signal
art
to
communicate
with
browsers
and
render
it
so
there's
a
very
lightweight
JavaScript
shim
that
runs
and
that
communicates
with
that.
So
if
you're
in
blazer
server,
you
can
do
things
like
securely
store
secrets
which
you
wouldn't
want
to
send
to
the
client
and
you
can
access
fold
on
that
framework
services.
So
there's
some
flexibility
there.
A
The
trade-off
is
that
the
server
has
to
do
all
of
the
work
it's
managing.
If
you
have
10,000
concurrent
connections,
the
server's
are
managing
10,000,
rendering
engine
events
etc,
as
opposed
the
web
assembly
where
it's
running
in
the
browser,
but
because
it's
in
the
browser,
I
can't,
for
example,
connect
directly
to
a
sequel
server
engine,
because
that
uses
ports
and
protocols
that
don't
exist
in
the
browser,
so
I
have
to
send
it
over
the
wire.
So
what
this
application
show
good
question.
B
A
The
cosmos
provider
has
two
modes,
there's
direct
and
gateway.
The
direct
mode
is
a
higher
performance
mode
because
it
uses
a
direct
connection
to
the
server's
over
TCP,
which
has
less
overhead
than
HTTP,
but
it
does
support,
what's
called
a
gateway
protocol
which
it
puts
a
web
proxy
in
front
of
the
calls.
So
you
can
call
out
to
http
so
because
it
uses
a
well-known
protocol,
that's
supported
by
the
browser
you're
able
to
execute
those.
Now
there
is
a
caveat,
and
that
is
cosmos.
A
Db
does
not
currently
support
Azure,
Active,
Directory
authentication,
and
you
don't
want
to
ship
your
keys
in
the
client.
Anything
that's
in
that
client
browser
I
as
a
developer
can
pick
it
apart
and
you
don't
want
to
be
having
access
to
the
keys
to
the
kingdom,
and
so
just
because
we
can
connect
directly,
it
doesn't
mean
we
should,
unless
there's
a
secure
way.
So
I
have
a
blog
post.
That
shows
a
solution
that
uses
Active
Directory
authentication
to
verify
that
the
user
is
allowed
to
access
it.
Then
it
talks
to
another
service.
A
That
creates
a
token,
so
cosmos
TV
can
issue
tokens
that
have
a
set
of
permissions.
I
can
say
it's
read-only.
You
can
only
look
at
this
container
and
that
token
comes
back
and
I
use
that
token.
For
the
connection,
if
I
steal
the
token
I
still
can't
do
anything
more
than
what
I'm
allowed
to
do
anyway.
So
it's
a
different
scenario.
So
there's
that
caveat,
but
it
is
because
it
uses
HTTP
that
we're
able
to
to
make
that
work
right.
A
A
So
you
can
see
that
I've
removed
those,
but
those
fields
are
required,
I'm
going
to
cancel,
and
then
the
final
thing
I'll
show
here
and
then
we'll
jump
into
some
code
is
I've,
got
that
edit
contact
up
I'm
going
to
paste
this
in
I'm,
going
to
change,
I'm
going
to
add
an
S
on
the
end
here
submit
it
and
you
can
see,
we
have
success,
I'm
going
to
add
a
Y
on
the
end
here
and
submit
it.
You
can
see
I
get
this
error
message.
A
A
B
To
clarify
is
you're,
basically
simulating
that
two
people
are
trying
to
edit
the
same
record
at
the
same
time,
and
what
we're
seeing
here
is
that
EF
is
helping
give
information
back
to
the
Blazer
application.
Saying:
hey,
that's
already
been
editing
the
database.
So
how
do
you
want
to
resolve
that?
But
that's
the
basic
idea
right.
A
Show
what
that
looks
like
in
here,
let
me
see
if
I
can
find
my
simplified
project
to
keep
the
example
simple,
I,
distilled
it
down
to
a
single
project.
Here
we
go
okay,
so
our
basic
building
blocks.
We
have
a
contact,
that's
our
class
that
we're
dealing
with,
and
it's
got
some
data
annotations
for
validation
on
it.
Then
we
have
a
contact
context.
A
This
is
how
we
define
our
interface
to
entity
framework
corfu.
What
we're
describing
the
shape
of
the
the
database
and
you'll
notice.
I've
got
some
helper
fields
here.
Row
version
and
contacts.
Db
I'll
talk
about
those
in
a
minute,
but
I'm
exposing
contacts
and
what's
interesting,
is
if
you
look
at
the
contact
class,
you'll
notice,
there's
no
concurrency
field
like
I,
don't
have
a
row
version
time
stamp
or
anything
on
the
class.
It's
just
a
pure
business
object.
A
So
what
I'm
using
here
is
what's
called
a
shadow
property
that
allows
entity
framework
to
track
a
column,
that's
pulled
in
from
the
database
without
it
having
to
be
defined
on
the
model,
so
in
other
words,
internally.
Entity
frame.
Work
is
aware
of
this
ro
version,
even
though
my
contact
class
itself
doesn't
have
it
on,
and
it
generates
some
internal
proxies
for
change
tracking
that
do
these.
So
what
I'm?
Basically
telling
it
is
here's
a
property.
Here's
the
name
of
the
property
and
telling
it
is
row
version,
informs
a
new
framework.
A
Yes
use
this
for
concurrency.
The
only
reason
I
implement
the
dispose
pattern
on
this
context
is
because
I'm
generating
these
Goods,
and
that's
just
so.
When
people
run
this
sample,
they
can
see
the
lifetime
of
the
dbcontext
and
confirm
that
there's
not
they're
being
correctly
disposed
of
and
taken
care
of,
etc.
So
what
our
guidance
for
Blaser,
server
and
and
this
whole
project
came
about,
because
we
had
some
people
giving
us
feedback
that
there
were
challenges
with
running
EF,
quorum,
blazer
server,
and
when
we
looked
into
it,
there
were
a
few
things
happening.
A
One
of
them
was
some
context,
we're
getting
shared
across
controls
that
were
trying
to
map
into
entity
framework
at
the
same
time,
and
the
other
was
that
there
were
asynchronous
operations
being
called
in
without
waiting
for
the
previous
one
to
complete
and
the
way
a
DB
context
is
set
up.
It
expects
an
asynchronous
operation
to
finish
before
the
next
one
begins.
So
the
idea
behind
this
guidance
is
to
provide
some
insight
into
how
to
use
DB
context
in
a
server
app
and
the
the
guidance.
The
first
level
of
guidance
is
pretty
simple.
A
A
The
exception
comes
into
place
when
you're
doing
a
few
things
that
a
media
framework
chord
does
well
and
does
for
you,
one
of
those
being
tracking
large
object,
graphs,
so
change
tracking,
where
you
have
a
list,
and
maybe
some
of
the
items
in
the
list
have
been
updated
or
deleted,
and
you
want
to
be
able
to
perform
that
sort
of
one
operation.
When
you
save
the
changes
like
a
unit
of
work,
the
other
is
concurrency
resolution,
so
entity
framework
will
manage
concurrency
for
you
in
a
very
transparent
way.
A
One
of
the
things
that
came
out
of
this.
As
we
said
you
know,
you
have
options
that
you
can
configure
your
context
with.
So
it
may
not
be
practical
to
do
a
new
with
a
context
every
time,
so
we
provided
a
factory.
Now
this
sample
is
going
to
have
a
very
simple
implementation
that
basically
returns
a
new
instance
so
that
you
can
use
this
to
grab
it
and
it's
doing
service
resolution.
A
So
if
I
have
dependencies
on
other
services
like
a
options,
configuration
it's
going
to
process
that
and
handle
it
now,
because
this
can
be
used
so
frequently,
there
is
a
version
of
this:
that's
going
into
F
core.
In
fact,
it's
available
right
now
in
the
daily
build,
so
anyone
using
the
daily
builds
can
start
to
use
this
new
factory
and
what
the
factory
in
the
builds
does.
A
Is
it's
optimized
to
understand
if,
for
example,
the
context
that
you're
creating
it
and
is
always
only
going
to
get
one
set
of
options,
then
it
will
compile
a
function
that
basically
just
returns
that
new
instance
without
doing
the
dependency
resolution
every
time,
so
it
is
designed
with
performance
and
in
mind.
You
can
certainly
new
a
new
data
context
too.
If
you
have
the
dependencies
you
need
so
there's
a
few
options
there
just.
B
That
context
pooling
is
and
like
Jeremy
said
earlier.
Creating
context
instance
is
fast,
so
pooling
usually
doesn't
provide
much
benefit.
But
if
you
have
a
very
fast
application,
that's
doing
a
lot
of
things,
or
rather
that's
doing
very
little
things.
But
creating
context
is
to
do
them.
Then
the
pooling
can
help,
so
that
will
be
integrated
to
nice.
A
I'm
in
the
index
page,
this
is
an
example
of
one
that's
going
to
use
a
context
per
operation,
and
this
is
the
code
right
here.
Basically,
I
create
a
context.
I'm
used,
taking
advantage
of
the
new
language
feature
that
I
don't
have
to
use
curly
braces
with
it,
using
it's
just
inside
the
containing
scope
and
will
automatically
be
disposed
at
the
end
of
this
we're
setting
a
loading
so
that
we
stop
input
on
the
UI.
While
this
is
happening,
we
call
this
first
in
sync:
oh,
wait:
I'm
in
delete
contact.
A
It
would
probably
be
better
if
I
showed
you
the
reload
async,
so
here's
the
reload
async
so
here
I'm,
creating
the
context
and
I
use
this
query,
adapter
to
fetch
the
contact
and
then
I'm
done.
Basically,
everything
else
is
data
binding
now
I
do
want
to
show
this
query
adapter,
because
this
is
one
of
the
things
I
love
about
entity
framework.
So
if
we
go
to
the
definition
of
this,
of
course,
they
can't
navigate
to
the
symbol
under
the
carrot.
That's
okay!
We've
got
our
query
adapter
here.
A
So
what
this
does
is
it
looks
at
the
filters
that
you've
selected,
so
you
can
filter
on
different
columns.
You
can
also
sort
on
different
columns.
This
is
a
dictionary
that
map's
a
column
like
city
to
a
expression
that
takes
a
contact
model
and
points
the
city.
So
it's
a
very
simple
expression.
Think
of
this
as
a
pointer
to
the
city
property,
here's
another
one
for
filters
that
provides
an
expression
for
what
the
filter
should
look
like.
A
So
for
most
of
these
we're
just
doing
a
where
city
contains
for
name,
though
we're
searching
across
first
name
and
last
name.
So
we
have
this
first
name
or
last
name,
and
then
the
adapter
basically
takes
the
iqueryable
that
we
can
get
from
the
DB
set.
It
will
apply
things
like
the
the
filter,
so
it
grabs
the
filter
here
and
applies
the
the
filter
to
the
corium,
so
we're
just
basically
extending
the
expression
that
we're
doing
and
then
it
can
add,
paging
skip
and
take.
A
And
then
it's
just
returned
that
as
no
tracking
and
the
reason
I'm
calling
this
out
is
because
the
ability
to
be
able
to
dynamically
apply
filter
sorts
is
very
powerful,
but
because
it's
strongly
typed
and
because
it's
using
link,
we
have
full
control
over
what
we
allow
here.
I'm
not
opening
up
the
world
to
be
able
to
perform
any
query.
I've
got
a
few
set
of
defined
parameters
that
come
in.
So
that
is
the
the
read.
A
If
we
come
back
to
the
index
that
we
showed
delete
because
the
lead
is
a
pretty
granular
operation
as
well.
Let
me
come
here
so
for
the
delete
operation,
which
is
what
I
was
in
earlier
I,
basically
grabbed
that
contact
off
now,
if
I
wanted
to
prevent
the
delete,
if
it
had
changed,
then
I
would
do
this
differently.
But
here
I'm
saying
if
you
confirm
I'm
gonna,
remove
it,
we
do
remove
and
save
changes
and
then
that
context
goes
out
of
scope.
A
So
that's
the
the
simple
scenario:
if
you
will,
there
is
a
scenario
where
we
want
that
contact
context
to
last
a
little
longer
and
that's
the
Edit
contact
so
in
Blaser
server.
This
works
a
little
bit
differently.
The
built-in
dependency
injection
scopes
or
the
lifetime
of
the
instances
that
you
configure
are
transient.
Singleton
and
scoped.
Transient
basically
says
anytime,
I
ask
for
a
copy
of
something
give
me
a
new
copy.
A
Scoped
lives
for
the
duration
of
a
session
which,
in
the
asp
net
world,
would
be,
for
example,
a
controller
action
and
then
singleton
is
throughout
the
entire
application.
So,
if
I
do
something,
singleton
and
I
have
five
users
connect.
Those
five
users
are
looking
at
the
same
copy
of
that
class,
so
it
obviously
wouldn't
be
something
that
I
would
want
to
share-
that's
contextual
and
for
me,
and
that
each
users
getting
in
Blaser
server.
A
We
have
this
weird
scenario
where
what
we
really
want
to
do
is
we
want
that
context
to
live
for
the
duration
of
a
component
and
what
I
mean
by
that
is
on
my
edit
page,
because
I
want
entity
framework
to
handle
all
the
concurrency
for
me.
I
want
the
context
to
track
that
concurrency
I,
don't
want
a
new
one,
every
time,
I
ask
for
it.
A
I,
don't
want
it
to
last
for
the
user
session
because
when
they
go
to
a
new
page,
I
want
them
to
get
a
new
copy,
so
I
need
something
in
the
middle.
So
the
Blazer
team
provided
an
opportunity
to
build
this
and
there's
two
two
ways
you
can
do
this
there's
something
called
owning
component
base
which
basically
brings
in
a
service
for
the
lifetime
of
that
component.
What
I
chose
to
do
here
is
initialize
and
manage
it
myself.
A
So
what
I've
done
is
I've
injected
the
factory,
but
what
you'll
see
is
instead
of
doing
a
using
statement
and
letting
it
go
out
of
scope
when
this
control
is
initialized
here,
I
check
to
see
if
there's
any
previous
context,
that
I
disposed
and
then
I
create
a
new
one
and
I'm
not
doing
as
no
tracking
I'm
grabbing
that
context,
and
that
is
what
is
data
bound
up
here.
So
this
property
is
basically
pointing
to
that
contact
and
then
that
control
has
an
edit
form
that
does
validation
and
everything
else.
B
Sorry
so
the
so
the
factory
itself
is
a
singleton
service
right,
so
you're
always
having
one.
You
always
have
one
instance
of
the
factory,
but
then
you're
using
create
DB
context
to
create
a
new
instance
of
the
context
itself,
which
isn't
then
bound
to
the
DI
scope
or
anything
like
that.
So
it's
independent
of
everybody
else
who's
using
that
Factory.
That
that's
right
is
it
that.
A
Is
correct?
Yes,
okay
and
I'm
gonna
I
mention
owning
component
base
because
I'm
going
to
show
it
in
a
different
sample,
but
basically
what
we
do
here
is
when
we're
initial,
as
we
create
the
new
contact
and
then
here
when
we
save
changes,
we
just
saved
directly.
We
don't
do
anything
else
now.
What's
gonna
happen,
though,
is
because
entity
framework
core
is
tracking
concurrency
for
us.
If
that
save
fails,
it
throws
this
DB
update,
concurrency
exception.
This
is
provided
to
me
by
entity
framework
core.
That
exception
actually
gives
me
a
few
utilities.
A
For
example,
I
can
get
the
original
database
values
off,
not
the
original
database
values.
But
basically
this
is
saying
the
database
has
changed
I'm
saying
well,
what
is
the
new
snapshot?
Look
like
so
I'm.
Getting
that
copy
of
what
the
new
contact
record
is
then
I'm
able
to
set
this
as
a
property
and
I
basically
have
a
very
simple
component
and
I'm
going
to
show
you
this
concurrency
field
component.
A
So
this
is
a
typed
component,
so
it's
type
of
T
and
I'll
use
it
to
be
type
of
contact
and
we
get
a
model
and
we
get
a
database
model.
So
this
is
what
the
user
is
trying
to
update.
This
is
what
came
back
from
the
database
and
then
I'm,
assuming
the
properties
are
I
comparable,
so
I
can
compare
them
to
each
other.
A
Where
is
it
okay?
So,
basically,
what
will
happen
is
if
we
get
this
exception
and
so
I'm,
showing
the
exception.
One
of
the
things
I
do
is
I,
set
the
original
values
to
the
database
values
so
now,
I'm
showing
basically
update
any
framework
to
make
it
look
like
I've
got
the
fresh
copy
from
the
database.
A
B
Go
ahead,
see
a
couple
of
questions,
a
couple
of
comments
on
that
as
well.
We
have
a
question
that
I'll
get
to
in
a
second,
so
the
this
a
optimistic
concurrency
control
is
something
that's
built
into
EF
six
and
it's
been
built
into
EF
core
from
very
early
on,
and
so
we
have
documentation
on
how
to
how
to
do
this.
It
also
applies
to
non
Blaser
applications.
A
lot
of
people
like
to
just
write
an
application,
so
the
last
save
wins,
which
is
fine.
If
that's,
if
that's
what
you
is
that
what
you
need?
B
Well,
this
is
a
great
way
of
actually
in
being
able
to
say,
tell
people
hey,
you
know
the
change
you
made
is
conflicts
with
something
somebody
else
made,
so
we
have
documentation
for
all
this.
The
question
was
how
about
unit
of
work
so
I
think
what
we're
showing
here
is
that
you're
using
a
context
for
a
unit
of
work.
The
unit
of
work
is
the
query,
the
change
and
the
save,
and
so
what
Jeremy
is
showing
here
is
by
using
the
factory
to
create
a
context
and
keep
it
associated.
A
Because
they
asked
that
again,
this
is
a
a
more
simple
straightforward
example.
I
do
have
another
example
that
gets
a
little
more
in-depth
and
implements
some
patterns.
So
let
me
go
ahead
and
then
another
solution
and
that's
going
to
be
this
one.
So
this
is
the
exact
same
application.
If
I
run
it,
there
is
one
difference
and
I'll
show
the
difference
here,
and
that
is
that
the
the
simple
one
just
uses
a
table
for
the
data
grid.
So
it's
not
that
responsive.
This
is
designed
to
be
a
responsive
application.
A
So
if
I
resize
it
you'll,
basically
see
as
the
size
goes
down,
some
columns
will
disappear
to
make
space
there.
The
street
address
just
disappeared.
Now,
we've
got
the
hamburger
menu
and
now
we're
basically
down
to
just
imagine
on
your
phone
tapping
on
name
now:
I
can
still
go
in
look
at
it.
I
can
still
edit
it.
So
it's
all
there.
It's
just
a
more
responsive
design
and
I
can
go
back
to
my
main
list
and
expand
that.
So
that's
what.
C
A
Ui
looks
like
if
we
go
into
the
application,
though
you're
going
to
see,
we've
got
a
little
bit
more
of
a
formal
project
set
up.
I've
got
a
dependent
the
dependencies
here
in
contacts
app
model
or
just
annotations.
That's
it
for
this
project,
and
this
defines
my
contact
and
some
filters.
My
data
access
layer
is
where
I
define
the
context
for
the
the
contact.
I've
got
the
contacts
here
and
for
this
example,
I've
got
the
data
DB
context
factory,
but
there's
some
interesting
things
that
are
going
on
here.
A
A
So
it's
important
to
note
is
this
is
doing
this
for
contact,
but
I
can
easily
make
this
class
added
adapter
of
T
and
generically
apply
audit
information.
I'd
basically
just
have
a
base
interface.
I
has
audit
info
and
I
could
use
that
interface
to
make
these
updates.
The
developer
doesn't
have
to
worry
about
it.
They
just
go
ahead
and
pass
Save
Changes.
A
Similarly,
if
it's
modified,
this
is
setting
the
modified
by
and
the
modified
on,
and
then
it's
using
this
property
changes
to
create
this
contact
audit
and
let
me
actually
pull
up
sequel
server
management
studio.
So
I
can
show
you
what
the
output
of
this
looks
like,
because
it's
inserting
it's
basically
adding
this
audit
to
the
current
Save
Changes.
A
It's
adding
the
range
of
audits
there
and
then
it's
calling
Save
Changes
async.
So
what
just
happened
there
is
by
me
calling
Save
Changes
in
one
call:
I'm,
not
only
updating
or
deleting
or
adding
whatever
entities.
I
wanted
to
they've
been
enhanced
without
it
information
what
user-created
modified.
The
dates
are
automatically
updated
and
I
get
an
audit
entry
in
my
database
table
and
that
entry
actually
is
a
snapshot
of
before
and
after
so
if
I
come
into
my
databases
and
let's
expand
that
out
and
we
look
at
blazer
contacts
DB,
we
look
at
tables.
A
A
A
So
the
other
thing
that
I
can
do
is
all
of
my
contacts
that
I'm
inserting
have
no
ID
until
I
save
them
so
once
I
save
I,
do
a
second
pass.
Look
for
the
added
context
and
I
update
the
IDS
so
that
my
audit
tracking
actually
has
an
identifier
for
inserted
column.
So
you
can
see
that
down
here
this
one's
added
and
you
can
see
it
actually
has
a
contact
ID
because
it
first
inserted
the
audit
record
and
then
updated
it
once
that
ID
became
available.
A
So
that's
one
of
the
things
that
can
be
done
just
on
the
data
context
and
make
life
easier
for
everyone.
Then,
if
we
work
our
way
up,
the
stack
I've
got
a
repository
that
has
a
unit
of
work
and
I
repository
implementation
has
actually
the
base
repositories
the
one
to
show
this
will
have
your
typical
get
list,
load,
async,
delete,
async,
attach
or
whatever,
and
the
implementation
is
in
addy
framework
core.
So
if
we
look
at
our
edit
component
here,
it's
going
to
work
a
little
different.
Let's
see
edit
contact
control
right
here.
A
A
If
we
look
in
the
actual
application
itself,
which
is
right
here
and
we
look
at
it
at
contact,
this
uses
the
owning
component
base
for
that
unit
of
work
and
that
unit
of
work
really
just
keeps
track
of
a
context
so
everything's
using
the
DB
context.
Factory,
it's
just
a
question
of
if
it's
long
lived
or
not
now
the
only
other
thing
I'll
show
this
go
ahead.
Arthur.
C
B
B
Just
you
know,
with
a
with
computed
sequel
or
default
value
sequel
rather,
but
beyond
that
you,
it
takes
more
work
on
the
database
side,
but
it
is
possible
to
do
it
more
database
side
and
reduce
reduce
some
of
the
the
round
trips
as
it
were,
and
likewise
I
would
like
to
look
at
the
jerem
and
I
should
look
at
the
propagation
of
the
value
from
one
place
to
the
other.
That
requires
the
second
Save
Changes
and
see
if
there's
a
different
way
of
doing
that.
A
I'm
gonna
address
one
more
question:
I
realize
we're
getting
near
the
top
of
the
hour,
so
I
want
to
leave
room
for
additional
Q&A
if
people
want
it,
but
one
of
the
questions
was:
why
is
there
need
to
attempt
to
abstract
over
F
with
repositories
and
unit
of
works,
even
though
this
is
already
built
in
and
I
agree
a
hundred
percent?
So
if
I
was
just
doing
the
server
project
that
I
showed
initially
I
wouldn't
feel
the
need
to
have
a
repository
pattern
for
this
project,
there's
a
very
specific
reason
why
it's
done
so.
A
A
A
And
can
I
just
say
that
the
the
new
laptop
is
working
splendidly
because
I
would
not
have
been
able
to
build
and
run
a
project
on
my
last
laptop.
So
this
is
using
identity,
the
identity
service
for
credentials.
Hopefully,
I
still
remember
my
test
credentials
here
and,
as
you
can
see,
it's
the
exact
same
functionality.
I
can
page
I
can
sort
I
can.
A
So
if
I
open
up
my
network
tab
and
I
clear
my
filter,
you're
gonna,
see
this
has
made
a
request
to
the
server
to
pull
back
the
data.
For
that
page.
Total
item
count
488
page
items
20,
so
this
is
running
in
the
browser
and
delegating
to
the
server.
But
what
I
was
able
to
do
with
the
design
of
this
application
is,
if
you
look
at
the
web
assembly
project,
let
me
collapse
these
and
go
into
this.
A
A
Yeah,
if
I
need
to
get
a-
and
you
can
see
the
logging
information
coming
out
here,
but
if
I
need
to
that
reusability
between
the
client
and
the
server.
The
repository
pattern
gives
me
an
interface
that
I
can
implement
differently
the
controller
on
the
server
side.
So
in
this
project,
I
have
an
ASP
nightcore
app
with
controllers
and,
for
example,
there's
a
query
controller,
and
this
is
doing
the
same
thing.
The
other
ones
would
be
doing
it's
using
an
ad
framework
or
it's
calling
right
here.
A
B
Yeah
I
was
just
gonna,
so
tying
that
back
to
kind
of
the
general
guidance
on
when
you
should
implement
a
repository
or
a
unit
of
work
or
those
kinds
of
patterns
on
top
of
here.
If
all
you
end
up
doing
with,
that
is
always
just
calling
through
to
EF,
and
it
only
ever
acts
as
a
separate
layer,
but
doesn't
really
add
any
value
doesn't
really
do
any
real
abstraction.
B
It's
just
kind
of
exposed
specially
if
it's
just
kind
of
Li,
you
know
exposing
I
grew
up
halls
and
things
like
that,
then
there's
very
little
value
in
doing
those
things.
However,
just
there's
anything
else,
if
your,
if
your
application
architect
gets
to
the
point
where
you
do
want
an
abstraction
like
Jeremy,
showing
here
for
client
and
server
side,
for
example,
then
that's
where
building
a
repository
or
whatever
type
of
a
structure
makes
sense
to.
You
is
really
valuable.
B
A
B
A
Can
and
I'm
gonna
continue
this
series
with
exploration
of
a
few
other
protocols,
for
example,
there's
a
G
RPC
web
protocol.
Excuse
me
that
is
a
binary
format.
So
it's
much
more
compact
than
JSON
that
also
uses
the
HTTP
protocol
to
transmit
information
over
the
wire.
So
I
may
look
at
adapting
this
sample
to
use
G
RPC
and
then
there's
always
graph
QL
as
a
API
to
and
the
nice
thing
about.
B
A
Interesting
for
different
views,
I
probably
need
to
get
into
more
details
with
that.
You
can
embed
a
blazer
application
inside
another
web
app,
it's
basically
just
a
web
container,
so
that
is
possible
and
part
of
the
blazer.
Experience
includes
what
we
call
tree-shaking
in
fact,
there's
some
challenges
I'm
running
into
because
of
tree-shaking
that
I'll
be
looking
into,
but
basically
what
happens
is
regardless
of
what
libraries
I
pull
in
when
I
deploy
a
blazer
app
to
production,
there's
some
optimization
to
strip
out
unneeded
code.
A
A
Did
stop
sharing
so
that
that's
pretty
much?
What
I
wanted
to
show
I
wanted
to
take
a
break
and
see
if
anyone
had
other
questions
around
that,
but
look
look
for
that.
We've
got
in
the
show,
links
the
link
to
part
one
of
that
series.
That
series
includes
a
of
standing
up
a
server
so
that
you
can
connect
the
cosmos,
DB
and
the
server
actually
handles
get
the
token
there's
another
example
that
uses
act
as
your
Active
Directory
and
functions
instead
of
a
server.
So
it's
a
serverless
solution.
A
If
you
will
there's
a
walk
through
of
all
the
philosophy
behind
all
the
components
for
the
web
assembly
project
and
then
another
one
that
basically
shows
how
the
server
project
was
able
to
pull
those
in,
and
it
took
about
20
minutes
to
build
a
server
project
because
of
all
the
the
code,
reuse
so
feel
free
to
check
those
out
and
like
I
said.
The
simple
example
that
I
started
with
is
something
that
we're
working
to
get
into
our
official
documentation
samples
and
also
we're
gonna,
have
some
documentation.
Guidance.
B
A
B
Yeah,
it's
very
cool
to
seeing
seeing
how
the
UI
frameworks
are
now
becoming
super
important
in
dotnet,
again
after
maybe
being
neglected
a
little
bit
for
a
while,
and
so
we're
really
working
with
a
lot
of
teams
to
take
care,
EF
core
support
and
demonstrate
how
all
that
works
with
all
those
things.
It's
very
exciting.
B
D
B
C
B
You
I
assume
that's
addressed
to
me,
so
I'm
gonna
put
this
up
again
and
another
call
out
to
Kent
Beck.
This
is
a
extreme
programming,
explained
first
edition
I
believe
when
we're
like
two
thousand
or
something
this
came
out
99
or
something
like
that.
This
is
really
my
introduction
to
agile
methodologies
and
how
to
develop
without
putting
a
huge
upfront
plan
in
place
and
trying
to
design
everything
upfront
and
it
changed
my
life
as
a
program
and
I've
never
looked
back
so
find
the
first
edition.
B
A
B
I'm
not
expecting
us
to
get
more
people
on
the
team
anytime
soon
we
always
go
and
ask
management
for
more
people
and
they
always
say
you're
delivering
what
we
want
you
to
deliver.
So
you
know,
keep
going
to
be
fair.
Everybody
always
needs
more
people,
I
mean
I,
think
that's
not
true,
just
at
Microsoft
but
everywhere
else,
and
there
are
so
many
really
valuable
things
that
we're
working
on
in
dotnet.
Now
that
I
can't
I
can't
really
make
the
argument
that
we
should
get
more
people
over.
B
C
D
B
B
B
So
you
never
need
to
use
DD,
set
properties,
they're
entirely
optional
and
there's
various
ways
of
managing
so
yeah.
The
there's
a
I'm,
not
sure
exactly
what
you're
referring
to.
But
there's
a
lot
of
flexibility
around
how
you
how
you
actually
map
your
entities,
DB,
set
on
a
context:
I
para
sugar,
everybody
uses
but
they're
only
a
sugar.
A
B
A
A
Let
me
do
this
real,
quick,
because
there's
an
ask
about
real-world
applications
and,
if
we'll
be
doing
more
scenarios
like
that
I
do
want
to
point
out,
at
least
for
the
the
stand-ups.
If
you
go
to
the
github
repo
for
you.if
core,
we
have
a
new
discussions
area
for
things
that
aren't
really
issues.
They're
topics
for
discussion
and
part
of
that
is
guest
products,
general
requests
and
demos.
A
So,
if
there's
features
you
want
to
see
the
team
demo
there's
a
discussion
for
that
to
collect
your
ideas
and
if
you
have
someone
that
you
think
should
be
on
the
show
or
if
there's
some
sort
of
request.
As
far
as
the
question
about
real-world
examples,
there's
going
to
be
a
combination,
there's
going
to
be
very
simple
guidance
to
get
started
across
platform.
So
this
is
what
you
do
in
WinForms
and
WPF
and
blazer
etc,
but
the
goal
is
to
have
full-blown
scenarios
as
well.
A
So
that
means
samples
that
we
can
build
on,
like
the
we
showed
that
address
patterns
that
people
are
seeing
so,
for
example,
with
xamarin
there's,
probably
some
specific
patterns
that
xamarin
requires
that
are
unique
to
xamarin,
and
those
are
things
that
we
would
look
at
having
samples
that
cater
to
those
and
I'll
just
quickly.
For
the
question
about
blazer
mobile,
there
was
a
recent
update,
blazer
mobile
bindings.
It's
not
something
I've
been
personally
following
too
slowly,
but
that
is
an
option.
There
I
believe.
B
C
One
one
point
on
that
is
that
we
do
also
have
a
xamarin
support.
There's
there's
a
whole
stream
of
work
about
making
that
work
the
best
way
possible
and
also
be
performant,
which
we
really
hope
to
to
make
some
improvements
in
45.0,
but
I
mean
that's
also
something
that
we
know
that
some
people
are
doing
success
quite
successfully
so
doing
if,
from
an
from
a
xamarin
mobile
application,
there
would
be
another
maybe
way
to
do
to
do
it.
But
xamarin
is
definitely
the
more
traditional
and
supported
way
to
do
this
on.
You
know,
on
mobile.
B
Absolutely
just
to
reiterate
what
Jeremy
said
a
minute
ago
since
at
the
end
here
we
have
those
discussion
issues,
there's
one
for
what
who
you
want
to
see
on
the
on
the
community
stand
up
and
what
you
want
to
see.
Demoed
so
definitely
comment
on
those
you
don't
have
to
keep
it
just
to
EF
people
as
well.
Anything
kind
of
data
related
in
dotnet
is
fair
game.
We're
already
reaching
out
to
a
few
people
not
directly
related
to
EF,
to
bring
some
of
those
things
on
so
so
anything
interested
would
be
great.