►
From YouTube: Updating the WinForms Designer for .NET Core 3.0
Description
There are many benefits that .NET Core can bring to desktop applications. With .NET Core 3.0, support is being adding for building desktop application with WinForms and WPF.
In this episode, Jeremy is joined by Merrie McGaw and Dustin Campbell who share some interesting insights on the work that’s going into getting the WinForms designer ready for .NET Core 3.
[01:16] - What are the benefits of Windows Forms on .NET Core?
[05:44] - What did it take to update the Windows Forms designer
[07:54] - What was it like updating the codebase?
[13:48] - What were some of the biggest surprises?
[17:25] - Were there any positive side effects from updating the codebase?
[19:37] - Was there any surprising feedback from the community?
[20:10] - How have the control vendors responded?
Download .NET Core 3
https://dotnet.microsoft.com/download/dotnet-core/3.0?WT.mc_id=ondotnet-c9-cxa
How to port desktop applications to.NET Core 3.0
https://devblogs.microsoft.com/dotnet/how-to-port-desktop-applications-to-net-core-3-0/?WT.mc_id=ondotnet-c9-cxa
Port a Windows Forms desktop app to .NET Core
https://docs.microsoft.com/en-us/dotnet/core/porting/winforms?WT.mc_id=ondotnet-c9-cxa
Port a WPF desktop app to .NET Core
https://docs.microsoft.com/en-us/dotnet/core/porting/wpf?WT.mc_id=ondotnet-c9-cxa
A
A
Welcome
to
another
episode
of
on.net,
my
name
is
Jeremy
lik
ness
and
I'm
here
at
the
beautiful
Microsoft
campus.
We've
got
awesome
weather
today,
I'm
here
with
Dustin
and
Mary,
and
we're
gonna
talk
a
little
bit
about
wind
forms,
but
before
we
get
started,
why
don't
we
start
with?
You
tell
me
a
little
bit
about
what
you
do
here
at
Microsoft,
I'm.
B
C
A
Cool
so
I've
been
with
dotnet
for
a
very
long
time
and
Donette
core
was
exciting
news.
One
of
the
pieces
of
feedback
we
got
when
it
first
came
out
was
what
about
the
desktop?
What
about
WinForms?
What
about
WPF
so
now
we're
coming
full
circle.
Dotnet
core
three
is
coming
out
and
we've
got
support
for
wind
forms
and
one
of
the
questions
I
get
a
lot
is
what
exactly
does
that
mean?
What
is
wind
forms
and
Donette
core?
Well.
A
B
C
From
a
perspective
of
an
application
developer,
it
means
that
you
know
somebody
building
a
WinForms
application
or
taking
an
existing
wind
force
application
and
moving
it
forward
into
dotnet
core
three
for
the
benefits
of
having
performance
improvements
being
able
to
have
a
side-by-side
experience
where
you
can
run
it
on
many
different
dotnet
cores,
you
can
pick
a
different
version
of
donek
or
you
can
stick
with
one
version,
of.net
core
and
avoid
some
of
the
problems.
We
get
a
lot
of
feedback
when
the
dotnet
framework
updates
on
Windows
and
and
that
it
just
affects
everybody.
C
Sorry
it
happens
in
place,
and
so
every
application
is
affected
by
that
and
so
with
dotnet
core
3,
because
you
can
have
multiple
runtimes
site
and
living
side
by
side
that
allows
a
bit
of
freedom
with
a
WinForms
application.
If
it's
a
if
it's
a
new
development,
great
you're
on
the
latest
and
greatest
and
it's
a
high-performing
platform,
we've
done
a
lot
of
performance
work
in
dotnet,
core
and
and
if
it's
a
legacy
application
great.
C
C
The
migration
path
is
a
little
bit
DIY
at
the
moment,
but
so
the
way
people
typically
typically
do
is
start
a
new
project
and
copy
all
their
code
over
in
a
dotnet
core
world.
You
don't
have
to
go
and
add
files
to
that
project.
Everything's
kind
of
added
for
you
and
and
the
project
file
is
much
slimmer.
If
you
checked
out
done
a
query.
A
C
A
much
slimmer,
slimmer
format,
so
you're
not
dealing
with
a
lot
of
the
kind
of
arcane
goo
that
shows
up
in
the
older
older
project
formats
for
done
at
framework,
so
you
kind
of
get
into
a
nice
clean
place
and
your
and
your
migration
path
most
in
most
cases,
I
had
a
I
had
an
application.
I
write
when
we
first
had
an
internal
build
of
this
working.
An
application
was
pretty
substantial,
there's
a
whole
debugger
for
text.
Adventure
games,
oh
yeah,.
C
A
nerd
I
forgot
to
say
that,
but
it
was
a
whole
debugging
engine
for
that
and
that
I'd
built
on
WinForms
number
years
ago.
I
was
like
well,
let's
port
it
over
and
see
how
this
works,
and
it
was
literally
copying
files
in
and
then
there
were
a
couple
of
cases
where
I
had
some
references
that
were
missing
and
I
could
go
out
and
find
them.
C
We
had
kind
of
up
on
NuGet
we
had
packages
available,
that
you
could
go
grab
to
access,
for
example
like
the
registry,
that
sort
of
thing
fair
and-
and
it
worked
fine-
it
was
great.
So
the
migration
path
isn't
too
hard.
If
you're
willing
to
put
in
just
a
little
bit
of
work
right
now,
there
maybe
have
an
opportunity
for
us
to
smooth
out
some
of
those
edges,
but
that's
kind
of
the
story.
It
should,
in
my
experience
it
generally
kind
of
just
works
with
most
framework
things
if
you're
often
the
weeds
a
little
bit.
C
A
B
B
C
A
A
lot
of
people
preferred
you
know
some
of
it
because
they're
comfortable
with
it,
some
of
it
just
because
it
was
so
mature
and
the
design
made
sense
how
WinForms
work
for
design
so
you're
working
on
taking
something
that's
essentially
been
around
for
years
and
years
and
fitting
it
onto
one
of
our
most
modern
frameworks.
What
is
that
like?
What
I
can't
even
imagine
where
you
start
with
that
yeah.
C
C
A
C
In
particulars
as
a
designer
is
really
a
key
part
of
that
experience,
I'll
I
loved
sam'l
I.
You
know,
I
love,
WPF,
I
love
the
sam'l
designer,
but
you
know
with
the
sam'l
language.
It's
it's
easy
to
go
and
fairly
easy.
I
mean
you
can
get
a
PhD
in
sam'l
and
you
can
go
and
you
can.
You
can
write
the
sam'l
code
yourself.
It's
not
it's
declarative
its
natural.
It's
not
that
difficult!
That's
not
something!
I
ever
want
to
do
with
WinForms
right
if
you've.
C
A
C
A
C
B
C
C
A
C
C
Right
and
the
idea
there
was
that
you
know
prior
to
Visual,
Studio
2005
would
be
the
was
the
code
name
of
that.
We,
the
wind
force
designer,
would
take
that
code
spit
in
it
put
it
into
the
same
file.
Okay,
so
there
would
be
a
form
1cs
and
would
it
would
had
initialized
component
method
and
it
hit
in
a
you
know,
in
a
pound
region
inside
your
okay.
C
C
Over
here
and
then
we
started
spinning
over
there,
so
I
can
see
I've.
You
know,
I'm,
coming
to
this
code
base
fresh
and
I'm,
looking
at
like
okay
I
see
that
refactoring
I
see
what
they
did
to
make
the
the
partial
classes
work
and
in
their
areas
of
the
code
base,
where
it's
pretty
clear
that
everybody
was
learning
c-sharp
100
as
it
was
being
read
as
c-sharp,
was
being
developed,
there's
a
lot
of
just
kind
of
old
anachronism
things
that
you
would
never
do
today.
C
There's
a
lot
of
old
collection
types
that
are
long
defunct
that
we
wouldn't
use
today.
You
know
today
you
might
use
a
list
of
T
well,
ArrayList
is
all
over
that
which
was
the
old
one
from
back
in
the
dotnet
100
days
that
we
replaced
in
oh,
so
it's
it's
kind
of
filled
with
us.
Where
think
so,
it's
got
a
kind
of
archaic
sort
of
bent
to
it.
C
That
makes
it
a
little
bit
difficult,
but
the
real
challenge
of
moving
it
over
to
operate
on
dotnet
core
3
is
that
is
that
the
WinForms
designer
works
by
actually
creating
the
form
itself.
Mm-Hm
creates
the
actual
form
object,
the
dotnet
object.
It
runs
that
initialize
component
method.
It
runs
your
user
code
in
order
to
do
that
and
the
challenge
there
is
that
now,
that
form
is
not
a
dotnet
framework
form.
C
C
So
we're
kind
of
in
a
world
we're
trying
to
create
dotnet
core
three
objects
and
make
them
kind
of
work
in
a
dotnet
framework
world.
Alright,
and
that's
the
key
challenge
there,
and
so
the
design
we've
gone
with.
It's
also
something
that
the
zamel
teams
designer
team
is
working
with
is
the
idea
that
it's
a
little
bit
crazy,
but
we
have
another
process,
that's
a
dotnet
core
three
process
and
we
create
all
the
objects
over
there
and
create
the
actual
form
and
then
we're
apparent
the
window
handle
from
that
process
over.
A
A
C
Then
we
just
talk
about
it
in
window
handles
and
then
over
on
the
visual
studio
side
we're
communicating
with
that
remote
process.
It's
there's
some
interesting
kind
of
old,
api's
and
dotnet
that
make
that
possible.
So
we
can
kind
of
you
know,
create
a
model,
a
code
Dom
model
of
all
of
the
code.
That's
in
your
project
or
your
initialized
component,
all
that
and
send
it
over
to
the
other
process
and
let
it
create
all
the
code
from
there
or
let
it
create
the
actual
objects
from
there.
C
C
Like
that
any
sort
of
modern
sort
of
language
constructs
you
would
use
for
doing
asynchronous
programming,
especially
when
you're
trying
to
talk
cross
process.
You
kind
of
want
to
you
know,
send
a
request
over
and
then
wait
right
here
for
a
respond.
I'm
back.
That
sort
of
thing
is
very
tricky
and
awkward,
and
and
so
we're
having
to
retrofit
the
windfarms
designer
with
a
whole
bunch
of
that
sort
of
thing.
So
mm-hmm,
that's
fun.
A
B
C
C
Well,
let
me
shift
gears
and
come
up
with
a
different
or
slightly
different,
modified
design
as
to
what
we
were
doing
and
that's
that's
an
ongoing
kind
of
process
right
now
we're
in
the
stage
of
what
we
call
the
punch
through
and
what
we're
the
idea
here
is
that
if
I
were
building
a
compiler,
this
would
be
a
stage
of
the
building.
A
compiler
would
be
trying
to
get
to
hello
world
just.
C
Hello
world
happen
to
get
enough
of
that
in
there,
so
we're
kind
of
putting
laying
down
the
bones
of
the
designer
systems
and
figuring
out
what
needs,
if
whether
our
design
is
going
to
hang
together
all
the
way
through
and
what
other
work
needs
to
happen
so
that
punched
through?
What's
it
look
like
it's
like
nine.
C
B
B
C
There's
a
lot
of
pieces
here
like
we
need
to
learn
how
to
figure
out
how
to
populate
the
toolbox
from
dotnet
core
three.
We
need
to
make
the
property
grid
now
the
property
grid
is
an
interesting.
It's
a
Windows
forms
control.
It's
actually
something
you
could
put
in
your
own
windows
forms
application,
the
little
property
browser
and
visual
studio,
that's
just
and
that's,
and
that
control
itself
the
way
it
works.
Is
it
likes
to
operate
right
on
your
object
sure,
but
that
objects
over
here
right.
C
C
C
So
well
then,
they're
used
by
the
property
grid,
and
so
we
have
to
we're
figuring
out
ways
that
we
can
in
Visual
Studio,
since
the
property
grid
is
in
that
process,
we
want
to
be
able
to
to
have
little
proxies,
not
like
not
like
dotnet
remoting.
That's
not
supported
in.net
course,
so,
not
like
done,
and
certainly
not,
between
Donna
Karan
Donna,
fair,
but
creating
our
own
proxy
objects.
C
They
know
how
to
communicate,
get
get
back
proper
enough
property
data
that
we
can
sort
of
synthesize
type,
descriptors
and
property
descriptors
for
these
proxy
objects
and
then
make
we
can
trick
property
grid
and
thinking
it's
talking
to
the
real
object.
At
least
it
has
the
data
it
needs
to
present
and
edit
its
we
prototype
that
last
December
that
looks
like
it
work,
but
these
are
some
of
the
systems
that
you
kinda
have
to
go
through
and
figure
out.
Okay,
that's
how
that
works!
Well,
it's
fascinating.
A
C
A
Ages,
past
been
a
while
yeah
you're,
having
the
dust
off
all
those
old
skills
and
apply
them.
Were
there
any
unexpected
benefits
or
positive
side
effects
from
doing
this,
change
that
you
came
across
or
is
it
more?
Let's
just
get
to
a
state
where
we're
parody
with
what
the
old
design
experience
was
only
on
top
of
Donna
core
three
and
its
benefits.
That's.
C
And
one
thing:
we
we,
we
kind
of
I-
guess
we
kind
of
alluded
to
it,
but
we
not
but
didn't
quite
state.
It
was
that
we're
leaving
the
old
designer
framework
designer
codebase
alone,
we've
completely
forked
everything.
So
now,
one
of
the
benefits
is
that
we're
getting
to
all
this
old
code
as
we
go.
It's
okay,
we're.
B
C
C
B
C
It's
the
same
thing
for
the
designer
and
the
the
thing
is
that
now
there's
an
opportunity
you
know
with
donek
or
three
than
the
next
version
of.net
core
and
the
next
version
it
on
that
core.
That
will
continue
to
rev
this,
the
wind
forms
and
it
will
continue
to
grow
and
potentially
evolve
and
as
we
do
that
we
want
to
have
a
wind
forms,
designer
codebase.
That
also
feels
like
it's
modern
and
we
can
evolve
with
that.
So
that's
kind
of
fun.
That's
that.
A
Is
fun
I
mean
it's
interesting
because
people
say
a
WinForms,
it's
old
tech
mm-hm,
but
a
a
lot
of
people
say.
But
this
is
what
I
write
my
desktop
apps
and
because
it
works
and
it
works
well
and
there's
no
reason
to
change
it
and
then
there's
a
question
of
well.
What
about
support?
Have
you
forgotten
about
it?
So
now
it's
revitalized,
you're
updating
it
have
you
had
any
surprises
or
feedback
from
the
community
that
you
weren't
expecting
or.
B
I'd
have
to
say
the
surprise
for
me
from
the
community
was
exactly
how
enthusiastic
they
were.
We
have
lot
several
new
features.
I
mean
full-sized
features.
The
community
members
are
proposing
and
they're
cleaning
up
old
code.
They're
writing
new
tests.
They've
been
extremely
excited
about
the
opportunity
to
get
in
there
and
kind
of
dust
off
their
favorite
old
old
technology.
Yeah.
C
And
even
though
it's
old
one
of
the
things
that's
always
been
appealing
about
wind
forms,
is
that
there's
a
there's,
an
ecosystem
there
that
goes
way
beyond
what
we
did
right
like
right.
Our
button
and
list
box
controls
are
pretty
basic
right.
But
if
you
take,
you
know
the
3rd
party
control
vendors
that
are
out
there,
the
DevExpress
is
the
infra
gistic.
So
you
know
the
telluric
sold
all
of
those
guys,
grapecity
they've
really
created.
You
know
controls
that
let
people
build
WinForms
applications
that
look
like
the
very
latest
office
or
whatever
right
and.
B
A
B
C
One
of
the
there's
a
couple
of
little
dirty
things
in
the
old
kind
of
design
of
the
wind
forms
in
the
designer
and
how
that
worked.
That
is
means
some
some
work
for
everybody
who
had
built
a
control,
for.net
framework
that
now
that
they
want
to
build
a
control
for
dotnet
core
3
and
have
a
great
designer
experience.
They're,
probably
gonna
have
to
do
things
differently
in
the
old
well
in
the
designer
api's
that
are
there
today,
and
these
are
part
of
done
at
framework.
There's
a
system
design
assembly
in
the
framework
that
has.
A
B
C
C
Core
and
dotnet
framework,
but
it
gets
down
into
two
places
where
just
the
very
control
designer
class,
if
you
wanted
to
make
a
piece
for
visual
studio
for
your
control
that
had
little
smart
tags
and
snap
lines
when
you
drug
it
around,
you
would
descend
from
this
control
designer
class
that
control
designer
has
a
property
on
it
called
control
and
it's
literally
a
reference
to
the
actual
runtime
control.
That's
on
the
form
right,
well,
that'll
break,
usually
in,
but
what
people
do
they're
designers?
C
B
C
B
C
B
C
B
A
A
B
A
C
B
C
We
get
the
kind
of
the
bones
laid
out,
then
it's
going
through
every
single
control
that
we
have
in
the
framework
and
making
sure
that
that
separation
works
right.
We
have,
we
have
we
use
those
same
those
same
classes
that
control
designer
there's
an
image
list
over
here.
There's
an
image
list
designer
over
here
and
the
those
need
to
be
taught
how
to
talk
cross
process
so
so
yeah
we're
kind
of
forging
ahead.
It's
quite
a
journey.
It
is
yeah,
nice.