►
From YouTube: .NET Design Review: HttpClient JSON Extension Methods
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
Button
all
right
friends,
we
are
live
again
today,
we're
going
to
talk
about
or
adjacent
extension
method,
so
it
should
be
climbed
which
thankfully
I
have
actually
written
this
back
for
so
let
me
just
go
over
the
general
gist.
So
basically
the
idea
is
this
right.
You,
you
write
some
sort
of
code,
that
you
know
it
capsule
eights
getting
data
from
a
server
and
this
could
be
in
a
blazer
app
or
in
any
other
kind
of
application.
A
Where
you
talk
to
another
server
via
rest,
and
so
the
idea
is
that
very
often
what
you
just
want
to
do
is
you
just
want
to
say:
okay,
go
to
this
URL
and
then
just
give
me
the
set
of
customers
back
that
come
from
there
as
Jason.
So
the
idea
is
that
we
have
these
extension
methods
that
make
that
very,
very
easy.
A
You
would
call
it
on
the
on
the
content
object,
because
we
also
have
extension
methods
directly
on
content
instead
of
saying
get
as
jason
asing,
you
would
say,
read
from
jason
async
parts
of
the
type
and
then
we
handle
the
DC
authorization
for
you
and
then,
of
course
the
same
happens.
You
know
if
you've
more
advanced
cases
when
you
want
to
change
them
when
you
want
to
send
data
to
the
server.
A
In
that
case,
we
have
a
new
jason
content,
type
that
works
with
or
to
the
other
content
types
where
you
just
create
one
with
the
factory
method,
passing
the
customer
and
then
you
know,
simply
send
the
request
to
the
server
by
this
mechanism.
The
key
thing
of
all
these
things
is
that
we
make
civilization
much
easier
than
instead
of
you
having
to
very
important
civilization,
and
this
relation
gives
them
to
Jason
api's
just
become
effectively
very
simple
method
that
just
accept
you
know
effectively
a
tea
or
an
instance.
A
The
goals
we
have
for
this
library
is,
we
want
to
have
it
available
by
build
because
laser
wants
to
ship
stable,
buy
build
and
they
would
like
to
take
a
dependency
on
this.
That's
why
we
do
does
the
defined
role
here,
because
originally
this
plans
to
do
a
preview
by
build,
but
it
turns
out
they
wanna
have
that
in
the
project
templates.
So
in
that
case
it
has
to
be
stable
in
order
to
you
know,
for
customers
to
make
sense
of
this.
A
It's
bit
weird
if
you
have
a
stable
product,
but
then
now
the
template
that
you
instantiate
has
preview
dependencies
that
you
might
not
be
aware
of
that's
pretty
much,
the
gist
of
it
and
so
I.
Think
at
this
point,
I
would
just
look
at
the
API
surface
unless
there
are
any
more
questions
on
how
the
feature
supposed
to
work.
B
A
B
A
A
First
of
all,
XML
is
already
fairly
rare
for
rest,
api's
and
then.
Secondly,
it's
like
even
if
you
wanted
to
add
that
it
would
not
the
magic
mind
type
seem.
Probably
you
would
probably
just
have
different
methods
like
you
know,
similar
we
have
get
from
Jason
Mason,
you
would
have
and
get
from
XML
async
and
then,
if
we
really
wanted
to,
we
could
still
add
other
API.
It's
like
you
know,
get
from
a
you
know
off
key.
Basically,
and
then
you
know
do
this.
You
know
basically
do
the
dispatch
in
that
method.
E
D
E
C
A
C
C
E
A
I
mean
I,
don't
know
what
what
happened
to
PR,
because
I
kept
tracking
it,
but
it
quickly
ran
out
of
you,
know
easy
to
use
a
var
today,
I
already
had
a
hundred
comments
within
busting
of
activity
all
right.
So
basically
the
idea
is.
We
have
always
overloads
they're
taken
this
utilization
options,
but
they're
optional.
So
the
idea
is
that
you
don't
have
to
pass
them
in
one
thing
that
was
brought
up
in
the
PR.
That
I
remember
from
discussion
with
Stephen.
Is
that
the
way
we
have
it
right
now?
A
A
Right,
which
is
also
kind
of
annoying
because
it's
wrong,
the
one
thing
we
could
do
is
you
could
just
add
another
overload
that
just
takes
the
cancellation
token
as
a
non-optional
and
then
only
have
the
wrong.
One
is
optional.
By
that
don't
have
some
personal
opinions.
I
get
people
think
that
cancellation
tokens
are
commonly
pasta
and
I
think
it
makes
sense.
A
A
H
J
H
Have
a
couple
of
different
cancellation
tokens?
We
don't
generally
cancel
the
work.
That's
gonna
start
on
the
server
just
because
the
client
gone
away
because
those
people
people
thought
about
it
assumed
that
we
would
want
that.
But,
like
that's
not
usually
the
semantics
that
you
want
I'm
more
thinking
about
cases
like
the
Blazer
is
where
love
components
might
kick
off.
Some
HTTP
requests
in
the
background,
but
then
what
they
cancel
it
if
the
user,
like
navigates
away
from
the
page,
so
it's
it's
fairly
common
I
wouldn't
say
it's
like
every
usage,
I.
A
I
believe
we
have
done
this
in
places
where
we
have
multiple
overloads,
that
we've
provided
one
where
a
cancellation
token
can
be
passed
in
easy
access.
We
don't
always
do
it,
but
we
always
try
to
make
installation
token
at
least
optional,
but
there
are
cases
where
we
have
something
over
load
stead.
It
will
be
a
pain
in
the
ass
similar
to
here
where
it's
like
the
last
argument
and
you
have
to
pass
them
for
other
things.
K
B
A
A
If
you
have
to
just
say
new,
your
I
passing
the
string
anyway,
then
you
might
as
well
just
have
an
overload
for
that,
and
it
also
merits
what
the
existing
HTP
vomiting
api's
have
done
in
a
spin
and
because
I
think
the
sample
code
they
be
asking
people
will
write
it's
pretty
much.
What
I
wrote
you
know
above
way,
you
would
want
to
basically
have
a
very
short
one
line
thing
to
talk
to
the
server
and
then,
if
they
need
to
customize
more
stuff
later,
like
headers
or
whatever
they
will
do
that.
A
E
A
D
E
H
I
wasn't
around
when
the
original
code
was
written,
but
if
they're
gonna
show
up
as
extension
methods,
you
can
call
that
Stevens
suggestion
sounds
like
an
improvement.
I,
don't
think
I,
don't
think
that
that
was
probably
a
question
that
was
asked.
I,
don't
know.
Maybe
Jeff
was
around
when
the
stuff
is
on
but
like
I,
think
I
think
everybody
who
worked
on
the
original
iteration
of
the
easiest
move
on
this
one
well.
B
E
B
E
A
B
We're
going
to
use
the
HTTP
response
message
before
when
they
call
post
our
current
HTTP
client,
send
async
by
default,
will
buffer
the
response,
and
if
we
over
it,
we
have
these
as
extension
methods
just
for
the
message
invoker,
then
there
would
be
no
buffering
unless
we
added
that
feature
into
these
extension
methods.
Also
yeah.
B
E
A
H
M
G
E
E
G
A
E
E
E
Goes
for
all
of
them,
then
next
up
for
the
post
as
Jason
async,
once
the
order
of
type
and
value
is
reversed
from
what
the
Jason
serializer.
E
A
E
J
E
N
E
My
main
concern
here
is
that
we're
you
work
we're
requiring
someone
to
pass
both
the
type
and
the
value
for
what
to
me
seems
like
a
security
concern
where
we're
wiping
our
hands
and
saying
we've
done
the
right
thing,
but
everyone
in
the
world
who
calls
us
is
gonna,
then
just
do
what
we
we
decided.
We
can
won't
do
ourselves
right
ever
in
the
world
if
they
don't
have
the
type
they
want.
They're
gonna
do
dot,
get
tight
and
value
yeah.
N
N
But
when
we,
what
do
we
talk
about
this?
We
said
that
we
defended
as
long
as
the
default
behavior
is
to
use
the
statically
known
type
of
the
author,
and
you
could
opt
into
using
the
runtime
place.
Instead,
that
would
be
acceptable.
E
F
F
Mean
anywhere
that
I
mean
like
yes,
you
could
have
something
that
took
object
as
a
parameter
that
you're
passing
into
this,
but
almost
always
that
I
can
think
of
that.
You
want
to
write
something.
You
have
a
strong
type
of
the
value,
which
means
that
the
generic
one
is
gonna
pick
the
static
type
of
that
expression,
and
it's
going
to
serial
as
it
is
whatever
var
would
have
done.
Then
why
has
it
non-generic
one
at
all?
If
it's
never
gonna
be
used?
E
B
F
N
E
N
N
F
N
B
I
think
that
if
we
want
people
to
use
the
generic
type
and
the
generic
overload,
and
if
that's
the
one
that
people
will
be
using
almost
all
the
time,
then
let's
just
have
the
generic
overload
and
remove
the
object
one
and
force
people
to
use
JSON
content.
If
they
have
that
super
advanced
situation
where
they
have
an
object,
do.
E
N
N
Basically,
what
I'm
saying
is
the
the
system
checks,
Jason
serialized
api's
are
what
they
are
like:
have
HTTP
console
or
have
HTTP
clients
exactly
mirror
the
API
surface
that
we
already
exposed
in
system
taps
Jason
like
we
shouldn't.
We
shouldn't
take
this
opportunity
to
be
reinventing
what
the
Jason
serializer
does
or
what
its
API
surfaces.
What
we
should
do
is
we
should
either
expose
the
same
API
surface
for
some
phenomena
like
we
shouldn't
expose
the
broader
API
surface
for.
E
A
Yeah
I
would
say
that
me
honestly,
Jason
Steele,
as
I
was
designed
also
very
similar
right.
That
gideon
was
that
we
make
it
very
easy
people
to
see
all
I
see.
Do
you
see
all
that
stuff
effectively
a
single
line
of
code
right
and
so
now
we're
just
saying
all
the
same
audience
also
wants
to
do
this
over
the
network,
so
what
we
give
them
the
same
ability
but
doing
a
get
request
and
visualize
at
the
same
time.
Well,.
N
H
Have
these
cases
all
the
time
in
their
code,
like
I,
think
I
think
we
really
underestimate
the
amount
of
code
that
users
write
in
applications
that
is
magical
or
involve
some
reflection
or
some
interaction
like
yeah,
not
just
frameworks,
people
like
completely
happy
with
the
resolution,
but
I'm
unhappy
with
statements
like
something
is
wrong
in
your
code.
Like
people
do
this.
H
F
Turns
out
my
mute
state
was
opposite
of
what
I
thought
was
well
via.
All
that
we
really
wanted
is
if
you
have
a
static
type,
we
want
to
see
realizes
the
static
type
and
that's
where
the,
if
you
didn't,
and
therefore
you
have
object,
that's
why
it's
like
fine.
The
only
thing
this
could
do
is
either
nothing
or
be
the
polymorphic.
That
is
probably
what
you
wanted.
If
you
had
object,
though
it's
semi
polymorphic,
because
it's
only
one
level
polymorphic
I.
B
F
B
So
I
think,
having
only
a
generic
overload
right
now
will
allow
people
to
specify
the
T
explicitly
if
they
have
a
type,
if
they're
passing
in
a
value
of
a
different
but
I
wonder
how
common
that
would
be.
Maybe
that's
an
escape
hatch.
We
want
to
give
them,
but
it
might
also
make
sense
to
not
make
this
generic
and
just
take
an
object
either.
E
To
down
sights
that
one
is
the
one
that
Jeremy
was
citing,
which
is
if
someone
does
have
a
user,
but
it
happens
to
actually
at
runtime,
be
a
user
with
payroll
information,
then
with
it,
statically-typed
is
user.
If
we
cast
it
to
object,
then
we
would
end
up
serializing
the
user
with
payroll
information,
whereas
if
they
have
a
user,
they
probably
wanted
it.
That's
user.
B
E
B
E
N
And
that's
why
I
was
also
saying
earlier,
like
we,
we
shouldn't
expose
api's
that
deviate
from
what
jason
serializer
does.
We
should
expose
either
the
exact
api's
or
a
subset
of
them,
but
we
shouldn't
invent
a
new
calling
pattern
now,
if
we,
if
we
want
to
invent
a
new
calling
pattern,
we
should
do
it
on
Goosen
serializer
itself
and
then
back
one
over
here.
Sure.
A
B
F
F
J
E
We
yeah
it's
a
slightly
different
situation:
I,
don't
know
how
common
it
is,
but
if
you
don't
have
it
like
as
a
static
type
T,
but
you
have
the
system
type
for
it.
You,
if
you
were
to
just
call
the
the
generic
one
with
object,
you'd
get
the
wrong
results,
because
the
deserialize
would
have
no
idea
what
it
was
supposed
to
do.
Serialize
it.
As
do
you
have
to
provide
type
information
jump
somehow,
which
means
either
a
generic
type
parameter
T
or
a
type
object,
is.
N
H
N
K
E
K
So,
by
the
way,
that's
only
in
blazes,
like
experimental
stopgap,
II,
yeah
I,
think
we
it's
the
Web
API
client.
That
is
not
our
equal
she's
missing,
because
all
you
do
is
get
AC
coffee
and
it
calls
for
matter.
They
didn't
have
specific,
Jason
or
XML
specific
overloads,
I.
Think
that
concern
somebody
just
wanted
to
me
and
that
PR
was
that
like
get
from
Jason
a
sink
sounds
like
you
are
reading
object
that
was
listen.
K
What
Jason
hissing
sounds
like
you're
trying
to
get
adjacent
string
or
something
along
those
lines
I
kettle
take
the
actual
tea
is
not
DC
lies
from
Jason,
but
like
we've
had
like
the
laser
API
is
out
there
for
about
two
years,
and
people
haven't
had
complaints
about
it.
Then
again,
it's
not
supersonic
effect
because
we've
been
telling
people.
This
is
experimental,
its
way
to
go
away.
Yeah.
B
A
So
I
think
that
one
I
never
made
this
like
I,
think
the
original
formatting
api's
have
the
same,
naming
that
what
panel
is
saying
and
there
ought
for
even
much
longer
so
I
think
like
they
are
you
definitely
don't
for
multiple
years,
but
that's
why
I
originally
had
them
as
get
Jason
I
think
but
then
I
changed
it
based
on
the
API.
You
think
we
got
last
time
for
the
same
reason.
That
Cory
is
just
quoting
but
I
mean
I.
A
P
B
A
B
Serve
our
current
content
types,
they
don't
use
a
factory
pattern
to
create
them.
Oh
sorry,
are
we
talking
about
Jason
content
now.
A
B
E
B
B
B
That's
how
you
do
it
I
think
I'm
just
wondering
if
we
can
do
it
better,
because
I
think
usually,
if
you're
posting
JSON,
you
might
be
expecting
a
JSON
response
and
the
naming
of
the
T
generic
type
might
be
different
in
that
case,
if
you
have
two
different
generics
right
in.
E
E
E
F
A
B
We've
actually
had
a
fairly
popular
issue
that
highlighted
the
way
people
are
using
HTTP
client
today
is
they
prefer
to
not
inspect
the
response
message,
but
rather
use
the
ensure
success
status
code
thing
that
to
me
means
that
maybe
they
would
want
to
not
have
a
response
message
and
in
return
they
might
grab
an
object,
type
or
something
I
mean,
but
I
think
we
can
add
that
later
we
can
have
like
a
minimum
bar
today.
There's
no
reason
to
put
it
on
Mouse.
It
complicates
things
given.
A
That
the
caller
cannot
name
the
generic
argument
anyway,
it's
just
more
documentation
within
the
overload
than
anything
else.
So,
even
if
we
have
to
add
an
overload
when
you
can
pass
in,
you
know
two
T's,
it's
fine
in
that
I
think
switches
from
t
video
to
no
T
request.
He
responds
to
just
you
know,
make
it
clear
where
they
go.
I,
don't
think.
That's
that
bad
either
I
mean
I'm,
always
more
concerned.
F
I
sort
of
feel
like
we
would
want
a
different
method
group
for
the
thing
that
Otto
deserialized
as
well,
because
it
is
a
different
semantics,
because
it's
gonna
throw
one
non
success,
codes
versus
the
one
that
doesn't
which
gives
you
the
message
and
then
you
inspector
response
codes.
So
it
doesn't
feel
like
an
overload.
It's
it's
a
it's
a
new,
it's
a
new
thing,
I
think
it
has
value
it's
just
what.
A
F
F
A
All
right
so
then
I
mean
while
I
was
just
digging
around
in
the
in
the
formatting
api's,
it
seems
I
may
have
actually
up
or
I
just
did
what
ryan
told
me
over
the
wire,
because
the
I
cannot
find
any
get
api's
they
take
Jason,
which
is
basically
what
people
said
it
earlier.
So
it
seems
like
if
you
talked
about
the
naming,
then
what
are
the
names
that
we
want
to
have
for
these
methods?
So
we
said
no,
it's
definitely
here.
A
L
The
mouse
they
as
they
are
removing
from
does
give
me
that
feeling
that
I'm
actually
going
to
get
some
sort
of
Jason
type
object
back.
Not
my
deserialized
object.
I
just
get
Jason
async
doesn't
feel
right
to
me
get
from
Jason.
It
makes
me
it
does
make
me
stop
and
think
for
a
second
but
then
I
land
on
the
expectation
that
it's
going
to
do
what
it's
going
to
do.
K
M
A
F
E
No
I,
the
Jason's
name,
makes
total
sense
to
me.
I
was
questioning
post
Jason
versus
post
on
Jason,
but
I.
Think
I
are
just
in
my
head
and
argued
myself
down
from
that
and
that's.
If
T
is
a
string,
then
I
think
post
Jason
is
probably
ambiguous
about
whether
that
string
just
contains
the
Jason
to
be
sending
or
whether
it's
actually
gonna
do
some
sort
of
transformation
to
convert
it
into
Jason,
whereas
post
as
Jason
makes
it
pretty
clear
that
there's
a
conversion
happening
yeah.
A
Ten
minutes
in
you're,
almost
done
with
the
API
service,
I'm,
actually
surprised,
I
thought
I
have
to
weigh
in
all
right.
So
no
the
content
one.
So
it
should
be.
The
same
pattern
went
from
Jason
async,
except
this
one
is
over.
It
should
be
content,
so
we
are
saying
here
we
leave
the
type
in
and
believe
the
generic
one
right.
So.
E
Yeah
institution
method-
there
are
a
few
things
here.
One
is
the
the
discussion
around
the
type
end
value
and
I
think
we
were
saying
we
would
leave
that,
and
you
know
if
he
just
had
an
object.
You
would
just
bind
to
the
create
to
the
generic
one.
However,
that
does
highlight
that.
There's
an
asymmetry
here
between
the
generic
and
the
non-generic
so
for
the
non-generic
use
the
constructor
for
the
not
for
the
generic
you
use
create
methods
to
me.
E
Otherwise,
it's
like
you
know
the
the
argument
from
earlier
was
well.
If
you
just
you,
can
just
pass
in
your
your
value
and
we'll
use
whatever
it's
typing
is
and
if
it
happens
to
be
check
them,
we'll
call
get
type
that
doesn't
work
when
someone
just
says
new,
JSON
content
and
there's
no
generic
option
or
when
they
say
Jason,
content,
dot,
create
and
there's
no
non-generic
option.
B
E
E
Mean
you
could
argue
that
I
guess
my
concern.
It's
you
know
the
the
Jason
content
dot
create
methods
they
can
be
used.
If
you
just
have
an
object,
so
they
can
be
used
for
the
non
generic
thing
as
well.
My
concern
with
the
Constructors
is
primarily:
are
people
gonna,
even
notice
the
create
methods,
if
they
just
say
in
your
JSON
content,
and
their
only
option
is
to
pass
in
a
type
in
a
value.
A
A
E
K
K
K
E
F
Like
I've
just
found
especially-
and
maybe
it's
you
know,
when
writing
tests
and
overly
helpful
things
of
that,
I've
lost
the
ability
to
strong
type
things
and
then
the
only
way
that
you
can
call
the
generic
is
by
grabbing
the
reflection
and
getting
the
the
method
info
and
then
calling
create
type
like
it's
it's
annoying.
But
if
you
know
the
type
that
you
wanted
and
you
have,
you
can't
strongly
type
the
call.
As
far
as
the
compiler
is
concerned,
the
non
generic
one
gives
you
an
escape
valve.
A
L
The
cases
where
I,
wouldn't
that
I
can
think
of
not
having
the
type
at
hand
as
if
I'm
writing
my
own
data
access
layer.
This
is
just
a
real
thin
shim
over
top
of
this
layer,
so
I
can
do
centralized
error
handling
and
things
like
that.
It's
not
that
big,
a
deal
just
drop
down
one
layer
and
deal
with
content
directly
and.
E
E
O
E
R
F
E
L
F
E
A
I
think
what
Stephen
is
saying
is
that
the
if
you
so
the
problem
is
because
it's
in
it
only
property
right
so
like
if
you
derive
from
JSON
content,
you
have
a
JSON
content
of
T.
That
constructor
has
to
do
something
right,
and
so,
if
this
thing
is
not
virtual,
then
you
can't
make
it
lazy
right.
Basically,
the
base
type
will
always
have
to
assign
this
thing
and
that
that's
when
the
boxing
happens,
unless
you
yeah
dispatch
to
a
virtual
internal
method
right,
oh.
M
A
E
F
F
F
E
A
F
E
A
A
B
A
E
A
B
A
O
In
order
for
that
to
work,
you
need
to
create
a
media
taker
value.
That
array
specifies
the
encoding.
B
A
Like
for
these
kind
of
things,
my
care
level
is
almost
zero,
because
if
you
do
the
wrong
thing,
you
really
get
an
actionable
exception
right.
It's
not
dumb
thing
to
make
something
doesn't
work
at
all
or
whatever
like
it.
What
work,
but
it
will
tell
you
why
it
doesn't
work,
every
touch
it.
What
to
do
away
so
I.
Think!
That's!
A
A
I
mean
if
your
argument
is
like
the
media
type
is
ill-defined
as
a
string
and
we
should
only
take
the
header,
video
I.
Don't
have
much
to
say
for
that,
because
I
I
think
the
only
thing
I
remember
is
that
Ryan
mentioned
that
screen
is
common,
but
I,
don't
know
how
strongly
you
thought
about
that.
So
we
could
just
see
you
know,
you
know
what
we
are
doing
with
this
I
mean
you
could
just
say
we
start
with
only
having
media
type
at
a
vegan
and
see
what
Ryan
says.
A
A
B
L
B
L
K
A
media
type
can
have
a
chance
at
that.
She
feels
like
the
encoding
type.
You
just
have
to
fall
like
the
bars
over
the
Lord
rather
than
like
calling
the
constructor
and
that
you
that
should
be
able
to
like
support
both
those
things.
Sophie,
you
know
in
the
string
media
type
if
I
simply
call
the
parse
API
instead
of
the
constructor
like
you
should
be
able
to
specify
a
string,
D
formatted,
you
know,
text
elastase
and
jaws
it
equal
to
utf-8.
K
A
Well,
the
hell
with
it,
let's
start
with
just
because
I
mean
I,
don't
like
the
idea
of
having
like
six
overloads
because
they
already
have
generic
on
generic
and
then
there's
already
lots
of
various
things.
So
what
movie
just
started?
The
only
heavy
media
type
header
video
and
you
construct
that
guy
love.
Where
you
see
fitting
you
have
to
pause
that
guy
in.
E
B
A
F
M
A
But
I
mean
overrides,
are
transparent
and
I
like
I
mean
like
it
just
means
I
mean
you
can
always
call
them
an
existing
base.
Is
that
the
in
il
they
would
skip
it?
It
just
means
that
when
you
do,
when
you
derive
from
the
type
and
you
call
base,
you
might
get
rid
behavior,
but
you
can't
derive
from
these
types.
The
users
will
not
be
able
to
observe
that.
A
E
A
Also
I
would
say,
like
this
team
is
only
a
fine.
We
generally
are
very
liberal,
with
Fred
Schultz,
and
even
though
we
know
there
is
a
burgeoning
polymer
virtual
is
what
people
derive
from
it.
I
can't
remember
a
single
case
where
this
has
did
not
oh
I'm,
quite
okay,
with
saying,
even
if
that
results
in
some
weirdness
a
long
time
senior.
This
is
a
real
scenario,
but.
F
C
Yeah
I
think
that
the
concern
with
splitting
the
ref
is
basically
only
when
yeah
yeah
yours
playing
internet
crap
as
well,
but
it
you're
also
shipping
the
assembly
in
box,
which
I
don't
think
that
it's
been
decided
yet
for
this
one
I
think
that's
when
the
concern
happens
and
and
the
concern,
as
you
pointed
out,
Jeremy
is
when
automatic
roll
forward
comes
into
play.
So
for
this
one,
that's
not
yet
decided
I
believe.
So
it
might
be
something
that
we
don't
have
to
concern
ourselves
with
yet,
but
but
we
should
check
with
Eric
cuz.
E
They
can't,
let
me
understand
the
situation,
so
it
basically
be.
We
put
this
in
box
and
down
at
five
and
then
we
ship
a
new
version
of
the
OOP
package
that
includes
additional
surface
area
such
that
it
doesn't
and
in
dotted
5.
We
add
overrides
that
don't
exist
in
the
hoop
and
then
someone
builds
against
that
new
version
of
the
sorry.
C
Recompiling
you're,
fine,
that's
what
I
meant
what
the
problem
is
with
Auto
roll
forward
so
like
if
you
compiled
against
the
net
standard
1
3
acid,
but
then
you
try
to
run
a
newer
framework,
so
let's
say
dotnet
5,
which
has
extra
overloads
and
then
the
assembly
also
ships
box.
So
like
some
somebody
inside
the
ship
framework
is
trying
to
call
the
new
overloads,
but
your
your
app
config
file,
it's
tying
back
to
the
net
standard,
1/3
version
of
it
which
doesn't
have
the
overloads.
So
that's
when
mismatch
can't
happen
yeah.
So
that
is
kind.
E
C
Doesn't
ship
in
a
package
anymore
right
so
like
we
have
system
nation
to
be
packages,
but
just
like
for
legacy
stuff,
so
we
don't,
we
don't
keep
proving
it.
So
that
would
be
a
difference.
In
this
case
we
are
still
we're
still
adding
stuff
into
the
next
energy
roll
surface
area.
So
that
would
be
difference.
F
F
E
F
B
A
Earlier,
like
what
the
expectation
is
right,
we
ship
this
table
in
Maine,
maybe
ship
another
stable
version
of
our
stuff
in
flight,
but
between
500
and
in
May.
I
can
totally
see
us
getting
feature
requests
and
then
saying:
oh
yeah,
let's,
let's
add
this
over
okay,
because
you've
already
running
production,
Epson
blazer
right
sure.
What
about
what.
A
C
A
C
Yeah
that
might
make
it
yeah.
We
would
have
to
think
about
that
a
little
bit
more
see
what
it
means
but
like.
Ideally,
if
this
is
something
that
we're
only
gonna
ship
for
net
sender
to
go
for
a
blazer.
What
we
can
do
is
just
like
create
the
package
on
release
three
one
branch
and
then
just
remove
it
in
runtime,
repost,
cuz
I
mean
and
runtime
repos
just
kind
of
ship
as
part
of
the
framework.
C
G
K
The
thing
that
we
ship
in
me
is
net
standard
to
one
based.
It's
like
based
off
of
mono
Azam,
and
that
said,
like
I,
wouldn't
expect
I
mean
even
if
there
are
feature
requests,
I
think
it
should
be
fine
to
tell
people
like
hey,
you
can
be
it
until,
like
the
end
of
the
year,
people
have
been
making
do
with
their
own
implementations
all
this
file
if
they
had
to
like
unlock
themselves
so
like
telling
them
made
a
couple
of
months
is
not
too
bad.
Well,.
A
I
mean
they
should
I,
don't
agree
with
you.
My
problem
of
these
kind
of
decisions
is
that
I
like
this
to
be
a
policy
decision,
not
a
technological.
You
know
how
that's
the
only
thing,
a
new
decision
right
because
I
mean
if
the
buck
is
bad
enough
or
if
the
feature
request
is
urgent
enough
buy
some
money
like
I
think
we
should
be
able
to
do
it.
Whether
we
do
it,
then
it's
a
different
thing,
but
it's
pretty
bad.
C
So
it
won't
be
frozen
until
we
in
bucks
it
somewhere.
So
if
like
well
we're
fine
with
like
shipping
one
version
right
now
in
release
three
one,
because
we're
only
going
to
ship
out
an
instant
or
200
ref
assembly,
so
yeah,
there's
gonna
be
a
split
in
ref
assemblies,
but
that
won't
be
shipped
until
we
ship
neck
or
five.
A
K
A
Neck
as
I
don't
care
honestly
at
that
point,
I
would
say:
yeah
I
think
it's
fine.
If
we
convert
the
API
service
between
now
and
November
and
then
post
November
I
think
it's
fine
to
people
like
you
have
to
mostly
five
law
and
then
the
only
outcome
is
okay.
They
may
have
some
issues
between
previews,
but
that's
fine.