►
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
Welcome
to
the
asp
net
community
stand
up,
so
we
have
a
special
guest
today,
Ryan
Nowak
hi,
John
hi,
everybody
how's
it
going
I
will
answer
for
everyone
and
say
great
yeah
I'm
happy
to
have
you
on.
So
this
is
a
thing
that
we're
doing
now
is
Damien
cannot
make
Tuesday
mornings,
which
is
awesome,
because
that
gives
us
an
opportunity
and
kind
of
forces
us
to
bring
some
other
people
in.
So
we
we've
got.
We've
got
folks
from
the
team
coming
in
and
showing
us.
A
You
know,
late-breaking
features
things
are
working
on
and
then
Scott
Hanselman
was
travelling
all
over
Europe
and
got
in
super
late
last
night
and
is
probably
deep
asleep
right
now,
so
he
told
me
that
he
would
not
be
on.
We
will
be
taking
questions.
I
will
you're
gonna
be
doing
most
of
the
talking
and
so
I'll
switch
over
to
that
and
I'll
be
watching
for
questions
as
they
come
in
and
normally
we
have
the
normally
we
have
across
the
bottom.
We
have
people's
names.
A
B
I'm
Ryan
I'm
on
the
a
subpoena
team
I've
been
working
on
a
feature
called
HTTP
client
factory,
which
I'm
going
to
be
showing
you
all
about
today.
I
work
on
pretty
much
all
things:
MVC
and
razor
and
I'm
kind
of
all
over
the
place
in
the
higher
levels
of
the
stack.
So
I'm
excited
to
be
on
the
show
and
show
you
guys
something
new
that
we've
been
working
on
for
the
last
couple
months,
cool
so.
B
I
think
you
care,
because
we're
gonna
make
you
fall
in
love
with
HTTP
client,
again.
I
think
that
there's
there's
a
lot
of
power
lurking
there
and
there's
a
lot
of
power.
That's
unlocked
with
having
integrated
logging
integrated
di
and
a
sort
of
opinionated
way
of
configuring
it
setting
it
up,
and
hopefully
the
demos
that
I
have
to
show
today
are
going
to
gonna,
get
your
mind
going
some
of
the
things
that
will
help
you.
B
If
you
use
HP
client
today
in
your
applications,
what
what
are
some
new
things
you
can
take
advantage
of
that
will
simplify
your
life
cool,
though
we're
ready
to
get
started.
Sure
all
right,
let's
see
some
code.
So
when
I
flip
over
to
my
flip
over
to
my
screen,
sharing
here
and
let's
go
to
is
this:
is
it
showing
up
for
you
John?
It.
A
B
Great
so
I've
got
a
I've
got
an
MVC
application
here
and
I've
got
another
MVC
application.
That's
running
here
in
the
background
hi
background,
we'll
just
ignore
this
is
kind
of
a
test.
This
is
kind
of
a
test
server
for
all
the
things
I'm
doing
since
we're
doing
HTTP.
We
have
to
have
something
to
do
HTTP
to
so.
Let's,
let's
dive
into
a
quick
sort
of
hello
world
example
here.
B
So
this
is
in
this
is
in
startup
of
an
asp
net
application,
so
we're
just
going
to
do
at
HTTP
client
on
service
collection,
and
so
what
we're
doing
here
is
we're
defining
a
named
client.
The
name
is
example,
and
it's
gonna
it's
going
to
do
some
stuff
to
the
service
collection.
It's
going
to
put
some
things
in
the
service
collection
and
then
I'm
going
to
show
a
controller.
B
That's
gonna
have
the
the
more
interesting
bit
of
code
for
all
these
demos
and
I
just
have
a
bunch
of
methods
here
and
if
you've
used
HTTP
client
before
this,
this
shouldn't
look
too
different.
For
you,
the
only
thing
that's
different
free,
that's
going
to
be
different.
If
you
use
this
before
is
we're
injecting
this
new
type,
HTTP
client
factory
into
the
constructor,
so
this
is
a
new
singleton
service
that
we
can
populate
in
DI,
and
it's
going
to
know
about
all
the
configuration
that
you
do
in
your
startup
code.
B
B
B
We
can
get
a
response
from
my
other
server.
We
see
we
see
down
here
in
the
debugger.
I
apologize,
that's
a
little
bit
small,
but
we
can
see
down
here
in
the
debugger.
That's
a
200,
ok
and
we
can
read
the
content
as
JSON
and
if
we
return
this,
we
can
go
back
to
I'm
just
going
to
continue
here
go
back
to
our
browser,
so
we
can
see
we
rendered
a
JSON
blob
that
we
got
back
from
the
server,
so
hopefully
you're
not
too
impressed
at
this
point.
B
This
is
all
standards
that
we've
been
able
to
do
for
a
long
time.
The
one
the
one
thing
that
I
do
want
to
crow
about
here:
Web
API
client,
is
back
so
the
this.
This
set
of
extension
methods
here
on
HTTP
content
that
you
might
be
familiar
of
your
a
Web,
API
user
or
a
a
system
web
MVC
user.
In
the
system,
net
HTTP
formatting
assembly.
B
We
have
an
upcoming
release
of
five
to
four
of
this
package,
which
is
going
to
have
declared
proper
support
for
a
net
standard
OH.
So
if
you've
tried
to
use
this
package
on
an
asp
net
core
application
in
the
past
or
any
any
net
standard
library
in
the
past,
you
know
about
putting
gross
workarounds
in
your
project.
File
that
I
won't
I
will
mention
here
we're
doing
a
release
of
this
soon,
that's
going
to
contain
the
proper
net
standard
to
support,
and
so
you
won't
have
to
hack
your
way
around
it
anymore.
B
So
that's
that's
example:
let's
example
zero.
Let's,
let's
make
it
do
some,
let's
make
it
do
some
tricks,
so
I
headed
back
to
headed
back
to
to
the
HTTP
client.
Let's,
let's
do
something
more
complicated,
because
I'm
sure
I'm
sure
everybody
that
sees
HTTP
client
has
done
more
stuff
than
just
new
it
up
and
pass
in
a
single
URL.
So,
let's,
let's
make
a
call
to
get
up
so
we're
gonna
we're
just
going
to
call
a
github
API
in
this
case
it's
the
index
API.
So
it's
kind
of
the
it's
kind
of
the
landing
page.
B
It's
an
index
of
other
services
that
getup
can
provide
on
their
API
page.
So
something
something
interesting
about
github
if
you've
used
their
API
is
before
is
want
you
to
declare
an
API
version
and
they
do
that
with
content
types.
So
we're
setting
an
accept
header
here
to
their
content
type,
which
specifies
v3
of
their
API
github,
also
requires
a
user
agent.
So
we're
setting
a
user
agent
here
to
HTTP
client
factory
sample
and
we're
gonna
set
the
base
address
to
API
github
comm.
So
we
don't
have
to
hard
code
there.
Their
address
everywhere.
That.
B
It
does
it
doesn't
stand
for
it
does
stand
for
vendor.
So
it's
a
prefix
of
of
content
types
on
the
the
suffix
tree
for
for
Jason.
Basically,
so
the
idea
is
that,
if
you
want
to
define,
if
you
want
to
define
your
own
content
types
that
are
that
are
JSON
as
a
format,
then
you
can
use
the
VND
prefix
for
them
and
be
a
good
citizen
without
having
to
register
them
with
the
ia
and
a
and
things
like
that.
But
you
know
github
uses
it
for
versioning.
Some
people
use
it
for
versioning.
B
Some
people
use
it
for
providing
specific,
like
a
data
type
if
they
use
schemas
or
if
they
declared
data
types
for
their
endpoints
I.
Think
github
only
uses
it
for
versioning,
but
that's
what
that
is
so
so
setting
this
content
type
gives
you
v3
of
their
API.
Basically,
and
the
reason
why
we're
doing
this
in
startup
code
is
everywhere
that
we
create
an
HTTP
client.
We
don't
want
to
have
to
put
this
cup
right.
B
That
makes
that
make
sense
that
you
wouldn't
want
to
put
this
code
everywhere,
that
you
use
an
HTTP
client,
because
you
might,
you
might
use
it
in
a
lot
of
places
and
we're
gonna
set
we're
gonna
set
the
base
address
to
I.
Think
I
mentioned
that,
so
the
fact
that
we've
declared
this
name
github
is
significant.
So
if
we
flip
back
over
to
this
controller,
we
can
again
create
a
client
by
name,
and
we
can
you
get
string
on
the
root
notice.
B
We
don't
have
to
specify
the
URL
here,
because
we
we've
already
specified
a
base
address,
so
we
just
have
to
put
in
the
relative
pre-fit
the
relative
path,
and
then
we
get
a
result.
So,
let's,
let's
just
run
this
real,
quick,
so
sample
one
hits
this
action.
We
get
the
client,
we
run
the
request.
We
return
the
result
and
it's
a
string
in
this
case,
so
I'm
going
to
continue
and
I
see
a
big
JSON
string
blob
in
in
the
browser.
So
this
is
what
this
is
why
this
is.
B
What
github
return
to
us
is
a
string
cool.
So
there's
not
too
much.
You
know,
there's
not
too
much
exotic,
there's
not
too
much
tricky
here.
Let's,
let's
crank
this
up
a
notch,
so
something
that
I
showed,
but
that
I
didn't
talk
about
before.
Was
this
so
I've
got
that
highlighted
I,
don't
know
how
much
that
pops
on
the
screen
that
I
have
that
highlighted,
but
so
we
have
this
github
client
class
and
if
I
go
to
that
this
is
this
is
code
that
I
wrote.
So
this
is
a
code.
A
B
B
And
if
I
go
here
and
I
can
step
over
this
and
there's
not
too
much
to
see
because
I
don't
have
any
local
variable,
sorry
and
if
I
go
again,
we'll
see
we
get
the
same.
We
get
the
same
data
back,
so
I've
created
I've
created
now
a
strongly
typed
class
that
represents
my
operations
on
some
remote
server
and
I've
defined.
B
That's
specific
to
this
named
client,
and
this
configuration
I
can
now
take
that
magic
string
out
of
all
my
code
because
I'm
using
a
DI
friendly
pattern-
and
you
can
you
can
you
can
put
as
much
or
as
little
code
here
as
you
want.
If
you
don't,
if
you
don't
care
about
this,
but
you
want
to
use
this
pattern
because
you
want
to
you
want
to
be
able
to
get
clients
from
di.
B
You
know
just
expose
the
client
as
a
property
and
treat
it
as
a
handle
or
put
functionality
here
or
put
virtual
methods
here
and
turn
this
into
an
abstraction
for
tests.
We
think
that
this
we
think
that
this
this
this
kind
of
grew
out
of
the
desire
to
both
have
named
clients
and
also
avoid
magic
strings
by
by
using
a
DI
friendly
pattern,
and
we
think
that
this
might
have
some
legs
so
we're
interested
in
what
we're
interested
in
what
you
the
community
think
about
this
is
this.
Is
this
good?
Are
there
problems
with
it?
B
B
A
Got
some
questions
starting
to
come
in
I
think
by
the
way
I
think
your
audio
might
be
set
so
that
my
voice
is
coming
out
of
your
speakers
and
getting
a
little
echo
okay.
So,
okay,
so
a
few
questions
here,
we've
got
Steve
Gordon
says:
is
this
baked
enough
that
finish
finishing
off
my
blog
post
about
it
is
reasonably
safe?
He's
added
draft
about
it,
he's
been
updating
since
October
as
he
watches
the
repo.
Yes.
B
I
would
say:
I
would
say
that
they're
still
there,
no,
there
are
no
fundamental
issues
that
we're
trying
to
resolve.
At
this
point,
there's
one
there's
one
topic
that
we're
going
to
talk.
We'll
probably
have
some
time
to
talk
about
later
that
we
still
need
to
resolve
related
to
life
times
DNS
and
some
complicated.
You
know
trickery,
but
the
shape
of
this.
We
don't
really
expect
to
change
too
much
unless
we
got
significant
feedback
that
we
got
something
wrong
or
that
we're
missing
something
the
work.
B
Don't
know
all
right
what
I
will
say
what
I
will
say
to
Brad,
actually,
actually
I
will
I
will
answer
that,
but
not
not
speaking
as
an
official
Microsoft
person.
Speaking
as
a
a
Ryan
Nowak
Microsoft
person,
one
one
thing
here
that
there
is
is
there
is
a
refactoring
that
you
can
do
to
make
them
a
sink
I
think
if
I
control
dot
here,
oh
gosh,
I'm,
trying
to
find
a
way
to
trigger
it.
B
There
is
a
refactoring
here
that
you
can
use
to
make
a
method
a
sink
and
it
might,
it
might
actually
be
a
code
fix
and
watch
watch
this
Brad.
This
is
for
you
boom,
so
interpret
that.
However,
you
want,
you
know
it
was
probably.
It
was
probably
the
the
choice
that
made
the
most
sense
for
for
the
folks
who
worked
on
that
particular
code
fix
I'm
generally
of
the
opinion
in
my
own
development
life
to
not
fight
the
tools.
B
A
B
B
B
Get
back
to
him,
I'll
have
to
spend
I,
would
love
to
spend
some
more
time
talking
about
that.
That's
something
that
we're
very
that's
something
that
were
we're
dedicated
to
solving
I,
don't
want
to
just
say
we're
interested
in
solving
we're
dedicated
to
there
being
a
solution
for
dotnet
users.
For
that,
so
we
will.
We
will
get
back
to
that.
I
want
to
I
want
to
continue
with
what
we're
I
want
to
continue
with
my
story,
all
right.
B
So,
let's,
let's
take
a
look
at
a
handler,
a
simple
one.
This
is
this
is
something
this
is
code
that
you
hopefully
will
never
have
to
write.
But
this
is
this
is
what's
called
a
delegating
handler
and
the
signature
looks
like
this
and
it's
got
this
cool.
Send
async
method
here
and
send
async
is
basically
the
the
do.
B
Http
method
right,
and
so,
if
you
look
at
this,
you'll
see
that
this
looks
kind
of
a
lot
like
the
middleware
pattern,
where
you
get
called
you
know
who
your
next
your
next
is
next
is
next:
is
this
inner
handler,
if
you're
a
delegating
Handler
and
base
base
dot?
Sundae
sync
is
kind
of
the
equivalent
to
next
in
a
middleware.
So
if
you
write,
if
you
write
a
handler
like
this,
you
can
stitch
it
up
together
into
an
HTTP,
client
and
you've.
B
Now,
you've
now
decorated,
whatever
is
going
on
inside
the
client
with
with
a
middleware
effectively.
So
we
we
on
the
team
refer
to
these
as
outgoing
middleware
and
our
our
conversations,
because
they're
very
similar
to
the
middleware
pattern,
but
for
outbound
traffic
instead
of
inbound
traffic,
so
I've
written
I've
written
two
of
these
handlers.
This
is
not
production
code.
B
I
just
wanted
to
show
an
example
of
something
that's
possible,
so
if
you
guys
want
to
tear
me
to
shreds,
feel
free
to
tear
me
to
shreds,
but
this
is
not
production
code,
so
I
just
wanted
to
have
something
to
show
for
this
demo.
If
you
have
suggestions
about
how
to
improve
it,
let
me
know
so:
I've
got
a
I've
got
a
caching
Handler
and
I've
got
a
timing
Handler,
and
what
I'm
going
to
do
with
those
two
things
is
in
the
startup
code.
B
In
example,
number
three
I'm
gonna
add
these
as
transient
services,
so
transient
services
means
every
time
you
ask
for
it.
You
get
a
new
copy
and
then
I'm
going
to
create
an
HTTP
client
called
unreliable
and
I'm
going
to
use
this
to
talk
to
an
unreliable
endpoint
in
my
other
server,
which
is
actually
somewhat
it's
unreliable,
but
it's
actually
very
predictable,
so
I've
written
a
unreliable
endpoint
here
that
will
pause
you
for
two
seconds
and
then
give
you
500.
B
Every
other
request
on
the
evens
and
odds
which
you
know
might
might
be
similar
to
some
services
that
you've
had
to
call
so
I'm
just
going
to
call
this
I'm
gonna
call
this
in
a
loop
and
I
want
to
I
want
to
sort
of
demonstrate
how
these,
how
these
handlers
play
together.
The
other
piece
of
this
that
I
think
we
need
to
see
before
we
start
is
HTTP
client
adage,
DB
client
returns
a
builder
that
you
can
use
to
do
more
stuff.
B
So
in
this
case
we've
put
two
additional
handlers
there,
and
this
overload
that
takes
a
T
will
get
a
handler
from
the
DI
system.
So
I've
added
these
two
handlers
to
services
and
I'm
gonna
add
them
to
the
message
handler
pipeline
here.
This
is
ordered.
So
what
it
means
is
that
the
timing
handler
surrounds
the
cache
handler
which
surrounds
the
execution
of
the
actual
HTTP
request.
So
if
we
fire
this
up
again,
we
should
see
this
when
I,
when
I
go
to
the
correct
URL.
B
B
B
So
you
can
see.
We've
got
some
some
logging
here
that
you
get
by
default.
We're
interested
we're
definitely
very
interested
in
your
feedback
about
the
logging
that
we
provide
by
default
and
how
useful
it
is
to
you
and
what
would
be
what
would
what's
the
sweet
spot
for
logging
I
think
that
this
will
take
some
iteration
to
get
right
and
it's
possible
that
we
may
not
get
it
right
for
everybody,
so
we're
interested
in
opinions
from
a
broad
array
of
sources
about
what
you
think
is
what
you
think
would
be
best.
B
So
you
can
see
a
couple
things
that
are
interesting
here,
so
we
were
using
this
system
net
HTTP,
unreliable
logging
source.
So
our
our
logging
that
we
provide
by
default
is
going
to
have
the
name
of
your
named
client
in
it
so
that
you
can
configure
different
levels
per
per
client.
So
you
can
adjust
the
logging
verbosity
as
necessary
for
each
client,
and
this
is
this-
is
the
start
of
a
this?
Is
the
start
of
a
flow?
B
So
we
log
saying
hey
I'm,
starting
this
request
and
you
can
see
the
URL
and
then
we
get
inside
the
timing.
Handler
and
the
timing
handler
says:
request
started.
Then
we
get
down
to
the
client
handler,
so
we
have.
We
have
logging
at
both
ends
of
the
pipeline
here
and
they're
both
on
by
default
at
the
information
level,
so
we're
interested
we're
interested
in
your
thoughts
on
this.
B
B
But
if
I
use
the
handler
to
say,
add
those
headers,
you
could
see
them
change
between
the
outside
and
the
inside
of
the
pipeline
or
if
I
used
a
if
I'm
doing
you
know
more
of
a
micro-services
kind
of
thing
or
if
I'm
using
service
discovery,
you
could
see
a
handler
that
did
service
discovery
and
resolved
a
logical
URL
to
a
actual
URL
or,
if
I'm,
using
a
handler
that
does
authentication.
For
me,
you
could
see
a
handler
that
attaches
an
authorized
header
to
the
request.
B
So
we
think
that
the
this,
the
the
kinds
of
handlers
that
people
write
are
really
going
to
grow
up.
Some
of
these
things
already
exist
by
the
way,
and
so
we
think
that
there's
probably
some
value
in
treating
these
as
two
separate
two
separate
inputs
or
two
separate
data
points.
So
so
let
us
know
what
you
think
about
that.
Let
us
know
if
this
is
you
know
too
loud
or
too
quiet.
B
So
then
you
can
see
we
step
through
the
client
handler.
We
see
the
request
went
out.
We
see
that
it
came
back
after
about
two
seconds
and
it
was
an
internal
server
error.
Then
we
get
into
the
cache
handler.
The
cache
handler
says.
Oh
no,
it
was
a
failure
I'm
using
my
cached
response
and
the
timing
handler
says
hey
by
the
way.
This
whole
process
took
about
20,
28
milliseconds,
and
then
we
get
back
out
to
the
top
level,
and
this
says:
ok,
this
took
a
few
more.
B
It
took
a
few
more
milliseconds
to
buy
the
right
line
is
slow
so,
and
you
can
see
also
at
the
end,
by
the
way
that
it
turned
into
an
ok.
So
these
kind
of
things
like
yeah,
the
actual
response,
was
an
internal
server
error
and
the
response
that
the
application
saw
was
an
OK.
Those
kinds
of
things
can
be
interesting
when
you're
talking
about
like
system
handlers
that
do
retries
or
handlers
the
cache
data
to
try
and
avoid
fragility
or
those
kinds
of
things.
B
A
Questions
or
thoughts
as
you're
saying
this
one
is,
it
seems
like
since,
due
to
the
way
you've
got
it
factored
and
the
way
you
can
inject
everything
and
all
that
the
people
could
build
these
as
NuGet
packages
right
and
I
didn't
okay,
so
so
somebody
could
create
the
whatever
logging
or
the
service
discovery
or
whatever
delegating
hand
handler.
You
know
with
a
cooler
sounding
name:
oh
well,.
B
The
the
great
thing
about
this
is
that,
because
HTTP
client
is
already
part
of
the
BCL
and
it's
already
been
around
for
a
long
time,
it
integrates
with
lots
of
other
stuff.
So
speaking
about
speaking
about
people
building,
strongly-typed
clients,
there's
this
great
library
called
refit.
Have
you
have
you
heard
of
that?
John
I
have
yeah
you've
heard
of
refit,
so
for
anybody
on
the
stream
that
hasn't
heard
of
refit,
it's
really
cool.
You
should
check
it
out.
I!
Think
it's
I,
think
it's
it's
github,
that's
another
all
bets
thing.
B
Yeah,
there's
a
probably
there's
a
Paul
Beth
project,
so
reef.
It
is
reef.
It
is
awesome,
I'm
using
it
for
something
really
stupid
simple
in
here,
but
it
can
do
it
can
do
lots
of
cool
stuff,
so
I've
got
I've
got
my
I
hello,
client
and
the
way
the
way
reef
it
works.
Shout
me
down
if
I'm
lying
about
any
of
this
by
the
way,
if
you
know
reef
it
better
than
I
do
but
the
way
reef
it
works.
B
Is
you
write
an
interface
you
attribute
that
interface
with
with
relative
URLs,
with
parameters
with
all
kinds
of
metadata
and
the
refit
library
will
generate
a
client
for
you
and
I
believe
we
do
it
at
Build
time,
but
I
might
be
wrong
about
that.
Don't
quote
me
about
that.
Ask
ask
the
office
the
refit
library
will
generate
client
code
for
you
and
that
will
do
what
will
do
the
HTTP.
So
that's
that's
cool
right
like
that's.
B
So
you
can
see
I've
added
this
Hello
client
I've
set
the
base
address,
just
to
prove
that
I
can
do
something
to
it
and
I've
added
the
typed
client-
and
this
is
a
this-
is
a
method
that
I
haven't
shown
I
haven't
introduced.
Yet
it
does.
It
does
something
very
similar
to
this.
So
adding
adding
the
typed
client
here
inside
add
to
HTTP
client
is
a
shortcut
for
this
at
HTTP
client
with
no
arcs.
B
So
think
of
those
two
is
the
same,
and
the
reason
why
I'm
not
using
the
no
args
version
is
because
I
need
to
pass
arts.
So
this
this
has
got
an
implied,
I
Hello
client
here
by
the
way
so
I'm
passing
in
a
funk.
If
we
go
look
at
what
ad
type
client
looks
like
there
are
a
couple.
There
are
couple
flavors
of
this,
so
there's
the
no
arc,
there's
the
no
arc
flavor,
which
you've
seen
there's
a
flavor
that
is
T
client,
T
implementation.
B
So
if
your
implementation
is
different
than
your
client
will
instantiate
your
implementation
and
then
will
by
passing
it
an
HTTP
client,
and
so
that's
another
way
that
you
can
create
typed
clients.
If
your
client
interface
and
your
implementation
code
are
different
or
you
can
give
us
a
func
and
give
us
a
func
that
creates
a
client
given
an
HTTP
client
or
you
can
give
us
a
func
that
creates
an
H,
creates
your
typed
client
given
an
HTTP,
client
and
the
services.
So
there's
a
lot
of
ways
that
you
can
do
this
and
reef.
B
It
already
provides
the
ability
to
just
plug
in
a
client.
So
if
we,
if
we
look
at
what
this
looks
like
here,
this
is
this
is
their
API,
of
course,
so
you
can
give
it
an
HTTP
client.
You
can
give
it
a
settings.
Their
settings
have
things
like
authorization,
stuff,
I'm,
not
sure
what
this
would
be
used
for
in
our
case
or
Jason
serializer
settings
different
different
things.
You
should
go
check
out
refight
if
you
haven't
seen
it.
It's
pretty
awesome.
A
A
To
that
too,
in
the
in
the
chat
that's
going
on
there's
if
you
search
for
Paul
Betts
be
ETTs
and
refit
our
EF
ite
you'll
find
it
alright.
B
Thanks
for
having
my
back
John
so
again
like
like,
we
saw
before
with
the
get
up
client,
the
ad
type
client
registers
this
type
as
a
service
in
DI.
So
it's
now
available
for
dependency
injection
in
that
so
inside
this
controller,
I
can
inject
the
I.
Hello,
client
and
I
can
set
a
breakpoint
right
here
and
I've
I
have
correctly
set
this.
As
my
start
up
project
and
waiting
for
this
to
build.
B
So
you
can
see
we
get
here
and
if
we
look
at
you
can
see
that
this
is
an
the
type
of
this
I
realized.
That's
small
I
apologize
is
the
type
of
this
is
auto-generated
I,
hello,
client.
So
it's
the
generated
code.
That
brief
it
has
created,
and
inside
of
here
is
an
HTTP
client
and
you
can
see
it's
got.
The
base
address
set
just
like
I
did
in
the
startup
code,
so
this
will
compose
with
all
the
other
things
that
you've
seen
any
custom
Handler.
B
As
you
write
anything
like
that,
and
of
course
we
step
we
step
over
this
it'll
it'll.
You
know
it'll
work
and
it's
it's
just
calling
one
of
the
endpoints
that
we've
already
seen
before
to
get
a
message.
So
that's
another
thing
that
you
can
do
speaking
of
typed
clients
and
and
people
shipping,
libraries
with
clients.
B
If
you
have
a
if
you,
if
you
have
a
or
if
you
build
a
a
you,
know
SDK
for
github
or
for
any
any
site
that
people
want
to
use
or
any
API
that
people
want
to
consume
that
that
can
be
constructed
with
an
HTTP
client.
Anybody
can
use
it
with
this.
We
we.
We
hope
that
this
is
open.
We
hope
that
this
is
flexible
enough
for
everybody
scenarios
to
be
possible,
one
other
one.
B
Other
example
that
I
want
to
show
here
and
this
this
relates
to
something
that
we
talked
about
before
or
is
we
talked
about
retries
and
we've
talked
about
integrating
third-party
stuff,
so
I
want
to
show
another
another
great
library,
that's
not
from
Microsoft.
That's
from
the
community
is
Polly.
If
you
have
your
polygon
yep.
A
B
Haven't:
okay:
they
they
there's
a
surprising
level
of
depth.
Here,
it's
really!
It's
really
cool.
We've
chatted!
We've
chatted
with
the
folks
who
work
on
it
a
couple
times
and
we're
we're
thinking
about
building
our
own
integration,
for
it
we're
not
sure
exactly
what
shape
that
would
take.
I
think
I,
think
the
worry
with
us
doing
it
is
is,
if
we,
if
we
go
to
basic,
it
could
be,
it
might
not
mean
everybody's
needs
and
it
might
be,
might
might
be
bad.
B
So
we're
talking
about
doing
it
sure
exactly
what
our,
what
our
level
of
investment
would
be,
and
that
would
be
us
basically,
shipping
and
documenting.
You
know
how
to
use
poly
with
this
and
providing
maybe
some
helpers
for
using
it
with
asp.net
if
we
think
that
that
can
be
done
in
a
good
way,
but
what
I
want
to
say
about
that
is
well
if
you're
doing
HTTP
across
service
boundaries,
and
especially
if
you
own
multiple
services
having
something
like
poly
is
pretty
fundamental.
B
If
it's
not
a
success,
you
know
if
this
were
production
code,
I
would
probably
say,
throw
it
if
it's
not
a
500
or
throw
it
if
it's
a
500
and
let
it
go
through
if
it's
a
400,
but
you
know
you
need
to
me
very
and
then,
when
I
handle
an
HTTP
request,
exception,
I
want
to
wait
and
retry
so
I'm
going
to
retry.
This
is
retry
count
I'm
going
to
retry
five
times,
and
then
this
is
a
linear
back
off.
So
this
is
a
func.
B
That's
going
to
be
called
with
the
current
retry
count,
and
it's
going
to
generate
a
time
span
of
how
long
to
wait
before
we
try
again
so
I
just
implemented
this
simple
linear
back
off
here.
So
first
retry
it
would
wait
one
second,
second
retry
two
seconds
and
so
on,
and
then
the
third
thing
that
I've
got
here
is
I'm
going
to
log
when
I
I'm
gonna
log
when
I
fail,
because
I
want
to
know
you
know
how
unreliable
is
this
thing
inside
the
execute
async
method?
B
This
is
the
thing
that
actually
does
stuff
I'm
gonna
call
base,
which
again,
if
you
think
of
these
as
outgoing
middleware,
it's
like
calling
next
and
then
I'm
gonna
ensure
to
success
status
code
because
I
want
to
throw
if
I
didn't
get
a
success,
and
my
logging
method
is
pretty
standard.
If
you
used
our
logging
stuff
before
you
see
an
ilogger,
it's
it's
pretty
standard.
B
B
So
it's
going
to
go
right
to
it
and
I'm
gonna
refresh
I'm
gonna
refresh
this
a
few
times,
I
think
I
think
actually
this
goes.
This
goes
in
a
big
loop,
I
think
just
mine.
This
is
my
wrong
sample.
I
think
this
just
goes
in
a
big
loop.
So
if
you
look
at
the
logging
pane
down
here,
you
can
see
you
can
see.
This
is
the
debugger
view,
so
you'll
actually
see
when
there's
an
exception,
and
you
can
see
sending
request,
get
received
response
internal
server
error
that
threw
an
exception.
B
Oh
my
gosh
I'm
scrolling
off
the
screen.
I,
don't
know
if
there's
a
way
to
pin
this
I'll
just
pause
it.
Okay,
so
we're
just
stopped
in
the
debugger
here
so
received
an
HTTP
response.
It
was
a
500
internal
server
error.
That's
right
here,
I
read
through
that
exception
and
then
BAM,
my
retry
handler
was
hit.
I
said
I'm
gonna
retry
again
in
a
second
and
it
retried
the
retry
count
is
1
or
the
failure
count
is
1.
I'm
gonna
send
a
get
to
this.
B
Url
I
get
a
response
to
nine
milliseconds
and
it
was
ok
and
then
it's
gonna
bubble
back
out
and
it's
gonna
say:
ok,
the
overall
I
was
able
to
succeed
after
retrying,
and
so
the
overall
successes
isn't
okay,
and
so
this
is.
This
is
again
like
I
mentioned
before
we're
doing
logging
at
two
levels
here
we're
doing
logging
when
we
actually
send
a
request
and
we're
doing
logging
when
we,
when
we
bubble
outside
the
message
handler
pipeline.
So
everything
that
I
everything
that
I
have
highlighted
here
was
a
single
call
to
the
client.
So.
A
You're
doing
your
job
well
because
at
the
beginning,
I'll
be
honest,
HTTP.
Any
any
thing
that
ends
with
the
word
factory
kind
of
starts,
to
put
me
to
sleep
and
I
was
not
expecting
to
be
excited
about
this,
but
I
can
see
tons
of
opportunity
as
and
as
I
told
you
before,
the
call
I
didn't
want
you
to
sell
it
to
me
beforehand,
because
I
wanted
to
come
in.
A
You
know
new
and
representing
people
watching,
but
the
the
ability
to
stack
middleware
like
you're
talking
about
the
ability
for
people
to
create
libraries
and
share
them
yeah
and
like
to
have
a
client
that
understands
like
oh
I'm,
talking
to
this
endpoint,
and
so
it
can
know
to
set
special
headers
or
it
can
know
about
my
you
know.
Maybe
there's
API
restrictions
on
how
often
I
can
call
it
or
whatever,
and
that
sort
of
thing
can
encapsulate
some
of
that
stuff.
For
me,
right,
mm-hmm.
B
Yeah
so
I'm
glad
that
I'm
glad
that
you
think
it
I'm
glad
that
you
think
it
resonates.
I
think
that
this
is
something
that's
going
to
grow.
I,
hope
it's
something!
That's
going
to
grow,
I
hope
it's
something
that
develops
energy
I'd
like
to
think
that
we're
providing
a
platform
here
that
other
people
are
going
to
other
people
out
in
the
community
are
gonna,
find
ways
to
extend
into
to
improve
and
where
we
want
to
get
your
feedback
on
all
these.
B
B
So
I'm
gonna
direct,
so
you
can
do
that
I'm
gonna
direct
David
here
to
this
repo,
so
this
is
Glenn
my
my
p.m.
buddy,
who
works
on
this
with
me
and
oops
wrong,
one
sorry
to
find
the
right
one.
This
is
the
right
one,
so
here
in
there's
a
global,
a
si
X,
and
here
somewhere
this
is
this
probably
looks
familiar
to
you
because
we've
you've
seen
a
lot
of
configure
services
kind
of
stuff
yeah
this
this
may
not
so
this
is
a
web
forms
application.
B
That's
going
to
create
a
create
a
DI
container
inside
of
inside
of
the
application
start
method
and
make
the
service
provider
available
as
a
static
in
in
asp.net.
So
you
can
kind
of
you
can
take
this
and
go
wherever
you
want
with
this.
If
you
have
a
long-lived
console
application,
just
throw
just
throw
these
three
or
four
lines
of
startup
code
in
the
beginning
of
it
and
and
there
you
go
so
we
we
want
this
to
be
for
everybody.
B
We
think
that
everybody
can
use
it
if
you,
if
you
think
that
you
can't
use
it,
and
you
want
to
let
us
know,
let
us
know
what
you're
doing
and
why
why
it
doesn't
work
for
you.
We
think
we
think
that
everybody
can
use
us,
provided
that
you
can,
you
can
do
net
standard.
This
is
net
standard,
oh
and
where
we
intend
to
keep
it
that
way.
A
A
B
Is
a
little
painful
to
get
running
at
this
point,
we're
working
on
getting
together
the
first
preview
of
two
one
I,
don't
have
any
dates
that
I
can
share
about
that
other
than
to
say
there
were
we're
nearing
the
end.
So
if
you
want
to
get
started
with
this,
you
can
go
to.
If
you
want
to
try
this,
it's
probably
the
way
to
think
about
it.
You
can
go
to
donÃt
CLI
homepage
and
you
can
grab
an
installer
for
the
latest
available
nightly
of
the
CLI.
B
So
you
can
throw
that,
throw
that
on
your
machine
and
then
you'll
have
the
shared
framework
installed.
So
the
shared
framework
is
kind
of
like
the
SP
net,
all
packaged
and
it's
included
in
ASP
at
all.
If
you're
not
building
a
web
application
or
you're,
not
you
know
you're
not
sort
of
on
the
asp
net
train.
You
can
just
grab
the
latest
Knightley's
if
you
want
to.
If
you
need
to
try
this
out
before
the
preview.
B
B
Try
and
ignore,
try
and
remember
which,
which
of
the
10,000
feeds?
This
is
so.
This
is
our
feed.
This
is
our
feed
where
our
nightly
builds
go
and
you
can
grab
this
and
stick
this
in
your
new
get
config
this
either
these
URLs
and
then
you
should
be
able
to
get
access
to
your
latest
Knightley's
of
of
this
by
by
using
a
2-1,
Oh
Virgin,
and
you
can
browse
that
feed
to
see
what
builds
are
available.
The
package
for
this
is
HTTP
client
factory.
Oh,
this
is
not
the
right
project.
B
Let's
get
let's
get
into,
let's
get
into
lifetime
issues
of
httpclient,
one
of
our
favorite
one
of
our
favorite
topics,
so
I'm
going
to
provide
a
little
bit
of
background
I
realize
the
people
asking
the
question.
You
guys
already
know
why
you
care
I,
want
to
make
everybody
care
so
httpclient,
how
many
of
them
should
you
have
that's
a
really
hard
question
to
answer
actually
so
a
couple
classical
problems
that
exist
with
httpclient
that
we're
working
on
getting
to
the
bottom
of
I'm,
gonna
flip
back
to
my
webcam.
B
So
you
know
who
I
am
so
a
couple,
a
couple
sort
of
classical
problems
with
httpclient
that
we're
trying
to
get
to
the
bottom
of
is:
if
you
create
too
many
HTTP
clients,
you
have
two
problems:
one
it's
inefficient,
because
each
one
will
have
its
own
connection
pool
for
the
remote
server.
So
that
means
that
you
pay
the
cost
of
reconnecting
to
the
server
for
every
client
you
create,
which
is
not
good
right.
It
slows
you
down
the
other,
bigger
problem
that
you
have
with
HTTP
client.
B
If
you
create
a
lot
of
them,
is
you
can
run
into
socket
exhaustion,
so
socket.
Exhaustion
means
that
you
basically
used
up
too
many
sockets
too
fast,
so
so
Windows
and
Linux
and
all
operating
systems
basically
basically
have
a
limit
of
how
many
sockets
you
can
have
open,
which
you
wouldn't
think
would
be
a
problem,
because
when
the
client
goes
away,
the
socket
would
go
away.
But
it's
not
actually
that
simple,
TCP
sockets
that
get
used
have
to
sit
around
in
an
idle
state
for
I.
Think
in
Windows.
B
B
One
choice
that
you
might
choose
to
make
instead
is
to
say
okay,
so,
instead
of
creating
a
lot
of
HTTP
clients,
HTTP
client
is
mutable,
but
it
is
thread
safe
as
long
as
you're
not
mutating.
It,
therefore,
I
will
create
one
and
I'll
put
one
and
I'll
put
one
in
my
service
container
or
I'll,
create
one
and
start
up
and
put
it
in
a
static
and
then
I'll
use
a
single
instance
for
the
whole
application
and
I
will
avoid
the
problem
with
socket
exhaustion,
because
I'll
only
ever
have
one.
There
will
be
one
connection.
B
Pool
small
number
of
connections,
that'll
be
fine.
This
is
a
really
efficient
way
to
use
HTTP
client,
except
the
problem
that
you
have
now
is
that
it
will
keep
connections
open
too
long
and
not
respect
the
DNS
time-to-live.
So
the
situation
that
you'll
find
yourself
in
now
is
that
your
your
connections
will
never
get
DNS
updates.
B
So
if
some
server
that
you're
talking
to
is
going
to
have
its
address
change,
like
let's
say
you're
in
a
micro
services,
kind
of
environment
or
you're
doing
Bluegreen
deployments
or
any
kind
of
rolling
deployments,
you
really
care
about
your
DNS
address,
that's
being
able
to
update
and
some
reasonable
time
frame,
and
so
as
people
move
towards
more
componentized
services
and
sort
of
go
on
down
that
spectrum
of
more
active
deployment.
More
active
service
changes.
B
The
problem
that
you
run
into
really
quickly
is
that,
like
okay
I
need
my
DNS
update
time
to
be
five
minutes,
I
need
my
DNS
update
time
to
be
thirty
seconds.
I
need
the
time
to
live
on
my
DNS
to
be
really
low
because
that
server
might
be
pulled
out
from
underneath
me
and
I
can't
just
keep
talking
to
that
IP
after
it's
gone.
A
If
you
mentioned
Bluegreen
deployments
but
like
if
that
terms
not
clear
to
some
people
like
deployment
slots,
is
one
place,
I've
heard
of
that
come
up
with
right
on
a
juror
or
other
cloud
providers
right
if
you're
doing
swapping
in
and
you
don't
want
any
downtime
you
deploy,
and
you
want
it
to
swap
well,
if
some
clients
hitting
that
they're
not
going
to
see
that
you've
made
that
change
and
they're
not
going
to
be
hitting
the
live
site.
Yeah.
B
Don't
I,
unfortunately,
don't
have
one
because
I
wasn't
able
to
get
one
set
up,
but
we've
been
adding
a
feature:
we've
added
a
feature
to
HTTP
client
factory
that
I
have
in
this
sample
and
I.
Believe
it's
not
actually
I
can't
demo
it,
but
the
code
is
written,
but
we've
got
this.
Oh
no,
that's
the
wrong
place!
Sorry,
dear.
B
May
not
be
able
to
show
it
in
code.
I
had
to
I
had
to
revert
to
an
earlier
version
of
the
libraries
to
get
a
consistent
set
and
I
may
not
be
able
to
show
I
may
not
be
able
to
show
what
this
does.
I
may
just
have
to
tell
you
so
yeah
I,
don't
see
I,
don't
see
it
here
on
the
Builder,
so
I
must
have
a
I
must
have
an
earlier
version
of
libraries.
It
doesn't
have
this
feature,
but
I
can
show
code.
So,
let's
go
to
yeah,
it's
not
there.
B
Let's
go
to
get
up
and
my
screen
is
shared,
so
you
should
be
seeing
good
up
at
this
point
and
I'm
going
to
go
to
the
HTTP
client
factory
repo,
and
let's
look
at
something
here,
trying
to
remember
if
I
put
it
in
this
code
or
not,
I
did
not
put
it
in
this
code.
Okay,
let's
just
go
directly
to
the
API,
though
the
strategy,
the
strategy
for
this.
By
the
way,
the
feature
that
I'm
talking
about
sorry
I
realized
I'm
spending
a
lot
of
time.
B
Building
up
to
it
is
it's
something
that
I
refer
to
as
as
handler
rotation.
So
the
idea
for
handler
rotation
is
that
we
can
pool
the
underlying
client
handler,
so
the
client
handler
think
of
it
as
like,
the
the
delegating
handler.
That's
at
the
end
of
the
pipeline
or
the
message
handler.
That's
at
the
end
of
the
pipeline,
here's
the
API
I
was
looking,
and
so
the
delegating
handler
at
the
end
of
the
pipeline
is
the
one
with
all
the
action
and
what
I
mean
by
that
is
that
it's,
the
one
that
actually
does
HDB.
B
It's
also
the
one
that
keeps
the
connections
open
and
it's
the
one
that
does
all
the
actual
networking
for
the
most
part,
and
so
by
pooling
these
and
giving
you
a
new
HTTP
client
every
time
you
ask
for
one
we're
taking
away
the
expensive
part.
So
the
expensive
part
of
creating
an
HTTP
client
is
creating
the
message,
handlers
and
creating
the
connection.
B
So
if
we
pull
the
handler
but
then
give
you
a
new
HTTP
client,
we
don't
have
to
worry
about
you
mutating,
durable
State,
because
HTTP
client
is
durable.
So
if
we
are
as
mutable
and
if
we
catch
them
forever,
then
you
could
see
you
could
see
some
spooky
things
if
you
change
those
properties,
which
is
why
the
initial,
why
we
initially
chose
not
to
cache
the
clients
themselves,
so
we
cache
the
handlers,
which
is
the
expensive
thing
to
create.
B
So
what
this
feature
is
and
there's
a
very
long-winded
description
of
it
here
is
we
cache
each
handler
and
each
handler
chain
that
we
create?
We
create
them
on
demand.
So
when
you
request
a
client
for
forget
up,
we
create
the
github
handler
chain
according
to
your,
according
to
your
configuration
and
we'll
keep
it
and
we'll
keep
that
chain
around
according
to
the
handler
lifetime.
B
They'll
get
a
second
one
and
any
any
any
clients
that
are
using
the
old
handler
chain
are
still
valid
because
we
haven't
disposed
it
we've
just
retired
it,
and
so
it
sits
in
a
retired
pool,
and
we
have
a
background.
We
have
a
background
job
that's
going
to
through
that
pool
and
say
for
every
for
every
handler
that
is
sitting
there.
B
Is
anybody
still
using
it
basically,
and
we
can
do
that
through
the
magic
of
weak
references
and
we
can
say,
have
all
references
to
this
handler
gone
out
of
scope
and
if
all
references
to
this
handler
have
gone
out
of
scope,
it's
time
to
dispose
it.
So
it's
kind
of
a
mixed,
it's
kind
of
a
mixed
design.
B
So
you
get
you
get
to
avoid
creating
lots
of
connections.
You
get
to
have
lots
of
HTTP
clients,
you
get
to
mutate
them,
but
you
can
avoid
creating
lots
of
connections,
but
then
they
don't
live
too
long.
Unless
you
know,
unless
you
want
them
to,
then
they
live
as
long
as
you
want,
it's
not
a
solution
for
the
underlying
issue.
B
It's
it's
more
of
a
workaround.
So
what
I'd
hope
I'd
hope
to
be
able
to
show
an
example
of
this
working
in
progress,
the
code
the
code
is
written.
Okay.
What
I
had
hoped
to
show
today
was
some
some
examples
of
of
more
guidance,
kind
of
thing.
Like
you
know,
how
would
you
do
this
on
down
the
framework?
How
would
you
do
this
on
OSX?
B
What
platforms
do
you
need
to
use
this
on?
What
platforms?
Don't
you
need
to
use
this
on,
because
there's
there's
been
lots
of
discussions
about
service
point
manager
on
Windows
and
those
using
service
point
manager
configuration
solve
this
for
you
if
you're
on
desktop,
but
it
doesn't
solve
it
for
you
on
core.
So
what
I'd
hope
to
get
through
was
sort
of
the
the
the
guidance
around
using
this
so
expect
that
soon
and.
A
B
We've
also,
we've
also
been
talking
a
lot
with
the
folks
working
on
the
managed
handler
on
the
core
FX
team.
So
if
you've,
if
you've
and
I'm
sure
that
a
lot
of
people
on
this
call
have
been
people
who
have
commented
on
these
issues
on
the
core
FX
repo,
there
have
been
some
bugs
that
have
had
a
lot
of
comments
and
a
lot
of
feedback
from
people.
Basically
saying
hey.
B
Why
don't
you
guys
just
make
it
work,
which
I
think
is,
is
a
certainly
a
motion
that
I
can
empathize
with
they're
they're,
rewriting
the
managed
handler
there
so
they're
they're
writing
a
new
top
to
bottom
httpclient
handler
or
that
will
that
will
try
to
behave
more
consistently
for
donek
or
between
Windows
and
Linux,
and
so
they're.
Putting
a
lot
of
work
into
improving
the
performance
of
that.
Getting
that
getting
that
worked
on.
We've
talked
to
them
about
the
DNS
issues
on
their
list
of
things.
To
think
about.
So
that's
going
on.
B
I
think
that
the
handler
the
this
idea
of
handler
rotation
is,
is
kind
of
it's
something
we
might
have
to
do
and
we
we're
interested
in
getting
the
defaults
right
so
that
you
have
the
experience
of
not
having
to
think
too
hard
about
it.
That's
my
goal,
but
we'll
have
to
we'll
have
to
let
you
know
in
the
next
few
weeks,
so
the
the
answer
that
I
have
you
know
we're
aware
of
the
problem.
B
A
B
Yeah
I
think
this
is.
This
is
probably
a
case
where,
if
the
underlying
system
is
not
going
to
be
bulletproof
for
everything
that
everybody
needs
all
the
time,
then
you
need
a
power
tool,
and
so
this
this
is
kind
of
a
power
tool
approach
and
if
it
needs
to
get
more
complicated,
then
we'll
will
embrace
that
I
mean
if
it's
I,
I
I
think
that
we
need
to
solve
these
kinds
of
hard
problems.
B
A
Almost
seems
like,
as
a
consumer
like
as
I
call
in
to
an
endpoint
I'd
like
the
endpoint,
to
be
able
to
give
me
a
more
information,
and
maybe
they
do
I'm,
but
you
know
about
like
there's
time
to
live,
but
there's
information
about.
You
know
I'd
like
to
hear
from
an
endpoint
about
I.
Don't
know
you
know
how
regularly
I'd
expect
the
endpoint
to
change
or
that
kind
of
thing.
Yeah.
B
B
Another
potential
use
of
HTTP
client
factory
and
the
pipeline
model
is
to
implement
caching
inside
the
pipeline,
so
very
early
in
the
request
pipeline
after
you've
figured
out
who
you're
talking
to
you,
let's
figure
out,
if,
let's
figure
out,
if
we
need
to
ask
again
or
should
we
assume
that
the
data
we
got
last
time
is
still
good
based
on
based
on
parameters
configured
by
the
server.
So
there's
a
there's,
an
HTTP
back
around
caching
and
I.
B
A
B
A
All
right
well
we're
at
about
an
hour.
We
should
probably
wrap
up
here.
I,
don't
there's
been
some
some
good
discussion.
Glenn
Glenn's
been
on
the
chat
and
there's
some
good
kind
of
discussion
going
on
there
and
it's
all
over
my
head,
so
I'm,
no
I,
hope
I,
don't
see
anything
specific
to
call
out.
So,
as
you
pointed
out
there
that
that
repo,
the
can
you
show
that
the
repo,
oh
yeah.
B
A
Let
us
know
we'll
be
happy
to
line
those
up.
Also
I
didn't
have
any
community
links
for
this
week.
There's
there
are
some
great
ones:
I
had
eight
or
ten
of
them
and
I
on
yet
time
to
read
them
in
enough
detail
to
do
them.
Justice
so
we'll
have
those
on
next
week.
So
still
have
community
just
I'm
not
talking
about
it
today,
all
right.
Well,
so
so
I
guess:
let's
wrap
up
there
thanks
a
lot
right,
yeah
all
right!