►
Description
Join members from the ASP.NET teams for our community standup covering great community contributions for ASP.NET, ASP.NET Core, and more.
Community Links: https://www.theurlist.com/aspnet-standup-2019-11-19
A
B
B
A
A
B
A
Start
starting
off
here,
Stuart
Lang,
pointing
out
his
favorite
way
of
handling
HTTP
status
codes.
So
he
talks
about
first
of
all,
the
HTTP
status
code.
You
know
in
system
net
how
it's
better,
with
the
asp
net
core
status
codes.
You
have,
you
know,
you've
got
the
I,
don't
know
it's
got
the
number
and
the
string
right.
B
C
A
C
A
A
A
C
A
B
B
C
C
C
A
And
you're
trying
to
remember
so.
This
is
kind
of
a
nice
all
right.
So
Derek
writing
here
about
Orleans
health
checks
using
ASP
net
core.
So
a
benefit
of
using
generic
hosts
here
is
now
that
we
can
integrate
these
together.
So
here
is
he's
showing
how
he
writes
he
does
this
by
building
writes
a
health
check.
You
know
using
a
health
check
grain
that
he's
created
himself
and
then
he
creates
a
an
extension
method
and
so
then
he's
injecting.
A
Let
me
see
setting
it
up
here
where
it
just
says,
add
health
checks
and
a
d'orléans
health
check.
This
is
a
very
simple
one.
Just
saying
like
as
a
health
is
the
grain
available,
but
then
the
nice
thing
here
is:
it's
all
integrated
now,
so
you've
got
them
one
view
and
you
could
have
health
checks.
It
integrate
multiple
things.
B
A
So
this
is
something
Alan
sent
me
over
Twitter.
So
thank
you
Alan.
This
is
Anne
cosmos,
implementation
of
the
asp
net,
core
identity,
backend
nicer,
yeah,
so
so
being
able
to
just
you
know,
store
your
stuff.
So
nice
walk
through
here
pulling
in
the
the
nougat
package,
configuring
the
the
connection,
and
then
you
know
pretty
standard
being
able
to
to
both
use
the
standard
identity
and
then
to
extend
it
so
pretty
similar
to
the
other
extension
points,
but
nice
nice
to
be
able
to
do
that.
A
B
A
A
Feel
free
to
cut
me
off
because
I'll
just
do
my
summarization
here,
but
he's
talking
specifically
about
you're
no
longer
able
to
inject
services
into
the
startup
class.
This
actually
seems
like
something
you
would
do
kind
of
rarely,
but
he
talks
about
cases
where
you
I
have
something
pre-configured
before
startup
happens
or
have
something
injected,
so
you
can
use
it
to
make
a
decision
on
configuring,
your
other
stuff,
so.
C
Friends,
yeah
on
this
whole
thing,
so
the
way
this
used
to
work
before
3.0
is
we
used
to
build
two
containers
want
to
bootstrap
the
application
and
then
one
after
that
it
was
bootstrapped
that
can
cause
torn
state
for
Singleton's.
So,
for
example,
imagine
you
injected
a
lager,
a
lager
in
the
into
your
start
class,
and
then
you
added
it
again
in
your
configure
method.
You
get
two
different
singleton
instance.
If
it
became
two
because
they
came
from
two
different
containers,
so
we
write.
A
C
A
Yeah,
okay,
that
makes
sense
so
he
talked
through
the
case
here,
specifically
his.
He
gave
kind
of
aid
like
this
example
here
of
an
injected
thing
used
to
decide
what
you're
going
to
configure
a
more
concrete
case
that
he
walks
through
down
here
is
identity
server
yep.
So
he
talks
about
changes
for
identity
server
and
going
through
what's
written
up
in
their
documentation-
and
you
know
like
like
here
it's
you
know
using
factory
methods
and
stuff,
not
not
too
much
to
be
difficult,
but
so
yeah
nice
to
see
that
written,
always
great
they're
amazing.
A
I
I
love
his
format
like
it's.
It's
always
he
gives
a
clear
introduction.
Here's
what
I'm
gonna
do
here's!
What
we'll
talk
about
like
builds
things
up
here
as
very
good
code
samples
and
then
the
summary
at
the
end
I'll
of
the
summaries,
because
half
the
time
I'll
get
to
the
end
of
be
like,
oh
I,
didn't
totally
catch.
You
know
this
specific
thing
or
sometimes,
if
I'm
losing
the
plot
partway
through
I'll
jump
down
to
the
summary
and
then
go
back
and
read
the
rest
of.
A
Yes,
okay,
so
I've
got
my
usual
suspects
group
together.
Here
we
had
Andrew
lock
and
now
we've
got
Steve,
Gordon
and
so
Steve
Gordon
about
connection
pooling
with
httpclient.
So
this
is
really
kind
of
fun.
History
I
had
some
some
flashbacks
and
a
few
nightmares,
but
he's
he
talks
through
kind
of
the
history
and
has
some
really
nice
diagrams
going
on.
A
One
thing
he
talked
about
here
was
this
this
case
where
there
was
the
guidance
to
reuse
or
to
to
reuse,
your
HTTP
client
instance
prevent
exhaustion,
etc.
However,
you
went
into
this
case
where
DNS
changes
aren't
respected
and
if
your
DNS
changes,
for
instance,
if
you're
doing
anything,
fancy
with
like
a
j''r,
you
know
as
your
outings
or
stuff
it's
not
going
to
get
picked
up.
If
you
have
a
long,
long
used
connection
instance.
A
So
so
there's
there's
all
these
workarounds
and
things
to
do,
and
then
he
kind
of
talks
through
a
changes
since
dotnet
core
to
one
and
the
two
sides,
one
on
the
HTTP
client
factory,
but
also
on
the
socket
HTTP
handler
from
the
dotnet
team
and
how
that's
kind
of
handles
up
for
you
yeah.
So
anyhow,
then
he
talks
about
how
you
don't
need
to
mess
with
the
connection
pooling
and
I.
Don't
know
if
you
want
to
jump
in
so.
C
C
If
you
use
a
singer
than
HP
client
you
would
you
know
we
cashed
the
DNS
resolution
for
the
entire
lesson
of
the
client,
so
the
advice
was
to
use
some
HP
clients
and
that's
kind
of
vague,
so
the
HP
client
factory,
what
it
did
was
it
would
pull
handler
instances
you
get
that
refresh
on
donut
framework.
You
could
you
could
configure
the
service
point
manager
to
have
a
timeout
for
some
time
frame
for
DNS
resolution
and
on
to
point
one
and
up.
C
A
C
A
A
C
A
C
Pooling,
specifically,
is
for
other
features
like
di
friend
in
this
configuration
friendliness.
It's
mostly
a
wrapper
over
a
pipeline
of
HTTP
handlers
that
has
log
in
by
default
that
can
be
injected
into
your
controllers
or
your
your
a
spinning
application,
and
it
also
happens
to
do
handler.
Caching,
but
that
isn't
the
main
like
thing.
A
A
C
Is
clear,
is
you
can
tell
in
like
in
every
single
space,
there's
the
declarative,
people
and
people
who
love
imperative
code
and
really
that
was
Larry's?
That
kind
of
like
go
to
your
you,
what
you
prefer,
if
you
want
to
write
a
lot
of
logic,
imperative
Lee,
to
determine
your
validation?
You
use
this
library,
otherwise
use
attribute
yeah.
A
All
right,
this
is
nice
from
Jimmy
Bogart.
So
what
he's
doing
there's
this
contoso
University,
which
is
standard
sample
that
the
box
team
has
maintained
for
a
long
time
and
they
have
kind
of
a
fork
of
it.
That
does
things
the
way
that
they
build
things
at
head
spring.
So
this
is
just
a
nice
kind
of
opinionated.
You
know
a
thing
where
it's
like,
for
instance,
using
CQRS
with
mediator
validation.
We
just
looked
at
so
they're
using
fluid
validation
here,
integration,
testing,
etc.
A
So
this
I
love,
this
kind
of
style
of
you
know,
there's
kind
of
a
standard
like
it's
already
written
up
in
the
docs.
It
already
explains
all
the
problem,
space
and
everything
in
the
docs
and
then
no
no
need
for
Jimmy
to
go
and
write
like
his
own
completely
new
sample
write.
Instead,
just
we
can
look
at
the
diff,
so
this
is
nice.
You
know
just
kind
of
going
through,
for
instance,
looking
at
you
know
in
the
tests
and
he's
using
the
shrewdly
library
to
bring
in
these
should
base
tests
and
yeah.
A
A
A
B
B
Actually
fly,
you
know,
no
matter
whether
it's
a
wind
forms,
don't
their
core
app
on
Windows
or
a
console
app
that
you
want
to
run
on
Linux
or
something
like
this,
which
is
a
cross-platform
desktop
application
in
this
case
using
blazer
for
dotnet
core.
But
you
could
also
imagine
it
uses
some
experimental
like
blazer
native,
like
you
know,
Steve
showed
blotter
blue
blazer
for
flutter
at
NDC.
B
Also
this
year
and
other
people
have
experimented
with
blazer
native
mappings
for
other
native
stacks.
You
could
really
do
a
nice
layered
offering
here
such
that
you
just
publish,
hey,
publish
my
app
and
you
get
out
in
the
air
for
a
given
set
of
rids
and
you
get
out
the
other
side,
a
bunch
of
really
cool
installers
that
just
do
the
right
thing.
Yeah
quote-unquote,
all.
C
A
It's
just
amazing
I
did
a
demo
of
this
recited
this
keynote
and
in
Istanbul
and
I
it
was
so
cool
to
like
show
here's
the
folder
and
it
was
like
a
meg
and
a
half.
You
know
so
yeah.
So
here
he's
saying
you
know
this
is
it's
an
experiment,
not
making
promises
and
if
we
do
have
people
watching
that
are,
you
know,
have
a
lot
of
C++
or
Objective
C
experience
he's
looking
for
more
helping
review
there,
but.
B
A
A
C
C
What
it
would
do
is
it
would
set
a
thing
called
an
activity
which
is
basically
a
glorified
async,
local,
that
stores
the
ID
and
other
state
for
the
current
async
flow.
So
your
request
comes
in
you,
get
a
new
activity
and
you
flit
to
any
album
call
and
it
would
create
a
child
activity.
So
you
get
this
kind
of
like
a
bunch
of
spans
that
have
IDs
that
are
linked,
so
you
can
do,
for
example,
these
pretty
graphs
and
like
Zipkin
or
Jager,
or
app
insights,
to
see.
C
If
for
your
Microsoft
application
that
contains
multiple
apps,
your
client
front-end
back-end,
you
can
see
the
entire
trace
going
through
with
IDs
and
it
also
correlates
logs.
So
every
log
statement,
by
by
default
in
a
snit
course
should
have
the
activity
ID
for
the
whole
trace
and
the
span
ID
for
the
current,
like
the
current
thing
being
the
current
request
so
that
that's
an
inn
3.0,
we
added
support
this
thing
called
w3c
trace
context.
A
Very
cool
yeah
and,
in
the
whole
I
mean
a
big
point
of
this,
is
as
we're
building
more
distributed
applications.
It's
really
like
it
gets
harder
to
troubleshoot
where
an
error
is
happening
or
what
we
know.
So
it's
some
weird
interaction
between
two
services
or
something
yeah,
well,
cool,
all
right,
gr,
pcs,
so
James
writing
up
comparing
gr
PC
versus
HTTP
API
is
I
mentioned
last
week.
I
get
a
lot
of
questions
about
these
people
are
asking
you
know
when
should
I
use
which,
and
how
do
I,
how
do
I
update,
etc?
A
This
is
based
on
so
James
gave
a
presentation
at
NDC
Sydney
and
this
Maps
pretty
well
to
his
presentation
there.
So
if
you,
if
you
prefer
reading
this,
is
these
are
great
notes.
If
you
want
to
watch
him
actually
talk
through
this,
you
can
see
his
video
from
in
DC
Sydney,
and
that
was
one
of
the
links
I
shared
last
week.
Yeah.
B
The
reality
is
that
the
GRP
C
requires
some
HTTP
two
features
that
are
not
supported
currently
in
HTTP,
which
means
they're
not
supported,
is
which
means
they're
not
supported
by
things
like
application
request.
Routing
IR,
which
is
built
on
is,
which
also
means
they're
not
supported
in
a
lot
of
the
azure
services,
which
use
one
all
of
those
technologies
that
I
just
mentioned.
B
One
of
those
is
a
trap
services
which
is
probably
the
most
impactful,
because
folks
try
and
deploy
their
a
spinner
application
that
uses
G
RPC
to
as
your
app
service,
and
you
get
just
a
nondescript
error
at
request
time.
It's
very
hard
to
diagnose
like
why?
Is
it
not
working
it?
Does
it
still
doesn't
work
if
you
use
app
service
for
Linux
I've?
Seen
a
little
bit
of
misinformation
where
people
like
our
it'll
work
with
app
service
for
the
nexus,
a
Windows
problem.
B
Unfortunately,
up
service
for
Linux
still
has
a
because
there's
a
front-end,
that's
sort
of
before
your
application
in
app
service.
That
still
has
this
issue,
and
even
though
you
might
be
running
on
Linux
on
your
back-end
machine,
the
front
end
won't
pass
through
the
relevant
information
that
it
needs
for
geodesy
to
work.
We
don't
have
a
timeline
to
share.
I
can
tell
you
that
David
is
working
on
this
along
with
a
whole
bunch
of
other
folks,
from
different
teams
to
try
and
essentially
get
this
support
added
in
the
requisite
places.
C
I'll
tell
you
whether
we
have
we
do
have
the
first
builds
of
our
HTTP
sis
managed
server.
That
does
use
the
new
features
that
were
put
into
Windows
version
new
new.
That
isn't
that
no
one
has
yet
besides
us
to
test
the
end-to-end,
and
it
does
work
at
that
level.
Oh
cool,
after
that
we
have
to
make,
is
changes,
and
then,
after
that
yeah
this.
B
B
B
It
can
be
short,
cutted
and
parallelized,
because
we
can
share
code
between
teams,
but
with
regards
to
releasing
this
to
customers,
it
can
only
ship
as
fast
as
the
slowest
component
and
obviously
today,
that
is
generally
Windows,
because
their
honor,
what
two
updates
a
year
strategy
for
this
type
of
change,
which
is
a
feature
change,
saying,
I,
don't
think,
there's
any
timelines
for
the
Windows
Server
stuff
that
we
can
share
yet
yeah.
There's.
C
B
A
C
B
A
B
C
C
B
C
B
B
B
And
if
you
remember
those
folks
who
were
programming
on
darknet
back
when
WebSockets
became
a
thing,
you'll,
remember
some
of
the
I'm
trying
to
find
the
right
word.
You
remember
some
of
the
things
we
had
to
deal
with
back
then
as
well,
where
we,
for
example,
you
couldn't
use
WebSockets.
Unless
you
were
on
a
new
version
of
is
which
I
think
was
the
windows,
8.1
version
or
eight
or.
B
And
same
for
the
client,
like
you,
had
to
have
a
new
version
of
Windows
to
be
able
to
use
WebSockets
in
the
browser
on
the
client.
If
you
were
using
the
windows,
internet
IP
stack,
HTTP,
stack,
sorry
and
then
for
each
should
be.
It
was
the
same
thing.
So
if
it
was
Windows
10,
they
recall,
and
you
had
to
wait
for-
is
10
to
get
HTTP
to
support.
B
A
B
A
I
ran
into
this
when
I
was
like:
oh
I'll
show
off
the
the.net
conf,
you
know
keynote
demos
I
was
like
oh
shoot.
I
need
to
do
some
work
to
set
up
all
that.
Well,
all
right,
one
last
very
quick
one.
So
just
an
announcement
on
dotnet
core
three
one
preview,
three-
and
so
this
is
all
this
is
saying-
is
here's
how
to
update
your
applications?
So
this
is,
you
know,
primarily
bug
fix
release.
You
can
update
your
blazer
templates
and
you
know
you
can
update
your
packages
and
give
feedback.
A
B
A
B
C
B
B
A
C
A
couple
of
things:
so
what
have
you
been
working
on
so
my
so
husband
in
this
blog
post,
I
didn't
even
know
until
he
showed
me,
oh
about
my,
my
Mike
github,
and
what
I'm
working
on
just
random
things
that.
C
B
C
B
C
C
C
A
C
A
C
Houdini
and
stuff,
but
there's
some
stuff
here,
that
he
didn't
show
so
project
bedrock
if
you've
ever
seen
me
talk
anywhere.
Maybe
I've
mentioned
it
in
passing.
It's
not
all
those
things
that
that
weed
I
think
has
a
ton
of
like
customers,
but
if
you're
doing
this
kind
of
programming
it's,
it
should
be
super
helpful
for
those
kinds
of
kinds
of
things:
project
who
Dini
it's
a
fun
name.
I'll
talk
about
some
more
as
we
go
through
it.
Microcontroller
is
the
third
one
and
it
kind
of
stems
from
Houdini
a
little
bit.
C
B
C
B
C
C
A
C
C
It's
called
platform
benchmark.
Okay,
this
is
the
platform
plaintext
benchmark
all
this
living
is
the
client
sends
sixteen
requests
and
then
read
sixteen
responses
and
be
right.
Perdy
used
in
the
level
code
and
cash
flow
to
me
that
work
so
Castro
in
the
very
beginning
was
an
application.
Sir.
It
was
a
web
server.
It
was
built
for
a
very
specific
purpose
before
dotnet
had
sockets
I
mean
believe
it
or
not.
This
is
like
before
there
was
a
cross-platform
stock
in
implementation.
C
We
grabbed
levy
off
the
shelf
from
the
GS
and
stuck
it
in
in
the
SP
neck
or
when
sockets
came
all
in
a
2.1.
We
introduced
an
abstraction,
so
we
could
run
on
both
and
it
took
us
like
up
until
2.1.
I
think,
to
get
all
the
perf
we
got
from
the
DVD
in
sockets,
so
we
wouldn't,
you
know
just
run
with
both
transport
side
by
side
and
kind
of
perfect
as
those
and
we
noticed
that
we
were,
we
were,
we
ended
up.
Having
I
ended
up
having
a
networking
abstraction
over
both
transports.
C
A
time
went
by
it
got
more
mature.
If
you
look
at
the
second
power
benchmark,
I
showed
back
here.
This
is
our
htx,
that's
the
Red
Hat
transport,
so
the
Red
Hat
team
wrote
a
custom
transport
for
Kestrel
that
uses
Linux
native
API
is
and
there's
a
cool
of
a
bunch
of
cool
awesome
additions
that
we
don't
do
in
the
BCL
custom.
C
C
A
C
Intent
was
take
the
same
model.
We
have
for
a
spin,
it
Cora.
We
have
htb
context
middleware
that
runs
on
top
of
that
mutates
it
and
then
there's
an
application
on
top
and
put
it
into
the
actual
stack
right.
So
as
an
example,
here
are
some
things
that
would
be
transport
so
TCP.
We
have
that
today,
with
sockets,
you
use
the
main
socket.
There's
quick,
there's
name
pipes,
there's
no
domain
sockets,
the
shared
memory
middle
work
would
be
TLS,
login
compression
protocols,
HP
one
two
three,
you
know
a
signaler,
AMQP,
etc.
So.
B
C
Types
of
traffic,
exactly
okay,
so
basically
you
so,
for
example,
if
we
want
to
get
so,
signaler
is
built
on
bedrock
and
if
Sigler
one,
if
you,
if
you
want
to
run
Sigma
over
name
pipes,
you
change
a
transport
to
be
the
name
pipe
transport
right
Sam.
For
this
there's
a
thing
called
core
dub
CF.
If
you
aren't
aware
chord
of
C
F
is
an
open
source.
C
So
the
the
intent
was
that's
around
about
other
stocks
like
Java
and
Swift,
and
go
and
whatever-
and
we
saw
this
Potter
knows
they're
a
bunch
of
projects
that
kind
of
make
building
networking
applications
easy
Nettie's
one
for
java,
that's
very
popular,
easier,
the
easy
easier
that
easier
and
more
efficient
right.
Yes,
so
could
we
do
the
same
thing
for
dotnet
could
could
it
could
I
say
if
you
want
to
build
above
the
server
a
client
grab?
C
C
C
So
the
demo
I
have
this.
This
project
on
all
my
github
called
bedrock
transports
and
it
has
a
couple
of
products
inside
of
it
a
better
framework
client
on
a
server
and
in
this
other
random
stuff,
I
won't
go
into
and
the
intent
was
to
show
how
we
could
throw
together
a
couple
of
random
protocols
that
try
to
find
patterns
of
things
that
were
common
like
where
the
partials
common.
Could
you
share
stuff
between
client
and
server
to
kind
of
flesh
out
the
whole
design
right?
C
So,
let's
take
a
look
at
the
server
first,
so
here's
a
server
and
the
server
has
and
very
familiar
to
estimate
core
developers,
a
service
collection
where
I
call
ad
logging,
I,
add
console
logging
I,
add
signal
because
I'm
gonna
use
signal
in
one
of
my
endpoints
and
I.
Have
this
thing
called
a
server
builder,
so
I
create
my
search
provider.
I
do
new
server
builder
I.
Do
you
saw
case?
This
is
a
specific
transport,
so
I
could
do
things
like
you
know,
use.
C
C
Listen:
okay,
Yoriko,
listen!
So
I
didn't
finish
the
naming.
It
says
someone
somewhere
use,
but
the
intent
is
you
listen.
You
know
HTTP
to
as
a
transport
websites
at
the
transport
address,
signaler
I,
just
Sigma
is
actually
built.
So
if
you
are
familiar,
the
address
signal
our
service
is
basically
today
is,
is
is
kind
of
touted
as
like
the
signal,
our
scale
up,
backplane.
C
B
B
B
C
C
C
B
B
C
B
The
advantage
of
doing
it
this
way
is
that
the
it's
still
typed,
it's
not
like
a
loose
bag
of
you
know
crap.
If
you
have
it's
still
tucked,
but
it's
fully
extensible
and
anyone
can
add,
manipulate
access,
augment
any
feature
anytime
in
the
pipeline
either
a
connection
establishment
or
while
the
connection
is,
is
going
right.
Yeah.
B
Through
to
the
known
feature,
so
we
we
have
high
level
property,
so
you
just
deal
with
a
should
be
context
as
an
app
developer,
because
that's
part
of
our
app
model,
the
very
top
of
the
stack
that
David
showed
before
in
that
slide,
there's
an
application
model
and
we
still
build
on
all
this
stuff
under
the
covers.
But
if
you
interact
with
like,
is
there
a
session,
my
people?
I'm?
Sorry?
Is
there
a
request?
B
Your
request
is
actually
a
feature
in
the
clincher
collection
and
the
response
is
a
different
feature,
but
you
don't
get
them
by
that.
You
just
go.
Don't
request
that
response
yep,
because
you
have
a
wrapper
object
that
delegates
for
you
there
are
other.
There
are
other
features
in
that
collection
today,
in
a
spirit
core
that
we
don't
promote.
It's
a
lot,
there's
actually
quite
a
lot
of
them,
but
if
you
see,
if
you
want
to
just
like
explore
bit
a
little
bit
more
about
this,
do
it
for
that.
B
B
C
C
B
A
C
My
so
specific
for
one
I
wrote
a
dummy,
HTTP
server.
That's
the
committee
mini
Kestrel,
so
this
kind
of
shows
how
you
would
how
you,
with
layer
on
other
platform,
other
op
models,
so
use
the
same
it
over
and
then
you
know,
I
want
a
server.
I
said
up
for
HTTP
and
here's
my
application
and
I
was
trying
to
experiment
with
a
different
model
than
the
mobi
high
for
Kaaba.
So
it's
using
this
is
a
cannibal
to
feed
you
requests,
asynchronously
cool
so
like
just
for
fun.
Dis
are
fun
to.
B
C
C
Sigma,
okay
I
can
actually
run
signaler
on
top
of
TCP
directly
or
any
transport
that
implements
this
abstraction.
So
I
have
the
signaler
protocol
here
running
here's
my
chat
hub
I,
broadcast
to
all
people
that
are
currently
on
this
port
mqtt
is
a
very
popular
yo
T
protocol,
so
I
grabbed
this
random
library
off
of
the
internet
called
mqtt
net
I
just
mean
they
already
supported
some
of
the
abstractions,
so
I
plug
it
into
this.
This
news
that
they.
C
B
C
And
then
I
go
server
with
TLS
logging
is
after
decryption
here,
so
I
should
print
plaintext
and
I.
Think
the
client
side
has
logging
like
before
encryption,
so
it
prints
garbage
for
fun
and
then
the
last
port
it
prints
out.
This
is
a
custom,
a
custom
binary
protocol
that
I
wrote.
That's
pretty
basic
and
I
was.
C
Was
playing
with
a
generic
protocol
reader
I
writer,
so
you
implement
this
interface.
I
protocol
writer,
I
protocol
reader,
so
given
a
message
right
to
this,
this
byte
array,
given
a
regional
sequence,
parse
a
T
and
if
you
implement
two
of
these
pieces,
you
can
just
say
give
me
a
protocol
reading
writer
and
it
wouldn't
do
all
the
boil
plate
to
parse
and
do
handle
parks,
messages
and
handle
like
drop
frames,
and
you
just
call
really
think,
and
you
get
better.
It's.
C
B
Yeah
and
like
I
know
like
I,
this
still
like
I'm,
some
twenty
percent
of
the
the
vision
of
bedrock
is
actually
in
the
product
now
and
then
a
lot
of
what
you're
showing
us
here,
which
is
this?
How
how
far
can
we
go
with
the
idea
of
abstracting
networking
programming?
So
if
you
want
to
implement
a
protocol,
you
just
like
Emily
and
a
protocol
and
you
plug
it
in
prefer
and
all
the
really
hard
stuff
is
just
taking
careful
yeah,
including
what
you
just
said
like
you
know.
Well,
the
protocol
failed.
C
A
C
Just
reads
an
integer
from
the
length
its
length
prefix,
so
you
read
integer
to
begin
with
the
way.
What
is
open
know
if
it's
less
than
the
length
like,
don't
read
it
if
it's,
if
it's
more
than
the
length
to
get
the
actual
message,
therefore,
write
is
very
simple
length
first
and
then
the
payload
so
very.
C
So
this
is
the
server
and
then
the
client-side
similar
same
primitives
builds
build
client
and
then
this
for
kind
of
different
demos
and
methods
echo
server.
So
on
the
server
there
was
a
severability
on
the
client
there's
a
client
builder,
and
it
has,
you
know,
used
socket.
So
this
is
a
transport
and
then
this
is
the
same
middleware
that
using
a
server-side,
so
the
intent
is.
There
are
some
classes
of
middleware
that
you
can
run
on
both
server
client
so
and
dumping
advice
is
pretty
like
Brandeis.
It
doesn't
require,
knowing
which
one
you
are
right.
C
Echo
server,
pretty
simple
copy,
the
sound
input
to
the
transport
and
then
read
the
output.
I
have
an
HP
client
that
does
DNS
caching
using
middleware,
so
this
middleware
itself
runs
client
site
and
it
caches
the
DNS
resolution
for
some
amount
of
time
before
before
it
will
run
connect
again.
So
every
connect
take
this
this
DNS
and
uses
the
cache
IP
address
for
some
time
frame
and
then
will
pass
through.
C
This
is
this
is
the
signal
our
client
using
sockets
using
the
the
socket
some
transport
and
then
echo
server
with
TLS.
So
let
me
run
this.
Oh
one
more
thing:
it's
pretty
cool
here's,
an
in-memory,
server
and
client
that
just
runs
all
in
process,
so
I
can
run
the
server
on
Clint
within
the
same
process,
give
it
the
memory
transport
and
it
will
just
write
bytes
in
memory
back
and
forth
for
fun,
because
that's
pointless!
C
C
Here's
a
server,
here's
all
the
endpoints
let´s
do
echo
server
hello
world
here,
the
bytes
or
the
hex,
here's
the
actual
bytes.
This
is
newline
server-side,
but
that
was
are
pretty
lame,
I
gotta,
say
well.
Well:
okay,
I
shouldn't
say
that
the
demo
is
like
the
demo
itself.
Why
show
is
lame?
Okay
and
I
can't
hear
any
claps
I'm
clapping
in
my
head
for
myself,
so
that
was
echo
server.
It's.
C
Code
yeah,
exactly
good
I,
feel
better.
Here
is
the
edge
to
be
quiet
example,
say
HBO
on
Oh
food,
so
there's
the
get
foo
HP
101,
here's
a
response,
server
received
it
you
know
roar
the
response,
so
pretty
basic.
No,
let's
do
something
a
little
bit
more
slightly
more
interesting
here
is
signal
are
running
so
here's
a
hub
protocol,
printing
out
the
entire
thing:
hey
hello,
les,
invoking
the
chat
on
the
server
side.
So
this
is
like
signal
running
over
TCP
directly.
B
A
B
B
A
B
C
Yeah
very
much
so,
okay,
they
call
it
a
networking
tool
kit.
Basically,
if
you
want
to
build
your
own
server,
a
client
right,
you
grab
stuff
up
the
shelf.
I
know
you
like
put
it
together
and
you
make
a
whole
ant,
Anstead,
okay,
so
I
think
part
of
it
is.
You
need
to
have
an
ecosystem
of
things
to
make.
C
C
On
the
server
side,
you'll
see
it's
actually
like
decrypted
and
not
garbage,
and
it
printed
out
by
have
TLS
and
the
version
is
1.2
and
the
hash
algorithm
is
sha.
384
I,
don't
know
what
that
is,
but
it's
not
512.
That's
not
due
to
two
things
just
in
between,
so
it's
more
secure
for
somehow
it's
more
secure
than
okay,
so
that
was
better
on.
B
C
I
can
probably
show
and
I
will
show
you,
but
the
cool
thing.
What
I
did
so
far
was
basically
adding
address
Ziggler
at
the
transport,
because
there's
a
there's,
a
public
protocol,
that's
documented
for
reading
the
wife,
often
the
network,
for
handling
that
the
Sigler
multiplex
protocol
I
basically
made
it
a
transport.
So
the
application
doesn't
even
understand
that
it's
using
signal
are
so
I
put
the
string
in
here
from
the
azure
like
the
Azure
service.
C
B
C
C
C
C
A
C
B
It's
typically
effective,
very
large-scale
needs
and
before
the
code
even
gets
to
your
app,
so
they
have
some
type
of
age
yep
new
listener.
They
want
to
build
a
custom
edge
listener
that
can
do
things
like
you
just
said,
like
they
can
inspect
the
TLS
handshake,
which
is
very
hard
to
do
on
Windows
dip
like
if
you
use
the
native
stack
and
then
they
can
like
do
things
like
reject
the
connection
based
on
arbitrary,
whatever
right,
because
that
scale
you
need
to
do
stuff
like
that.
Exactly
yeah
and
we're.
C
Looking
at
having
something
similar
or
something
to
plug
into
a
to
be
client
for
different
transport,
so
if
you
run
them
in
G
RPC
over
name
pipes,
you
have
to
go
to
plug
in
some
kind
of
transport
thing
right,
so
we're
looking
at
that
Bible
to
figure
out
what
the
abstraction
should
be
for
you
to
be
client
any
more
questions.
For
this
thing,
no.
A
B
Example
today,
the
model
binding
and
validation
system
is
kind
of
all
tied
together,
yep
and
you
typically
consume
them
via
an
MVC
controller,
with
an
action
which
is
decorated
with
some
information.
You've
got
some
type
information,
there.
You've
got
parameter
names
and
you
may
have
some
attributes
and
all
that
feeds
into
it.
You
don't
actually
deal
with
the
types
directly
the
subsystems
they're
all
buried
deep
inside
NBC,
but
what
if,
for
example,
a
model
binding
could
just
be
middleware?
We
talked
about
like
feature
feature
collections
before.
B
Why
couldn't
there
just
be
a
middleware
that
some
point
in
the
pipeline
that
decides?
It's
gonna,
look
at
input,
values
on
the
request,
constructor
type
for
you,
based
on
how
its
configured
and
shove
that
away
in
a
feature
so
that
you
can
get
to
it
later.
If
you
want
to
very
similar
to
how
endpoint
routing
happens
at
some
point
and
those.
B
B
B
C
B
I
think
one
of
the
things
that
comes
out
of
that
that
we'd
really
like
to
see
happen
is
that
it
means
other
framework.
Authors
from
the
smallest
to
the
largest
can
reuse
these
pieces
a
lot
more
simply.
We
have
so
many
people
ask
us:
how
can
I
use
the
razor
view
engine
game
over
and
in
my
custom
you
know
framework
and
we're
like
well.
The
raise
of
your
engine
is
actually
tied
to
copy.
C
Other
things
that
we
wanted
to
get
cross-platform
so
well
cross
cross
framework.
Auth
was
a
big
one.
So
today,
NBC
has
anti
forgery,
authorization,
error,
handling
and
the
thing
called
error
filters
exception
filters
for
matters
model,
binding,
open,
API
support.
If
you
want
to
get
support
for
swagger
or
use
flash
buckle,
those
things
require
NBC.
You
cannot
use
like
endpoint
routing,
eroding
directly
and
get
swagger
endpoints.
So
how
do
we
make
those
things
work
for
more
than
just
the
MVC
framework,
so
the
intent
was.
C
C
C
The
early
and
asp
net
core
people
would
always
ask
things
like
how
do
I
know
a
mid
where
what
controller
is
gonna
run?
Well,
the
fact
is
you
didn't,
because
it
only
it
only
knew
at
the
point
you
entered
NBC,
so
you'd
have
to
guess
like
if
the
URL
contains
like
home,
or
that
was
the
name
called
controller.
It
was
impossible.
So
now,
with
the
current
design,
if
you
put
your
middleware
in
between
use,
running
use,
endpoints,
we
enlighten
DHCP
requests
with
a
feature
saying
the
current
endpoint
is
blah.
C
I
know
different
pieces
of
middleware
can
act
on
that
endpoint
and
do
things
so
off
is
a
big
one
off
no
works
the
same
across
all
the
stacks
that
that
built
on
running
so
before
we
had
an
off
filter
and
NBC.
We
hadn't
taught
off
on
an
off
concept
in
Sigma
and
then
health
checks
came
up
and
we
went
okay,
you
can
do
use
health
checks
in
the
pipeline,
but
no,
how
do
you
often
oops?
Do
we
build
a
new
framework
for
health
checks?
C
To
do
off
turns
out
no
it's
too
low,
so
instead,
what,
if
would
have
helped
X?
Just
hung
off
of
routing
I'll
be
hot
off
from
fur
routing
or
for
endpoint.
Then
it
would
all
just
work.
So
now
we
have
author
for
health
checks
as
well,
so
yeah
this
is
kind
of
I'm
Ryan
Ryan
was
kind
of.
This
was
Ryan's
brainchild.
He
actually
built
this
himself
in
three.
Oh
and
it's
super
optimized.
You
should
watch
this
talk
at
I
think
it
was
where's.
This
talk,
it
wasn't
Sydney.
It
was
on.
B
C
C
Turns
people
off
people
that
are
not
already
our
customers
that
knew
what
NBC
was
before
people
think
it
is
literally
an
MVC
framework.
I
didn't
mean
it
kind
of.
Does
that
as
well?
It's
not
just
NBC
right,
it's
NBC,
nice
API
is
it's
the
entire
stack,
oh
yeah,
so
we
kind
of
want
to
make
the
name
be
less
in
your
face.
That's
why
in
three,
oh,
we
made
the
the
method,
add
controllers
and
add.
C
Yeah
we
made
them
very
specific
because
NBC
was
kind
of
a
catch-all
term
for
like
every
framework
that
was
not
middleware
right,
so
the
intent
is
to
change
that
naming
and
change
that
whole
make
it
disappear
yep
and
then
we
discuss
declarative
versus
imperative.
So
do
you
want
to
write
code
in
the
controller
action
or
do
you
want
the
firm
to
write
code
for
you
and
we
want
to
offer
more
choice
today,
we're
very
declarative.
So
if
model
biting
fails,
you
need
to
use
an
exception
filter
that
runs
before
your
code
runs
to.
B
C
B
B
Interesting
is
I
mean
this
goes
often
do
a
whole
of
the
10
here
about
what
folks
different
folks
perceive
as
complexity.
So
you
could
say
just
learn.
C-Sharp
just
learn:
C
sharp
right
if
you
learn
c-sharp
you'll
go
to
anything,
but
that's
obviously
not
true,
because
in
c-sharp
you
learn
to
handle
exceptions,
as
Davis
said
by
doing
a
try-catch
statement,
and
you
don't
really
have
to
think
about
anything
else
like.
B
If
you
write,
there's
a
stack
and
you
there's
a
you
call
a
method,
they
might
call
something
else
and
there's
a
very
logical
set
of
operations
that
are
happening
there
and
if
you
want
to
catch
something
you
know
exceptions
bubble.
So
you
have
to
do
it
higher.
But
then
you
get
to
something
like
this
and
you
don't
own
any
of
the
code
that
is
happening
before
your
thing
happens,
but
that
might
cause
an
exception
to
happen.
So
then
you
go
we'll
have
my.
B
A
B
B
For
every
single
aspect
of
anything
in
the
framework,
the
others
declarative
versus
just
writing
code,
an
if
statement
filters
does
this:
does
this
middleware
execute
or
not?
Well,
if
it's
an
if
statement,
really
easy,
if
it's
something
else
that
happened
at
some
other
point
that
decided
to
take
a
branch
you.
B
B
C
I
realize
so
we
got
an
email.
There
was
a
bug
on
github
about
a
stack
of
tracer
that
didn't
have
any
user
code,
but
it
had
like
an
exception
in
somewhere
deep
in
Razer
I
realized
that
action
results
where
you
return
control
to
the
framework
after
execution,
you
lose
your
stack,
you
don't
know
what
caused
it.
You
don't
know
what
view
caused
it.
All
you
all
you
see
is
framework
code
going
error
happened
and
that's
kind
of
like
the
the
issue.
C
C
Interesting,
we
are
investing
a
little
bit
and
a
bunch
of
helpers
to
make
what
we
call
route
to
code
a
bit
easier.
Today
you
can
write
hello
world
and
that's
about
it.
The
moment
you
want
to
do
Jason.
Reading
our
model
binding
at
this
level,
like
I
mean
you
probably
have
to
use
the
NBC
primitive
Jason.
B
A
A
C
C
C
B
Less
code
philosophy
to
make
up
do
more
stuff,
for
you
is
you
end
up
people
say,
but
what
about
blah?
What
about
blah
yep?
So
you
have
to
add
an
extensibility
hook
which
makes
it
more
complex,
and
it
also
means
you
know.
As
someone
used
to
go
from
job
to
job
as
a
consultant,
you
would
find
people
implemented
the
same
same.
B
B
A
B
C
C
See
what
this
crazy
thing
they
did
is
so
where's.
My
thing
alright.
So
here
is
the
framework.
So
let
me
start
with
the
actual.
Oh
no
reveal
yet
no
reveal
in
the
reveal
here
is
my
program.
So
yes,
very
simple,
nothing
different.
So
far,
startup
CS
has
an
adjacent
which
is
just
ignore,
for
no
it
has
use
eroding.
So
this
is
an
point:
roading
use
authorization
use
endpoints,
and
it
has
this
new
thing
called
map.
C
C
C
So
it's
not
very
interesting,
but
it
has
all
these
like
kinds
of
different
things,
Rachel
from
form
from
header
from
ID,
and
normally
these
things
would
be
filled
in
from
model
mining
right.
What
if
we
could
make
that
code
as
what?
If
we
started
from
first
principles,
I
said:
what
would
you
have
to
write
manually
to
have
this?
C
All
work
like
you'd
have
to
read
the
form
read
this
read
a
specific
field
and
then
put
that
string
into
this
call
right
over
and
over
and
over,
but
then
for
things
like
int
they're,
very
complex
that
you
need
to
read
the
end
from
a
header
or
from
the
query:
string:
ain't
not
tryparse,
to
make
sure
it
is
there.
If
it
fails,
you
know
you
want
to
throw
an
error
if
it
doesn't
feel
you
want
to
keep
running.
Nullable
is
even
more
complex.
C
You
need
to
handle
the
mill
case,
or
not
no
case
so
like
this
very
simple
piece
of
code
ends
up
being
a
super
complex,
like
modeled,
by
Nene
style
code.
So
I
said
what,
if
we
can
write
this
code
by
hand
but
put
in
your
project.
C
C
C
Up-To-Date
check
and
sometimes
it
doesn't
run
my
stuff
I
haven't
fixed
it
yet
so
here
I'm
in
my
controller
I
hit
this
last
row.
So
this
is
all
working.
If
I
look
at
the
call
stack
you'll
see
like
Castro
thread,
pool
middleware
pipeline
and
there's
one
piece
of
code
that
runs
before
my
code
and
it's
this
generated
class.
That's
in
my
table
school
or
something
hoc.
B
Hang
on
so
that
you're
saying
just
look
at
that:
Col
stack
again.
Everything
in
gray
is
a
framework
piece
from
today
go
canonical
or
lower
and
we
got
as
far
as
routing
yep
and
then
custom
framework
kicked
in
yeah.
But
it's
your
code
because
it's
it's
dark.
It's
not
great!
That's
right,
because
it's
in
your
project,
but.
C
C
A
C
Would
you
write
manually
if
you
want
to
literally
create
a
new
controller
and
pass
the
HP
context?
You
would
do
this
like
new
block
controller
call
your
method,
but
what,
if
you
get
more
complex?
What
if
we
look
at
something
like
you
know,
returning
a
result,
so
you
get
your
get
your
result
back
and
then
the
framer
under
the
covers
will
create
and
I'll
check
result
for
you
and
then
call
its
cue,
and
that
thing
this
literally
is
the
entire
framework.
The
entire
framework
is
a
compile
step.
C
C
B
B
Coach
MC,
sharp
and
then
it
makes
those
assemblies
we
do
that
with
razor
razor.
We
coach
in
the
C
sharp
from
your
razor
files,
which
think
compiled
to
assemblies,
blazer,
yep,
coach
ins,
come
see,
sharp
and
then
effectively
compiles
that
back
into
your
app
into
your
SEM
assemble.
Exactly
it's
a
two
pass
to
phase
compilation
like
this
okay.
So
it's
not
that
dissimilar
yep!
This
is
what
we've
never
done
it
for
non
UI,
stuff.
C
C
So
so,
for
example
like
if
you're
trying
to
just
parse
a
single
int,
so
imagine
we
said
you
should
write
all
the
code
to
parse
and
like
translate
the
Korea
strain
to
an
in
or
out
to
an
in.
You
have
to
basically
write
this
code
that
reads
from
Rose
make
sure
there's
not
it's
not
no
doesn't
try
parse
handles
Mel
and
calls
you,
and
this
is
this-
is
a
single
parameter.
This
is
like
one
argument
right,
so
I
think
there
is
some
middle
ground
between.
C
Can
you
make
this
thing
as
pay-for-play
as
possible,
but
still
have
a
nice
syntax
for
authoring
link
controllers
right?
So,
for
example,
you
want
to
inject
a
logger
from
services.
It
will
resolve
that
one
service.
Just
one
point
to
pass
into
you.
Query
string
field
super
simple,
the
more
complex
one.
Is
this
one
hello?
It's
like
parsing,
a
form
value,
a
header
value,
query
string
value
to
querying
values.
Some
inaudible
is
some
aren't
nullable
I.
B
B
Debug
it
you
can't,
do
you
can't
step
into
the
framework
so,
but
we
did
other
things
right
to
support
stepping
we
have
source
link.
Now
we
can't
sure
if
we
have
during
ovulation
in
vs,
like
we
have
yep
things
that
let
you
do
the
debugging
part,
and
we
had
that
wonderful
feature
in
Dax
that
we
all
still
miss,
which
was
replacing
a
supreme
worker
things
with.
C
B
The
fact
we
have
you
better
because
it's
just
your
cards
in
your
code
because
there's
less
frame
you're
not
calling
in
too
much
framework
code
of
any
yep,
because
basically
the
big
difference
is
that
any
time
we
see
common
code
in
a
framework,
we
put
it
in
a
method
somewhere
its
internal.
We
call
it
over
and
over,
but
then
it's
very
easy
for
us
to
create
a
very
deep
into
interrelationships
between
things.
We
can
make
them
hard
to
link
away.
It's.
B
C
Here's
the
trick
right.
Here's
the
issue
this
map
handler
is
a
code
is
code
in
the
framework,
ideally
to
make
it
more
linkable
you'd
want
to
remove
that
you
completely.
You
want
to
create
hard
links
to
all
the
things
that
are
used.
Yes,.
A
C
C
B
C
A
B
To
talk
about
yeah,
there's
nothing
to
show
really
there.
We
have
an
experiment
of
one
thing,
but
oh
this
is
picture
yeah.
We
have
a
picture,
it's
why
everyone
thinks
we
want
Li
one
while
you're
developing
what
we
call
the
inner
loop,
while
you're
developing
a
dotnet
app,
doesn't
matter
whether
it's
a
desktop
app
or
a
saml
app
or
a
console
app
or
a
server
like
a
speck
or
or
whatever.
B
We
have
magic
that
does
that
behind
the
scenes,
which
is
basically
a
reimplementation
about
never
watch,
okay,
that
can
do
fast
up
to
date,
check
and
all
that
type
of
stuff
so
to
be
quicker,
but
it
still
has
to
recompile
the
entire
app
shut
down.
The
previous
version
of
the
app
reboot,
the
application
get
the
service
stood
up,
intercept
HTTP
request
in
the
meantime,
so
you
don't
get
there
in
the
browser
itself
doesn't
do
that
today.
Just
relies
on
a
baton,
switch.
B
A
new
app
like
your
old
app
state
is
gone.
So
if
you'd
had
anything
like
a
cache
that
was
built
up
as
a
result
of
requests
coming
in
or
if
it's
a
UI
app,
you
might
have
a
page
open,
which
is
a
lot
more
typical,
which
you
built
out
of
components,
and
then
you
had
they
have
state
or
the
interactive
state,
and
you
edited
one
component
on
an
overall
page
when
you
rip
it,
the
app
or
the
state
for
all
the
other
components
goes
away
later.
B
Code
reruns
because
therefore
Blaser
componentize
app
models
which
is
very
common
now
in
the
clients,
clothes,
so
angular
react
view
blazer.
You
want
to
be
able
to
edit
components
and
very
quickly
see
their
changes
without
blowing
away
the
state
of
all
the
other
components.
We
don't
want
to
have
to
reinvent
the
model
for
how
we
do
that
with
dotnet
for
every
single
stack.
This
is
what
we've
done
to
date.
Every
single
dotnet
application
model
effectively
does
its
own
version
of
how
do
I
automatically
restart
the
app
or
how
do
I
do
it?
B
The
smallest
possible
reload
that
I
can
within
the
running
app
in
order
to
preserve
as
much
data
as
possible.
This
goal
for
dominate
and
we're
not
going
to
finish
this
in
dot
near
five,
we're
gonna
start
it
in
dotnet
five
is:
can
we
come
up
with
a
model
that
scales
to
pretty
much
any
app
model
that
we
can
think
of
and
then
go
and
implement
that
model
for
a
few
different,
app
models
that
we
care
about?
Can
we
do
it
for
blazer?
Can
we
do
it
for
razor
and
a
spinet
core
application?
B
B
The
account
we
do
it
yeah
exactly
and
can
we
do
it
for
or
improve
what
we
have
already
for
xamarin
and
zamel
apps
and
those
type
of
things
so
we'll
see
how
far
we
get,
but
that's
the
gone.
We
have
not
started
any
actual
coding
on
this,
yet
we're
still
in
the
definition
phase.
In
fact,
I
have
a
lie
or
paper
this
week.
You
know
what
it
started:
I.
B
B
Cool
and,
of
course,
I,
don't
know
five
planning,
as
I've
said
before,
we
are
in
the
planning
phase
right
now,
where
we're
doing
the,
what
we
call
framing
documents
are
like
a
one-page
document
per
big
area,
they're
jus
in
the
next
like
two
weeks,
and
then
after
that
that
will
go
into
the
big
blender.
The
director
bossy
people
will
decide
which
one
of
those
they
want
to
do
and
what
roughly
thinks
their
fits
with
the
amount
of
developers
we
have.
That
will
become
the
official
framing
plan.
B
4.95
it'll
become
a
little
more
public
at
that
point
and
then
the
actual
hard
work
of
designing
the
features
that
will
make
up
those
things
will
start,
and
that
will
be
a
lot
more
open.
You'll
see
you
know,
github
stuff
and
people
will
debate
how
things
should
work
and
then
will
cost
them
and
then
we'll
go
yeah.
We
kind
of
fought
any
of
it
and
then
we'll
do
half
of
it
all.