►
Description
Come chat with the team that's building YARP: a reverse proxy toolkit for building fast proxy servers in .NET using the infrastructure from ASP.NET and .NET.
Community Links: https://www.theurlist.com/aspnet-standup-2020-09-01
[Featuring: Chris Ross (@Tratcher), Sam Spencer (@samsp)]
A
A
A
B
A
A
A
A
C
A
A
All
right,
so,
as
always,
the
links
are
shared
via
the
url
list,
so
I
will
share
the
links
in
the
chat
in
the
description
everything
they're
always
there.
So
let's
run
right
through
first
of
all,
we'll
start
with
a
a
fun
little
discussion
here,
andrew
lock,
starting
starting
things
up
fun
with
a
should
you
unit
test,
asp.net,
api
and
mvc
controllers,
and
you
know
really
really
interesting
discussion.
It
kind
of
goes
through
the
things
that
you
actually
would
test.
I've
seen
you
know,
there's.
Definitely
that
was
a
thing
about
mvc.
A
I
remember
when
it
was
kind
of
first
created
was
like
hey,
it's
all
unit
testable,
but
in
reality
I
was
writing
a
lot
of
unit
tests.
That
said,
does
it
return
the
view?
Yes,
it
returns
to
view
and
there's
not
really
a
lot
of
value
in
that
a
lot
of
the
time.
So
he
goes
through
and
kind
of
deconstructs.
A
What
you're
not
testing?
You
know
you
don't
need
you're,
not
testing,
routing
you're,
not
testing
model
binding.
Those
are
all
framework
level
concerns
you're,
not
testing
model
validation,
you're,
not
testing
the
filter
pipeline.
There's
all
this
stuff
that
happens
and
you're
not
testing
and
you
shouldn't
test,
and
so
then
he
goes
through
and
talks
about
what
you
are
testing,
and
you
know
the
focus
here
of.
Are
you
testing
thick
controllers,
which
you
really
it's
kind
of
a
bad
practice
generally
to
have
a
thick
controller?
A
A
controller
should
really
be
working
with
services
and
repositories,
and
things
like
that.
So
so,
then
you
know
what
you
end
up
with.
Is
your
controllers
really
should
be
pretty
thin
and
what
you
really
want
to
be
testing
is
either
the
services
or
the
interaction
level.
So
he
kind
of
ends
up
there.
A
Talking
about
the
testing
at
the
integration
test
level-
and
you
know
it
calls
out
to
steve
gordon's
recent
course-
and
I
featured
that
as
a
link
previously
and
and
also
he
calls
out
to
khalid
abraham's
recent
post
and
his
post
is
just
a
bunch
of
different
tips,
but
one
of
his
things
is
favoring
integration
tests
as
well.
So
a
lot
of
good
stuff
there
so
interesting
post
to
get
you
thinking
this
morning,
all
right.
A
Here's
a
fun
one,
so
matthew
jones
has
been
doing
some
recent
posts
on
games
using
blazer,
and
so
here
he's
looking
at
yahtzee
and
it's
it's
really
interesting.
Looking
at
making
a
game
because
you
end
up
with
these
interesting
domain,
modeling
constraints
that
you
would
normally
kind
of
just
kind
of
work
around
or
not.
You
know
think
I
don't
have
to
deal
with
this,
but
going
through
and
looking
at
what
he's
modeling
here.
So
he
he's
starting
this
one
this.
A
This
is
the
first
in
a
series
and
he's
looking
at
the
model,
so
he
goes
through
and
just
does
all
the
domain
modeling
so
going
through.
And
you
know
it's
interesting.
You
can
go
through
and
you
can
look
at
a
score
card
or
you
can
teach
a
kid
to
play
yahtzee
in
a
few
minutes,
but
when
you
actually
go
through
and
break
down
what
the
model
is
doing
and
how
what
all
the
rules
are,
it
gets
more
complex.
A
So
he
goes
through
and
defines
you
know,
what's
involved
in
a
play,
what's
involved
in
winning,
what's
involved,
even
in
the
simple
things
of
modeling
the
dice,
and
so
then
you
know
wrapping
up
at
the
end.
Here
we
go
through
some
things
with
like
how
do
you
tell
if
somebody
even
has
a
full
full
house
or
a
straight,
and
so
so
that
at
the
end
of
this
we
get
to,
we
have
a
model
complete
and
then
he's
going
to
continue
on
in
the
series,
so
fun
stuff,
speaking
of
games
with
blazer.
A
So
here's
david
and
he's
talking
about
game
dev
he's
this
is
part
nine
of
his
series
and
here
he's
looking
at
a
finite
state
machine.
So
you
know
part
of
just
running
game
logic.
You
you
often
end
up
with
with
a
some
sort
of
state
machine
and
so
he's
looking
at
a
finite
state
machine
and
how
that's
modeled
and
his
posts
in
this
series
are
all
pretty
short,
there's
a
decent
amount
of
code,
but
they're
really
kind
of
bite-sized.
A
A
You
actually,
when
you're
deploying
out
to
a
host.
You
can
host
just
about
any
anywhere
but
you're
hosting
static
files,
and
so
you
need
to
include
that
build
step
and
you
need
to
do
the
full
kind
of
publish
pipeline
in
order
for
that
to
work,
and
so
here
he
goes
through
and
looks
at
how
to
set
that
up,
starting
with
the
blazer
web
assembly
pushing
out
to
github,
and
then
he
sets
this
up
using
a
github
action
workflow.
A
A
So
there
is
some
some
stuff
involved
here,
but
once
you
get
the
kind
of
setup
going
and
here
you
see
his
final
yamas
not
too
complex,
and
then
you
have
the
whole
kind
of
published
pipeline
so
all
right
and
then
I
think
the
last
one
on
my
kind
of
front
end
blob
at
the
beginning.
Here
we've
got
adding
signalr
to
a
vue.js
app.
So
here
he
talks
about
some
things
relatively
straightforward.
A
few
things
to
look
at
you
do
need
to
handle
the
the
mapping
hub.
A
A
A
A
So
here
he
goes
through
and
shows
his
his
json
converter
and
talks
about.
You
know
the
things
extracting
values
and
mapping
values
back
and
forth
here
he
shows
here's
his
actual
json
object
and
the
end
result
after
after
writing.
The
serialization
code
is
that
you
know
he's
able
to
model
or
to
map
back
and
forth.
Also
he
shows
the
benchmarks,
and-
and
it's
nice
to
see
that,
like
I
was
mentioning
earlier,
both
faster
and
generally
a
lot
less
allocation
too.
So.
B
A
A
A
So
she
talks
about
you
know
creating
the
api
project
copying
assets
over
and
then
she's
actually
going
in.
Let
me
see
and
she's
running
as
a
lambda
function,
so
she's
actually
creating
using
the
here.
It
is
using
the
project
and
the
publish
thing,
so
the
the
aws
tooling
for
visual
studio
is
actually
pretty
good.
A
I
found
it,
and
so
here
going
through
and
creating
the
publish,
handles
a
lot
of
stuff
and
then
she
kind
of
wraps
up
with
what
actually
got
created
in
the
in
the
portal
in
the
aws
portal.
So
you
know,
as
you
know,
good
reminder
as
a
net
core
developer.
Your
stuff
runs
everywhere,
we're
just
previous
post
was
looking
at
wsl
and
unix,
and
here's
aws
so
net
superpower,
you
know
running
running
all
over
the
place
and
then
all
the
clouds
is
a
good
thing.
A
Christo's
here
so
christos
pm
on
identity,
and
here
he's
writing
about
securing
grpc
services
with
net
core
and
azure
ad.
So
here
you
know,
writing
it's.
You
know
both
writing
the
grpc
application
and
then
setting
up
all
the
stuff.
So
usually
with
this
I
end
up
going
through
and
and
checking
out
the
docs
there's
identity
stuff
that
can
be
complicated
to
figure
out,
but
the
tooling
has
has
kind
of
simplified
over
time.
So
that's
nice!
A
So
if
you
go
to
live.asp.le
net
or
live.net,
then
it
actually
includes
that
in
in
the
page
itself.
So
what
he's
talking
about
there
if
we
go
to
live.net
I'll,
just
drag
this
over
and
share
the
screen
so
you'll
see
in
these
for
all
of
these
down
here
where
it
says
community
links.
So
here's
the
community
links
you
can
click
on
this
and
see
them
right
now,
so
pro
tip
all
right,
let
me
crank
through,
as
always,
I'm
like.
A
Oh,
I
don't
know
if
I
have
many
links
this
week
and
then
when
I
review
I'm
like,
I
have
too
many
links
this
week.
So
this
is,
this
is
cool.
This
is
jury
writing
about
running
asp.net
core
on
an
azure
b1
of
is
vm.
So
just
talking
about
things
to
do
as
far
as
running
on
a
small
vm-
and
you
know
it's
always
interesting
as
you're
going
through
and
shrinking
things
down
and
running.
So
here
he
talks
about.
You
know
that
you
can,
but
it
needs
to
be.
A
You
know
very
slim
and
and
tiny
one.
This
one.
I
did
see
some
comments
too.
People
are
like
yeah,
you're,
really
kind
of
pushing
it
up
against
the
limits
on
that
vm.
But
so
all
right
so
vms
are
are
difficult.
Let's
move
to
docker
and
there
we
go.
Scott
hanselman's
been
doing
these
kind
of
intro
videos.
A
A
A
A
So
I
ended
up
using
minicube
on
my
on
my
macbook,
but
the
docs
are
really
good
on
this.
The
the
project
tie
docs,
but
you
do
actually
need
to
read
through
this,
so
he
talks
to
her.
He
sets
up
the
in
azure,
using
azure,
aks
and
and
creating
a
cluster,
and
it
goes
through.
I
actually
ran
through
using
minicube
locally.
A
So
that's
that's
interesting.
So
we've
got
some
questions
already
on
yarp
and
we
will
throw
them
right
over
to
them
as
soon
as
I
wrap
up
these-
and
I'm
just
about
done
with
my
community
links
here
so
here
he
goes
through
and
shows
deploying,
and
this
is
a
really
cool
thing
too.
The
deploy,
interactive
shows
kind
of
it's
a
step-by-step
kind
of
command
line,
wizard,
where
it
asks
you,
you
know.
What
do
you
want
to
do
and
where
do
you
want
to
deploy
to
so
I
I
definitely
did
like
using
that.
A
It
was
kind
of
a
lightweight
thing.
Also,
an
important
thing
at
the
end
of
these
sorts
of
things
is
to
clean
up.
Otherwise,
you
can
end
up
running
a
kubernetes
cluster
for
a
lot
longer
than
you
meant
to,
and
spending
maybe
a
lot
more
money
than
you
wanted
to
so
so
this
is.
This
is
definitely
useful.
So
I
love
this
series
from
dave:
keep
them
coming
and
also
great
references
at
the
end
here
all
right,
clto
3-0
is
out.
A
I
saw
a
tweet
from
cecil
phillip
this
morning
on
that,
so
you
know,
we've
been
talking
through
the
micro
services
kind
of
section
of
these
community
links
and
steel
toe
adds
a
lot
of
kind
of
tooling
and
stuff
for
microservices,
with
net
core
so
stuff
like
rabbitmq
messaging.
That
is
definitely
a
handy
thing
and
then
integration
with
kubernetes
as
well.
So
a
lot
of
great
stuff
in
steel
toe-
and
this
is
you
know-
like
mentions-
you
know,
there's
interop
with
cloud
foundry,
but
there's
quite
a
bit
more
to
it.
A
A
So
a
lot
what's
cool
with
these
community
stand-ups
is
we've
already
had
demos
on
just
about
all
of
this
stuff,
which
is
pretty
neat,
definitely
some
stuff
like
we
just
recently
featured
we
had
a
blazer
deep
dive
where
they
previewed
a
lot
of
this
stuff.
So
so
that's
that's
pretty
cool
like
css
isolation
for
blazer
components.
A
We
had
the
the
team
on
so
check
out:
recent.net
community
stand-ups,
also
lazy
loading
etc.
So
there's
there's
information
on
how
to
how
to
update
and
what's
in
all
the
blazer
things,
and
then
you
know
things
like
model,
binding
validation
with
record
types
which
is
so
cool.
I'm
excited
about
that
and
then
it's
you
know
just
some
other
things:
jason
console.
A
So
definitely,
you
know,
try
it
out,
give
feedback
to
the
team
preview
8
it's
getting
close
and
the
last
post
I
have
to
share
by
sam-
and
this
is
from
back
in
may,
which
is
the
introducing
yard
preview
one
and
some
cool
stuff
in
here,
but
rather
than
dig
deeply
into
this,
why
don't
we
just
jump
over
to
you
folks
and
we'll
get
the
latest
and
greatest?
What
is
this
yarp
thing.
C
So
yarp
is
a
reverse
proxy.
You
may
be
familiar
with
regular
practices,
which
are
kind
of
sit
between
your
organization
and
the
internet
and
use
for
outbound
traffic.
Reverse
proxy
is
the
opposite,
so
it
sits
on
the
edge
between
the
internet
and
your
data
center.
It
is
the
front
end
that
the
public
sees
and
it
can
then
map
those
requests
from
the
internet
over
to
individual
servers.
Actually,
can
we
show
the
slide?
C
Yes?
Yes,
there
we
go
sorry
only
a
couple
slides
use
uses
demonstrations,
so
requests
can
come
in
and
it
can
say.
Oh
I
want
slash,
customers,
reverse
proxy
listens
to
that
looks
the
url
and
then
can
go
and
load
balance
that
across
a
set
of
different
servers,
and
so
it's
basically
looking
at
the
headers
of
the
request
and
based
on
any
of
the
fields
there
can
decide
how
to
route
that
traffic.
It
has
eventually
load
balance
between
between
servers.
You
get
health
checking
set
the
servers
down.
C
It
won't
send
traffic
to
that,
but
also
you
can
offload
work
from
those
back-end
servers
onto
the
reverse
proxy
encryption
off
compression
caching
and
then
also
you
can
collect
metrics
and
logging
at
the
the
reverse
proxy.
So
particularly,
if
you
have
a
heterogeneous
set
of
services
written
in
different
languages,
different
environments,
sticking
a
risk
proxy
in
front
of
them
means
that
you
can
remap
the
urls
as
you
need
to,
but
also
you
can
collect
metrics
and
logging,
regardless
of
what
that
back-end
system
is
using.
A
B
C
So
yarp
is
a
reverse
proxy
built
on
asp.net,
so
we
had
a
number
of
teams
come
to
us.
I
work
on
the
networking
side
of
net
chris
works
on
asp.net
and
they
came
to
us
independently,
basically
asking
how
do
we
build
reverse
proxies,
and
so,
after
having
a
couple
teams
come
to
us,
it
was
like
we
probably
ought
to
do
something
here.
C
A
C
I
do
have
another
slide.
That's
me
to
switch,
so
one
of
the
other
scenarios
that
people
use
reverse
proxies
in
is
what
they
call
the
service
mesh
so
again,
really
good
for
heterogeneous
services
example.
Here
I've
got
two
hosts
one
hosting
service,
one
two
and
three
and
the
other
hosting
service
abc,
and
let's
assume
that
service
one
wants
to
talk
to
service
b.
It
doesn't
necessarily
know
or
sorry.
Oh,
my
diagram
is
wrong.
C
According
to
my
clients,
okay,
so
once
called
across
the
surface
a
rather
than
it
having
to
know
which
servers
actually
handle
service
a
it
could
just
talk
to
localhost
and
say:
hey,
send
this
request
to
service
a
mesh
proxy.
There
will
knows
about
all
the
other
mesh
proxies
and
so
basically
says
hey
host
two.
I
think
you've
got
a
service
a
so
it
sends
the
quest
to
go
over
to
the
mesh
proxy
on
host
two,
and
that
goes
oh
yeah.
C
So
the
key
difference
between
yarp
and
these
other
services
is
what
we
heard
from
people
internally.
The
teams
internally
who
want
proxy
is
generally.
They
want
to
do
something
a
little
bit
weird,
and
so
they
want
to
be
able
to
write
code
and
the
problem
with
the
existing
proxy
solutions
is
they're,
generally
c,
plus
and
so
you're,
either
using
an
extensibility
system
of
like
java,
javascript
or.
C
Lower
but
all
around
teams
are
using.net
and
they
want
to
be
able
to
write.net
code,
and
they
also
want
that
extensibility
to
be
fast,
and
so
that's
where
europe
comes
in,
we
have
our
own
little
pipeline
as
part
of
the
arc
that
does
load
balancing
health
checks,
request,
transformation,
there's
other
pieces,
and
so
you
can
either
modify
the
existing
components
or
add
and
insert
your
own.
If
you
want
to
do
authentication
or
other
pieces,
you
can
do
all
that
using
that
pipeline.
B
C
Good
good
good
prompting,
so
we
we
have
not
yet
done
a
deep
drive
into
the
perth
of
yarp,
but
we
have
a
great
benchmark
lab
that
we
run
internally
and
so
we're
actually
tracking
the
perf
of
a
couple
of
different
competitive
proxies
and
europe.
We're
not
quite
there
yet
with
a
red
line
in
this
compared
to
the
others.
But
we
would
believe
we
can
be
competitive
with
envoy
and
nginx,
at
least,
if
not
aj
proxy.
C
Okay,
so
we've
already
been
doing
a
bunch
of
work
on
that
in
the
five
the
net
five
time
frame.
Actually,
europe
has
been
we've
been
making
less
progress
on
the
art
for
the
last
couple
of
months,
because
the
resources
have
been
working
on
getting
those
features
into
dot
net
five,
so
that
we
could
take
advantage
of
them
in
europe.
A
B
C
A
C
A
C
That
is
that
that's
a
really
so
ocelot
is
a
reverse
proxy
and
an
api
gateway.
The
big
difference
in
the
advantage,
the
thing
that
ocelot
does
is
it
will
actually
interpret
and
crack
the
body
of
the
http
requests
and
responses.
One
of
the
decisions
we
made
in
europe
is
we're
not
doing
that
in
v1.
It
means
that
we
can
stream
the
content
directly
from
the
client
to
the
back
end
and
the
back
and
back.
We
don't
need
to
buffer
it
once
you
do
buffer
it.
C
It
has
perf
impact,
but
there
are.
There
are
pros
and
cons
to
that.
It
has
perf
impact,
but
then
you
can
do
interesting.
Things
like
rewriting
that
request
redoing
the
body
so
ocelot
can
take
a
request
and
split
it
and
send
send
that
to
individual
servers
and
then
merge
the
responses
back
together
again,
okay,
so
what
we
do
in
the
arc?
Is
we
just
work
off
the
we
kind
of
decide?
The
line
is
we'll
work
off
the
headers,
not
the
body
off
body
of
the
request.
A
B
A
A
B
So
let's
go
look
at
the
config,
so
this
auto
look
really
familiar
every
asp.net
core
template.
Does
this
and
then
people
wanting
to
configure
kestrel
can
start
adding
these
endpoints
here?
So
this
is
just
an
asp.net
core
app.
It's
listening
on
hbs
5001,
http
5000,
all
right,
and
then
we
get
into
the
arp
fun.
B
B
A
C
B
A
A
B
A
B
To
report
the
final
conclusion
of
your
stream
did
it
exit
gracefully?
Did
it
get
up,
killed
whatever
okay,
so
the
clusters,
a
cluster,
has
a
couple
simple
options:
we've
got
load
balancing
built
in,
we
have
session
affinity,
components
and
then
a
cluster
is
primarily
a
group
of
destinations
and
each
destination
has
its
address.
A
A
B
A
A
B
A
B
C
C
Because
it
turns
out
that
round
robin
is
actually
not
the
best.
You
think
it's
the
best,
the
best
load
balancing,
but
there's
a
bunch
of
research
that
round
robin
is
actually
the
way
the
worst
okay,
because
you
can't
like
individual
requests,
don't
tend
to
have
the
same
input.
All
requests,
don't
have
the
same
impact,
and
so
it
just
ends
up
with
one
server.
Getting
pegged.
A
B
A
B
B
A
A
A
A
B
A
B
A
A
B
B
B
A
A
B
A
B
B
C
B
B
A
C
B
B
A
B
A
B
B
B
Let's
look
at
a
few
of
the
other
extensibility
points,
real
quick,
so
in
the
other
sample
you
saw,
map
reverse
proxy
was
just
a
single
line,
and
when
you
do
that
single
line
it
includes
a
few
can
defaults,
such
as
session
affinity
and
load
balancing
these
are,
for
the
most
part,
these
are
somewhat
normal,
asp.net
core
middleware
and
if
you've
written
some
middleware
examples,
you
recognize
this
pattern.
This
is
the
hp
context
and
that's
the
next
middleware.
A
B
B
B
A
B
A
A
B
How
do
I
run
a
callback
on
every
request
and
assign
the
right
route
and
we've
got
some
theories
going?
No,
not
a
lot
of
code
to
share.
Yet,
although
the
standing
theory
is
that
you
end
up
adding
one
catch-all
route
in
the
table
and
then
you
end
up
just
writing
a
simple
middleware
like
this.
That
says:
no!
No!
I
know
where
it
belongs.
A
C
So
azure
functions
and
websites
are
examples
of
this
where
they
host
many
many
many
many
domains
and
they
don't
know
up
front
which
they
can't
cash.
All
that
information
up
front,
but
also
also
dynamically
they'll,
be
spinning
like
if
sam.com
hasn't
been
used
in
a
long
time
that
may
not
be
running,
and
so
they
will
they'll
see
like.
Oh,
I
don't
have
that
entry.
C
A
A
B
A
A
A
A
A
B
A
A
B
A
B
C
B
C
A
Okay,
so
one
kind
of
holy
grail
question
we
always
get
is
we
have
people
that
are
migrating
large
applications
that
were
originally
written
with
asp.net
web
forms
or
mvc2
or
whatever
and
they're
moving
over
to
asp.net
core
and
they're,
trying
to
synthesize
it
into
one
front-end
app
and
they're,
maybe
creating
some
services
that
are
running
asp.net
core
and
but
they
wanted
the
whole
kind
of
like.
Oh,
the
admin
section
is
still
web
forms,
but
the
front
end.
Whatever
does
this
help
with
that.
A
C
Yeah,
so
I
I
was
talking
to
a
team
just
last
week
who
were
doing
exactly
the
authentication
case.
They
had
an
internal
website
that
was
using
good,
old-fashioned,
password
auth
and
they
wanted
active
directory
integration,
so
they're
actually
using
yarp
to
authenticate
to
the
front
end.
They
then
block
on
the
website.
They
can
only
be
accessed
via
the
proxy
and
pass
through
information.
That
way.
B
C
A
C
A
What
do
you
see
as
some
of
the
main
like
custom?
Where
is
this
a
good
fit
and
a
bad
fit,
especially
at
this
point
for
people
that
may
be?
You
know
interested
in
trying
this
out.
What
are
the
kind
of
slam
dunk,
easy
things
or
the
things
that
are
not
you
shouldn't
look
at
for
this
point
like
I
know,
you've
been
you've
been
overviewing.
A
What
it
does
you've
you've
just
shown
all
the
all
the
different
features,
but
I'm
just
trying
to
think
of,
for
you
know
for
people
that
are
interested
in
looking
at
the
like,
for
instance,
you
showed
performance
is
not
it's
good,
but
it's
not
like
as
high
as
some
competitors
at
this
point
and
there's
some
things
you're
still
working
on.
So
what's
what's
the
yeah,
you
should
absolutely
try
it
for
this
sort
of
thing
or
you
should
kind
of
hold
on
it
for
other
sorts
of
things.
B
C
A
C
I
would
say,
I
would
say,
like
we
have
the
basic
functionality,
the
basic,
the
the
the
core
fundamentals
in
there
now
we're
going
to
improving
things
like
the
metrics
and
logging
being
able
to
do
a
b
switching.
So
if
you
have
a
new
version
of
your
service,
people
will
stick
a
reverse
proxy
in
front
of
that
and
say.
C
That
we're
working
on
right
now,
health
checks
so
there's
both
active
and
passive
health
checks.
Activities
like
let
me
go
ping
the
destination,
every
30
seconds
or
whatever
make
sure
sure
it's
live
passive
is
let
me
look
at
the
requests
and
the
responses
coming
back
there
and
ensuring
that
I'm
not
getting
server
errors.
Individual
response
errors
may
be
correct,
but
it's
kind
of
how
do
I
interpret
that
and
then
decide
that
there's
a
there's,
a
there's,
a
problem
with
that
server
or
not.
B
B
C
A
B
C
A
B
B
A
B
A
C
B
C
A
A
A
A
C
A
B
A
A
Wonderful,
that's
the
way
to
do
it.
Cool,
yep
and
and
you're
also
included
in
the
show
notes
on
this.
It's
it's
listed
there
and
we're
doing
some
work
also
on
the
the
page
for
this
it'll.
Actually,
thank
you.
Sam
that'll
actually
make
it
so
that
they're
included
more
in
with
the
actual
show
listings
so
very
cool.
This
is
since
the
first
post
I've
been
like.
Oh,
we
got
to
get
you
folks
on
the
the
show
and
and
learn
more
about
this.
A
So
and
I
I
really
love
the
idea
of
like
this
totally
makes
sense
to
me
now
of
how
integrating,
in
with
the
asp.net
pipeline,
really
simplifies
a
lot
of
things
and
and
being
able
to
write
custom.net
code
to
manage,
like
you
know,
distribution
in
the
in
the
failover
and
all
that
kind
of
stuff
sounds
really
neat.
So.
A
Okay,
all
right!
Well,
I
think
that's
a
great
great
place
to
wrap
up.
So
thanks
a
bunch
and
then
let
us
know
in
the
future,
as
you
get
you
know,
get
closer
to
release
or,
if
there's
more
stuff,
to
show
off
a
lot
of
great
questions
and
excitement
from
the
community
as
as
we're
doing
these.
So
I'm
you
know
happy
to
have
you
back
on
cool.
Thank
you.
So
much
all
right!
Thanks
a
bunch!
That's
it!