►
From YouTube: .NET Design Review: GitHub Quick Reviews
Description
00:00:00 - Approved: Implement global proxy configuration for HttpClient https://github.com/dotnet/corefx/issues/36553
00:34:19 - Approved: HttpClient.DefaultRequestVersion https://github.com/dotnet/corefx/issues/37224
00:47:46 - Approved: add Netlink, Packet and Can to AddressFamily and ProtocolFamily enum https://github.com/dotnet/corefx/issues/35143#issuecomment-488053098
A
All
righty,
so
we
have
some
conference
projection
issues,
so
we
all
look
at
our
laptops
right
now.
You
can
see
the
blue
screen
in
the
background,
so
it's
not
really
helping
our
case,
but
basically,
when
I
look
at
to
httpclient
issues
before
we
go
over
the
other
ones,
w
preference
for
which
one
first
of
the
proxy
proxy.
C
C
So
we
have
a
lot
of
blocking
issues
already
where
people
can't
even
do
you
get
restore
you
know,
because
it
uses
HTTP
cuz
they're
on
a
corporate
network
that
uses
default
credentials
requiring
on
a
proxy
and
there's
no
way
to
tell
any
of
the
components.
They
should
do
that
so
basically
we're
trying
to
replace
app
config,
which
we
don't
haven't
gotten
in
court
generally,
and
we're
also
trying
to
replace
a
common
pattern
that
people
used
in
the
framework,
which
was
a
method
called
web
request.
C
That
was
the
actual
type
dot
default
web
proxy,
which
was
the
static
property.
They
moved
away
from
all
of
the
web
request
classes
because
we
considered
those
legacy
they're
part
of
our
system
that
requests
namespace
type
and
library.
So
basically,
what
we
need
to
do
is
add
back
something
that
enables
customers
to
latch
on
to
what
what
the
default
proxy
is
and
the
default
proxy
now
is
cross-platform.
So
it's
not
just
when
I
net
settings
and
Windows
it
can
be
environment
variables.
C
We've
also
enabled
environment
variables
for
Windows
as
well,
so
they
get
the
same
experience
across
all
the
platforms,
OS
X,
Linux,
etc.
So
this
kind
of
completes
the
rest
of
the
puzzle,
oh
for
global
proxy
config,
and
enables
them
to
set
just
credentials
if
that's
what
their
environment
is
or
have
a
hard-coded
proxy,
which
a
lot
of
customers
did
in
the
existing
app
config.
We
already
have
an
existing
schema.
That's
a
framework
add
for
system
net,
a
lot
of
interesting
things
and
people
keep
complaining.
Where
is
that?
C
Where
is
that
there's
a
plan
that
someone
else
can
write
a
compat
layer
that
basically
will
parse
the
XMP
old
style,
XML
file
or
Jason,
follow
wherever
people
want,
but
we
need
an
API
mechanism
in
core
that
could
enable
those
scenarios
because,
of
course
we
don't
have
a
direct
config
replacement
in
core
so
anyway.
This
is
really
this
property's,
all
about
and
kind
of
completes
our
enterprise
authentication
scenarios
for
proxies
so
that
someone
can
inject
the
credentials
using
the
default
proxy,
there's
a
credentials
property
on
it
or
they
can
inject
a
separate
proxy.
C
C
That's
making
these
HTTP
clients
for
everybody,
and
they
don't
have
direct
control
and
the
one
thing
you
know
they
want
to
be
able
to
control
as
being
on
a
network,
that's
not
under
their
control,
so
they
need
to
inject
sort
of
a
little
bit
of
configuration,
and
this
is
how
they're
going
to
do
it,
and
it's
very
similar
to
the
pattern
we
have
in
framework.
It's
just
on
a
different
type,
with
a
slightly
different
name.
D
So
I
had
a
little
bit
of
confusion
about
what
you
just
said.
So
you
had
mentioned
that
in
the
past,
in
full
framework,
we
would
be
able
to
throughout
config
specify
proxy
settings.
Did
you
say
that
the
intent
here
was
also
to
allow
something
similar
to
that
or
to
allow
or
or
or
is
the
idea
going
to
be
that
if
I'm
an
application
developer
I
should
a
tap
start
read
a
value
from
somewhere
and
then
call
those
properties?
No.
C
If
you're
an
app
developer,
you
can
use
this
API
directly,
okay,
but
there
will
be
customers
that
say
we
live
and
we
have
components
that
just
we
like
defining
app
config,
and
you
guys,
you
know
we
wrote
a
thing:
that'll
parse,
app,
config
and
kind
of
emulate
everything
it
did.
We
just
need
api's
to
make
it
work
cook
up,
and
now
we
have
an
api
to
make
it
work.
So.
D
D
A
C
You
don't
implement
it,
you
do
a
get
and
you
automatically
get
something
useful.
You
automatically
get
these
the
proxy
up,
that's
defined
on
the
system
settings
on
the
platform.
It's
basically
it's
an
it's
an
object
model
of,
what's
already
defined
on
the
platform,
and
now
we
have
a
mechanism
like
there's
two,
this
two
basic
use
cases
I
put
in
the
sample.
Api
usage.
C
Part
of
this
issue
right
here,
there's
the
case
where
I
just
want
to
use,
what's
defined
already
on
the
machine
like
I
met
when
I
net
settings
and
the
IE
or
an
OS
X,
there's
max
settings
or
on
Linux
I,
have
environment
variables
or
maybe
I
have
environment
variables
on
the
other
machines
too.
But
I
there's
no
way
for
me
to
say:
I
want
to
use
default
credentials,
so
I
need
a
place
to
inject
that-
and
this
is
the
this.
Is
the
mechanism
so
default
proxy?
The
default
value?
C
The
initial
value
of
this
property
is
non
null
and
it
represents
an
object
that
you
can
set
the
existing
properties
on
it
already
exposed
that
this
property
exposes
the
iweb
proxy
interface,
that's
already
defined
in
the
framework
and
core,
and
it
has
a
mechanism
that
you
can,
just
as
you
see
just
set
credentials
and
now
once
you
do
that
one
line
now
it
will
use
the
system
proxy,
but
now
it
will
be
able
to
carry
the
using
credentials
and
get
through
of
the
authenticating
proxy.
That's
the
that's
the
one
important
use
case.
D
C
A
C
So
I
was
describing
so
what
I
was
describing
here
is,
irrespective
of
us
doing
this
API
mm-hmm
it's.
This
is
what
we've
now
enabled
in
dotnet
core.
As
of
three,
oh
in
the
master
branch,
where
we
have
a
consistent
mechanism
or
because
environment
variables
had
been
a
very
traditional
way
on
Linux
and
customers
also
were
asking
for
I
wanted
to
work
the
same
on
Windows
two,
because
I
have
all
these
docker
containers.
C
So
as
part
of
broadening
the
scenario
we
made
environment
variables
work
in
a
consistent
way,
you
have
environment
variables
that
are
certain
set
defined.
It
will
use
that
as
the
basis
of
the
platform,
proxy
definition,
but
environment
variables
alone,
don't
capture
the
credentials
that
you
want
to
inject.
So
all
of
us
describing
here
is
well.
How
else
is
this
used
with
the
rest
of
the
mechanisms
that
we've
already
enabled
in
core?
E
F
C
A
F
C
On
so
so,
I'll
turn
that
question
and
say:
is
there
a
way
to
configure
HTTP
client
not
to
use
a
system
configured
proxy?
That's
the
way,
I'll
turn
your
question
around,
because
the
environment
variables
are
just
another
way
of
saying
I
have
when
I
net
settings,
which
also
say
use
a
proxy.
So
is
there
a
way
it
needs
to
be
client
to
say,
don't
use
system
proxy
settings,
and
the
answer
to
that
is
yes.
C
In
general,
HP
client
has
a
mechanism
when
you
create
an
instance
of
it
to
say,
use
proxy
false
and
it's
not
going
to
use
any
proxy
at
all,
no
matter
what
adding
this
is
also
now
an
additional
mechanism,
because
you
could
inject
a
default
proxy
with
the
setter
and
your
my
proxy
custom
proxy.
Basically
is
no
proxy.
You
sure
that
you
define
the
bypass
setting
and
now
you
don't
use
it
for
experiments.
Oh
yes,
and.
C
Talked
to
AST
net
in
the
sense
of
they
can
in
they
can
use
this
mechanism
if
they
want
and
call
it
their
app
settings
Jason
right
now,
I
mean
they
define,
they
may
define
their
own
schema
they
if
they
want.
If,
if
they
want
to
enable
config
like
things
to
sort
of
replicate
the
XML
schema,
we
had
an
app
config
web
config.
They
can,
they
can
define
it
whatever
they
want
it
to
be,
hopefully
it'll
be
similar
and
they
can
use
this
API
to
make
it
work.
G
C
E
D
E
E
C
One
way
it
will
never
return
Norrell,
even
if
you
so,
if
you
didn't
define
any
environment
variables,
it
will
still
return
this
object,
but
the
object
will
have
sort
of
the
side-effect
of
its
bypass.
B
C
You
can
so
we
can
decide
that
was
sort
of
an
implementation
behavior.
We
were
trying
to
like
figure
out
what
made
sense,
because
either
way
the
issue
with
Linux
right
now
is
Linux
is
the
one
OS
platform
where
we
don't
have
two
choices
of
system:
proxy
settings
on
Windows.
We
have
environment
variables
and
if
they're,
not
there,
we'll
use
IE
settings
which
of
course,
IE
settings
may
result
in
no
proxy
either
and
then
the
same
for
OSX.
We
can
still
choose.
C
C
C
Really
is
the
same
thing
even
on
even
on
Windows.
At
the
framework,
the
default
proxy
and
web
request
was
non
null.
Even
if
IE
settings
had
all
the
boxes,
unchecked
or
IE
settings
said
I'd
like
to
discover
a
pac
file
and
of
course
there
wasn't
one
on
the
network,
so
it
would
still
return
a
non
null
object,
but
the
effect
was
you
never
went
through
a
proxy,
so
that's
fine
I
can
make
thing.
We
can
do
that
and
then
then
we
have
a
consistent
story.
A
C
We
do
actually
we
have
a
web
proxy
class
that
we
can
use
and
it's
a
sort
of
a
simple
kind
of
class,
and
you
can
give
it
some
interesting
little
parameters
when
you
create
it.
It
actually
has
a
history
of
there's
some
brokenness
in
it,
and
I
didn't
really
even
want
to
attach
anything
more
to
that
class.
We
have
it
for
compatibility.
C
We
have
some
other
weird
methods
related
to
it
that
return
instances
of
web
proxy
instead
of
an
interface
and
I
web
proxy,
which
we
didn't
want
to
do,
but
there's
a
lot
of
interesting
historic,
fifteen
plus
year
old
comments
and
framework
that
say
wow.
This
was
really
broken,
blah
blah
blah,
but
anyway,
that
answers
your
question.
Yeah.
If
developers
don't
even
want
to
implement
the
three
methods
of
iWeb
proxy
for
custom
proxy
shorts,
they
can
just
uses
the
web
proxy
class
for
a
quick
conversion.
H
H
C
C
C
In
general,
you
don't
know
for
sure
when
you're,
if
you're
using
a
proxy,
unless
you
call
the
get
proxy
method
of
the
proxy
with
a
destination
URI,
you
know
and
it
returns,
whether
you're
being
bypassed
or
not.
We're
we're
basically
returning
an
object
model
of
something
that
represents
the
settings
that
tells
you
like.
This
is
how
you
can
figure
out
if
your
destination
URI
actually
goes
through
a
proxy
many
times.
C
If
you
know
you're
on
a
corporate
network,
there's
a
JavaScript
pack
file
that
got
fetched
and
it's
got
a
complicated
algorithm
for
figuring
out
for
certain.
You
are
eyes
you're
going
through
proxy
one
for
certain
your
eyes,
you're
going
through
proxy
two
for
other
your
eyes,
you're
going
direct
and
so
to
answer
the
question
about
whether
you're
going
through
a
proxy
depends
on
what
URI
you're
providing.
So
it's
it's
really
a
function,
but
it's
an
argument
passed
to
a
function
and
but
you
could
tell
if
you
are
actually
since
we're
always
returning
a
non-null
object.
C
F
A
Right,
you
think
the
question
from
Fredrik
was
probably
more
along
the
lines
of
like
you.
If
you're
in
Linux,
no
environment
variables,
I
could
figured
the
environment
settings
are
basically
saying:
don't
use
the
proxy,
then
the
instance
we're
giving.
You
is
basically
in
null
instance
by
the
base.
It
just
says:
don't
do
anything
and
how
would
you
know
that
and
the
answer
from
you
would
be
you
shouldn't
special
case
that
you
should
just
generally
assume
yeah.
C
H
Only
question
is
purely
about
naming
and
I:
don't
have
a
agenda.
Here's
just
a
question:
every
other
property
on
httpclient
controls
that
instances
behavior,
whereas
I
think
this
is
the
first
static
we're
talking
about
adding
HTTP
clients.
So
we
should
be
sure
that
this
is
where
we
actually
want
to
put
it.
And
then
you
know
from
a
naming
perspective
default
probably
makes
sense,
but
the
next
api
we're
looking
at
I'm
proposed
that
it
also
be
prefixed
with
the
halt.
H
But
it's
actually
the
pros
as
an
instance
and
it's
affecting
something
where,
where
that
also
makes
sense.
But
now
we're
gonna
have
two
defaults
that
both
make
sense
for
their
own
thing,
but
one
of
them
being
a
static
and
one
of
them
being
an
instance.
So
I
just
want
to
make
leave.
Maybe
we
should
like
I
mean.
C
Is
this
the
default
request
headers
on
on
HTTP
client
I
mean
if
we
don't
like
default
proxy
I
used
the
word
default
because
historically
we
had
default
web
proxy
on
the
web
request
method.
You
know
we
could
also
use
system
proxy.
You
know
or
platform
platforms
kind
of,
not
a
great
word.
I
know
systems.
A
great
word
I
mean.
H
C
Thought
it
was
I
thought
it
was
the
least
bad
of
all
names
and
and
not
and
not
and
not.
It
was
also
discoverable
Morton,
because
people
would
be
looking
to
ask
about
web
request
default
web
proxy
and
you
know
we're
telling
them
a
web.
Hd
client
is
the
thing
you
should
be
thinking
about
using
now
and
and
so
it's
I
thought
it
was
more
discoverable.
D
Yeah
I
mean
I
think
the
only
thing
that
I
would
stay
at
all
based
off
of
Steve's
raising
the
point.
Eight,
this
be
on
a
separate
class
called
something
like
HTTP
client
defaults,
so
that,
if
you
have
other
static
defaults
in
a
sort
of
these
are
the
Global's.
And
then
these
are
the
instances
so
and
yeah.
C
So
I
I
thought
about
that
and
it
sort
of
brought
me
back
to
the
horror
service
point
manager,
which
was
the
other
sort
of
global
class
that
then
everything
else
depended
on
and
I
sort
of
thought
like
I
didn't
want
to
go
there,
and
so
that's
why
I
thought
that
it
was
more
discoverable
to
just
put
it
on
the
thing.
That's
ninety
nine
percent
you're
using
it
with.
So
that's
why
I
wanted
it
on
HP
client.
C
Klein
factories,
not
a
thought
net
core
class,
it's
something
that
got
created
grow
as
a
workaround
for
the
fact
that
our
HTTP
stack
doesn't
do
true.
Ttl
timeouts
of
you
know
on
DNS
and
connections,
and
it
was
created
as
a
nice
workaround,
but
eventually
we
expect
HP
client
factory
not
to
be
needed.
Once
we
improve
our
stack
to
be
more
aware
of
like
time
to
live
on,
DNS
records
and
stuff,
we.
A
I
D
Now
you
can't
like
when
you,
because
intellisense
doesn't
as
far
as
like
well
doesn't
that
really
distinguish
between
instance
and
static
you're
on
an
either
you're
on
an
instance
of
the
thing
and
you
hit
dot,
you
see
all
the
defaults,
but
what
you
really
wish
is
that
it
only
showed
you
the
static
ones,
on
the
static
type
in
I.
Believe.
A
E
C
A
No
now
I
think
the
problem
is
more
if
you
want
to
have
an
instance
method
and
a
static
method
with
the
same
name,
because
that
does
the
fly
as
I
all
doesn't
support
them
because
they're
not
different
instances
a
mile,
but
thinking
too
sharp
they're,
separate
namespaces,
but
I
agree
with
Stephan,
like
from
the
point
of
view
like
it's
the
first
one
you
know
do
we
want
to
have
said
that
I
mean
what
if
we
do
other
things
like
before
proxy
like
this
is
a
good
place
to
put
it.
If
so,
then,
let's
do
it.
F
A
D
D
E
H
H
Hp
client
wraps
that,
with
some
helpful
functionality,
there's
also
a
send
async
that
just
kind
of
goes
directly
through
to
the
handler,
but
it
layers
on
functionality
like
some
some
nice
helpers
for
just
saying
just
get
string
async
like
get
me
the
whole
contents
of
the
response,
as
a
string,
so
just
a
one-shot
call
or
get
bytes
async,
or
it
allows
you
to
have
it
handle
offering
the
response.
If
you
don't
want
to
do
it
yourself
and
so
on.
H
All
those
helpers,
though,
because
there's
sort
of
this
one-shot
thing
layered
on
top
of
that
send
async
they
end
up.
Creating
that
HTTP
request
message
for
you,
so
you
know
they
rather
than
you
saying:
VAR
M
equals
new
HP
request
message
configure
it.
However,
you
want,
and
instead
fast
office
and
async
HP
client.
Does
that,
on
your
behalf,
HP
request
message:
has
a
version
property
on
it
and
that
controls
the
protocol
version
that
the
underlying
handler
uses.
H
So
if
you
specify
one
point,
one
you'll
be
using
HP
one
point
one:
if
you
specify
2.0
you'll
you're
asking
for
the
handler
to
do
hb2,
but
with
HP
client
creating
that
message
for
you,
you
have
no
way
to
control
what
version
it
sets
it
to
and
that's
a
pretty
important
thing
to
be
able
to
control.
So
what
this
would.
H
Like
HP
client
has
default
request,
headers
or
whatever
the
property
is
called
where,
basically,
when
it
creates
one
of
these
message
hit.
One
of
these
request
messages.
It
populates
the
headers,
with
whatever
you
specified
in
that
collection,
ihb
client.
This
does
the
same
thing
when
you,
when
it
creates
a
request
message
for
you,
it
will
populate
the
version
with
the
version
you
specify.
Now
there
is
one
small
difference
and
it's
worth
talking
about,
and
that
is
for
better
or
worse,
the
way
that
that
default,
request,
headers
property
is
implemented
today.
H
It
adds
those
to
every
message
that
you
send,
regardless
of
whether
it
creates
the
message
for
you
or
not,
whereas
this
default
request
version
would
really
be
a
default.
If
it's
creating
the
message
for
you,
it's
going
to
set
it,
but
if
you
just
give
it
a
nature,
you
request
it
wouldn't
touch
the
version
at
all.
A
C
So
I
must
tell
you
the
background
of
this.
Is
we
thought
a
year
ago?
Maybe
we
were
gonna
come
here
with
opt-in,
opt-out,
we're
adding
h-2b
to
feature,
and
we
thought
maybe
we'd
have
a
version
and
then
actually
we
had
a
conversation
about
it
at
the
time
and
we
actually
had
it
in
a
different
format
and
it
was
decided
we're
not
ready
to
have
this
API,
because
we
don't
know,
you
know
why
we
adding
it.
Is
it
because
we
want
off
tin,
we
want
opt-out,
and
so
it
was
decided.
C
Then,
if
you
just
want
to
play
around
with
the
experiment
of
the
experimental,
then
at
the
time
HB
2
then
use
app
context
using
environment
variable
just
allow
people
to
try
it
out
and
come
back
to
us
later.
When
you
have
an
API.
Now
we're
coming
back
with
an
API
and
that's
kind
of
why
there's
a
DejaVu
going
on
here
about
this
yeah.
A
I
thought
there
was
some
issue
that
I
think
they
discussed
at
some
point
where
somebody
suggested
adding
an
default
member
to
HTTP
version,
which
would
basically
be
in
max
video,
and
then
it
would
just
use
the
highest
version.
That's
available
on
an
open
platform
which
might
be
too
low
for
someone.
One
fatherÃs
and
I
think
we've
rejected
that
one,
and
that
might
be
because
we
talked
about
that
one.
But
I
have
definitely.
C
C
Is
we
tweaked
one
of
our
classes,
HP,
request,
method
to
feed,
request
message
and
we
said:
let's
make
the
default
version,
property
be
to
O
and
then
maybe
stuff
will
just
light
up
and
it
actually
works
that
way
for
you,
80
and
we're
gonna
leave
that
behavior
for
you
AP
and
master,
and
what
we
discovered
is
that
well
there's
some
things
that
we
don't
want
to
make
HP
to
the
default.
You
know
the
NT
authentication
kind
of
works
in
some
differences,
and
so
we
decided
that
we
really
the
default.
C
The
initial
value
should
be
1:1,
but
we
need
an
easy
mechanism
to
allow
people
to
turn
it
on
when
they
need
it
for
G,
RPC
and
other
reasons,
and
so
this
has
sort
of
been
the
learnings
that
live
up
to
what
Stephen
row
here
in
the
proposal
for
for
this
property.
Allow
them
in
easy
mechanism
to
turn
on
HTTP,
to
the
reason
why
we
want
a
property
on
HP
client.
Is
that
many
of
its
methods?
You
don't
pass
in
an
HTP
request
message.
C
You
just
say:
I
want
to
do
a
get
a
sink
to
this
URI,
and
so
the
question
is
well.
Who
is
creating
the
internal
HTTP
request
message?
They
have
the
version
property.
Well,
it's
HTTP
client,
it's
doing
the
convenience
for
you,
so
for
customers
that
just
use
the
less
convenient
way
they
use
a
send
async
call
of
HP
client.
Where
you
create
an
HP
request
message:
they
can
create
it
with
whatever
they
want.
C
It
defaults
to
say
one
one,
but
they
can
simply
set
the
version
property
and
for
that
request
it's
going
to
use
whatever
version
they
want,
but
this
property
is
mainly
useful
for
the
80%
case
that
use
the
convenience
methods
of
HP
client,
where
they're
not
creating
a
separate
request
message
and
we
need
a
way
or
HP
client
to
do
a
good
job
at
deciding
what
that
default
should
be
since
they're,
not
creating
it
directly
right
and
that's
the
motivation
for
this
property.
An
HTTP
client
instance
didn't
you
I,
think.
A
A
C
Discussed
it
I
discussed
it
I
kind
of
proposed
it
originally
with
Stephen
and
our
smaller
team
meeting,
and
then
we
kind
of
went
back
and
forth
on
it
and
goes
well.
The
problem
with
a
global
setting,
like
that
is,
you
would
be
affecting,
like
maybe
a
library,
that's
creating
HTTP
these
messages
and
that
could
really
change
things.
The
way
the
library
maybe
isn't
tested
for
that
it's
different
than
like
injecting
proxy
settings
which
are
environmental.
This
is
injected.
C
A
F
C
Was
what
I
proposed
I
originally
proposed
as
part
of
this
having
a
static
property
on
request
message
itself,
which
sort
of
just
changes
every
request
message
that
anybody
or
any
layer
makes
use
this
default
instead?
But
you
know
so
we
still
have
that
ability
if
you
choose
to
go
down
that
route,
but
this
so
adding
this
property
as
an
instance
method,
HP
client
doesn't
mean
we
can't
do
the
other
thing
which
we
may
not
want
to
do
it.
Whether.
A
A
H
I
D
D
G
C
Yeah
that
that's
in
general,
how
H
to
be
to
works
it
its
first
actually
does
the
TLS
connection
and
in
in
the
ALP
n,
it's
kind
of
saying:
hey
I
want
to
do
a
TLS
connection,
because
I
want
to
connect
the
h-2b
tube.
So
it's
passing
that
little
h2
and
then
the
server
you
know
at
the
TLS
layer
says:
I,
don't
understand
this
no
way
and
then,
by
the
time
the
TLS
connection
comes
back.
Everyone
knows
whether
or
not
they're
gonna
be
happy
talking,
hb2
or
not
it's
something
like
requesting
them
or
something.
G
D
They
request
immersion
doesn't
its
since
it
came
down
great
that
that's
protocol
created
on
the
messaging.
You
call
it
like.
This
is
just
deciding
what
it
does
when
it
creates.
The
other
object.
That
already
has
this
property
well
default
names.
Great
cuz
I
mean
Kent
and
to
server
negotiating
101
stud.
Also,
even
if
you
say
one
one,
oh
sure
yeah,
so
it's
never
truly
honored
anyway.
Yeah.
A
A
A
A
C
Leaving
okay,
so
we're
not
talking
about
this
property
in
particular,
but
we're
talking
about
what
is
the
deep?
What
is
the
default?
The
initial
value
when
I
create
an
HTTP
request
message
and
we,
like
I,
said
we
changed
it
last
year
to
oh.
We
had
already
changed
it
three
years
ago
for
UAP,
because
we
didn't
have
this
property
on
HP
client
and
we
wanted
a
mechanism
that
would
light
up
what
we
had
done
for
you,
ap
in
the
wininet
stack
and
the
WinRT
stack,
which
was
oh.
We
wanted
the
majority
of
customers
building
apps.
C
You
know
for
the
Windows
Store
app
store
when
they
used
the
winner
when
they
used
the
system
that
HP
client,
which
used
the
WinRT
api's.
We
wanted
them
to
have
an
instant
light
up
for,
oh
because
that
was
deemed
the
the
right
choice,
and
so
that's
motivated
the
Oh
default
or
a
request
message,
and
then
we
generalize
that
last
year,
as
we
were
doing,
h-2b
to
work
for
the
rest
of
the
guttacore
stack.
C
A
C
C
When
you
change
a
major
version
and
like
I
said
by
introducing
this
property,
you
know,
in
addition
to
us
changing
the
HTTP
request
message
default
back
to
one
one:
by
introducing
this
property,
it's
a
softer
landing
for
anybody
that
needs
HTTP,
client
being
200
if
they
want
to
use
this
property
on
their
instance
of
HTTP
client
and
said
it
the
tool.
So
it's
kind
of
the
right
the
right
way
to
migrate
people
to
300
and
give
us
a
clean
way
of
making
me
to
be
to
work
for
the
G
RPC
scenarios
and
everything
else.
The.
H
I
think
we
we
would
our
ideal
would
be.
We
would
still
use
a
should,
be
client
and
we
would
have
yet
another
implementation
in
socket
HP
handler.
That's
supported,
no
quick
yeah.
That
would
be
the
ideal.
We
haven't
actually
implemented
a
means
to
know
whether
there's
anything
that
would
prevent
that.
C
C
I
mean
our
goal
is
definitely
the
client
should
work.
The
same
I
mean
all
of
these
new
transports.
Like
you
know,
hb2
and
HP
3.
They
really
don't
change
the
fundamental
like
way
that
it
still
h2p
1:1
under
the
covers
the
really
the
messaging
works
and
the
headers
there's
optimizations,
there's
compression,
etc.
You
know
and
with
HTTP
3
with
quick.
C
All
of
that,
we
may
add
little
optimizations
for
things
I'm,
even
in
the
gr
PC
world
with
me
getting
duplex
streaming
working
or
like
with
when
you
think
about
push
notifications,
there's
all
these
little
really
expert-level
things
that
are
interesting
and
if
we
need
to
enhance
the
HP
client
API
for
those
we
will.
But
we
think
HP
client
is
general-purpose
enough,
that
it
will.
It
will
continue
because
the
fundamental
building
blocks
of
what
you're
sending
is
aren't
the
same.
They
haven't
changed.
A
A
A
A
G
A
A
D
D
G
A
F
D
Don't
want
it,
you
don't
see
it,
but
if
it
just
says
like
address
family
that
can
like
I
can
certainly
given
that
that
is
a
word
in
English.
That
means
this
is
a
possibility.
I
can
see
a
lot
of
people
being
like,
oh,
maybe
that's
a
Discover
or
something
so.
The
fact
that
that
works
out
to
be
a
word
is
yeah,
so
I
think
it
would
just
call
it
controller
area
network,
and
if
somebody
doesn't
like
that
word
being
long,
they
can
they
can
make
their
own
pasta.
I
mean.
A
A
A
D
Let's
posit
a
packet
address
family
packet,
the
packet
sockets
are
used
to
receive
or
send
raw
packets
at
the
device
driver
level.
So
I
don't
know
if
we
should
call
it
raw
packet
or
we
can't
call
it
packet
socket
because
it's
only
a
packet
socket
after
you
use
the
address
to
have
a
packet
and
I
don't
have
a
Linux
packet,
but
it
seems
a
very
unfortunate
name
for
whoever
chose
it.
Then
I
guess
I.
Don't.
A
D
Think
of
a
better
different
name
from
it,
but
that's
just
from
like
30
seconds
of
looking
at
a
man,
page
I
think
it's
an
unfortunately
generic
name.
If
that
may
be
simply
the
name
of
it
but
like
searching
for
AF
packet,
you
get
you
know.
What's
the
difference
between
a
half
packet
and
a
high
net,
they
put
two
packets.