►
From YouTube: Desktop Community Standup - August 27th 2020 - WinForms Innovations & XAML tooling updates
Description
Join members of the .NET WinForms and XAML tooling product teams to discuss the latest news. This week we'll cover performance improvements in Windows Forms, what's new for WPF/UWP developers in Visual Studio 2019 Update 7 (which is now GA!) and talk about the progress that has been made in the new WebView2 Chromium web control
Community links: https://www.theurlist.com/desktop-community-standup-8-27-2020
[Featuring: Dmitry Lyalin (@LyalinDotCom), Jeremy Kuhne (@Tofudebeast)]
A
A
A
A
So
we're
going
to
kick
it
off
in
a
minute
with
jeremy
he's
going
to
be
doing
a
lot
of
great
demos
and
talking
to
us
about
winforms,
but
just
to
kind
of
recap.
What
we're
going
to
be
talking
about
as
an
overall
topic
today,
we're
going
to
start
with
the
winforms
conversation
jeremy's
going
to
go
as
long
as
he
needs
to.
He
has
such
a
good
topic.
A
We
really
want
to
get
through
all
of
it
and
then
we're
going
to
switch
over
towards
the
end
and
talk
a
little
bit
about
what's
been
happening
in
this
world
of
xaml,
similar
to
what
we
did
last
week,
but
just
to
recap
to
anybody
who's
missed
it
and
give
an
update
on
the
webview
control.
But
with
that
I
really
want
to
get
to
jeremy's
topic
so
again,
jeremy!
Thank
you
for
being
here.
Maybe
you
can
tell
folks
a
little
bit
about
who
you
are.
A
B
Sure
you
know,
there's
you
know
in
dot
net
core
as
a
whole
and
I'm
sure
that
most
of
you
are
familiar
with.
The
performance
has
gotten
significantly
better.
So
for
the
net
core
runtime,
the
libraries
you
know,
and
if
you
weren't
aware
of
why
the
basic
just
is
that
you
know
we,
we
were
able
to
shed
some
of
the
legacy
stuff,
like
notably
abdomens
and
and
and
code
access
security,
and
that
that
made
for
a
sort
of
a
slimmer
foundation
that
we
were
able
to
build
on.
B
But
the
bigger
thing
is
we
were
able
to
like
iterate
faster
because
we
weren't
using
a
shared
code
base
among
multiple
versions
of
the
framework
which
you
know
made
it
very
difficult
to
make
changes
on
on
the
existing
or
the
old.net
framework
and
the
other
part
of
it
is.
You
know
there
has
been
a
an
increased
focus
on
what
was
called
peanut
butter
internally
and
they
even
have
that
in
the
blog
post.
B
Is
it's
saying
like
well,
you
know
little
changes
in
or
changes
in
very
specific
areas
may
not
add
up
on
their
own.
But
when
you
do
that,
as
kind
of
a
general
thing
you,
you
aggregate
to
some
pretty
significant
performance
improvements
that
are
visible
just
broadly
right
and
that's
part
of
how
things
have
really
made
a
big
difference
on
dinette
core
itself.
B
You
know
in
winforms
we're
starting
to
take
that
same
sort
of
approach
to
go
through
and
clean
that
peanut
butter
out
and
that's
kind
of
what
I'm
going
to
talk
a
little
bit
about
one
of
those
things.
I
did
this
time
for
done
in
five
and
a
big
part
of
that
peanut
butter,
incidentally,
is
just
trying
to
get
a
cable
on
allocation
right.
B
So
a
big
portion
of
where
your
performance
impacts
come
from,
is
you
know,
putting
undo
work
or
unnecessary
work
on
the
garbage
collector,
the
more
the
garbage
collectors
do,
the
slower
your
apps
get.
So
that's
kind
of
the
one
of
the
the
biggest
top
line,
things
for
peanut
butter
to
come
out,
and
you
know
we
take
care
of
that
a
bit.
B
You
know
in
core
three
one,
but
the
primary
focus
has
been
even
still
now
is
getting
the
designer
up
and
making
sure
that
winforms
is
there
at
all
right
now,
yeah,
it's
significant
work
and
that's
what
most
of
the
effort
still
is
on.
You
know
getting
the
designer
polished
up
and
and
ready
for,
like
you
know,
prime
time
usage,
and
but
despite
that
you
know
we
have
been
doing
effort
or
making
an
effort
on
this.
You
know
performance
and
other
features
have
been
coming
in.
B
Like
accessibility,
stuff
has
been
in
progress,
the
one
of
the
big
parts
that
we
did
starting
in
3-1,
and
now
we
did
it
more
significantly.
Is
we
improved
the
interop
or
the
the
interfacing
with
windows
itself,
so
we're
being
much
more
efficient
about
how
we
talk
to
the
native
windows
apis,
which
actually
makes
a
big
difference?
You
know
kind
of
across
the
board.
B
There
was
some
peanut
butter
there,
and
you
know
I
basically
cleaned
that
up
and
re-architected
that
to
to
get
better
performance
on
the
redraw,
at
least
for
you
know
the
drawing
aspect
of
that,
and
I
have
a
demo
that
I
can
show
you
and
we'll
go
into
that.
It
was
partially
also
driven
by
the
the
need
to
get
a
better
handle
on
our
allocat
or
our
management
of
native
resources.
A
So
yeah
it's
really
exciting.
I
mean
I
used
to
be
a
winforms
developer.
Before
I
even
joined
microsoft,
I
shipped
one
app
to
production
in
the
bank
and
it
was
just
such
a
great
product
even
back
then,
but
it
certainly
has
you
know,
has
had
a
lot
of
age
on
it.
Like
we've,
we've
been
working
in
wind
farms
for
a
while
we're
working
on.net
and
that
core
has
been
a
really
exciting
journey.
A
B
All
right,
so
you
know
what
I
have
here,
I'm
going
to
zoom
in
for
a
bit
you
know,
is
I've
got
a
project
with
three
winforms
apps.
They
all
have
the
exact
same
code,
a
matter
of
fact.
You
can
see
the
arrows
it's
just
linked
into
the
other
projects
and
there
is
a
onetargeting.net
core
3.1,
then
there's
net
5
and
then
dinette
framework
48.
B
And
that's
what
we're
going
to
be
looking
at
here
and
go
back
out
of
the
zoom
here
and
what
I
am
doing
here
is
you
know,
I'm
going
to
start
up
a
main
forum
and
you
know
I'm
firing
off
other
forms
with
controls
on
them
and
then
forcing
a
redraw
by
directly
calling
into
windows.
Here,
there's
a
redraw
window
here
in
a
you
know,
an
update
window
and
I'm
doing
that
multiple
times.
So
I
can
get
an
average
of
the
allocations
that
are
being
done
by
calling
gc
good
allocated
bytes
for
current
thread
and.
A
B
B
So
it
this,
this
looks
at
how
many
bytes
the
the
the.net
runtime
has
actually
allocated
for
the
current
thread,
and
then,
when
you,
you
know,
do
it
again,
you
just
take
the
difference
and
then
you
can
see
what
was
done
specifically
for
the
work
that
you're
doing
on
whatever
the
current
thread
happens
to
be
so.
We
know
that
this
is
all
stuff
that
we
directly
impacted
on
this
thread
right.
B
B
Just
one
all
right
and
above
it
is
the
dotnet
3.1
core
31
and
over
here
is
framework.
Four
eight.
Now
I'm
running
at
150
percent
scaling-
and
this
is
kind
of
intentional.
I
want
to
show
you
this,
I'm
actually
designing
for
high
dpi.
Here,
it's
one
of
the
things
we've
done
a
little
bit
better
on
in
dot
net
core,
and
you
see
the
4
8,
even
though
it's
the
exact
same
code
as
it
just
doesn't
scale
quite
the
same
way
right.
B
Right
now
this
one
right
here,
so
that's
this
one
here
and
then
this
one
over
here
is
3.1,
and
this
is
done
that
five.
So
the
first
thing
I'm
going
to
do
is
I'm
going
to
kick
open
form
here
by
clicking
on
this
button
with
a
data
grid
view
and
that's
really
pretty
much
our
heaviest
weight
control
that
we
have
or
one
of
the
heaviest
weight
ones.
So
it's
it
does
a
lot
of
work
and
a
lot
of
it
isn't
drawing.
But
I'm
going
to
kick
that
up.
B
B
We'll
kick
that
off.
Here
too,
and
here
we
are
down
from
222
kilobytes
to
205..
It's
a
small
improvement.
It's
it
all.
Improvements
are
good,
so
that's
good,
but
in
in
five
we'll
kick
this
off
again
and
you
know
run
through
the
same
50
iterations,
because
this
is
the
exact
same
color
on
each
one.
Now
we're
down
to
72.7.
B
B
That's
huge
so
pretty
significant.
The
next
one
is
a
similar
sort
of
thing,
with
a
bunch
of
controls,
this
one's
out
of
one
of
the
things
in
our
in
our
actual
solution
for
the
for
winforms.
We
used
to
test
it's
not
as
complicated,
but
you
know
similar.
You
know
variety
of
controls
and
it's
75
kilobytes,
so
on
4.8,
so
less
stuff
going
on.
So
that's
why
it's?
B
A
B
Pretty
big
jump-
and
you
know
some
of
some
of
this
stuff
work-
that's
happening
during
redraw-
is
not
actually
drawing,
there's
actually
checking
the
state
of
the
data
and
all
that
sort
of
thing.
So
the
next
one
I'm
going
to
show
you
is
the
group
box
and
it's
just
because
there's
really
no
significant
logic
to
a
group
box
right
as
far
as
when
it
redraws
it's
just
a
bunch
of
lines
to
give
you
the
sort
of
3d
effect
of
the
lines
and
the
text
right.
B
So
we
can
see
what
that
looks
like
and
because
there's
not
significant
stuff
going
on
here.
I'm
doing
this
actually
ten
thousand
times,
but
it
doesn't
take
long
and
you'll
see
that
we're
you
know,
even
though
this
is
just
drawing
a
few
lines:
you're
still
taking
eight
and
a
half
kilobytes
for
for
each
redraw
and
we'll
look
at
core
three
one.
B
B
Would
you
get
when
you're
doing
a
re
redraw
that
has
a
graphics
object
associated
with
it
and
graphics?
You
know,
system
drawing
dot,
graphics,
you
know,
implements
eye
device
context,
and
if
you
wanted
to
draw
text
you
would
use
text
render
and
when
forums,
and
you
could
pass
it.
The
idevice
context
that
you
get
out
of
that
which
pass
it
the
graphics
object
basically,
and
you
can
draw
into
that.
The
thing
is
with
that.
You
know
like
when
we're
getting
stuff
from
windows.
B
B
So
you
now
have
the
ability
to
pass
your
your
painting
that
args
directly
into
anything.
It
takes
an
idevice
context
and
in
the
cases
where
we
can
take
advantage
of
the
optimizations,
we
will
right.
So
the
next
part
of
that
is
a
mic.
We
actually
added
span
overloads
to
to
text
renderer,
so
you
could
pass
your
text
in
as
a
span
rather
than
having
to
allocate
a
string
when
you
don't
need
to.
B
So
what
I'm
going
to
do
here
is
I'm
going
to
ten
thousand
times
I'm
going
to
like
update
the
text
and
you'll
see
it
count
as
it's
going
up
ten
thousand
times,
and
you
know
it's
destroying
a
very
simple
string
and
you
know
on
the
diagonal
framework.
Four
eight.
You
know
we
have
3.2
kilobytes
to
draw
one
string,
and
you
know
it's
also
repainting
the
background.
So
it's
a
fill
and
then
drawing
text
right
all
of
those
and
on
three
one.
B
You
know
there
is
a
small
improvement,
it's
down
to
2.8
and
on.net
5.
I
am.
I
would
get
a
similar
sort
of
improvement
on
things
but
or
a
bigger
improvement,
but
like
I'm,
also
going
to
be
doing
the
span
stuff
here
and
I'll
show
you
what
that
good
looks
like
when
we're
done
here,
but
you
do
the
same
10
000
things
and
you
should
probably
should
see
that
that's
sort
of
perceivably
faster.
But
it's
doing
you
know
0.25
kilobytes,.
B
So
it's
it's
not
terribly
sophisticated.
It's
just
you
know
in
the
case
here,
so
I
got
this
text
on
a
forum
thing
and
I'm
just
using
a
string
builder
in
both
cases
to
like
build
up
my
string,
I'm
adding
the
paint
count
into
it
and
doing
a
format
on
it
and
the
string
number
is
actually
pretty
efficient
at
this.
I
actually
worked
some
on
screen
builders,
so
I
know
we
did
some
improvements
on
string
builder,
too,
and
also
in.net
core.
But
here
I
said,
look
well.
A
Yeah
yeah,
that's
huge,
so
yeah
these.
These
are
great.
So
basically
like
a
lot
of
these
improvements
are
gonna,
come
from
just
just
switching
over
to
to
working
with
dot
net
core
five
for
your
application
for
making
that
the
runtime
and
then,
if
you're,
really
heavy
on
strings.
People
should
take
a
look
at
this.
B
Different
way
of
doing
it,
you
know
part
of
this:
is
you
know
the
reason
I'm
doing?
This
is
to
also
illustrate
that
you
know
we're.
You
know
we're
on
a
journey.
This
isn't
like
done,
and
so
we
have
plenty
more
to
do,
but
like
we're,
definitely
like
moving
forward
and-
and
you
know,
we're
getting
lots
of
contributions
from
the
community.
B
A
Visual
studio,
all
right,
awesome,
yeah,
we'll
get
all
those
links
from
you
and
we'll
make
sure
they're
in
the
show
notes.
If,
if
folks
focus
on
where
to
go,
we'll
make
sure
that's
easy
to
find
cool,
is
there
anything
else
in
the
journey
that
you
you're
thinking
about
now
like?
What's
what's
the
next
step,
you
talked
about
being
a
journey?
What
are
you
doing.
B
B
Know
the
monitor
that
we
got
back
then,
which
was
actually
more
than
a
4k,
but
just
barely
was
actually
a
24
000
monitor
at
the
time.
So
you
know
a
lot
has
progressed
since
then.
But
you
know
I've
been
very
passionate
about
things.
Looking
nice
and
sharp
you
know
for
me,
it
was
like
moving
from
dot
matrix
to
laser
printers.
You
know
it's
get
the
same
similar
effect,
so
I'm
taking
quite
a
I'm
taking
a
look
at
the
you
know
our
layout
engine
in
particular.
B
A
B
Know
we
still
have
to
make
the
existing
apis
work
the
way
they
always
did.
So
you
know
you
some
of
the
inefficiencies
of
the
slowness
come
around
the
model
because
we
have
to
notify.
You
know
you
know
for
things
that
are
on
the
on.
You
know
on
paint
and
what
all
the
other
things,
and
you
know
the
way
that
that
was
set
up
when
it
was
originally
started.
You
know
in
winforms,
was
the
coding
for
wind
farms
actually
started
in
the
mid
90s
or
what
became
one
forms?
B
You
know
there
was
a
vastly
different
environment
back
then
and
that
one
certainly
didn't
have
nearly
the
amount
of
functionality
later
on.
So
you
know
the
designs
were
based
on
things
when
you
didn't
have
generics
and
all
this
sort
of
stuff
so
and
also
running
on
windows,
95
right,
so
you
know,
there's
significant
allocation
in
the
design
to
to
make
that
happen.
B
So
you
know
you're
getting
feedback
from
things
that
you
see
that
are
particularly
slow
is
also
useful
right
to
see
that
like
well
do
this
thing,
it
seems
really
it's
allocating
a
ton,
or
I
see
this
sort
of
stuff.
You
know
that
can
help
clue
us
into
things,
because
you
know
winforms
is
a
huge
code
base
and
it's
you
know.
While
I
can
see
things
when
I'm
walking
looking
through
the
code,
I
go.
Oh
wait
a
minute.
I
could
do
that
better.
B
You
know,
there's
the
aggregate
of
stuff
in
these
real
world
user
scenarios
to
to
help
illustrate
where
prioritization
should
happen.
So
you
know
I'll
continue
to
scrape
the
peanut
butter
off
as
I
go
through
and
see
things
it.
It
helps
to
know
where
that
peer,
which
peanut
butter
aggregates
more
in
your
actual
scenarios.
B
So
that's
that's
useful
information
to
give
to.
Even
if
you
don't
know
technically,
what's
going
on
and
you
can
say
like.
Oh,
I've
got
the
small
thing
I
did,
and
you
know
it
seems
like
wind
farms
is
allocating
a
ton
for
that,
and
you
know
that's
all
very
interesting
stuff
for
us
and
for
even
the
community
members
that
are
actually
you
know,
contributing
to
the
code
base
as
well,
because
it
is
fun
and
rewarding
for
some
people
to
took
a
few
people
to
like
actually
take
something
and
make
it
better.
B
B
A
These
improvements
might
or
might
not
be
obvious
right,
like
they're
we're
changing
the
foundation
of
the
system,
we're
making
sure
we're
optimized
and
the
memory
pressure
grab,
which
collector
collection
and
such
so.
Therefore,
folks
should
see
that
as
positive
indicators.
If
they
see
those
indicators
trending
down,
then
that
means
the
changes
are
doing
what
they're
supposed
to,
and
I
guess
we're
just
looking
for
feedback
if
folks
see
something
running
faster,
running
slower,
please
let
us
know
if
the
app
begins
you
know
begins
to
work
strangely
like
this
is
the
time
to.
B
Yeah,
we're
doing
you
know
quite
a
bit
of
like
there's
like
plenty
more
work
to
do
and
like,
but
you
know,
we've
done
a
significant
amount
of
effort
too,
and
if
you
look
at
the
evolution
of
the
core
runtime,
you
can
look
at
like
steven
tobes
performance
posts
over
the
years.
Very
very
epic
posts,
yeah
they're,
pretty
epic
and,
like
you
know,
that's
it's
a
pro.
It's
a
process.
You
know
in
three
and
1.0
when
we
did
it,
there
was
yeah.
B
We
made
some
improvements,
but
you
know
there's
a
lot
of
a
lot
of
busy
work.
I
mean
I
went
through
all
those
releases,
so
there's
a
lot
of
busy
work
in
one
and
one
one
and
two
one
zero
just
to
get
the
functionality
in,
but
we
were
still
making
performance
improvements
and
winforms
is
still
in
that
same
sort
of
bucket
as
like
early.net
core.
You
know
where
we're
we're
doing
our
best
to
get
everything
up
online,
make
sure
everything
works
and
yet
still
you
know,
deliver
some
features.
B
You
know
and
and
and
improvements-
and
you
know
if
stuff
is
as
we
move
forward
and
the
other
stuff
slows
down.
You
will
be
able
to
focus
more
time
on
the
improvements
and
speed
and
with
feedback
that
helps
drive
it
too.
You
know
if
these
things
are
are
meaningful
and
interesting
to
you
and
you're
voicing
that
that
helps
helps
everybody
here.
You
know
know
how
to
prioritize
to
make
sure
that
everybody's
as
happy
as
we
can
make
them.
You
know.
C
A
Awesome
well,
this
is
great.
I
really
look
forward
to
see
what
the
community
has
to
say
about
it.
So
we
we
have
some
statements
in
the
chat.
People
seem
excited.
You
know
they
have
winforms
applications
with,
like
hundreds
of
controls
and
they're
they're
hoping
these.
These
improvements
make
a
difference,
so
folks,
like
daniel,
definitely
give
it
a
shot.
Let
us
know
what
you're
seeing
take
a
look
at
some
of
the
performance
traces
that
the
agnostic
hub
is
giving
you
and
see
if
you
can
feel
anything
in
application.
A
A
B
B
A
Okay
sounds
good
all
right.
Well,
since
there's
no
other
questions
to
the
community.
I
just
want
to
thank
you
for
your
time.
We
hope
to
see
you
back
on
when
you
have
more
to
say
and
we'll
keep
an
eye
on
what's
happening
for
winforms
yep.
This
is
awesome
all
right,
jeremy.
Thank
you.
So
much
for
being
on
see
you
next
time,
yep.
A
All
right,
so
that
was
jeremy.
Thank
you
again
for
him
for
joining
us,
so
we're
gonna
switch
gears
a
little
bit
right
now
and
and
just
fyf
folks,
in
the
chat
of.
If
you
do
have
more
questions
you
come
up
with
for
jeremy.
If
you
put
him
in
the
chat,
you
know
he
is
up
on
twitter,
so
we
can
try
to
get
him
to
answer
them
there
so
just
feel
free
to
to
keep
those
coming.
But
yeah
he's
he's
off
the
call
right
now,
so
we're
gonna
share.
A
A
So
if
anybody
in
the
livestream
doesn't
know
I'm
actually
the
program
manager
that
works
in
xaml,
tooling,
so
jeremy's
from
the
winforms
team,
they're
they're,
like
a
you,
know,
team
really
close
to
us
here
in
the
xaml
tooling
space
but
xaml
is
where
I
spend
my
time
and
I'm
really
excited
about
the
you
know.
Visual
studio,
update,
7.
update
7
has
gone
ga
recently,
so
this
happened
after
the
last
community
live
stream
that
we
did.
A
So,
if
you,
if
you
watch
the
last
one,
we
talked
about
some
other
things
that
were
coming
as
ga
now
ga
is
here,
and
I
just
wanted
to
point
out
all
the
features
that
we
shipped
as
part
of
that
ga,
in
other
words,
features
that,
as
far
as
we
know,
should
work
100
and
we
hope
you're
using
them,
testing
them
and
giving
us
feedback.
So
those
features
in
1607
include
some
refinement
work,
so
we've
been
refining
the
in-app
toolbar
experience
in
visual
studio.
A
So
if
you
run
your
application,
you
get
that
little
bar
inside
inside
of
the
app
that
has
the
buttons
in
it
and
we've
tried
to
make
that
just
be
smaller
and
really
out
of
your
way,
try
to
keep
it
in
the
toolbar
itself.
So
that's
the
kind
of
work
that's
been
ongoing
for
multiple
releases
and
we've
done
some
more
work
here
in
this
release,
and
then
we
we
launched
a
major
new
feature.
So
I'm
really
excited
to
talk
about
design
time.
Data
support.
A
A
Yet
100
you're
just
kind
of
laying
controls
out
you
want
to
start
seeing
things
so
we're
trying
to
make
that
scenario
be
much
better
and
give
people
choice
in
how
to
implement
that
and
that's
design
time
data
and
I'm
going
to
go
ahead
and
demo
that
in
a
minute.
But
let
me
just
go
through
a
few
more
things
here.
So
another
change
that
came
in
based
on
customer
feedback
was
that
people
wanted
the
refresh
button
in
the
designer.
A
There
were
certain
situations
where
things
in
a
really
complicated
solution,
just
went
out
of
whack
and
the
designer,
if
you
would
close
reopen,
would
actually
fix
it
for
you
and
we
acknowledge,
like
you
know,
xaml
is
really
hard
language
to
to
visualize.
Sometimes
things
do
go
wrong,
so
adding
that
refresh
button
helps
and
in
fact,
there's
certain
design
data
scenarios
where
the
refresh
button
does
the
trick,
where
you're
changing
design,
time
data
and
for
just
sort
of
like
historic,
architectural
reasons.
Some
things
won't
won't
update
in
the
in
the
designer
view.
A
But
if
you
were
to
close
it
or
hit
the
refresh
button,
it
would
do
the
trick
so
that
button
is
available
for
both
wpf.net
core
developers
and
uwp
developers.
Unfortunately,
we
weren't
able
to
kind
of
in
a
cheap
way,
bring
it
back
to
that
net
framework,
but
keep
the
feedback
coming.
If
you
really
think
it's
needed,
we'll
certainly
listen
to
you.
A
If
we
can
and
then
we
did
a
feature,
that's
been
a
really
long-standing
customer
request
and
the
customer
request
was
to
add
a
color
visualizer
to
to
the
xaml
code
editor,
and
this
was
possible
through
third-party
extensions
community
projects
and
such
we
finally
built
it
in
so
now.
This
should
be
available
for
everybody,
wpf
core
framework
and
xamarin
forms.
A
There
is
some
basically
like
architectural
challenge.
We
dwp
right
now.
So
that's
the
one
framework
that
didn't
get
this
feature
but
again,
like
keep,
keep
us
honest,
keep
the
feedback
coming.
We
are
trying
it's.
You
know
we
really
wanted
it
there,
but
we're
causing
performance
problems,
and
we
definitely
don't
want
to
do
that
just
by
hitting
a
color
visualizer.
So
we
had
to
pull
that
back,
but
core
framework,
wpf
and
then
xamarin
forms
were
able
to
get
it.
We
also
just
to
acknowledge
some
more
recent
community
feedback.
A
Folks
have
told
us
that
a
few
people
have
said
like
we
don't
like
the
color
visualizer,
like
it's
great,
that
you
added
this
to
the
people
that
want
it.
We
don't
want
it.
Please
give
us
a
way
to
remove
it,
so
we
are
considering
adding
a
setting
in
the
future
too,
to
make
this
a
switch
that
you
can
turn
on
and
off.
So
that's
that's
the
update
there
all
right.
A
So
let's
switch
real,
quick,
I'm
going
to
open
visual
studio
and
show
design
time
data
in
action,
so
in
visual
studio
here
on
go
full
screen
you
you
can
look
at
my
sample
application,
so
this
is
up
on
github
I'll,
put
a
link
to
it
in
the
show
notes.
This
is
a
really
simple
app.
It
doesn't
do
anything
real.
This
app
is
completely
here
to
just
demonstrate
design
time
data,
and
here,
let's
start
with
this-
this
label
control.
So
this
label
control
here
has
has
content
right.
So
that's
easy
right.
A
We
can
show
content,
but
let's
say
you
know
that
you
don't
want
the
app
to
start
with
content
in
it.
So
we've
added
this
new
d,
colon
and
the
colon
is
there
for
every
single
property.
So
if
you
type
the
colon
you're
going
to
see
every
property
that
was
normally
available,
let's
start
it
from
the
beginning.
So
I'm
going
to
get
rid
of
the
content.
A
Let's
just
do
a
warm-up
there.
Okay,
so
let's
say
I
was
typing
content
right,
intellisense
would
say:
hey
yep,
there's
a
property
called
content
grade.
If
I
type
b,
colon
and
actually
typing
content
once
again,
content
would
be
available,
so
every
property-
that's
normally
available
in
control-
is
available
here
and
once
I
set
that
property
to
something
let's
say,
dimitri,
the
designer
will
show
it,
but
when
you
run
the
app
we
strip
out
all
the
d
column
properties,
so
this
property
here
this
fake
text,
property
here
on
the
text
block,
etc.
A
All
of
these
will
be
stripped
out.
That
means
that
as
you're
as
you're
building
and
visualizing,
your
application
with
the
colon
you,
you
know
that
your
running
application
is
safe
and
you're
able
to
very
easily
set
the
real
values
like
in
the
real
world.
This
text
box
might
be
coming
from
a
binding
path.
A
It
also
kind
of
avoids
the
limitation
that
if
you
had
a
control
that
that
wasn't,
you
know
like
wasn't
bound
to
a
view
model.
Let's
say
it
was
a
big
code
behind
or
something.
Then
you
were
kind
of
stuck
that
was
hard
to
create
designs
and
data,
for
this
makes
it
super
easy.
It
does
increase
the
amount
of
example.
You
have
a
little
bit,
but
it
gives
you
a
feature
for
it.
So
definitely
a
powerful
thing
and
I'm
just
gonna
go
ahead
and
just
demonstrate
the
kind
of
things
that
I'm
able
to
visualize.
A
A
I
can
even
change
the
character
that
I'm
using
to
see
if
one
character
would
look
better
versus
another
character,
I'm
able
to
do
more
complex,
ridgebox
setups,
so
I'm
able
to
not
just
decoding
a
property
but
d
colon
or
you
know
which
textbox
that
document
and
the
column
flow
document
and
paragraphs
able
to
mark
all
those
ups
here
to
make
it
look
exactly
like.
I
would
expect
it
to
look
like
and
this
works
for
lists
it
works
for
a
data
grid,
see
here's
a
data
grid
where
I'm
you
know
mocking
up
all
the
data
here.
A
The
real
data
grid
has
bindings,
but
then
I'm
setting
the
item
source
to
a
very
much
a
fake
x
array
using
a
d
colon
data
grid,
item
source
and
again
all
of
this
gets
stripped
out
of
runtime.
So
none
of
this
makes
it
into
your
running
application,
and
this
will
work
for
everything
from
list
boxes
to
buttons
you
can
you
can
see
what
a
button
looks
like
enabled
disabled
without
you
know,
checked
without
having
to
worry
that
that
will
leak
into
your
relapse.
A
You
can
set
a
fake
image.
The
only
the
only
kind
of
limitation
is
the
image
has
to
be
part
of
your
solution
so
somewhere
in
your
project.
So,
but
if
you
do
have
a
like
a
test
image,
you
can
set
the
image.
You
can
imagine
this
working
with
resources
that
are
naturally
embedded
in
your
solution,
such
as
you
know,
icons,
etc,
and
you
can
test
what
different
icons
would
look
like
or
different
different
visualizations
that
are
images
in
your
projects
and
this
even
works
with
things
like
date,
controls,
etc.
A
So
or
like
this
progress
bar.
So
this
sample
app
will
give
you
all
those
examples.
We've
got
a
you
know.
Even
the
data
status
bar
down
here,
that's
fake
faked
in
terms
of
the
data
that
is
showing
so
everything
that
you
can
do
in
xaml.
Pretty
much
can
be
done
with
design
time
data
and
I
hope
you
give
it
a
shot.
The
feature
is
there
for
you,
it's
it's
not
hidden
under
any
feature
flags.
If
you
have
167,
it
is
considered
ga,
so
it
is
available
for
you
as
well
all
right.
A
A
In
fact,
if
you
look
at
preview,
if
you
look
at
preview
2
for
for
the
most
recent
release,
which
is
our
16
9
release,
so
if
you
go
to
the
preview
notes
there
and
then
you
you
scroll
through
lots
of
great
features
coming
in,
but
we're
also
working
on
xml
tooling,
so
we've
got,
you
know
we're
trying
to
improve
settings
and
and
other
things
that
are
going
on
in
the
application.
We're
enabling
this
is
really
really
awesome.
A
Super
super
requested
thing
from
the
community
xamarin
forms
uwp
support
for
zamoja
reload
has
been
delivered
as
part
of
this
preview.
This
is
one
thing
that
sometimes
not
clear
to
folks
watching
on
the
stream.
Like
I
I
say
well,
I
work
on
you
know.
Example,
tooling
example:
tooling:
exists
for
both
desktop
customers
and
xamarin
forms
customers.
A
So
whenever
I'm
doing
anything,
for
example,
I'm
thinking
about
all
of
the
old
type
of
customers
and
therefore
my
my
engineering
teams
that
I
work
with
some
that
are
sort
of
in
xamarin
and
some
are
that
are
in
in
the
desktop
tooling.
We
contribute
to
each
other.
We
help
each
other
build
the
product
in
a
holistic
way.
So
when
the
xaml
tooling
does
something
they
don't
exclude,
xamarin
right,
we
do
it
for
everybody.
A
It's
really.
It's
really
amazing
for
me
as
a
pm
to
have
so
many
engineers
helping
make
sure
all
this
gets
put
together.
So
I'm
always
as
excited
for
xamarin
changes
as
desktop,
and
I
hope
so
you're
as
well.
The
last
thing
that
we're
going
to
talk
about
today
is
olia,
who
normally
hosts
this
community
standard,
but
she's
she's
enjoying
some
well.
What
is
your
vacation,
so
I
hope
hope,
you're
out
there
having
fun
right
now,
but
she
wanted
us
to
mention
the
blog
post
she
did.
A
This
is
on
the.net
blog
and
the
dalton
blog
is
where
we
we
bring
features
from.
You
know
things
relevant
to
the
community
at
times.
Not
just
you
know,
purely.net
framework
updates
and
stuff
like
that,
but
this
is
webview
two
updates,
so
webview
two,
if
you're
not
familiar
it's
a
chromium-based
web
control,
it
is
the
replacement
for
the
current
webview,
so
webview
the
current
one
versus
webview2,
the
new
one,
and
because
it's
based
on
chromium,
it
is
so
much
more
powerful
right.
It's
it's
the
most
up-to-date
web
control
you
can
possibly
get.
A
It
is
literally
like
installing
the
new,
the
new
edge
edge
web
browser
on
your
machine
and
we've
really
tried
to
bring
it
to
every
single
developer.
We
can
possibly
bring
this
control
to
now.
Here's
our
train
of
thought.
We
know
that
applicative
applications
across
the
board,
whether
that
their
win
forms,
whether
they're
wpf,
whether
they're
on
framework,
whether
they're,
they're
on.net
core.
It
doesn't
matter
right.
You
you
have
web
browsers
somewhere
somewhere
out.
A
When
you
know
windows
7,
and
then
it
works
with
basically
every
kind
of
combination
of
framework
and
language
that
you
can.
Think
of.
So
that's
all
available.
Please
check
out
web
web
youtube.
Please
keep
the
feedback
coming,
but
that's
a
an
active
project,
we're
investing
in
very
strongly
all
right.
A
So
with
that,
that's
all
we
had
for
today.
I'm
gonna,
I'm
gonna,
stop
sharing
here
and
thank
you
all
for
coming.
I
don't
see
any
questions
in
the
chat
that
I
could
answer,
but
I'm
available
up
on
twitter
at
lylan.com.
Please
follow
me.
Please
send
me
questions
if
you
have
any
desktop
questions,
I'm
always
there
to
help.
I
really
try
to
try
to
be
somebody
in
the
community
that
is
responsive
and
my
dms
are
open.