►
Description
Join members from the ASP.NET teams for our community standup covering great community contributions for ASP.NET, ASP.NET Core, and more.
Community Links: https://www.theurlist.com/aspnet-standup-2019-10-29
A
A
A
A
B
A
A
B
I
am
happy
that,
like
number
one
as
a
founding
member
of
the
stand-up,
it's
great
to
have
you
back
on
more
often
and
then
also
there
was
the
common
conversations
lately,
with
asp
net
core
3
being
released
people
trying
to
deploy
it,
having
conversations
on
twitter
and
like
hey,
what
am
I
doing
wrong
and
that
kind
of
stuff?
And
so
I'm
glad
you
could
walk
through
that
stuff.
Yeah.
B
B
Ray
okay,
cool
Khalid,
ib'n
hokhmah,
it's
talking
about
request,
features
and
asp
net
core
3.
This
is
interesting,
and
what
he's
talking
about
here
is
from
his
write-up
and
it
does
sound
like
it's.
It's
mostly
any.
It's
been
used,
mostly
as
an
implementation
detail
like
it's
a
thing
where,
if
there's
a
feature,
it
can
kind
of
short-circuit
and
return
something
like
office
static
file.
So
here's
his
kind
of
call
out
here
for
feature
exists.
It
can
send
a
requested
static
file
from
physical
path,
so
much
faster.
Otherwise,.
B
They're
slower
alternatives,
so
here
he
kind
of
he
the
way
he's
writing
it
up.
It's
been
mostly
used
as
kind
of
an
implementation
internal,
but
he's
saying
that
you
can
use
it.
Also,
you
can
create
your
own,
so
we
walked
through
creating
a
clock,
middleware
and
then
hooking
it
up
as
a
request
feature,
and
so
here
he
shows
you
know
some
some
magic
registering
the
request
feature,
and
so
then
also
the
ability
here
to
mutate,
a
request
feature
which
sounds
pretty
neat.
So
here
is
using
a
setting
clock
settings
by
an
HTTP.
B
So
then
he
talks
through
pros
and
cons
of
it
and
and
there's
several
different
ones.
Kind
of
the
main
one
hands-on
is
performance.
There's
also
ability
to
do
things
like
tie
to
the
request,
context
and
simplicity
compared
to
IOC,
and
let
me
see
so
then
talking
also
about
comparing
it
to
HTTP
context
items
and
some
some
different
things
that
are,
you
know,
possible,
there's
constraints,
differences
and
also
allocation.
So
this
is
honestly
something
I
had
not
looked
at
it
all
before
so
I
think
this
is.
A
B
Anyhow,
from
gunner
people
in
here
he's
talking
about
a
thing
that
I've
run
into
myself
and
people
bring
it
up
regularly
when
they're
talking
about
asp
net
core
3
is
compiled
views
and
so
as
I'm
just
kind
of
used
to
in
my
day
of
workflow
I'll,
modify
view
and
then
I
I,
don't
see
them
precompiled
anymore
and
I,
just
kind
of
gotten
lazily
used
to
that.
And
so
he
talks
about
sorry.
A
So
we
disabled
runtime
view
compilation
by
default
in
three:
oh,
they
are
and
if
they
get
compiled
as
part
of
the
normal
project
build
step
now.
And
so,
if
you
make
a
change
to
a
view,
you
have
to
rebuild
the
application
which
vs
will
do
for
you
automatically.
But
there
is
a
package
which
I'm,
assuming
is
what
this
post
is
about
to.
In
reenable,
the
runtime
compilation
feature
yep.
B
So
showing
showing
that
and
then
here's
a
kind
of
a
node
thing
that
I
should
have
thought
of
is
additional
right.
So
here
he's
saying
if
in
debug
setup
your
conditional,
runtime
cop
and
again
we're
hopping
back
and
forth
between
pre,
compiling
and
friend
time,
compiling
here
he's
saying
if
in
debug
then
add
runtime,
compilation
right.
B
And
that
was
something
that
he
had
called
out
is.
Is
a
difference?
Is
making
that
change,
because
it
is
it's
just
it's
more
optimal
like
there's,
like
you
said,
there's
no
need
to
add
that
to
your
to
your
release
overhead,
but
when
you're
working
locally
and
you're
changing
your
views
and
you
want
it
can
be
nice
yeah.
A
Yeah
I
mean
they're
they're.
The
reasons
are
little
more
complicated
as
to
why
we
remove
dicks
I'm
sure
some
folks,
I'm
thinking.
Why
did
you?
Why
didn't
you
just
do
this
in
the
templates
by
default?
Why?
Why
did
you
remove
it
at
all?
A
lot
of
it
was
to
do
with
typically
its
basic
arguments.
We
always
make
it's
all
about
trade-offs
and
people
will
note
that
the
default
templates
today,
if
you
don't
specify
options,
don't
contain
nougat
package
references
and
it's
not
that
they're
hidden.
They
actually
don't
exist
anymore.
A
So
as
part
of
the
all
the
optimizations,
we
did
to
try
and
ensure
that
the
getting
going
experiences
as
fast
as
possible
and
that
the
install
or
impact
footprint
of
the
installer
itself
for
installing
the
dotnet
core
SDK
is
as
small
as
it
can
be.
Today
we
made
those
changes.
We
made
those
trade-offs.
Adding
a
new
get
package
introduces
a
bunch
of
overhead
that
we
didn't
want
there
to
be.
A
Hey
new
console
app
a
new
web
app,
a
new
class
library
as
much
as
we
possibly
could
to
get
back.
You
know
there's
developer
seconds,
so
that's
why
those
changes
were
made.
It
also
was
related
to
specifically
with
this
feature
not
having
a
compiler
in
the
shared
framework,
so
the
a
spinet
core
shared
framework
up
until
you
know,
including
had
Roslyn
in
the
shared
framework.
Okay,
because
that's
what
Razer
needed
to
do,
the
compilation
which
adds
surface
area
and
adds
features
that
customers,
don't
like
the
idea
of
that
there's
a
compiler
in
their
runtime.
A
They
see
the
compiler
as
being
something
that
they
should
only
have
in
the
SDK,
and
if
they
want
a
clean,
lower
tax,
surface
sort
of
server
install,
they
don't
want
to
have
the
compilers
even
available,
and
so
that
was
another
trade-off.
That
we
made
was
to
remove
the
compilers
from
the
shared
framework.
Also
they're,
very
big.
A
That
can
be
done,
and
so
it
actually
has
quite
a
sizable
impact
on
startup
time
at
the
application,
which
again
is
something
that
we
don't
want
to
have
to
pay
for,
especially
when
you're
developing
locally
we'd,
rather
reuse,
Rozlyn
instances
from
the
developer
tool
chain,
because
we
can
do
that
in
the
developer
tool
chain.
We
have
like
the
Roseland
build
server
and
the
MS
build
evaluation
server
and
all
these
type
of
things
that
cache.
You
know
that
evaluations
and
processes
and
things
while
you're
developing,
so
you
don't
have
to
pay
that
startup
cost.
A
We
want
those
those
benefits
while
you're
developing,
but
if
you're
just
pre
compile
the
views,
you
don't
even
need
to
worry
about
it
when
it
comes
to
to
release
time.
So
there
was
a
whole
bunch
of
things
that
went
into
this
decision,
but
we
at
least
made
the
package
available
so
that
for
you,
so
that,
if
you
do
want
to
pull
it,
bring
it
back
in,
you
can
do
that.
This
is
how
you
do
it.
That
was
one
explanation,
but
that
has
to
mean
no.
B
A
I
mean
when
you
say
they
don't
show
it
again.
It
depends
in
vs.
They
do
so
if
they're
not
showing
for
you,
that's
a
bug.
So
what
will
happen
is
that
if
you
launch
from
Visual
Studio
and
again,
it's
have
to
be
careful
how
to
speakers
this
nuance,
based
on
people's
workflows,
my
workflow
is
I
control
f5
to
launch
without
the
debugger
attached.
I
know
a
lot
of
people
hit
f5
every
time
they
want
to
launch
the
application,
which
is
much
slower.
A
So
if
you're
not
actually
gonna
do
debugging
I
would
encourage
you
to
train
yourself
to
use
control
f5
for
when
you
don't
need
to
debug
and
then
attach
with
control
RP.
You
know,
keystrokes
make
this
much
easier
if
you
do
need
to
attach,
but
then
you
can't
debug
start
up.
If
you
need
to
debauch
start
up,
then
obviously
have
to
launch
with
debugging
it.
A
If
you're
envious-
and
you
launch-
you
know
without
debugging,
which
is
what
I
tend
to
do-
control
i5,
then
vs
will
track
changes
to
files,
including
your
views,
and
then,
when
it
detects
that
you've
made
a
change
to
a
file,
it
will
kill
the
application
for
you
and
then
the
next
time
you
hit
the
application.
The
vs
interception
process
which
sits
in
between
is
Express
and
your
application
or
coordinates.
All
of
that
will
then
force
the
recompile
of
the
application
on
the
next
request
that
comes
in
and
then
you'll
get
the
change
to
the
view.
A
A
Can
any
tree
compile
views,
so
you
can
make
quick
changes
to
views
and
see
those
live,
but
you
will
you
should
see
a
change,
even
if
you
don't
have
that
assuming
you're
using
vs,
if
you're
using
vs
code
and
you're
not
using
donate
watch
or
using
vs
o
Mac,
then
you
won't
get
that
experience
and
run
time.
Compilation
would
certainly
be
beneficial
if
you're
just
doing
view
updates
there.
So,
like
everything,
it's
always
complicated.
A
It's
something
that
we're
looking
at
in
dotnet
v
to
improve
we're
gonna,
look
at
it
more
deeply
at
hot
reload
scenarios
for
sort
of
all
dotnet
core
apps,
not
just
MVC
views
and
razor
and
other
things
right.
We
want
to
actually
come
up
with
a
solution
that
works
for
lots
of
different
workload
types.
So,
okay,.
A
Poly
app
with
the
debugger
attack
right.
So,
if
you
launch
with
debugging,
you
have
attached
a
debugger
to
the
running
application.
When
the
debugger
is
attached,
you're
limited
what
you
can
do
right
already
lives
as
long
as
the
process
is
alive,
and
if
you
want
to
recompile
the
app
you
have
to
kill
the
process,
and
so
that's
why?
For
web
apps
launch
without
debugging
is
generally
I,
find
it
vastly
more
productive.
A
If
I'm
working
on
the
sort
of
the
front-end
aspects,
like
you
know,
the
views
and
the
CSS
and-
and
you
know
JavaScript
and
that
type
of
stuff,
because
you
can
just
make
the
change,
save
and
hit
f5
in
the
browser,
and
it
will
work
once
you
introduce
raise
of
views.
The
runtime
compilation
is
an
extra
thing
to
add
back.
That
will
give
you.
A
You
know
the
fastest
possible
recompile,
but
as
soon
as
you
make
any
other
code,
change,
you're
gonna
have
to
restart
the
application,
and
vs
will
do
that
for
you,
if
you've
launched
without
debugging,
if
you
launched
with
debugging
you're
back
in
editing,
continued
land,
which
is
yes
folks,
probably
know,
is
quite
limiting.
There's
only
a
certain
amount
of
changes
you
can
make
with
it
and
then
continue
with
the
debugger
attack.
B
This
is
interesting.
This
is
I,
believe
Stephen
had
a
time
warp.
Engineering
he's
writing
about
the
Blazer
state,
so
this
is
blazer.
State
is
a
package
for
handling
state
and
it
is-
and
so
here
he's
got
a
walkthrough
in
order
to
do
that,
so
this
is
kind
of
seeing
the
sort
of
like
redux
style
handling
of
state.
It
is
always
interesting
to
me
to
see
how
people
handle
state
that's
always
kind
of
a
trade-off
with
front-end
applications.
It's
like
how
how
much?
B
How
much
structure
do
you
want
to
place
over
your
state?
So
there's
some.
You
know
there
are
some
different
state
management
like
examples,
including
in
the
blazer
tutorial
and
stuff,
so
this
is
kind
of
a
more
structured
one
and
this
walks,
through
some
things
like
handling
state
mutation
and
stuff,
so
nice,
to
see
this
level
of
documentation
here
for
for
a
package
for
this
go
alright,
so
I'm
in
my
front-end
and
blazer
section
of
the
links
here.
This
is
from
Peter
Vogel
here
also
looking
at
action
and
management
kind
of
on
the
front
end.
B
So
here
the
idea
is
that
telluric
UI
UI
controls
support
for
actions,
and
so
here
they
have
some
built-in
window
actions
for
here
with
the
navigation,
we've
got
minimized,
restoring
clothes
and
then
trapping
and
hooking
into
that
for
different
things.
So
this
is.
This
is
a
way
that
you
can
improve
your
experience
on
the
front
end
where
it's
not
just
simple
navigation.
Now
we
can
do
a
lot
of
things
based
on
that
so,
based
on
you
know,
if
there's
a
user
there,
my
handle
actions,
differently,
etc.
B
So
this
is
nice
and
and
good
to
see
like
that
control
them.
You
know
polish
and
fit
and
finish
on
things
like
this,
where
there's
the
integration
between
multiple
different
components,
so
they
can
all
respond
to
an
action
all
right,
also
looking
at
blazer.
This
is
several
people
sent
this
to
me,
and
this
is
crostini
with
an
in-depth
look
at
routing
in
Blazer
and
what
he
does
here
is
look.
You
know
digging
under
the
covers.
Looking
at
the
interception
of
navigation
events
in
JavaScript.
A
B
Intercepting
those
link
clicks,
then
how
that's
passed
over
with
the
Interop,
oh
and
then
also
as
part
of
this
looking
at
how
we
can
simulate
browser
navigation,
because
we
know
how
the
JavaScript
air
is
working.
So
using
you
know,
push
state
there.
Here's
the
integration
with
the
how
those
navigation
events
are
pushed
over
to
c-sharp
and
the
navigation
manager
and
then
the
interaction
here
with
blazer
server
and
the
router
component
as
well.
So
quite
a
lot
of
parts
sort
of
fit
together
from
from
the
file
new
project
blazer.
B
You
really
can
work
at
the
router
level
and
not
need
to
know
about
all
that's
going
on
here,
but
it
is
good
to
see
this
kind
of
to
understand
the
entire
stack
and
then
also
to
see
here.
This
is
sort
of
what
happens
at
your
level.
If
you
do
something
wrong,
if
a
match
is
found,
you'll
load
a
page.
Otherwise
you
get
the
the
not
found
template
so
a
nice,
in-depth,
walkthrough
and
I.
B
You
know
good
to
understand
that
more
deeply,
all
right
this
one
from
you,
Jenny
talking
about
angular
and
asp
net
core
3
deep
dive.
What
he
a
particular
thing
that
he
points
out
here
that
I
appreciate
is
a
lot
of
people
make
kind
of
an
either-or
decision
on
their
applications
they'll
build
either.
You
know
a
back-end
raiser
pages
application,
everything's
rendered
on
the
server
or
they'll
build
a
entirely
front-end.
B
So
we've
got
you
know,
we've
got
our
website,
we're
able
to
take
advantage
of
that
where
it
makes
sense,
building
out
razor
pages
or
MVC
in
this
case
here,
but
building
out
you
know
using
the
backend
technology
and
then
integrating
the
angular
projects
where
it
makes
sense.
So
here
he's
you
know
pulling
in,
and
also
this
is
a
change.
B
That's
that
I've
liked
in
more
recent
versions
of
angular
is
moving
to
more
of
a
component
based
approach
and
working
with
with
web
components,
so
that
that
makes
it
easier
to
kind
of
sprinkle
in
through
the
project.
So
you
know
a
nice
in-depth,
walk
through
quite
a
bit
here,
but
that's
kind
of
the
things
that
he
pulls
out.
There
is
the
building
components
and
integrating
them
within
the
application:
cool
yep
all
right.
B
This
is
cool
from
Siva
and
Naveen
writing
about
deploying
an
asp
net
core
web
api
application
to
AWS
using
aurora
database
and
cloud
formation,
so
hooking
those
parts
together
cloud
formation,
a
my
sequel
and
Postgres
sequel,
compliant
database
back-end
database.
So
here's
just
kind
of
walk
through
using
the
AWS
CLI.
B
You
know,
and
the
integration
with
you
know
the
different
configuration
files
and
all
that
and
just
just
walking
through
how
to
do
that,
including
here
than
the
API
testing.
So
just
kind
of
a
you
know
a
checklist
style
post,
but
it
just
shows
that
kind
of
walkthrough
so
nice
to
see
that
all
right,
alejandro
writing
up
using
deploying
the
asp
net
core
application
using
docker
hub
and
azure
DevOps.
B
So
here's
the
walkthroughs
going
through
creating
creating
the
application
relatively
straightforward,
docker
file,
the
kind
of
interesting
thing
that
caught
my
attention
here
was
just
the
pointing
out
that
docker
hub
has
a
web
hook
and
integrating
the
web
hook
into
Azure.
Devops
is
a
nice
way
to
kind
of
you
know,
connect
the
dots
and
make
the
application
actually
deploy.
So
you
know
we've
got
the
the
different
parts
hook
together.
B
B
So
nice,
you
know
relatively
straightforward
but
nice
to
see
that
that
kind
of
simple
experience
here
using
in
swing,
we
did
yeah
yeah
movin
here
we've
got
a
Andrew
locks,
been
writing
about
features
in
dotnet
core
three
and
how
how
you
can
use
them
in
asp
net
core
application.
Last
week
we
featured
a
global
tool,
cake
global
tools
and
he
had
just
kind
of
some
small
bits
of
cake
samples,
and
here
this
is
kind
of
a
more
in-depth
one.
B
So
here
you
know
it's
great
to
be
able
to
take
a
dependency
on
a
global
tool
and
include
it
with
your
project
and
so
by
including
those
local
tools.
You're
able
to
do
that.
So
I
don't
need
to
include
just
a
my
readme
hey.
If
the
bill
fails
is
because
you
didn't
get
cake,
it's
I
can
include
it
in
my
local
tools.
So
what
he
does
here
is
give
some
more
concrete
walkthrough
showing
how
this
can
be
set
up
using
your
power,
shell
and
your
bash
scripts.
B
So
you
know,
including
here
the
actual
here
we've
got.
We
know,
we've
got
our
dotnet
tool,
restore
and
calling
into
you
know.
Dotnet
tool
run
cake,
and
so
here
shows
integrating
that
into
a
powershell
script
and
then
also
he
shows
that
in
a
bash
script
and
he
does
call
out
differences
with
script
using
Alpine
so
also
using
the
Alpine
ash
shell,
instead
of
bash
I,
learned
something
there
I
did
not
know
we
had
ash
instead
of
ash.
B
Alright,
so
here
we've
got
Barry
ranting
about
HTTP
cookies
moved
to
same
site,
so
it's
a
little
I
had
to
read
through
this
a
few
times,
but
basically
my
understanding
is:
we've
had
same
site,
the
the
spec
for
same
site
has
been
around
since
like
2016,
but
it
was
pretty
lacks
and
now
chrome
is
changing
so
that
if
something
is
missing,
it's
going
to
assume
worst
case.
It's
going
to
assume
strict
and
that
breaks
open.
Id
flows
I
probably
said
that
incorrectly
I
had
to
I
contemplated
just
reading
this
out
loud
and
I'm.
B
A
A
A
I
yeah,
the
last
thing
that
we
want
to
do
is
reintroduce
any
type
of
framework
level
browser
capabilities
feature
like
we
had
in
dotnet
framework,
which
just
goes
horribly
out
of
date,
super
quickly
now
so
you
know,
we've
had
this
wonderful
period
now,
where
we've
typically
just
not
had
to
think
about
the
browser.
That's
hitting
us
to
any.
B
A
I
mean
this
is
right.
This
is
just
that
in
one
of
those
parts
of
the
web
web
programming
right
way,
it
starts
out
simple
and
you
start
getting
the
we'd
really
quickly
and
everything
seems
really
complex
and
the
reality
is.
It
is
kind
of
complex
and
things
change
quite
regularly
and
we're
still
not
in
a
world
where
there's
one
browser
and
one
standard,
which
is
a
good
thing,
but
it
does
cause
pain
and
you
have
to
keep
up
to
date
on
these
things,
otherwise
apps
just
unfortunately
break.
B
A
B
A
I
mean
they
literally,
everything
was
unplugged,
I
mean
it's
just
unfortunate
is
but
yeah
I
was
like.
Oh,
like
sorry,
I've
got
like
nine
minutes,
it'll
be
great
and
I
walked
in
the
computer,
wasn't
even
on
to
turn
it
on
I
didn't
find
the
remotes
for
the
TVs
or
the
whole
things
I
had
to
remember
how
to
turn
the
Danka
lights
are
off.
I.
Remember
that
much,
but
this
thing
was
the
hardest
thing,
but
we're
here
now
it's
all
good.
So.
A
Talk
a
little
bit
about
upgrading
right
from
prior,
like
the
2x
I'm,
not
going
to
talk
about
1x
at
the
end
of
life,
if
you're
still
on
1x
as
I
know,
there's
a
few
thousand
of
you
who
were
still
maintaining
1x,
apps,
I'm,
sorry,
but
yeah
migrating
from
1x
of
300
is
probably
not
something
you
want
to
take
lightly.
It
probably
best
to
move
to
2
X
first
and
then
move
from
2
X,
2
3.
Oh
so
three
hours
been
out
what
a
month
or
something
September.
B
A
And
3
1
will
be
out
before
the
end
of
the
year.
We've
seen
incredible.
Uptake
of
3,
oh
I,
have
to
say
I'm
still
kind
of
flawed
at
just
how
quickly,
especially
asp.net
core
developers
have
moved
or
have
started
using
3.
Oh
I
put
that
down
to
a
couple
different
things:
one:
it's
included
in
dev
16
like
in
vs
29
there
was
it
20
nineteen,
sixteen
point
three.
So
it
was
there.
We
added
it
in
vs
and
it's
the
default.
A
And
so,
if
you
create
a
new
project,
a
web
project
or
a
dotnet
call
console
app
or
anything.
It
is
going
to
be
300
unless
you
go
and
change
it
so
that
helped
I
think.
Secondly,
it
either
was
a
big
upgrade
like
a
lot
of
people
were
waiting
for
features
that
were
in
300,
and
also
it's
just
that
magical
3,
Oh
number
I,
think
there's
a
lot
of
people
who
have
who
me
maybe
started
their
migration
during
2.
A
X
I
started
the
investigation,
but
then
because
of
where
2
X
got
us
to,
but
then
300
was
kind
of
the
tipping
point
where
people
were
like
right
now
we're
going
to
go
in.
We
also
saw
a
fantastic
preview
usage
in
3
yard,
like
massively
bigger
than
we'd
seen
prior
to
that,
like
we'd,
still
have
to
see
more
people
use
previews.
A
Now,
of
course,
we
have
migration
Docs,
which
is
great
and
I,
was
gonna,
bring
those
up.
I've
just
been
battling
with
some
vs
installed
issues
I
like
I've,
dated
ves
yesterday
on
this
laptop
knowing
I
was
gonna.
Do
this
and
I
came
in
right
now
to
create
an
app
but
I
couldn't
create
it
to
accept,
because
I
know,
there's
some
bugs
right
now.
If
you've
got
multiple
vs
instances
installed,
which
I
happen
to
have
so
I've
got
these
three
visual
studio
instances
installed.
I've
got
the
official
public,
16
3
7
right.
A
The
visual
studio
enterprise
20
19
I've
got
the
preview,
which
is
the
preview
channel,
which
is
at
16
for
our
preview
2
and
then
I've
got
the
super
secret
magical
internal
preview,
otherwise
known
as
our
the
derivative
dogfooding
bill,
which
we're
all
supposed
to
use
to
dogfood
the
next
release,
and
you
can
see
this
one's
currently
at
sixteen
five
like
preview,
one
or
something
right.
So
it.
B
B
A
So
this
is
a
2
app,
ok,
so
if
I
double-click
on
the
project
file,
this
is
a
2
web
application
and
you
can
see
straight
away
a
couple
of
the
changes
that
we
talked
about
your
3.
Oh
these
go
away.
There
are
no
packaged
references
like
I
talked
about,
but
you
know
straight
off
the
bat
we
can
say
yeah,
it's
a
2
app.
It's
a
standard,
2
app,
nothing
special
here.
A
If
I
control
f5
wait
for
it
to
build
ctrl
f5,
because
I
want
to
launch
without
debugging
all
right,
so
here
comes
it's
hitting
yeah
and
there's
my
app
ok,
oh
good
I
had
to
hit
accept
because
we
have
that
privacy
policy
thing
in
the
2-2
templates
I'm,
just
gonna
like
note
these
little
things
as
I
go
through
that
I
know
different
Ontario
all
right.
So
there
we
go.
There's
my
app
and
I
have
two
pages
home
and
privacy,
and
that's
what
you
get
when
you
file
new.
A
What
I'm
going
to
attempt
to
do
is
just
wing
it
and
update
this
app
to
three.
Oh
right,
because
it's
the
simplest
possible
update.
We
could
do
other
than
an
empty
web
app
which
is
pointless
and
then
I
encourage
and
invite
folks
to
ask
questions
along
the
way
if
they
have
any
specific
questions.
I
also
have
some.
You
know
that
the
docs
are
here.
People
should
start
with
the
migration
doc
migrating
from
A
to
B
net
court.
A
To
two
to
three:
oh,
you
can
see
it's
actually
fairly
extensive
and
now
that
doesn't
necessarily
mean
that
you
should
be
daunted
by
by
this.
If
you
look
at
like
the
two
one,
two
two
two
doc
and
we
just
look
at
the
scroll
bar
the
scroll
bar-
is
not
as
big.
You
can
see
the
size
of
the
handle
up
there
and
like
two,
oh
two,
two
one
yeah
that
one's
a
little
bit
bigger
but
to
two
to
three,
oh,
is
actually
a
small
handle,
which
means
it's
a
much
bigger
change.
A
A
scroll
bar
height,
that's
right,
and
that
doesn't
mean
business.
This
isn't
you
don't
have
to
do
everything
in
here,
necessarily
to
your
app
to
move
it
from
two
to
two
three,
oh
there's
gonna
be
a
bare
minimum,
which
is
the
stuff
that's
at
the
top
generally
and
then,
as
you
go
through,
there
will
be
things
that
will
only
apply
to
certain
apps,
depending
on
what
you're
doing
or
edge
cases
or
wherever
it
might
be,
that
you
need
to
take
consideration.
There
might
be
some
breaking
changes
that
hit
you,
whereas
other
app
store
hit.
A
Any
breaking
changes
at
all.
I
saw
a
couple
of
conversations
on
Twitter.
Someone
asked
what
was
it
like.
Moving
and
like
Nick
Craver
jumped
in
and
said
yeah
we
moved
all
of
our
apps
to
three
Oh
in
30
minutes.
That's
how
it
now
Nick's,
obviously
very
knowledgeable
guy
his
team
probably
knows
a
whole
bunch
about
Nicole.
We've
been
working
with
them
closely
during
the
300
previews.
So
you
know
for
them.
That's
probably
a
really
good
case
scenario,
but
it
gives
you
an
indication
of
that
yeah
like
if
you,
if
you
do
have
some
prior
knowledge.
A
You
you've
used
on
that
call
for
a
bit.
You
understand
a
little
bit
of
the
mechanics
about
how
the
project
composes
together,
how
references
work
you've,
hit
some
things
and
build
before
that
you've
worked
through.
Then
you
can
have
a
pretty
smooth
experience,
folks,
who
are
looking
to
move
for
the
first
time
or
that
only
just
got
to
to
something
or
then
they
were
moving
to
three.
It
might
take
a
little
bit
longer
and
that's
fine
again.
A
It'll
also
depend
on
what
type
of
terminal
dependencies
you
have,
because
some
areas
have
bigger
breaking
changes
or
bigger
changes
than
others,
and
if
you're,
not
even
using
that
area,
then
obviously
that's
not
going
to
impact
you
so
start
with
the
migration
dock.
I
got
to
it
by
just
you
know:
googling
for
HP
net
core
2,
2,
2,
3,
Oh
migration
dock,
and
this
was
the
first
result
for
me
anyway.
So
definitely
worth
checking
that
out.
Then
there
was
a
couple
of
other
places.
I
was
gonna
point
folks.
This
is
my
tag.
B
A
I
hope
is
up
because
I
have
injected
notice.
This
is
a
package
that
I
maintain
that
has
a
bunch
of
just
tag
helpers
right,
it's
a
bunch
of
like
very
small,
some
somewhat
opinionated
tag
helpers
that
probably
would
never
make
it
into
the
product
for
various
reasons:
they're
not
impactful
enough,
or
they
run
afoul
of
some
of
the
principles
of
what
we
want
to
maintain
in
the
box.
But
you
know
some
people
might
like
the
look.
A
I
have
an
if
tag
helper,
for
example,
which
some
people
think
is
complete
sacrilege,
but
I
kind
of
things
cool.
So
you
can
do
su
a
SPF
put
your
predicate
expression
in
here
and
then
that
element
won't
render.
If,
if
it's
not
available
right,
if
the
predicate
doesn't
match,
this
is
also
where
the
partial
tag
help
us
started.
So
before
we
had
the
partial
tag
upper
into
two.
It
existed
in
this
in
this
package
now.
The
other
thing
that's
interesting
is
this
package
is
built
to
support
all
supported
versions
of
asp.net
core.
A
Ok,
so
you
can
see
the
site
is
currently
running
on
to
113
our
net
core
to
113
on
Azure
app
service,
but
the
package
itself
is
authored
to
support
a
snake
or
two
one,
two,
two
and
three
o,
because
they're
all
the
supported
versions
and
up
until
a
couple
months
ago
it
also
supported
1x
right
because
it
was
supported
up
until
June
this
year
and
then
I
updated
my
package
to
drop
support
for
it
when
him.
That
was
our
support.
A
Then
that
will
be
the
only
version
of
a
spinet
core
that
you
can
run
on
that
no
framework,
which
is
a
useful
migration
stepping-stone
for
folks
who
were
migrating,
say:
MVC
5
or
web
AP
API
to
applications
from
rod
on
a
framework
and
then
looking
to
move
to
a
spin
that
call
that
could
be
a
good
intermediate
step.
Alright,
and
so
this
shows
you
how
to
do
that.
A
A
Obviously,
and
if
you
want
to
do
a
specific
diff
between
when
I
first
introduced,
3
Oh
support
and
then
when
I
finished
so,
like
you
know,
do
a
diff
between
the
commit
before
I
first
did
3,
oh
stuff
and
then
the
last
commit
and
then
you'll
just
see
that
the
Delta
of
oh
yeah.
This
is
what
it
looked
like
when
it's
supported
to
2
versus
what
it
looks
like
when
it
supports
3
Oh
or
you
can
just
go
and
look
at
the
project
file
as
it
is
right
now
in
source
sauce.
A
Take
output
pack
come
down
to
tack
up
a
pack
see
as
proj,
and
this
is
what
the
project
file
looks
like
for
a
tag,
helper
class
library
that
supports,
as
I
said,
all
supported
versions
of
a
spinet
core.
So
the
interesting
things
here,
what
target
frameworks
I'm
targeting
so
I'm,
targeting
no
there's
no
net
standard
here,
for
example,
because
I'm
specifically
doing
asp.net
core.
There
really
isn't
much
advantage
to
using
dotnet
standard
I'm.
Only
interested
in
supporting
the
platforms
that
asp.net
core
is
supported
on.
A
Ok,
so
I
don't
need
to
run
on
unity
and
I,
don't
need
to
run
on
xamarin
app
and
those
type
of
things
right.
I
wanted
to
support
dr.
core
3.
This
is
the
most
efficient
way
of
doing
so.
You
know
target
the
Tea
FM's,
where
HP
net
core
runs,
runs
on
net
framework
runs
under
core
three
runs
on
neck
or
2.1.
Ok,
so
that's
the
easiest
way
of
doing
that.
I
could
use
net
standard,
but
it
would
be
a
more
complicate
project
file
and
I
wouldn't
really
get
any
benefit
from
doing
it.
A
So
I
think
this
is
the
best
way
to
go,
and
then
you
can
see
down
here
where
I've
had
to
do
the
conditional
references
for
the
different
version.
So
you
can
see
straight
away.
One
of
the
biggest
differences
is
with
net
core
app
3.
You
don't
have
this
package
reference,
because
a
lot
of
HP
net
core
moved
out
of
packages,
as
I
mentioned
previously
into
what's
called
a
framework
reference,
and
you
can
see
that
down
here.
So
if
I
am
on
net
core
app
3
target
framework
is
equal
to
net
code.
A
3,
then
I
need
to
add
a
framework
reference
for
Microsoft,
a
spinet
core,
app
otherwise
known
as
a
shared
framework
or
a
runtime.
We
use
these
different
things.
All
these
different
names,
unfortunately
all
the
time,
but
in
in
the
in
the
parlance
of
the
project
file.
It's
correct
name
is
a
framework
reference,
but
if
I'm
let
if
I
am
NOT
3oh,
then
I
should
be
going
ahead
and
doing
a
standard
package.
Reference
like
we
did
back
in
the
day
now.
A
I
want
this
library
to
support
all
versions
that
are
supported
and
so
I
choose
the
lowest
one
that
supported
which
is
2.1,
and
this
will
happily
work
on
2.2,
ok,
cuz
2.2
is
backwards
compatible
with
two
ones.
So
I
can
just
reference
to
one
it'll,
happily
work
on
a
to
two
application
package.
Reference
obviously,
will
work
just
fine
in
an
a
spinet
core
application
running
on
dotnet
framework
or
net
core,
so
I
don't
need
to
differentiate
between
those
here.
Ok,.
B
B
A
Anything's
possible
so
I
guess
by
detect
you
mean
it
would
either
have
to
be
a
specific
gesture
where
you
like
right,
mouse,
click
and
say
retarget,
and
then
all
we
be
able
to
do
for
us
a
great
go
and
read
this
document,
or
it
could
detect
that
you
change
the
TFM.
But
then
we
have
to
do
like
it
sounds
like
a
bug.
Farm
to
me,
we'd
have
to
like
know
that
your
intent
was
to
change
from
one
to
the
other.
A
It
also
is
hard
to
understand
these
types
of
situations
where
you're
doing
multi,
targeting
which
is
not
uncommon.
If
you're
doing
library
development,
we
need
to
run
a
multiple,
so
yeah
like
I,
think,
it's
probably
fair
to
say,
we've
tended
to
shy
away
from
those
type
of
experiences
more
than
we
used
to
like.
A
If
you
think
back
into
the
2000s
in
the
just
pure
dotnet
framework,
you
had
to
use
vs
phase,
we
had
migration
stories
like
you
would
be
able
to
write
right
mouse
click
on
something
as
they
moved
to
dotnet
framework
4
or
convert
application
from
vb6
or
something
like
we
had
those
type
of
things
and
they
were
kind
of
a
mixed
bag.
I.
Think
it's
fair
to
say
often,
you
would
get
like
a
project.
A
It
would
initially
was
perceived
like
you,
the
expectation
that
set
when
you
have
a
menu
item
that
says
migrate
or
convert
to
or
new
update
to
this
thing
is
that
I'll
click
a
button
and
then,
after
a
couple
minutes,
my
app
will
be
perfect.
The
reality
is,
things
are
so
complicated
in
applications.
They
don't
all
look
like
the
template.
Now
it
almost
never
works
that
way
like
it
literally
almost
never
works.
That
way.
A
A
You
know
to
two
to
three:
oh,
but
what's
the
point,
you're
much
better
off,
building
a
dock
and
making
sure
that
the
vs
experience
is
good
when
you're
editing,
project
files
and
removing
new
Galica
and
adding
new
get
packages
and
the
more
the
errors
and
warnings
you
get
a
meaningful
and
point
you
to
the
right
thing.
That
was
probably
a
better
investment
of
effort
than
trying
to
build
a
click.
Click
click,
migration
story
that
will
just
never
work.
That's
that's
my
opinion
on
it.
A
A
B
B
A
A
Yeah
and
there's
been
some
other
sort
of
variants
of
that
idea.
I
think
like.
If
you
open
a
project
that
is
now
using
an
out
of
support
or
an
end-of-life
version,
maybe
we
could
throw
a
yellow
bar
up
that
says:
hey
you're,
using
an
end-of-life
version.
You
know
click
here
for
the
migration
doc.
That
will
tell
you
how
to
get
the
latest
version
right
that
that's
something
proactive
if
it
doesn't
rely
on
us
having
to
guess
what
you're
doing
and
that
we
can
easily
create
a
dismissable
experience
for
so
we
don't
annoy
you
again.
A
That
means
100%
of
the
time
we
understand
what
you're
trying
to
do,
because
this
variable
doesn't
exist
like
we
don't
know
what
the
value
of
that
is.
This
just
a
variable
right,
because
in
this
lot
we're
not
running
a
build
right
now.
Someone
also
asks
in
the
twitch
app
yeah,
so
if
you're
currently
running
to
to
on
full
frame
work
and
cannot
switch
over
to
core
because
of
whatever
reason
you
need
to
downgrade
to
200
men
supported.
Yes,
that
is
true.
A
That
was
announced
a
while
ago
now
and
2
to
life
cycle
has
been
sort
of
known
from
the
beginning.
We
try
and
make
every
effort
to
every
time
we
make
a
blog
post
announcing
a
new
version.
There
is
a
section
in
the
blog
post
that
talks
about
support
policy
and
support
life
cycle.
I'll,
reiterate:
dotnet
core
has
a
very
different
support
life
cycle
to
dotnet
from
previous
times,
dotnet
support,
Donna
frameworks.
Support
policy
was
very
much
tied
to
Windows.
Previously
the
a
spinette
teams
out-of-band
supports,
like
out-of-band
products.
A
Now,
with
the
advent
of
core
and
one
of
those
changes
is
the,
for
example,
the
exception
that
a
spinet
core
2.1
on.net
framework
will
be
tied
to
the
Dungey
framework
support
policy,
rather
than
done
the
corset
support
policy.
So
basically,
as
long
as
you're
running
on
a
supported
OS
on
a
supported
version,
of.net
framework,
we
will
support
a
spinet
core
to
one
on
that
forever
and
support
means
well.
A
You'll,
get
security,
patches,
right,
you'll,
get
security
fixes
and
you
can
contact
Microsoft
paid
support
and
and
get
someone
to
help
you
through
any
issues
that
you're
having
all
right.
So,
let's
get
back
to
trying
to
run
through
this
as
quickly
as
we
possibly
can,
because
I
talk
too
much
all
right.
So
a
couple
things
first
thing
I
will
always
do,
is
go
well.
I'm
gonna
go
off
and
change
my
trm
right,
so
doing
that
straight
away
is
going
to
affect
a
whole
bunch
of
other
things.
A
It's
not
just
what
I'm
compiling
against
that
changes
here.
So
remember
the
teeth.
The
target
framework
basically
sets
the
base
api's
that
you
have
available
to
you.
What
will
be
passed
to
the
compiler
as
my
default
set
of
references
and
what
versions
will
they
be?
That's
what
this
does?
Okay,
it
also
can
default
things
in
your
project
file,
because
this
line
up
the
top
here-
or
it
says
what
msbuild
SDK
are
you
using?
This
can
have
its
own
conditional
statements
that
are
based
on
this
value.
A
Okay,
so
as
soon
as
I
set
this
to
3,
oh
I
can
remove
the
hosting
model,
because
I
know
that
it
moves
to
in
process
by
default
in
3.
Oh
because
the
SD
of
the
web
SDK
does
that
for
me,
okay,
so
I
don't
do
that.
I
also
know
that
I
don't
need
any
package
references
by
default,
because
I
also
know
that
we
default
the
framework
reference.
A
There's
no
package
reference
anymore:
we
default
the
framework
reference
to
the
a
spinet
core,
app
reference
or
lower
web
SDK
when
you're
targeting
that
correct
300,
so
I'm
gonna
do
that?
Okay
done
so
I,
don't
have
any
errors.
I
don't
have
a
build
I'll
build
it
see
what
happens.
It's
building
remember.
I
still
have
to
to
code
so
I
have
to
to
code,
but
I
have
changed
my
project
file
to
look
like
a
3
project
file
and
it
builds,
which
is
pretty
cool
right
there
straight
off.
A
The
bat
I
was
able
just
to
change
my
project
file
to
a
three
oh
project
file
and
it's
still
built.
So
that
means
at
least
the
template
that
I
started
with
didn't
use
any
api's
that
have
like
completely
broken.
Otherwise
it
just
wouldn't
even
compile
right,
I,
don't
know
if
it'll
run
I
see
if
it
runs.
So
let
me
launch
it
ctrl
f5
and
it
failed
okay,
great!
So
that's
fine,
I!
Think
it
a
warning.
So
I
had
some
warnings
down
here
which
have
gone
away
again,
which
is
a
little
odd.
A
So
let
me
build
again:
oh
my
warnings
have
gone
away.
That's
a
little
I
did
have
three
warnings
error.
It
should
have
taken
a
screenshot.
Let
me
do
it
clean.
Let
me
do
the
classic
dance
here.
I'll.
Do
it
clean
in
the
build
and
see
if
I
can
get
my
three
warnings
back
there
we
go
alright.
So
what
does
it
say?
Maybe
one
of
these
warnings
will
tell
me
what
you
know
we'll
say:
hey.
A
You
should
have
read
me
when
it
was
a
build
warning
before
you
went
off
and
ran
the
application,
got
a
runtime
error.
Well,
it
says
compatibility
version.
Two
is
obsolete,
alright,
recommended
alternatives
of
Version
three
or
later
well,
it
doesn't
sound
like
it's
gonna
break
my
app,
but
okay,
I
hosting
of
Rome
is
obsolete.
This
is
I
will
be
removed
in
a
future
version.
Recommended
alternative.
Is
this
hosting
environment?
A
Okay,
so
that
sounds
like
we
made
a
fairly
big
core
change
right
at
the
base
level
of
the
application
when
it's
booting,
because
it's
in
the
hosting
layer
where
we
went
from
I
hosting
environment
to
I
web
host
environment,
but
it
wasn't
enough
to
break
the
compilation
and
then
this
one
looks
more.
Like
my
error,
my
era
had
to
do
with
MVC,
using
MVC
using
use
MVC
to
configure
it's
not
supported
when
using
endpoint
routing.
Well
not
supported
sounds
like
it
might
actually
throw
an
error
to
continue
using
it.
A
Please
set
an
able
endpoint
routing
to
false
Wow.
Okay.
So
that's
that's,
probably
my
culprit.
So
if
I
go
back
to
my
exception,
it
says
yeah
endpoint
routing
does
not
support
that.
To
use
it.
It's
the
exact
same
thing,
so
we
have
a
build
warning.
That's
basically
for
foreshadowing
the
fact
that
I'm
going
to
get
a
runtime
error.
So
that
probably
means
in
my
startup
file.
Here
there
is
something
that
has
fundamentally
changed
between
a
two
to
a
pin
a3
our
so
I
could
go
and
read
the
doc
at
this
point
right.
A
A
Oh
I,
can't
type
all
right
and
then
I'll
do
my
web
app,
I'm,
gonna
change
to
300
and
then
I'll
hit
create
and
then
what
we're
looking
for
here
is
the
difference
between
the
startup
files,
because
that's
where
all
this
configures
done
so
I'm
gonna,
say:
ok,
startup,
alright,
what's
going
on
here,
so
I'm
using
use,
MVC
well
I,
don't
see
any
call
to
use
MVC
in
three
days.
So
obviously
something
has
changed
there.
Okay,
I,
don't
see
MVC
at
all.
A
Actually-
and
this
is
one
of
the
biggest
changes-
was
the
move
to
end
point
routing.
We
introduced
endpoint
routing
a
two
point
two,
but
it
was
hidden
behind
MVC
you
couldn't
get
to
it
in
three:
oh,
we
have
endpoint
routing
front
and
center.
Now
people
are
now
calling
me
out
for
cheating,
which
is
you
know,
absolutely
fair,
so
I'll
jump
back
to
the
docs
and
I
will
show
you
that
there
is
a
big
section
here.
Big
there
is
a
section
somewhere
in
here
about
endpoint
rounding,
so
I.
A
Remember
it
showing
up
some
way,
and
now
it's
making
a
lot
of
me
because
I
can't
find
it
so
I'll
cheat
and
do
the
endpoint
routing
look
routing
startup
code
there
it
is
so
there
is
a
section
here
here
we
go
routing
startup
code
that
talks
about
the
thing
that
I'm
about
to
do,
which
is
the
chain.
Just
if
you're
not
calls
use
MVC,
then
you
blabber
blow.
You
should
migrate
the
app
to
endpoint
routing
that
I
can
click
on
that
and
look
there's
a
whole
set
of
stuff
about
endpoint,
routing
and
routing
in
general.
A
So
if
I
go
back
up
to
the
update,
the
section
here,
which
is
says,
startup
changes,
they've
got
a
nice
little
dip
here.
That
shows
you
the
difference.
They've
removed
the
call
to
app
use
MVC
they
removed
by
hosting
environment
they've,
removed
the
call
to
second
pad
ability
version.
These
are
all
the
things
that
we
got
warnings
on.
Ok,
so
it's
nice
to
see
that
the
Doc's
seem
to
match
up
with
what
I
experienced
when
I
try
to
do
this
right.
Now.
A
Ok,
so
let's,
let's
continue
our
winging
it
and
see
if
we
can't
figure
this
out
all
right.
So
you
know
what
you
would
do
here.
You
were
just
like
copy
all
this
right,
so
I
yeah
that
looks
the
same
development,
blah
blah
blah
HSTs.
That
was
all
in
2x.
This
looks
different
this
this
use
routing
and
then
use
endpoints.
This
is
the
own
lines,
46
two
lines
53.
A
This
is
the
new
way
of
doing
middleware,
that
routes
to
some
endpoint
wraps
to
some
terminal
thing
that
will
you
go
to
whack
foo
and
something
happens
all
right.
That's
what
endpoint
routing
is
about.
Endpoint
routing
is
routing.
That's
applied
globally
in
the
middleware
pipeline.
That's
what
it
means,
whereas
previously
routing
was
just
kind
of
like
a
little
island
in
the
pipeline,
and
it
was
just
an
island
for
whatever
added
it
now.
Endpoint
routing
Biskind
is
basically
considered
an
integral
part
of
the
middleware
pipeline.
A
So
you've
got
everything
that
happens
up
until
a
routing
decision
is
made
that
everything
before
you
is
routing,
then
you've
got
the
stuff
that
happens
in
between
when
the
routing
decision
was
made
and
then
you've
got
and
then
finally,
before
the
the
routing
endpoint
is
executed.
Ok,
so
now
we've
got
these
three
kind
of
these
three
stages
or
four
stages:
I
guess
before
our
route
is
matched
the
the
moment
of
matching
a
route.
A
The
stuff
that
happens
after
the
route
is
matched,
and
we
know
where
we're
going
to
end
up
executing
and
then
the
actual
execution
phase.
At
the
end
of
the
request.
Ok,
now
you
can
always
still
shortcut.
You
know.
Middleware
up
here
can
decide
nope
we're
not
going
to
continue
the
pipeline
and
we're
just
going
to
return
back.
That
can
still
happen,
but
this
is
the
normal
kind
of
flow
and
it
still
reads
top
to
bottom.
A
We
did
a
lot
of
work
on
the
API
here
to
kind
of
still
make
that
make
sense,
all
right,
so
I'm
just
gonna
rip
all
this
out.
It's
gonna
take
this
out
this
one
I'm
gonna
go
back
to
my
startup
app
and
I'm
gonna.
Throw
this
one
in
here.
You
can
see
some
of
the
same
calls
cookie
policy
is
now
removed
from
the
templates
are
still
available
for
you.
That
was
all
the
gdpr
stuff
that
banner
that
I
showed
at
the
beginning.
A
Okay
and
then
it
said,
don't
use
compact
version,
you
can
see
it's
underlined
here,
saying
it
doesn't
work
and
I
don't
need
MVC,
because
we
added
a
first-class
razor
pages
call
and
this
app
just
uses
razor
pages
at
the
moment.
If
I
want
to
use
controllers,
then
I
would
call
add
MPC
if
I
want
to
use
API
controllers
I
would
call
that
API
controllers
they're
all
sort
of
still
mix-and-match.
You
can
still
make
them
compatible
with
each
other,
but
they're.
A
Just
we
now
have
these
top-level
methods
that
are
more
tuned
to
the
actual
features
that
you're
using
okay.
So
let
me
recompile
that,
let
me
just
make
sure
it
bills
before
I
go
back
to
my
browser
and
try
and
f5
it
it's.
Let
me
F
five
look
at
that.
My
home
page
works,
so
there
we
go
all
I
had
to
do
was
replace
my
startup
code
with
the
three
Oh
startup
code.
Now,
the
actual
only
change
I
probably
need
to
make
was
the
the
routing
change
right.
I
could
have
just
said:
hey,
let's
fix
that.
A
One
error
with
calling
News,
NBC
I
could
have
turned
off
endpoint
routing,
because
my
I
could
have
said
I'll
know
my
app
can't
use
M
point
routing
yet
because
I
have
this,
their
party
dependency
that
has
been
updated
friend,
point
writing,
because
it
has
some
semantic
differences
and
I
could
have
followed
that
advice,
but
instead
I
just
moved
to
end
point:
routing:
okay
I
went
to
the
new
idioms,
and
so
now
my
app
works
privacy,
I'm
nothing's,
throwing
up
great,
that's
fantastic.
So
that's
the
simplest
possible
migration,
because
I
don't
have
any
data
I.
B
A
Cool
all
right,
so
that
that
has
moved
in
like
that.
That's
the
simplest
possible
thing
you
could
do
and
I've
kind
of
that
that
covers
the
biggest
sort
of
project
file,
changes
and
startup
code
path,
changes.
You
know.
Just
to
reiterate:
we
changed
our
TFM.
We
removed
our
package
references
because
they're
not
needed
anymore,
and
this
is
what
just
a
standard
a
spinet
core,
3
application
looks
like
now.
If
I
have
package
references,
obviously
they
come
back.
A
My
startup
code,
I
move
to
endpoint
routing,
which
is
the
big
change
and
I,
obviously,
don't
have
to
worry
about
setting
compat
versions
or
anything
anymore,
because
it
was
a
major
version.
It
just
reset
to
3.
Oh
and
we
removed
the
compatibility
flags
that
have
been
up
as
compatibility
flags
in
the
previous
versions.
That's
how
that
whole
MVC
compact
thing
works.
Ryan
has
a
whole
bunch
of
good
talks
about
that.
Yes,
quick.
B
A
So
Ryan's
done
some
good
talks
on
this
MVC
compatibility
feature,
which
is
what
it
basically
allows
us
to
make
behavioral
breaking
changes
in
minor
versions
of
MVC,
because
we
hide
those
changes
behind
the
compatibility
flag,
setting
and
a
specific
option
for
whatever
feature
that
we've
changed.
Okay,
so
the
compatibility
version
is
basically
a
grouping
of
options
that
we
have
changed
in
a
minor
version,
because
we
realize
there's
something
we
did
previously
was
basically
wrong.
A
What
we
want
to
take
in
a
different
direction,
but
we
can't
just
change
it
in
like
2.1,
2.2
or
3.1,
because
it
would
just
break
applications
when
they
move
on
to
3.1.
Ok,
because
the
behavior
changes,
so
it
forces
you
to
have
to
go
and
make
a
code
change
to
get
to
the
new.
You
know
quote:
unquote
fixed
behavior,
but
then,
when
we
roll
over
to
a
major
version
like
3,
oh
all,
bets
are
off.
We
just
break
it
right
because
it's
a
major
version,
so
the
compact
flag
goes
away.
A
A
That's
another
big
change.
I
would
go
and
update
the
package,
references
for
entity
framework
down
here
and
then
in
my
startup
I
may
or
may
not
have
to
set
a
compatibility
flag
or
change
the
compat
mode
from
the
default,
which
will
be
three
over
the
life
of
all
three
X
releases,
two
three
one.
If
there
was
a
behavior
breaking
change
that
we
introduced
in
three
one
and
MVC
that
we
had
to
put
by
an
a
compare
flag.
Okay,
that's
right!
A
That's
basically
what
that
thing
is
for
nothing
else
really
should
have
to
change
from
three
out
of
three
one
should
be
a
very
simple,
straightforward
migration,
because
it's
a
minor
version
change
all
right.
So
that's
all
we're
going
to
kind
of
get
through
today
in
terms
of
looking
at
code,
but
that's
the
simplest
migration
that
you
can
put
you
can
see.
Most
of
the
changes
were
around
the
TFM.
As
usual,
the
project
file
defaults
and
the
startup
code.
A
The
start
occur,
I
know
I,
didn't
do
the
hosting
environment
change,
so
I
will
still
have
a
build
warning.
You
can
see
it
still
works
the
way
I'm
doing
it
right
now
and
I
didn't
update
my
program
main
to
choose
the
new
host,
so
the
other
big
change
around
startup
was
that
we
introduced
the
generic
host
and
things
like
the
worker
service
template
and
that
required
us
to
sort
of
unwed
off
I,
the
hosting
startup
logic.
So
we
had
the
old,
odd,
the
hot,
the
old
hope
my
hosting
environment,
used
to
be
web
specific.
A
So
we
had
to
decouple
those
things,
which
is
why
we
had
to
like
change
it
to
iWeb
host
environment
and
we
had
to
move
our
hosting
environment
as
an
interface
actually
had
to
duplicate
it
to
a
different
namespace,
which
is
a
terrible
thing.
But
unfortunately
it
was
just
a
bit
of
legacy
that
we
had
to
push
through
for
three
Oh.
A
So
I
haven't
done
that
you
can
see
the
app
still
works,
booting
up
with
the
legacy
hosting
code,
but
I
could
also
go
into
my
program
main
and
change
the
host
style
up
code
as
well
to
use
the
new
three
Oh
way
of
starting
up,
and
the
benefits
of
that
are
that
you
can
then
attach
other
application
models
like
a
worker
service
under
the
same
host
in
the
same
application.
If
you
want
to
okay,
also,
the
web
host
data
will
go
away
and
donate
five
like
it.
A
300
will
be
the
last
release
where
it's
there
or
3x,
and
then
it'll
all
move
to
the
generic
hosting
model
exclusively
in
five.
So
the
other
big
things
that
I
haven't
touched
on
here,
Jason
net,
definitely
worth
calling
out
in
MVC.
We
used
to
depend
on
Jason
dinette
for
Jason
in.net
core
3.
We
introduced
a
new
low
level,
JSON
serialization
API
in
dotnet
core
itself,
MVC
defaults
to
using
that,
because
it's
in
the
shared
framework,
but
you
can
still
use
Jason
donate.
If
you
want
to
it's,
not
the
default
in
the
templates.
A
There
is
a
package
that
you
add
just
like
any
optional
component.
You
had
a
package,
you
call
an
API
and
your
startup
code,
and
now
you
go
back
to
using
JSON
net.
It
is
very
likely
that
you
will
want
to
do
that
as
the
first
step.
Oh
Jason
net
back,
because
the
low-level
API
as
it
is
right
now
does
have
a
lot
of
the
features
that
people
depend
on
currently
in
Jason
net
that
are
really
about
convenience
and
interoperability.
A
A
There's
the
host
builder
versus
web
host
builder
thing
I
just
talked
about,
so
you
can
run
with
the
web
host
builder,
which
I'm
doing
right
now,
but
this
is
how
you
would
go
ahead
and
convert
to
the
new
host
builder
instead
authorization
so
with
in
point
routing,
we've
introduced
a
whole
new
authorization
pipeline
authorization
used
to
not
be
a
step
in
middle-way.
Authorization
was
just
something
that
happened
in
earth
policy
in
the
DI
container.
A
Is
they
put
those
things
in
the
wrong
order?
Okay,
so
you
must
make
sure
that
your
call
to
use
authorization
and
use
authentication
which
I
don't
have
in
this
application,
because
the
template
doesn't
have
it,
but
I
can
put
it
in
here.
It'll
do
nothing
because
I
don't
have
anything
right
now.
They
must
be
in
between
use,
routing
and
use
endpoints.
A
Okay,
if
they're
not,
then
you
will
be
making
authorization
decisions
before
you've
decided
what
endpoint
you're
hitting,
which
means
you
don't
have
the
authorization
policy
for
the
endpoint
yet,
and
so
what
you'll
get
is
the
authorization
I'll
say,
yep
you're
authorized
and
then
you'll
hit
an
endpoint
that
has
an
authorization
attribute
on
it
and
it'll,
just
let
it
through
all
right.
That
was
a
bit
of
a
design
bug,
so
we're
fixing
it
in
three
one
so
that,
if
you
do
that
accident
it'll
actually
throw
an
exception.
A
Okay,
because
we
don't
want
you
hitting
endpoints
that
are
marked
as
authorized
and
not
having
the
authorization
evaluated
all
right.
So
we
did
fix
that,
but
make
sure
that
these
are
in
between
those
two
calls
that
will
fix
that
problem.
For
you
and
then
in
the
UI
has
a
couple
of
minor
changes,
but
there's
not
a
huge
set
of
changes
there.
We
basically
change
the
default
to
bootstrap
four
and
sort
of
bootstrap
three
to
match
the
templates.
A
What
else
is
big?
All
the
runtime
compilation
stuff?
We
talked
about
in
the
blog
post,
there's
a
section
there
about
opting
in
to
run
ton,
compilation
yeah
again
recommended
if
you
make
a
lot
of
view,
changes
and
you
just
want
to
be
able
to
do
independent
of
your
code
changes
and
you
want
to
be
able
to
see
those
instantly
while
you're
developing.
You
can
do
that
here,
I,
like
the
blog
post,
you
showed
that
was
doing
this
with
a
conditional
compile
flag.
It
actually
might
be.
That
might
be
a
good
addition
to
this
migration
doc.
A
Maybe
someone
wants
to
send
the
PR
and
say
hey
optionally,
if
you
only
want
to
enable
this,
while
you're
developing
put
it
behind
a
conditional
directive,
but
if
the
bug
or
an
environment
directive,
you
know
only
added
if
you're
in
the
development
of
Iram
has
another
way
of
doing
it
right,
although
that's
slightly
different,
because
it'll
get
compiled
in
blah
blah
blah
blah
blah
migrating
libraries
to
multi
targeting.
So
this
is
basically
talking
about
what
I
talked
about
with
tag
helper
pack.
Now
there
is
a
more
extensive
dock
coming
on
this
section.
A
Okay,
we
have
done
the
outline
for
and
Scott
addy
is
doing
the
authoring
for
it,
but
unfortunately,
we've
had
some
problems
getting
our
reference
Docs,
that
is
the
API
ref,
didn't
publish
for
three.
Oh
that's
taken
all
of
his
time.
Right
now
and
that's
the
priority
we
have
to
get
the
asp
net
core
and
signal
are
three
RF
docks
published,
which
I
think
are
now
partially
or
nearly
done
or
all
done
before.
He
can
now
turn
his
attention
to
the
more
extensive
library
authoring
guide
for
a
spinet
core
three,
but
that
is
coming
ok.
A
A
That
itself
is
compiling
against
three
different
versions:
of.net
some
people
do
this.
Other
people,
don't
is
usually
donate,
something
you
doing
tests
or
library
authoring,
but
this
one's
a
little
more
complicated
right,
because
this
is
a
full
web
app,
not
just
a
class
library,
and
it
runs
a
under
framework,
dotnet,
core
2.1
and
don't
know
choreo,
and
so
there's
a
lot
more
conditional
statements
here,
because
you
know
I
need
a
lot
more
packages
when
I'm
running
on
dotnet
4,
for
example,
versus
running
on
that
core.
Ok,
so
another
good
example
there.
A
For
folks,
you
might
need
that
for
folks
using
test
server.
There's
a
section
here
regarding
introduction
with
generic
host
and
also
I
will
notice
that
I
will
let
you
know
that
the
test
server
with
the
introduction
of
framework
reference
in
3.
Oh
the
whole
problem
of
the
meta
package-
reference
not
flowing
correctly
into
your
test
server
projects
is
fixed.
A
Ok,
once
you
move
to
framework
reference,
you
can
have
your
test
project
with
the
project
of
project
reference
to
your
web
application,
and
you
just
you-
don't-
have
to
worry
about
changing
to
the
web
SDK
and
setting
the
version
number
of
the
package
reference
to
match
the
implicit
one
they
that's
all
just
fixed
because
frame
of
reference
fixes
all
that
stuff
for
you
and
then.
Lastly,
two
last
things
that
are
there
in
the
migration
dog
there's
a
really
good
migration
dot.
A
By
the
way,
it
really
touches
on
all
the
points
that
we
have
seen
come
up
and
we
continue
to
modify
it.
As
we
see
people
hit
things
list
up
by
breaking
API
changes.
Obviously
most
of
them
I
mean
I,
think
it's
obvious,
but
I
shouldn't
say
obviously
at
the
low
level
in
dotnet
core
itself.
There
are
very
few,
like
very
few
people
typically
will
get
hit
by
changes
in
the
low-level
framework.
Most
of
the
changes
that
are
impactful
are
at
the
application
framework
level,
a
speed
on
a
core
and
entity
framework.
A
We
get
a
lot
of
feedback
about.
It
is
currently
being
rolled
out
the
runtime,
and
you
can
see
this
on.
We
have
a
website
HP
net
core
on
your
websites,
dotnet.
That
gives
you
status
for
all
the
supported
versions
of
HP
net
core
and
dotnet
core
across
all
the
azure
app
service
instances
across
the
planet.
Blue
means
partially
current
green
you'll
note
that
none
of
them
are
green
and
there's
a
reason.
Right
now
we
have
the
runtime
the
shared
framework
for
300
on
all
the
other
app
service
instances.
A
That
does
not
work
currently,
because
we
don't
have
the
dotnet
core
3
SDK,
installed
on
the
azure
app
service
machines,
yet
which
obviously
is
needed
to
build
your
application
using
3
o
on
those
machines,
and
the
reason
is
because
it's
complicated
because
in
order
to
build
you
need
msbuild
in
order
to
have
MS
build.
They
also
need
to
be
able
to
support
Donaire
framework
apps
building
and
they
need
to
support
dotnet
core
2,
1
and
200
and
100,
because
they
haven't
removed
1x
and
that's
because
it
would
break
people's
applications.
A
And
so
when
you
have
a
single
machine
that
needs
all
those
side-by-side
versions
and
you're
running
a
global
service,
you
don't
take
changes
to
those
shared
components
lightly
and
so
they've
had
to
do
a
whole
bunch
of
extra
due
diligence
and
testing
before
they
can
deploy
a
new
version
of
msbuild
that
supports
the
things
that
are
needed
for
the
dotnet
core,
3
SDK
to
work
that
supports
done
at
core
3,
etc,
etc,
etc.
Ok,
so
that's
why
that
took
longer
than
just
getting
the
runtime
update
now.
A
A
You
know
there's
a
big
conference
next
week,
so
if
folks
are
busy
doing
other
stuff,
but
in
the
meantime
you
can
do
as
long
as
you
can
build
it
on
it
on
something
else.
You
can
deploy
your
app
and
have
it
running
as
your
app
service
with
a
shared
framework.
Obviously,
before
that
you
could
have
run
self-contained
or
run
in
a
container
and
it
would
have
worked
just
fine
as
well.
Oh
that's.
B
B
A
A
Is
it
possible
to
in.net
call
2x
to
put
a
referenced
and
you
get
packages
content
into
output
directory
during
debugging
like
in.net,
core
3?
Yes,
that
was
one
of
the
other
changes.
Is
that
dotnet
core
3
SDK
now
defaults
to
copying
all
content
to
the
bin
folder
on
build,
whereas
it
didn't
do
that
in
dotnet
core?
The
question
is:
can
they
make
it
do
that
in
dotnet
court?
A
A
To
do
someone
Michael
asked
John
to
one.
What
does
this
mean
for
win7
future
so
and
I'm?
Assuming
that
simulation
in
relation
to
my
comment
about
as
long
as
you're
running
on
a
supported,
OS
on
a
supported,
dotnet
framework,
then
a
spinet
core
one
on.net
framework
will
be
supported.
That's
a
good
question.
I
know
for
dotnet
core
3.
We
you
support
Windows
7,
even
though
Windows
7
end-of-life
is
coming
up
like
really
soon
like
I.
Think
it's
like
January
next
year,
Windows
7
is
end-of-life,
and
so
it
might
be.
Gender
might
be
June
anyway.
A
It's
really
it's
really
soon,
but
doc,
neck
or
3x
will
continue
to
support
Windows
7,
because
we
know
we
have
a
bunch
of
customers
who
were
deploying
client
applications,
winforms
WPF
to
Windows
7,
and
we
want
to
be
able
to
enable
them
to
used
on
their
core
3.
So
that
was
an
exception.
We
typically
wouldn't
release
a
new
version,
of.net
core,
knowing
we
support
for
an
OS
that
we
knew
was
going
to
go
and
support
during
the
lifetime
of
that
version,
of.net
core
with
relation
to
asp
net
core
to
one
on
that
net
framework.
A
I'm
not
sure
we've
made
an
official
decision
regarding
the
OS
support
now
in
in
with
Windows
7
there's
and
there's
two
there's
two
sides
of
it:
there's
the
development
time
support
which
is
obviously
Windows
7
and
there's
the
server
time
support
which
more
relies
in
the
Windows
server
OS,
which
I
think
for
Windows
7
is
Windows,
Server,
2008,
r2
I
think
that's
equivalent
I
might
be
wrong.
That
might
have
been
Windows,
Eric
I.
A
Remember
so
that's
an
open
question
that
we'll
have
to
answer,
and
we
may
answer
that,
based
on
customers
asking
us
when
we
get
to
actual
support
inquiries
on
that
it
says,
can
we
we
can
still
track
netkar
out
to
one
or
three
or
four
win7,
two
bromans
right
so
answer
the
wins?
The
the
the
free,
oh
thing,
the
three
axing
for
a
spinet
core
2.1,
specifically
that's
a
little
bit
different
and
for
dotnet
core
2.1,
which
is
still
under
support.
My
understanding
is
we're
not
just
gonna
drop
support
when
Windows
7
goes
end-of-life
modulo.
A
The
fact
that,
if
the
issue
that
we
find,
if
you'd
like
a
support
issue-
or
we
find
an
issue
that
we
want
to
patch-
but
it
requires
a
Windows
patch
to
fix-
there's
not
much-
we
can
do
about
it.
You
know
there
are
layers
and
we
can
support
the
dotnet
core
2.1
part
on
there,
assuming
there
isn't
some
issue
with
Windows
7
yeah,
so
you
found
that
it
is
January
right,
which
is
how
I
understood
so
long
story
short
plan
to
get
off.
Windows
7,
all
right.
It's
going
in
our
support.
A
A
So
my
understanding
of
that
right
now
is
that
they're
hoping
the
team
is
hoping
to
find
a
member
in
the
community
or
a
group
of
people
who
will
take
on
maintaining
that
package,
because
we
know
that
it's
a
particularly
useful
API
for
a
bunch
of
folks
and
they
use
it
for
things
that
it
honestly
wasn't
actually
originally
created.
For
so
the
history
of
that
is
that
it
was
created
to
support
the
spire
services
package,
which
used
to
be
used
in
our
spa
templates.
A
Back
in
oh,
we
stopped
all
that
when
we
quickly
realized
after
oh
that
we
couldn't
keep
up
with
maintaining
that
deep
integration
with
the
client-side
frameworks
that
we
were
integrating
with,
which
was
angular
and
react,
and
something
else
at
the
time.
I
can't
remember
because
it
all
changes
so
quickly.
A
So
we
moved
to
a
different
model
for
our
spire
templates,
where
we
just
use
the
the
CL
eyes
that
came
out.
So
there's
an
angular
CLI
and
a
react
CLI
we
started
using
those
instead
and
then
we
have
this
little
folder
in
the
project.
That
is
just
a
client
side
app
and
then
we
lost
a
bunch
of
the
integration.
So
the
web
pack
middleware
the
server-side
pre-rendering
middleware,
which
is
what
used
well.
They
both
did
actually
used
the
node
services
and
spire
services.
A
We
stopped
using
those
in
the
templates
into
one
and
they
became
legacy
effectively
at
that
point
because
to
way
we're
now
support,
and
then
we
didn't
use
them
into
one.
So
the
decision
was
made
in
302
because
we
weren't
using
them
anymore
and
we
and
they
didn't
particularly
see
a
future
for
it
to
deprecated
those
so
obsolete
them,
so
they're
still
in
3
X.
Now
we
have
heard
feedback
since
that
decision
that
there
are
a
whole
bunch
of
folks
using
the
node
services
stuff
in
particular,
and
it's
problematic
and
so
Dan
who's.
A
B
All
right
cool.
Thank
you
very
much
for
walking
through
this
and
as
a
reminder
for
people
watching
when
the
show
ends.
There's
a
link
to
suggest
upcoming
shows
so
we've
got
some
great
shows
lined
up,
but
okay,
David
Fowler
lined
up.
We
got
Dan
Roth
talking
about
blazer
updates
got
that
deployment
one,
but
so.