►
Description
Join members from the .NET Desktop teams for our community standup covering EF Core 5 updates and WPF roadmap and community engagement.
Topics:
• EF Core 5 updates
• WPF Roadmap and community engagement
• .NET 5 Preview 6 and performance improvements
• Q&A
Links: https://www.theurlist.com/desktop-standup-7-23-2020
A
A
A
All
right
good
morning,
everyone
thank
you
so
much
for
joining
our
desktop
community
to
stand
up.
I'm
super
excited
to
have
amazing
guests
today,
so
my
name
is
olia
garish.
I
am
program
manager
on
dotnet
team,
focusing
on.net,
desktop
wpf
and
winforms.
I
have
my
co-host
dmitry
darling
with
me
dmitry.
Do
you
want
to.
B
A
C
D
E
Hey
everyone
I'm
pramalani
david.
I
am
the
new
pm
on
wpf,
my
team.
The
desktop
ecosystem
platform
team
recently
took
over
the
wpf
platform
and
I've
been
working
on
win
ui
all
this
time
and
I've
been
on
the
team
for
about
eight
years
and
I'm
excited
about
the
new
investments
we're
going
to
be
making
in
wpf.
A
I'm
very
excited
about
it
too.
Thank
you
so
much
for
joining
for
rolling
here.
So
today
we
will
be
talking
about
entity,
framework
and
wpf
strategy,
roadmap
etc.
But
first
I
wanted
to
just
start
it
with
the
new.net5
preview
7
that
we
just
released
and
are
there
if
you
could
share
the
screen.
For
me,
oh
perfect,
let
me
go
so.
This
is
the
blog
post
by
rich
lander
that
got
just
released,
announcing
dotnet
five,
oh
preview,
seven,
and
if
you
go
down
a
little
bit,
there
are
new
things
that
are
included
in
this
preview.
A
One
thing
that
I
wanted
to
highlight
is
the
performance
improvements
and
are,
if
you
click
under
performance
on
performance
improvement
link.
Yes,
this
one.
There
is
a
very
big
and
very
interesting
blog
post
by
stefan
that
talks
about
all
the
performance
improvements
in
dot
net,
where
the
dot
net
file.
Sorry
so
check
it
out.
If
you're
interested
in
that
area.
That's
a
very,
very
interesting
read,
and
with
that
I
think
we
can
go
straight
to
entity
framework
team
and
hear
about
all
the
new
things
in
this
area.
C
A
C
Okay,
so
what
what
the
plan
is
here
is
I'm
going
to
quickly
show
you
how
you
can
find
what's
new
in
ef
core
5,
which
is
shipping
the
same
time
as
dot
net
core
five
in
in
november,
then
we're
going
to
look
at
very
quickly
a
just
ef
core
101,
just
the
if
you
don't
know
anything
about
ef
court.
This
is
how
it
works,
and
after
that,
we're
going
to
switch
over
to
jeremy
and
he's
going
to
show
some
actual
desktop
applications,
winforms
and
wpf
using
entity
framework.
C
That
sounds
great.
If
we
get
time
at
the
air
at
the
end,
I
might
demo
a
new
feature
in
ef
core
five,
but
we'll
see
we'll
see
how
that
goes.
So
this
is
this
is
where
I
live.
This
is
the
ef
core,
github
page
dot
net
ef
core,
and
it
also
is
a
great
place
to
just
get
to
the
documentation.
So
you
can
see
I'm
clicking
on
the
documentation
link
here,
and
this
is
our
landing
page
for
all
the
ef
core
documentation.
C
If
you
want
to
know
what
we're
working
on
releases
and
platforms
is
the
place
to
go,
and
that
will
take
you
to
what
our
current
releases
are,
which
are
lts
and
all
that
kind
of
good
information
and
then
under
af
core
5.
We
have
both
here
a
high
level
plan
and
a
list
of
what's
new,
so
in
the
high
level
plan.
These
are
the
things
we're
basically
doing
sorry
wrong
button.
C
This
is
what
we're
doing
for
ef
core
five.
Many
to
many
navigations
many
to
many
mappings
is
the
biggest
feature
that
we've
been
working
on.
It's
the
most
requested
feature
on
github
by
over
500
folk,
and
this
basically
lets
you
map
two
collections
together
without
having
to
explicitly
specify
the
the
join
table.
C
We'll
just
do
the
join
table
for
you
underneath
many
too
many
navigations
is
another
part
of
that
we're
also
doing
tpt
mapping,
which
allows
you
to
instead
of
mapping
different
types
in
your
c-sharp
hierarchy
to
a
single
table.
You
can
map
them
to
a
different
table.
A
table
per
type
tpt
we
have
filtered
include
they'll.
C
Let
you
filter
what
you
get
back
from
include
and
split
include
that
can
make
includes
much
faster,
I'm
going
through
this
fast,
because,
if
you're
interested,
you
can
go
read
more
on
these
documentations
we're
also
doing
some
stuff
around
two
table
and
two
query
to
better
separate
those
and
then
just
some
general
general
enhancements
down
there
in
what's
new
you'll
see
lists
of
all
the
features
that
we've
released.
So,
as
you
saw,
we've
we've
just
released
preview.
Seven,
we
always
release
our
previews,
along
with
the
dot
net
core
previews.
C
That
has
some
features
like
db
context,
factory
for
registering
a
factory
for
db
contacts
in
di
if
you're
using
di
ef
works,
fine
with
or
without
di
resetting
the
state
new
pad
and
photoshop
generated
defaults.
There's
a
lot
of
stuff
in
here
and
as
you
go
down,
you
can
see
in
the
previous
previews
we've
done
things
like
improved
exceptions.
C
C
So
yeah,
thank
you.
So
let's
go
and
take
a
quick
look
now
at
this
is
like
the
simplest,
ef
core
demo
in
a
sense,
so
I'm
gonna
just
assume
that
you
don't
know
anything
so
ef
core
is
a
way
to
easily
connect
your
clr,
your
c-sharp
types
to
the
database,
save
them
in
the
database.
Query
them
from
the
database
update
them
the
way
you
fundamentally
do
that
is
you
create
a
class
that
derives
from
db
context?
C
Dbcontext
is
the
class
we
ship
and
then
you
have
various
options
here,
but
the
most
common
thing
is
to
declare
sets
of
the
types
that
you
want
to
store
in
the
database.
So
in
this
case
we
want
to
store
blogs
in
the
database.
So
we've
created
a
ddb
set
property
of
blogs,
and
we
just
put
that
on
our
context.
C
Then
you
need
to
tell
ef
what
database
to
connect
to.
There
are
various
ways
of
doing
this.
You
don't
have
to
do
it
in
the
context
yourself.
You
can
do
it
externally,
but
for
the
sake
of
simplicity,
here
I'm
overriding
on
configuring
and
I'm
telling
it
telling
ef
to
use
sqlite.
So
when
af
runs,
it's
going
to
save
all
the
data
in
the
sqlite
database
called
testdb
that
are
specified
here.
C
So
that's
my
context
to
use
it
all.
I
do
so
if
this
is
a
simple
console,
app
jeremy's
going
to
show
some
actual
ui
apps
a
bit
later.
What
I
do
is
I
create
an
instance
of
my
context.
Now
you'll
see
a
lot
of
examples,
especially
in
asp.net
core,
where
this
is
happens
in
a
di
container
and
you
actually
resolve
the
context
from
di
you
don't
have
to
do.
That
di
can
be
intimidating.
It's
not
necessary
for
every
application,
so
perfectly
valid
and
fully
supported
to
just
renew
up
your
context
like
this.
C
Normally,
when
you're
managing
a
database
schema
with
the
af,
you
have
a
variety
of
choices.
You
can
either
have
an
existing
schema,
schema
in
a
database
and
reverse
engineer
near
that
to
a
db
context
or
you
can
have
ef
create
the
schema
for
you.
So
what
when,
if
creates
the
schema
for
you,
it's
basically
going
to
look
at
your
the
types
that
you
have
the
blog
and
the
post
in
this
case,
and
it's
going
to
say:
okay,
I
need
an
id
property.
I
need
an
id
column
for
the
id
heat.
C
I
need
a
name
column
for
the
name,
property
and
so
on
and
so
forth.
You
do
that
with
migrations,
which
allows
you
to
generate
a
migration
which
has
the
sql
to
update
or
change
the
database
schema
as
necessary.
However,
if
you're
just
doing
testing
or
prototyping
or
trying
stuff
out,
you
can
just
have
ef
do
that
for
you
automatically.
So
what
I
do
here
is,
I
assure
the
database,
is
clean
from
last
time.
I
don't
care
about
saving
anything,
because
this
is
just
for
testing,
and
then
I
create
it
again.
C
If
you
look
in
our
documentation
page
there's
a
section
on
testing
with
ef
core.
That
goes
into
doing
this
kind
of
thing
in
a
lot
more
detail,
so
this
so
basically
now
we've
created
a
context
and
we've
said
told
the
database
make
sure
it
doesn't
doesn't
exist.
The
database
that
we
want
to
talk
to
so
that
it's
clean
to
start
with
and
then
we
said
now
create
it.
So
it's
going
to
create
an
empty
database
with
that
schema
in
it.
C
In
fact,
if
we
switch
on
simple
logging,
which
is
a
new
feature
in
ef
core5,
you
can
do
a
very
simple
log
thing
in
your
options,
which
just
says:
okay,
send
the
login
to
console
writeline.
If
I
run
this
application
you'll
see
down
here
when
we
look
at
what's
happening,
some
queries
from
later
on
in
the
application,
but
here
we've
actually
created
the
table
post.
So
this
is
what
migrations
would
normally
do
and
we
created
a
table
blocks,
but
this
is
actually
happening
here
because
we
called
ensure
created.
C
So
we
have
a
database
and
then
we
tell
ef
okay,
I
want
to
insert
some
stuff
into
that
database,
so
I'm
going
to
say,
add
range,
which
means
add
a
bunch
of
entities
to
the
database,
each
blog,
I'm
creating
with
a
name
and
then
I'm
giving
it
a
list
of
posts.
So
this
will
mean
that
each
blog
will
be
related
by
a
foreign
key.
C
You
know
it's
not
all
the
data
stored
in
the
database
now
create
a
new
one,
and
then
we
have
just
this
code
that
print
print
blogs
that
will
read
the
blogs
from
the
database
also
bring
back
the
related
posts
and
then
write
them
out.
So
if
I
remove
the
the
logging
down
here,
so
we
can
see
the
output
more
clearly,
you
can
see
that
when
we
run
that
it
prints
out
the
blog
and
the
post
that
we
saved
in
the
database,
so
that's
basically
ef
core
from
a
no,
in
a
nutshell,
a
one-on-one!
C
That's
what
af
core
does
that's
what
it's
for?
If
there's
any
questions
on
that,
we
can,
we
can
ask
them
and
if
not,
we
can
move
on
to
to
jeremy's
demos
which
show
win
forms.
A
C
A
Excellent,
thank
you
so
much
and
we
have
some
comments
about
wpf.
Thank
you
so
much
guys
for
that,
keep
them
going.
We
will
talk
about
wpf
after
entity
framework,
but
please
post,
I
read
everything
and
I
will
read
it
down
the
read
it
out
loud
for
primarly
all
right.
So
now
I
think
jeremy.
Do
you
want
to
share
something
with
us.
D
D
So
it's
a
windows
desktop
app
targeting
netcore
3.1
and
it's
using
entity
framework
to
create
a
ui
to
build
this,
and
I
want
to
show
you
just
some
of
the
pieces,
so
I've
defined
a
very
simple
category,
so
there's
a
category
and
a
name
and
notice,
I'm
using
a
observable
collection
list
source.
So
this
is
something
that's
provided
by
entity
framework
core
to
handle
the
two-way
data
binding.
That's
inside
of
winforms
app.
So,
instead
of
having
to
cast
or
build
your
own
proxy,
for
example,
this
will
automatically
do
all
that
change
tracking
for
you.
D
Similarly,
we
have
a
product
that
references
back
up
to
a
category,
so
this
is
a
navigation
property.
So
if
I
have
a
product
I
can
navigate
into
the
category
and
what's
nice
is
this
is
set
up
to
lazy
load,
so
it'll
basically
pull
back.
One
of
the
entity
sets
and
only
load
the
other
one
if
you
access
it
my
product
contacts.
This
is
what
establishes
my
connection
to.
The
database
shows
categories
and
products
we're
using
sqlite
and
again.
D
This
could
just
as
easily
be
sql
server,
but
to
keep
the
example
simple
and
self-contained
I'm
using
sql
lite
because
it
just
creates
a
local
file
and
I'm
using
these
lazy
loading
proxies.
These
are
what
detect,
when
you're,
trying
to
access
a
navigation
property
and
pull
them
in.
So
that
is
all
it
takes
for
me
to
set
up
my
database
portion
of
this.
D
When
the
forms
load,
I
create
one,
I'm
making
sure
that
database
is
created
now,
unlike
arthur's,
I'm
not
starting
fresh
each
time,
so
I'm
not
deleting
it
and
creating
it.
I
want
persistence
between
sessions,
I'm
loading
the
categories
and
then
I'm
just
using
a
binding
source
so
that
data
source
right
here
uses
this
entity
framework
extension
method
to
turn
it
into
a
binding
list.
D
That's
pretty
much!
It
we've
got
our
save
button
that
validates
and
calls
save
changes
and
then
refreshes
the
views.
So
let
me
go
ahead
and
run
this
and
show
you
what
the
experience
looks
like
give
it.
A
second
here
should
pop
up
shortly.
So
now
I
have
my
fancy
form
and
I'm
just
going
to
do
some
categories.
We'll
do
food
we'll
do
water,
that's
okay!
I
didn't
spell
it
right,
we'll
do
dessert
and
then
for
water.
D
Actually,
let's
make
this
drink,
let's
do
a
couple
drinks
we'll
do
soda
we'll
do
water
we'll
do
shake
and
then
for
food.
Let's
add
a
couple
entries
we'll
do
pizza
and
burrito
and
then
we'll
save
it,
and
you
can
see
our
ids
populate.
We
can
navigate
back
through
these.
Let's
go
into
the
drink,
let's
say
we
don't
want
water
too,
healthy,
save
that
and
now
you
can
see
that
we've
round
tripped
and
updated
the
database.
D
C
C
So
one
thing
that
jeremy,
one
thing
that
jeremy
mentioned
is
how
the
ids
were
populated
automatically.
So
I
think
it's
useful
to
understand
what
af
is
doing
under
there
and
kind
of
the
best
practices
with
ef.
C
So
you
really
don't
want
to
manage
your
primary
key
and
foreign
keys
yourself
and
here,
if
you
want
to
use
these
navigation
properties
like
we
saw
with
blogs
and
posts
and
with
categories
and
products
in
jeremy's
example,
where
you
connect
them
up
and
then
you
let
af
generate
the
ids
for
you
and
in
fact
it's
not
ef,
that's
really
generating
the
ids,
it's
the
database.
So
what
happens
when
af
saves
those
things
to
the
database
is
that
it
asks
them
to
the
database.
C
Because
it's
often
easier
to
it's
easy
to
get
into
a
state
where
you're
not
sure
what
you're
doing
and
you
just
set
keys
and
things
and
then
you're
really
fighting
against
df
rather
than
working
with
it.
One
more
thing
I
want
to
point
out
if
you
can
go
to
the
the
main
designer
page.
C
Yes,
there
so
scroll
down
to
the
initialize.
C
I
know
the
form
load,
that's
right.
The
form
load
so
there's
a
couple
of
things
that
are
going
on
here
that
are
interesting
in
terms
of
the
data
binding
scenario.
So
the
ef
context,
when
you
query,
or
you
attach
things
or
add
them
to
the
context,
it
starts
tracking
the
state
of
those
entities.
So
it
knows
what
values
have
been
added.
What
values
have
changed
and
can
do
automatic
database
updates?
C
C
That
means
it's
going
to
feed
those
changes
that
you
make
in
the
app
back
into
ef
and
because
af
is
already
doing
that
tracking
of
changes
when
it
sends
the
update
to
the
database,
it's
only
going
to
update
the
things
that
have
actually
changed
so
there's
a
very
tight
connection,
tight
integration
here
between
what
you're
changing
in
the
ui
and
the
things
that
are
marked
as
tracked
in
the
database,
so
you
can
very
easily
just
say
right.
I've
made
all
those
changes.
Do
the
update?
A
D
D
D
Category
is
the
same,
and
our
product
context
is
the
same,
so
exact
same
setup.
I
could
easily
have
this
in
a
shared
library
that
I
share
between
my
wpf
and
my
winform
application.
If
I
want
to
do
that
this
time
in
the
code
behind
for
the
main
window,
I've
got
my
product
context
and
then
in
the
xaml.
Let's
show
xaml
here
one
second
in
the
xaml
I've
defined
some
resources
here.
I've
got
two
collection
view
sources.
D
D
Then
we've
got
our
regular
data
grids
and
our
save
button
so
we're
doing
a
very
similar
thing,
I'm
basically
when
it's
loaded,
I'm
ensuring
the
database
is
created.
I'm
loading
it
only
this
time,
I'm
using
the
extension
method
to
observable
collection,
because
wpf
uses
the
notify
property
change.
So
it's
going
with
the
observable
collection
instead
of
the
binding
list
source,
but
that
is
the
only
real
change
here
when
we
click
the
button.
D
We
save
the
changes
entity
framework
core
is
smart
enough
to
understand
that
I've
modified
a
field,
maybe
changed
the
name
that
I've
removed
the
field,
I've
added
a
field
and
it
will
just
gather
those
changes
and
push
those
out
to
the
database
and
then
I'm
just
refreshing
my
grid
and
then
at
the
end
of
it
I'm
disposing
everything.
So
let
me
run
this
and
show
you
what
that
experience
looks.
C
D
As
as
I
was
designing
these
these
grids
and
fields,
so
let's
do
food,
drink,
dessert,
we'll
come
up
to
drink,
we'll
do
water,
soda,
shake
kombucha
and
then
we'll
save
that
and
same
thing.
We
get
ids
for
all
of
these.
We
can
navigate
off
the
food
to
drink.
Let's
say
I
decide,
I
don't
want
the
shake
I'll
highlight
this
row
I'll,
delete
it
I'll,
save
it
and
entity
framework
core
has
removed
that.
D
D
C
If
there,
if
there
are
questions
on
the
on
that,
we
can,
we
can
ask
those
if
not
I'll,
go
back
and
show
my
ef
core5
app,
which
demo,
which
shows
index
of
properties
a
new
feature.
Okay,.
A
C
Okay,
so
we're
back
in
exactly
where
we
were
before
this
is
where
I
left
off
before
jeremy
started.
Now
we
could,
if
we
wanted,
to
let's
say,
extend
this
model.
We
could
add
a
new
public.
Sorry,
if
I
can
type.
C
Let's
say
we
want
a
created
time
so
we'll
create
a
date
time
property
created
on
I'm,
making
these
all
just
public
properties
with
getters
and
setters.
You
don't
have
to
you-
can
use
read-only
properties,
initializing
them
in
constructor
and
all
that
kind
of
good
stuff.
That
ef
nef
will
still
understand
and
be
able
to
do
that.
So
I
can
do
this
and
I-
and
I
can
now
start
using
this-
I
could
add
things
here
to
date
times
and
everything,
but
let's
say
I'd
ship,
this
application
to
a
customer
and
they
wanted
to.
C
Actually
I
was
shipping
it
as
a
library
rather
than
application,
and
they
wanted
to
extend
the
library
previously,
of
course,
one
of
the
limitations
was
you
had
to
be
able
to
modify
the
actual
clr
type
in
order
to
add
a
new
property
to
it.
So,
even
if
you
could
modify
the
database
to
add
a
date
time
created
on
column,
if
you
weren't
able
to
actually
change
the
clr
type,
then
you
couldn't
get
that
new
column
in
the
database.
C
So
you
could
do
that
by
allowing
people
to
extend
the
types
you
know
derived
from
the
mag
columns
and
stuff
and
if
in
f,
core
5
we've
made
that
easier
by
allowing
indexer
properties.
So,
instead
of
being
defining
this
directly
as
a
date
time
I
can
put
in
here
a
index
of
property
for
see,
I
might
have
the
code
snippet.
C
Yes,
so,
rather
than
write
this
all
out
live,
let
me
just
post
this
on
there,
so
you
can
see
the
change.
So
what
I've
done
here?
Sorry
I've,
I'm
supposed
to
do
it
in
my
post
and
I've
started
to
do
it
in
my
blog.
So
let's
do
it
in
the
post,
where
I
was
supposed
to
do
it
in
the
first
place.
C
There
we
go
so
what
I've
done
here
is
I
haven't
added
any
specific
property.
I've
added
a
backing
field
of
a
dictionary.
This
is
just
a
string
to
object.
You
don't
have
to
use
two
objects.
If
you
know
you're
always
throwing
strings,
it
can
be
strings
of
string.
If
you're,
storing
against
you
can
be
string
queen
string
to
object,
lets
you
store
anything
and
then
I've
added
an
index
of
property
on
here.
C
So
this
is
an
index
of
property
where,
if
I
pass
it
a
name,
it's
going
to
try
and
get
that
name
out
of
the
dictionary
or
set
that
name
into
the
dictionary.
So
I
can
now
pass
this.
You
know
the
to
the
to
the
other
application
developer
and
take
this
out
of
my
library.
They
still
have
to
tell
ef
how
to
that
there
is
a
property
that
they
want
mapping
in
there,
which
is
done
in
this
model
builder.
C
This
is
the
fluent
way
to
map
entities,
so
we
can
do
entity
post
here
and
then
we
can
tell
it.
It
has
an
index
of
property.
So
this
is
what
I
would
do
so
because
we
have
that
index
of
property
on
the
actual
entity
type.
I
can
now
say:
okay.
What
I
want
to
do
is
I
want
to
store
a
date
time
in
that
and
call
it
created
on
now.
This
doesn't
require
me
to
change
my
post
type
at
all,
so
any
any
application
can
extend
this
and
just
say:
add
this
index
to
property.
C
So
we've
done
that
if
we
now
run
and
create
the
database,
what
we'll
actually
see
hopefully,
is
that
it
creates
a
property
for
that
when
we
create
the
database,
so
I'm
running
with
the
logging
on
again:
oh,
it
didn't
failed,
but
it
still
created
the
database
because
I
haven't
updated
this
rest
of
the
code.
Yet
so
you
see
in
the
database
now
we've
got
created
a
column.
It's
text
in
sql,
like
in
sql
server,
you'll,
see
date
time
2
by
default.
C
Sql
lite
has
a
very
limited
type
system,
so
date
times
are
stored
as
text
by
default.
You
can
change
that
in
efcor.
You
can
tell
it
to
store
them
in
different
formats
and
it
will,
but
you
can
see
that,
even
though
we
don't
have
that
created
on
property
in
my
post
class,
because
we
have
an
index
of
property
and
we
put
it
in
here,
we
now
have
that
index
property
in
the
in
the
in
the
database.
C
I
could
replicate
this
line
and
do
another
one
I
could
say:
okay,
we
also
want
a
modified
on,
for
example,
and
that's
fine.
That
code
will
work.
I
want
to
show
a
quick
tip
here
that
a
lot
of
people
seem
to
miss,
which
is
you
don't
have
to
repeat
yourself.
Quite
that
much.
You
can
do
this,
what
we
call
the
the
nested
lambda
syntax,
where
I
take
these
things-
and
I
put
the
first
one
in
here
and
then
I
can
also
do
another
operation
on
the
same
entity
type.
C
So,
instead
of
me
having
to
type
the
entity
type
post
twice
type,
do
this
sorry
do
entity
post
twice
there?
I've
only
actually
done
it
once
and
then
I'm
saying
okay,
I
could
do
lots
of
operations
on
that,
so
it's
kind
of
a
shortcut
rather
than
have
doing
model,
build.entity.post.property
model,
builder,
entitypost.property
and
so
on.
Over
and
over
again
for
the
rest
of
this
demo,
I
only
want
indexed
property,
so
I'm
going
to
remove
that
and
this
will
still
work,
but
you
can
go
to
the
other
syntax.
C
C
Okay,
so
hopefully,
when
I
run
this,
it
won't,
it
won't
crash
this
time
because
we're
actually
saving
things
into
the
properties.
Indeed
it
didn't.
So
what
you
can
see
here
is
on
the
insert,
so
it's
doing
insert
values
into
post
block
id
and
it's
using
my
created
on
and
if
you,
because
I
put
sensitive
data
on
me
by
normal
by
default,
ef
will
not
output
in
any
of
the
logs
any
of
the
values
from
your
database,
because
that
could
be
sensitive
data.
However,
when
you're
debugging,
it's
very
useful
to
see
those.
C
C
To
I
could
say
where
created
on
is
greater
than
this
or
less
than
that,
and
that
would
still
work,
and
when
we
look
at
the
output
of
this,
if
I
run
it
again,
we
now
see
that
the
output
down
here
we
have
the
the
created
ons
being
accessed
from
the
index
property.
So
that's
something
that
we're
putting
in
ef
core
5.0.
It's
primarily
there
because
this
is
actually
the
way
many
to
many
work
under
the
covers.
C
We
effectively
create
entities
that
are
dictionaries
that
have
the
information
that
you're
in
so
that
they
don't
need
to
be
specified,
but
because
we
built
this
in
a
kind
of
componentized
way,
you're
free
to
create
your
own
index
of
properties
and
use
them
in
your
own
way,
which
can
be
very
useful
if
you
want
to
extend
existing
metadata
in
this
way.
A
Perfect,
thank
you
so
much
for
the
demo
that
looks
very
exciting
and
we
had
a
few
questions,
but
we
already
had
answers
in
the
chat,
so
emily
were
asking
about.
Crap
templates
and
jeremy
responded
that
we
have
tutorials
all
right,
then
arthur.
If
you
wanna,
stop
sharing
the
screen.
Yep.
A
A
B
Studio,
it
helps
you
create
new
projects
in
visual
studio
that
are
wpf
uwp.
I
think
there's
potentially
xamarin
support,
but
basically
it's
like
a
nicer
file,
new
project
experience
that
has
complex
features.
You
can
integrate
mvvm
patterns
using
prism
or
some
other
library,
for
example,
so
that
your
your
new
project
has
all
that
built
in.
So
I
guess
that's
the
form
of
the
question
right
folks
on
the
chat
that
it'd
be
nice
to
have
a
check
box
to
start
adding
entity
framework
capability.
There
yeah.
D
B
B
A
D
B
Right,
yeah
in
any
real
world
app
that
has
those
kind
of
concerns.
Definitely
we
we
should
architect
to
the
technology.
I
think
for
if
the
demo
was
perfect
even
like,
I
would
build
a
simple
app
since
sql
light
is
local.
Some
of
those
concerns
are
not
there.
Unless
the
sequel
light
itself
becomes
really
big
or
complicated.
D
C
We
we've
we've
shown
some
some
of
that
in
the
past.
I
don't
think
we
have
any
current
samples.
I
don't
know
who's
tried
it
recently,
but
we
can
follow
up
on
that,
because
we
should
show
how
to
use
that
awesome.
A
A
E
So
as
julia
gets
started,
folks
to
show
you
the
roadmap
once
again,
I'm
pramalini
david,
I'm
a
new
pm
on
wpf,
my
team,
the
the
developer
ecosystem
and
platform
team
recently
took
ownership
of
wpf.
We
are
the
same
team
that
also
owns
win,
ui
and
react
native,
and
so
now
a
single
team
owns
all
of
the
ui
frameworks
and
invest
investments
that
go
in
there
and
we
are
going
to
be
ensuring
that
there
is
consistency
in
the
different
investments
made
across
the
ui
frameworks.
A
E
Yes,
so
dmitry,
if
you'd
like
to
zoom
in
ever
so
slightly
to
the
table
on
the
page
sure
so
folks
for
fiscal
year,
2020
2021,
my
team
is
committed
to
the
investments
that
you
see
in
the
table:
investments
in
wpf,
so
starting
off
the
first
one
framework
servicing
fixes
into.net
core
3.1
and
net
5..
E
This
is
something
that
was
started
by
the
earlier
team
that
owned
wpf
and
when
my
team
took
over
we're
essentially
continuing
on
that
work,
and
this
is
ongoing
work
and
and
it
will
go
on
through
the
year.
The
next
one
is
ongoing
integration
with
net5.
E
We
have
done
most
of
the
work,
I
want
to
say,
maybe
about
70
of
the
work,
so
we
will
have
this
done
and
wrapped
up
fairly
soon,
as
we
get
closer
to
wrapping
this
up.
I
will
refine
the
target
delivery
column
in
this
table
to
indicate
when
exactly
this
is
going
to
be
completed.
E
Number
three
on
this
list,
building
out
test
infrastructure,
to
add
tests
to
validate
and
merge
community
prs
now.
This
is
something
that
we
have
heard
from
you,
the
community
loud
and
clear,
and
we
are
actively
working
on
making
this
happen
so
that
we
are
able
to
enable
the
community
to
contribute
directly
merge
pr
prs
directly
once
we
have
our
test
suites
available
publicly.
E
So
this
is
a
heavy
duty
investment
for
us
we're
working
on
this
in
20
h2.
We
already
have
a
dedicated
developer
for
this.
For
this
particular
work
item
the
fourth
one
on
this
list
is
accessibilityupdates.net
5..
E
Now
there
are
certain
accessibility
bugs
as
well
as
features
that
we
need
to
add
in
order
to
meet
the
government
stipulated
accessibility
guidelines
in
the
various
countries
where
your
your
apps
run,
and
this
is
something
that
is
a
priority
for
us
and
we
are
going
to
take
this
up
in
21
each
one
and
the
last
item
there,
but
not
the
least,
is
arm
64.
E
As
you
are
aware,
we
microsoft
is
investing
in
new
devices
on
64
devices
and
we
look
forward
to
having
your
apps
running
on
those
devices
and
therefore
wpf
arm.
64
support
is
an
important
one
for
us
and
we
will.
We
are
going
to
be
taking
that
up
in
21
h1
as
well.
Once
again
as
we
get
closer
to
the
preview
timelines,
I
will
be
updating
this
table
with
more
refined
target
delivery
dates.
E
I
will
be
also
sharing
that
same
information
with
you
on
calls
such
as
this,
so
please
stay
tuned.
E
So
now,
if
we
want
to
scroll
down
a
bit
to
dimitri,
I
would
like
to
talk
about
our
sla
for
the
plethora
of
github
issues,
good
issues
that
we
have
now
for
all
new
issues
that
are
filed
after
july
10th.
We
have
a
sla
of
72
hours.
That
is
three
working
within
three
working
days.
We
will
triage
those
issues,
however,
that
does
not
mean
that
all
of
the
good
issues
that
were
filed
prior
to
july
10th
will
would
not
be
looked
at.
E
In
fact,
we
have
a
team
of
developers
come
pm
who
are
actively
triaging
the
the
500
or
so
issues
that
are
currently
on
github
to
bring
those
counts
down.
So
you
will
see
questions
coming
back
from
us
on
the
issues
that
you
may
have
filed
earlier.
E
We
come
back
to
you
with
questions
clarifications
about
a
certain
issue
and
that
will
that
will
show
you
that
we're
actually
actively
trying
to
bring
our
accounts
down
on
that
front
in
terms
of
the
pull
requests
that
you
have
submitted
now
we
are
committed
to
selecting
at
least
one
or
two
prs
per
month
to
merge
into
the
framework.
E
Now
the
criteria
for
selection
of
a
pr
is
the
bulleted
list
that
you
see
there
I'll
read
it
out.
It's
recency.
The
next
is
the
extent
of
reactions
which
may
be
likes
comments
the
thumbs
up.
You
know,
hearth,
sign
so
on
and
so
forth.
The
next
is
fixes
to
existing
issues.
That
is
it's
not
a
new
feature.
It's
an
existing
feature.
E
The
next
is
complexity
of
the
fix
in
itself,
then
we
have
breadth
of
the
impact
of
the
fix
how
widely
it
is
going
to
be
impactful
to
the
apps
in
the
ecosystem.
Today
the
next
is
low
potential
for
regression.
The
next
is
has
adequate
test
coverage.
The
potential
for
regression
is
also
tied
to
the
adequacy
of
test
coverage
that
we
have,
and
the
last
one
is
that
it's
not
a
new
feature
request.
E
Now
it
does
not
mean
that
if
you
have
filed
appear
for
a
new
feature
that
we
would
not
consider
it,
the
only
thing
is
that
at
the
moment,
for
the
moment,
with
our
current
number
of
resources,
our
team
is
committed
to
the
list
that
you
see
here
as
the
months
go
by
and
as
we
are
able
to
better
resource
and
staff,
our
team,
we
do
expect
this
list
to
get
refined
a
little
more,
at
which
point
we
will
be
able
to
accept
new
features.
E
We
also
expect
that
our
test
suites
would
then
be
available
publicly
to
you
and
you
would
be
able
to
merge
prs
directly.
The
next
topic
I
wanted
to
touch
to
is
about
the
non-code
prs.
These
are
documentation
bugs
documentation
issues
now
the
sla
for
this,
too,
is
72
hours
for
all
new
pr's
filed
after
july
july
2020.
E
The
next
one
community
calls
so
we
I
do
expect
to
be
on
community
calls
such
as
this
at
least
every
other
month.
I
will
also
be
on
the
win
ui
community
course
giving
you
updates
on
the
progress
of
the
work
in
the
investments
that
you
saw
in
the
roadmap.
In
addition,
we
are
definitely
looking
forward
to
your
questions,
your
feedback
on
the
investments
that
we
are
making.
E
So
I
do
expect
to
see
you
all
on
these
community
calls
every
every
other
month
last,
but
not
the
least
resourcing
the
resourcing
topic
heavily
influences
the
extent
and
the
depth
and
breadth
of
the
investments
that
we
make
in
wpf.
Our
team's
management
has
approved
the
additional
resources
that
our
team
needs.
E
It
just
so
happens
that
this
global
covet
pandemic
has
caused
our
hiring
to
be
slower
than
usual,
and
so
as
we
combat
this
pandemic
together
and
more
specifically
as
we
overcome
this
pandemic
together,
I
do
fully
expect
that
our
hiring
hiring
will
get
back
to
speed
and
we
will
be
able
to
hire
the
required
resources
for
our
team
for
this
project
and
as
and
when
that
happens,
we
will
be
refining
the
roadmap
with
the
investments,
probably
newer
investments,
some
additional
investments
that
we
could
make
for
the
coming
fiscal
year.
E
That
brings
me
to
the
end
of
the
roadmap
and
I'll
hand
it
back
to
olia,
or
you
know
I.
I
would
love
to
answer
questions
from
folks
on
the
call.
A
Sounds
great,
thank
you
so
much
for
melina
and
we
got
a
lot
of
questions
and
you
did
a
great
job
already
answering
them.
So
there
were
questions
about
the
staffing.
Is
someone
working
full
time
on
wpf
people
were
asking
to
explain
why
prs
were
blocked
for
the
last
year?
I
don't
know
you
already
talked
about
it.
If
you
want
to
add
anything
to
that
go
ahead.
If
not,
we
can
go
through
other
questions.
E
Nothing
new
that
I
haven't
already
mentioned
again.
We
we
just
took
over
wpf.
I
won't
be
able
to
speak
to
what
the
earlier
team
did
or
did
not
do,
but
now
that
we
have
taken
over
do
expect
that
you
will
hear
from
us.
We
we
have
a
team
with
limited
resourcing,
but
we
are
100.
E
Whoever
is
on
the
team
is
100
on
this
project
and-
and
you
will
be
hearing
from
us
on
the
github
repo.
A
A
E
That's
that's
a
good
point.
We
as
we
triage
the
issues
and
the
prs
we
are
adding
some
additional
labeling
that
is
not
camouflaged
in
some
internal
terminology,
so
I
am
going
to
actually
revisit
the
label
about
about
the
milestone
five
and
make
sure
that
it's
more
descriptive.
Apologies
that
between
the
earlier
team
and
and
our
team,
we
haven't
really
have
an
opportunity
to
look
at
the
labels.
Look
at
the
milestones
and
scrub
them
correctly,
but
we'll
get
on
top
of
it.
A
A
C
Store
procedures
is
a
is
a
a
big
area.
You
can
definitely
call
store
procedures.
We've
improved
the
mapping
in
the
f
core
five
there's
still
some
more
work
to
be
done
in
that
area,
but
you
can
use
them.
A
Perfect
yeah
and
they
get
a
command
about
that
after
a
year
of
silence,
any
goodwill
enthusiasm
for
community
engagement
has
faded.
It's
good
that
there
will
now
be
someone
running
the
project,
but
the
fact
that
it
was
abundant
without
any
communication
for
so
long
is
satan
on
the
project.
Staying
on
the
project
yeah,
unfortunately,
and
morgan
nielsen
is
here.
Yelling
at
us
just
merge
my
pr's.
They
work
they
work.
A
By
default,
all
right
any
more
questions
guys
go
ahead.
He
tested.
D
A
There
were
kudos
to
telerik,
and
I
want
to
join
that.
That
is
amazing
control,
vendor
and
our
dear
friends.
We
have
a
bi-weekly
calls
with
them
for
bin
forms
and
they
do
absolutely
amazing
job
their
greatest
people.
I
had
a
chance
to
meet
them
in
person
when
I
was
in
the
conference
and
yeah.
It's
a
pure
pleasure
working
with
these
guys.
C
E
Yes
and
it's
surprisingly,
cooler
than
usual
less
traffic
on
the
roads,
less
pollution,
and
so
it's
it's
really
nice
outside
the
the
only
difference.
It's
it's
completely
dark
outside
it's
night
time.
For
me,
it's
it's!
It's
11
30
in
the
night.
A
B
A
C
A
A
A
A
A
And
I
saw
earlier
there
were
questions
about
webview
2,
so
w2
is
supported
for
winforms
and
wpf
nwpfor.net,
core
and
dotnet
framework.
I
posted
the
link.
We
have
a
docs
on
getting
started
for
winforms
for
wpf.
That
is
the
link,
but
right
there.
You
can
also
find
getting
started
for
bin
forms
as
well,
and
that
is
a
new
chromium
based
controls.
We
are
very
excited
to
have
it.