►
From YouTube: ASP.NET Community Standup - June 18th, 2019 - ASP.NET Core 3.0 Preview 6 Release Party
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 for this week: https://www.theurlist.com/aspnet-standup-2019-06-18
A
B
D
B
B
Okay,
yes,
hooray.
Okay,
cool
I'm,
just
gonna
rip
through
him
ahead,
he's
doing
an
A
through
Z
series
on
asp
net
core
features.
So
this
is
letter
X.
This
is
XML
and
JSON
serialization
in
asp
net
core.
Sorry
here
is
showing
with
an
api
returning
both
JSON
and
XML
data,
so
doing
stuff.
You
know
showing
using
accept
header
showing
different
kinds
of
queries
here,
he's
working
through
you
know,
searching
and
all
kinds
of
good
stuff.
So
so
this
is
amazing
and
good
job
show
head
we've
been
on.
B
This
is
pretty
cool,
so
Andrew
Locke
has
been
doing
a
series
on
feature
flags
with
ASP
nut
query.
This
is
a
new
feature
and
anything
that
that
Andrews,
showing
here
is
that
feature.
Flags
are
not
just
a
binary
on
or
off
kind
of
thing
they.
Actually,
you
can
do
more
complex
things,
so
here
he's
showing
using
two
that
that
ship
with
it
one
is
a
time
window
filter.
B
So
here
he's
saying
is
saying,
for
example,
only
show
up
banner
during
crisp,
so
this
is
this
is
setting
up
the
the
thing
and
and
saying
you
know
this
is
my
time
window.
So
you
know
this
is
obviously
like
Christmas
could
be
done
with
shopping.
You
could
do
something
during
business
hours
or
during
a
conference
I've
done
things
where
I
hard-coded
stuff
during
conferences.
You
know
to
turn
things
on
and
off.
So
this
this
is
pretty
neat
and
then
he's
also
showing
rolling
a
feature
out
using
a
percentage
filter.
B
So
again
you
know
having
a
value
and
kind
of
rolling
it
out.
You
know
here
it's
a
ten
percent,
so
that's
that's
pretty
cool
to
others
said
I'm
just
showing
these
are
the
or
the
next
three
are
basically
long-form
textual
versions
of
stuff
that
you
folks
are
gonna,
show
so
I'm
gonna
make
them
even
faster
here,
Gunners
showing
feature
with
is
which
is
authentication
with
server-side
blazer
applications.
So
that
is
pretty
neat
exciting
to
see
that.
So
here
he's
walking
through
you
know,
enabling
it
and
then
showing
the
front
end
user
experience.
So.
B
Yep
automatic
reconnect
with
signal
r3o,
so
Jerry
Pelzer
walking
through
that.
That
is
also
super
cool
and
then
here's
your
post.
So
this
is
the
long
form
written
version
of
stuff
we're
showing
here
and
then
there's
there's
a
decent
amount
of
other
features.
We
probably
won't
be
able
to
get
to
today
right
we'll.
B
And
as
always,
I'll
share
these
links
in
the
show
notes
and
we'll
we'll
tweet
them
out
and
we'll
put
them
on
the
Twitter's
and
and
and
in
the
chat
on
both
twitch
and
all
the
stuff
twitch
in
YouTube.
All
right,
so
I'm
gonna
pass
it
back
over
to
you
and
there
we
go
all
right
should
we
show
some
features.
We
should
show
some
features.
Yes
and
as
part
of
this,
we
also
need
to
introduce
so
Dan.
B
E
F
F
All
right,
perfect,
all
right,
so
everybody
I'm
here
to
talk
about
Lars,
new
Auto,
reconnect
feature
which
was
introduced
to
the
JavaScript
and
typescript
client.
It's
definitely
there
also
there
other
previous,
but
we
really
have
documentation
for
I
want
to
get
people
trying
it
and
these
really
tedious
to
have
right
out.
So
if
any
of
you
are
interested
in
learning
about
signal
arc
or
new,
similar
features,
I
recommend
you
check
out
the
samples
at
github
comm
forward.
Slash
signal
are
Brady
when
he
told
me
that
I
was
going
to
be
speaking.
F
This
community
stand
up
suggested.
I
just
used
this
demo
with
automatic
reconnect
sample,
which
is
really
great.
It
actually
has
a
great
read
me
with
screenshots,
but
I
feel
that
most
of
the
people
watching
the
community
stand
up
might
have
seen
some
of
this
content.
So
I'm
gonna
go
through
thinking.
Another
sample
that
might
already
know
and
love
pulse
remar
might
have
seen
it
I'm
gonna
run
it
streamer.
It
was
created
by
a
co-worker
Brennan.
Conroy
also
did
the
streaming
feature
for
signal.
Are
that
enabled
this
whole
thing?
F
F
F
So
what
this
will
do
is
now
that
we've
done
with
automatic
reconnect
instead
of
firing
the
on
close
call
back
as
soon
as
we
lose.
The
underlying
TCP
connection,
we're
gonna
start
trying
to
reconnect
and
we
added
to
get
calm
callback.
So
reconnect
on
reconnecting
and
I'm
reconnected
and
we'll
demonstrate
really
quickly
how
that
look,
but
let's
first
restart
our
app
with
just
plain
old
default,
with
automatic
reconnect
and
see.
If
that,
just
like
fixes
the
streamer
example
right.
F
A
F
For
this
sample,
one
thing
that
I'm
gonna
do
is
I'm
going
to
open
up
the
dev
console
because,
as
soon
as
this
connection
dies,
we're
gonna
see
some
problems.
The
thing
is
like
okay,
Sigma
lawyer
is
gonna
automatically
try
to
reconnect.
If
you
still
have
an
app
that's
calling
server
dot
said
hundreds
of
times
a
second
that's
gonna
fail
until
the
server
starts
back
up
or
until
the
network
comes
back
up
or
whatever
cause
in
action.
F
F
F
I'm,
just
gonna
skip
ahead
and
hook
up
the
actual
back
seat.
So
the
real
problem
that
I'm
trying
to
demonstrate
this
demo
is.
We
thought
it
would
not
agree
connection
EC
API,
but
that
doesn't
stop
you
from
thinking
about
what
happens,
but
he
actually
disinfection.
A
lot
of
people
might
want
to
replay
the
best
things
that
the
client
might
have
missed.
If
you're
writing
some
sort
of
cat
room,
you
probably
don't
want
to
miss
chat
messages.
F
Alright,
so
what
I
was
trying
to
continue
with
is
just
adding
with
automatic
reconnect
to
your
hub
connection.
Builder
sequence
will
cause
the
clients
automatically
reconnect,
but
that
doesn't
stop
you
from
thinking
about
what
should
happen
once
the
client
does
reconnect.
If
I'm
a
chatroom
I
might
actually
want
to
query
the
database
and
get
any
messages
that
might
have
been
sent
to
the
room
that
I
missed
in
the
case
of
something
like
video,
it
might
be.
Okay,
just
you
know,
restart
the
video
live
because
replaying
live
video
to
me
doesn't
make
that
much
sense.
F
So
with
reconnect,
there's
rarely
a
one-size-fits-all
solution.
So
what
we
give
you
our
events
to
do
what
you
need
to
do
so
about
an
hour
before
the
stand
up
when
I
was
trying
to
make
this
app
work
with
automatic
reconnect.
I
did
this
myself
and
rather
than
struggle
and
figure
out
how
to
make
reconnect
work.
We're
gonna,
look
at
the
branches
that
I've
already
made
and
we're
gonna
check
out
my
Auto
reconnect
branch
and
look
at
it.
So
sorry
guys,
but
we
can
look
because
it
as
it
isn't
that
many
changes
so
the
biggest
thing.
F
F
F
So
if
we
were
to
scroll
down
when
we
start
watching
a
stream,
we've
recorded
that
stream
name
and
then
also
if
we
were
streaming
when
we
started
or
when
we
were
reconnecting
a
non
reconnected,
we
we
added
two
new
callbacks
on
reconnecting
which
stops
streaming,
which
gets
rid
of
all
those
airs
that
we
saw
if
we
were
watching
that
you
know
f12
window
with
the
counters
going
up
into
the
hundreds
and
then.
Secondly,
once
we've
reconnected,
we'll
restart
the
stream
we
were
sending
and
then,
if
we
were
receiving
any
streams,
we'll
do
that
as
well.
F
This
is
a
hack
because
the
the
other
side
since
we're
stopping
the
server
all
the
clients
are
disconnecting
at
once.
So
the
person
trying
to
watch
the
stream
might
start
watching
before
the
reconnecting
client
sends
the
stream
I
trust
that
you
would
be
able
to
do
something
smarter.
But
that's.
Why
there's
this
while
true
until
success
so
looks
production.
F
F
Dan
Roth,
so
we're
gonna
run
the
sample
again
and
in
about
five
to
ten
seconds,
we
can
get
the
updated
code.
So
the
only
problem
with
the
streamer
example
for
reconnect
is
the
restart
time
on.
This
is
a
little
bit
slow,
but
it's
not
too
bad
and
Safari
will
not
remember
that
I
want
it
to
allow
the
camera
usage.
It
might
be
because
we're
on
localhost.
So
let's
try
it
again.
We're
gonna
stop
the
server
I'm
gonna
pull
up,
and
we
were
not
doing
this
as
part
of
the
the.
E
F
We
can
save
some
bandwidth
peer-to-peer,
but
I,
guess
Google's,
big,
the
bandwidth
right
so
I
think
we're
okay,
either
that
or
Amazon
with
which
I
don't
know
where
everyone
watches
all
right.
So
here
you'll
see
that
we
have
the
on
reconnecting,
call,
backfired
and
whoa
work
the
first
time.
So
we
avoided
the
little
race
that,
while
we've
hopefully
saved
us
there
so
notice
that
I
didn't
refresh
any
of
the
browsers
and
we're
back
to
streaming
live.
So
that's
not
the
whole
extent
of
the
demo.
There
are
two
more
things
that
I
want
to
bring
up.
F
First,
is
that
by
default,
with
automatic
reconnect
will
try
reconnecting
as
soon
as
the
connection
is
lost
after
two
seconds
ten
seconds
in
30
seconds,
I
could
be
slightly
off
on
the
numbers.
I
highly
recommend
that
you
take
a
look
at
our
Docs
I'm
sure
you've
seen
this
before
you
can
go
to
doc.
Stop
Microsoft
comm
go
to
the
SP
network
Docs,
and
if
you
select
the
version
we
already
have
documentation
for
the
preview,
so
you
can
see
that
I
think
I
said
that
that's
0
to
1,000
and
3,000
milliseconds.
F
So,
and
if
you
pass
that
into
automatic
reconnect,
you
can
change
it.
So
if
you
want
to
keep
trying
even
longer
you
can,
you
know,
keep
on
trying
for
every
30
seconds
as
long
as
you
want
as
soon
as
you
hit
the
end
of
the
array,
if
the
reconnects
have
failed
every
single
attempt,
so
these
this
right,
zero
millisecond
delay
before
the
first
reconnect
2000
little
second
delay
before
the
secondary
Connect
10,000
millisecond
delay
the
board.
F
Third,
if
it
succeeds
right,
then
you're
done,
but
this
is
only
if
there's
failure
and
if
it
fails
at
every
time
the
closed
event
will
fire
and
at
that
point
you'll
autumn
you'll
have
to
restart
manually.
Another
thing
to
consider
is
that
if
start
throws,
so
if
you
call
connection
start-
and
it
throws
an
exception-
we
will
not
automatically
reconnect
in
that
case
because
you
never
connected
in
the
first
place.
So
for
that
initial
start
failure,
you
can
imagine
if
someone
had
like
configured
their
signal,
our
client
wrong.
That
would
be.
F
If
it
you
know,
we
tried
for
30
seconds
before
you
know.
You
saw
that
you
put
in
the
wrong
URL.
So
that's
the
reasoning
behind
that
logic.
Someone
might
just
want
to
retry
forever.
So
if
you
do
that
passing
an
array
of
delays
before
each
retry
isn't
gonna
work,
so
the
last
API
that's
available
to
you
is
one
that
takes
it
interface.
So
here,
if
we
go
your
retrying
policy.
E
F
Today
it
takes
two
arguments:
the
number
of
previous
retries
and
the
number
of
milliseconds
we've
spent
from
the
very
beginning,
try
to
reconnect
so
far
since
we
first
lost
the
connection,
and
this
will
use
a
random
retry
them
out
retry
length
and
the
reason
for
doing
that
by
the
way
is
if
the
clients
are
reconnecting,
because
the
server
has
like
crashed
having
every
client
wait.
The
same
delay
can
obviously.
E
F
B
It's
interesting
as
you're
showing
this,
because
the
just
today
like
having
the
YouTube
stream
drop
and
all
that
having
the
website,
like
basically
people
have
to
know
to
refresh
their
browser.
All
this
stuff
is
very
applicable
because
a
better
version
of
the
website
would
be
checking
and
like
restart
automatically
and
all
that
right
in.
F
Post
3,
oh
we've
talked
about
some
crazy
ideas.
Like
seamless
reconnect,
I'm
calling
it.
You
know,
copyright
trademark,
not
sure
someone's
already
copyrighted,
but
you
know
we
might
even
think
about
ways.
We
can
automatically
replay
some
messages
for
you
and
you
know
Reef
reconnect
periods.
You
know
if
it
doesn't
use
too
much
memory,
but
we
were
very
careful,
at
least
on
iteration
one
of
automatic
reconnect
not
to
do
too
much
for
you,
because
if
you're
doing
something
like
you
know,
streaming
live
ASCII
video.
F
You
might
not
want
to
waste
all
that
memory
when
the
clients
gone,
for
you
know
half
a
minute
so
that
I
think
concludes
what
I
had
to
say
about
the
automatic
reconnect
feature.
The
only
thing
I
would
add
is
that
in
preview,
6
the.net
client
has
the
same
API.
It
will
be
on
Docs
Microsoft
comm
very
soon,
but
it's
a
basic
transliteration
I
would
say
of
the
typescript
API.
So
if
you,
you
know
liked
what
you
saw
in
the
typescript
API
you're
gonna
see
something
very
familiar.
C
A
Alright,
so
I'm
here
to
talk
about
some
stuff
that
we
already
covered
in
a
jerky
specific
show,
but
I
thought
I'll
show
again,
so
this
is
called
out
on
the
blog
post.
We
have
a
couple
of
things
that
have
landed
in
preview
6.
It
got
support
for
a
manager,
PC
client.
We
have
you,
know:
JIRA
PC,
client,
factory,
Allah,
HTTP,
client
factories
support
and
then
we
have
support
for
JIRA
PC
interceptors.
So
let
me
go
ahead
and
show
a
couple
of
things.
So
we've
added
support
for
a
managed
client.
A
B
E
A
A
Okay,
so
if
you
folks
can
see
my
screen
over
here,
abbis
ample,
where
I'm
reading
a
certificate
from
the
store-
and
let's
see
oh
yeah
I'm-
opening
the
my
store,
I'm
loading,
the
cert
that
I've
created
and
in
this
example
I'm
actually
not
sending
the
client
sort
with
the
sample.
I've
set
up
the
server
yeah
and
if
you
look,
if
we
jump
over
to
Castro
Kestrel,
expects
the
client
certificate.
If
I
go
ahead
and
try
to
run
my
PC
client
sample.
Let
me
go
ahead
and
run
this.
A
My
client
never
sent
a
client
certificate
and
the
server
rejected
with
the
403
and
ends
my
client,
you
know
blew
up.
I
haven't
written
any
one
code
to
handler,
so
we
can
go
ahead
and
change
this.
Let
me
go
jump
back
into
the
client
code.
There's
nothing!
Fancy
here!
I!
Just
you
know:
newing
up
an
HTTP,
client,
Handler
and
adding
a
client
certificate
to
it.
This
is
the
same
way:
you'd
use,
client
certificates
with
HTTP
client
all
along
and
then
using
that
to
create
my
error.
Client.
A
If
I
go
ahead
and
run
this
sample
now
we
can
see
that
since
I
have
sent
a
client
certificate,
server
actually
accept
my
request,
so
the
sample
I
am
showing
you
is
a
simple
client
streaming
sample,
so
I
can
send
it.
It's
the
the
samples
an
address.
I
can
send
a
bunch
of
streamed
messages
and
then,
when
I'm
done
and
I
send
a
new
line,
the
server
will
reply
with
the
sum.
It
is
something
that
maybe
we
would
required
clients
or
certificates,
which
was
impossible
before
the
other
thing.
A
A
The
GRP
see
handler
is
just
one
of
those
handlers
in
that
pipeline
and
your
entire
interceptor
pipeline
runs,
and
then
we
have
the
same
thing
on
the
server
side,
where
you
have
your
middleware
pipeline
run
and
we
use
it.
We
are
integrated
into
endpoint
routing
in
three
or
the
jpc.
Handler
is
just
your
terminal
endpoint
that
runs,
and
then
your
entire
service
interceptor
pipeline
runs.
A
Nice,
so
there
are
couple
things
which
are
harder
to
do
with
delegating
handlers
and
middleware
is
like,
especially
when
you
do
streaming
requests.
You
can
wrap
the
stream
so,
instead
of
only
having
the
ability
to
act
on
every
request
to
response,
you
can
act
on
every
message
that
sent
as
part
of
the
request
or
response.
So
I
have
an
example
up
here
where
they
implemented
a
request,
request
timeout
interceptor.
So
the
purpose
of
this
middleware
is,
if
Mike
it's
for
my
clients,
Timmy
request.
A
A
One
of
our
devs
did
okay,
and
so,
when
you
enter
implement
the
interceptor
you
would
have
to.
You
know,
implement
a
handler
for
all
four
requesters
which
our
unity,
client
streaming
service
streaming
and
duplex
streaming.
In
my
case,
I
know
this:
the
only
service
call
I'm
making
is
lion
streaming
so
for
the
sake
of
brevity,
I've
only
implemented
one
of
these,
but
it's
pretty
straightforward
and
you
can
do
the
same
thing
and
the
actual.
A
If
we
look
at
the
wire
up
Gordon
my
server
at
the
time
of
adding
my
PC
service
to
the
pipeline,
you
can
also
configure
all
your
interceptors
and
when
you
have
it
this
way,
it's
it's
a
scoped
interceptor
and
we
have
ways
to
add
like
global
singleton
interceptors,
so
it
very
much
mimics
what
middlewares
look
like.
So,
if
I
go
ahead
and
run
this
now
so
I
think
my
me
jump
over
to
my
server
is
already
running.
A
A
Threw
me
off,
we
can
see
that
the
server
actually
terminated
the
stream
on
the
client,
and
this
intercept
it
actually
works,
and
it's
not
just
way
prepare.
But
your
point,
Stefan
jealousy
lends
itself
to
a
server
to
server
communication.
There
are
things
like
obviously,
client,
sirs
enforcing
policies
through
interceptors,
like
support
for
mutual
pls,
things,
which
are
not
necessarily
the
strengths
which
signal
are
versus
their
things.
Signal
are
does
much
better,
especially
when
it
comes
to
dealing
with
browser
clients
having
multiple
transports,
invoking
methods
on
clients
having
groups
of
clients.
A
But
browser
the
api's
don't
give
you
access
to
xhr
to
or
fetch
you
can't
really
get
HTTP
to
framing
from
a
browser.
Well,
there
you
have
it.
So
it's
not
an
exhaustive
answer,
but
there
are
there,
are
you
know
and
you
can
use
both?
You
know
you
can
resolve
the
hub
context
from
your
G
RPC
service
and
party,
on
both
your
PC
and
Sigma.
All
right,
I'm.
F
E
E
E
We've
turned
on
authentication:
we've
done
a
bunch
of
work
in
the
framework
to
provide
abstractions,
so
you
can
get
access
to
the
current
user,
have
components
for
pivoting
content
based
on
whether
you
have
a
current
user
or
not
I'm
gonna
we've
been
able
to
all
the
options
like.
If
you
want
to
do
as
your
ad
or
as
your
db2,
C
or
Windows
off,
you
can
do
that.
I'm
gonna
pick
the
option,
that's
basically
using
a
spinet
core
identity,
cuz,
that's
what
we
ship
and
it's
fun.
So
let's
go
ahead
and
create
yeah
that.
E
All
available
we
haven't
turned
them
the
options
on
yet
for
the
Blazer
web
assembly
templates.
We
just
haven't
done
the
work.
The
abstractions
are
all
there,
though
we
just
need
to
do
the
the
template
work
to
turn
it
on
for
the
client-side
blazer
templates.
Okay,
so
we've
got
our
application.
I'm
gonna
go
ahead
and
run
it.
So
we
can
see
what
this
app
does
in
the
meantime,
I'll
show
you
a
little
bit
of
the
code
while
it's
getting
up
and
running
so
we're
using
the
default
identity,
UI
for
the
login
page
and
registration
users.
E
That's
all
just
a
Razer
class
library
that
we've
included
in
the
app
here
it's
coming
up
already.
I'll
show
you
it
in
action.
Alright,
so
we
get
the
app
running
now
up
in
the
upper
left
hand
corner.
You
can
see
that
we
have
some
login
and
register
links,
let's
go
ahead
and
register
a
new
user,
and
this
popped
me
over
to
that
default.
Identity.
Ui
like
this
is
actually
now
we're
in,
like
a
razer
class
library,
that's
just
added
to
the
project.
I
can
go
ahead
and
add
a
new
user.
Let's
add
my
favorite
password.
E
Just
super
secure
and
secret
and
then
we'll
register
that
your
new
user-
this
will
now
require
me
to
migrate
the
database,
because
this
is
using
a
new
framework
or
under
the
covers
to
set
up
the
identity
schema
and
boom
there.
We
are
we're
logged
in
to
our
application.
Now
we
can
click
on
that.
We
can
get
back
to
the
identity
UI
and
we
can
see
all
the
normal
stuff
for
like
changing
your
password
and
doing
confirming
your
email
and
so
forth.
E
So
all
the
normal,
a
snit
core
identity
features
are
working
here
but
integrated
with
a
server-side
blazer
app
okay.
So
now,
how
does
that?
How
does
that
work
like?
Where
does
this
UI
come
from?
Let's
go.
Take
a
look
at
the
code.
If
we
look
in
our
layout
in
the
main
layout
you'll
see
that
there
is
a
login
display
component,
that's
added
to
the
layout,
that's
what's
rendering
those
three
links
now
this
is
just
a
component.
That's
in
the
template!
It's
not
like
a
built-in
thing!
What
if
we
go?
E
Look
at
its
implementation
in
this
you
know,
login
display
dot,
raiser
file.
We
can
see
that
that
component
is
implemented
using
this
authorized
view
component.
This
is
a
built-in
component.
This
is
new.
This
is
a
component
that
says.
I
will
only
render
my
content
if
the
user
is
authorized
and
logged
in.
If
there's
a
user
I'll
render
my
content
and
it's
also
a
a
templated
component.
It
has
different
template
parameters
for
rendering
different
things
depending
on
the
users
logged
in
state.
E
So
if
the
users
logged
in
and
authorized
it'll
render
the
you
know
hello
and
logout
links,
if
the
users
not
logged
in
and
not
authorized,
then
you
get
the
register
and
login
link.
So
that's
how
that
works.
You
can
do
even
fancier
things
as
well
like
if
you
want
to
set
up
a
policy
that
says
you
know
you're
only
really
logged
in.
If
you
match
the
likes,
Donuts
policy
or
whatever
you
can,
you
can
do
that
and
that's
using
the
standard,
a
snit
core
authorization
system
for
configuring
policies
and
such
also.
E
B
E
Two
factor
auth
support
is:
is
the
normal
two
factor,
awesome
port
that
just
comes
with
a
snit
core
identity,
so
all
the
standard
token
flows
that
a
snake
or
identity
sports
is
what's
enabled
here.
We
basically
just
took
that
pre-canned
UI
and
wired
it
up
in
a
server-side
blazer
app,
so
Authenticator
apps.
Yes,
they
absolutely
work.
That's
a
pretty
common
scenario
with
using
the
tooth
to
a
to
a
thing.
Awesome.
E
B
E
Than
I
do
okay,
so
the
templates
in
this
component
they
get
access
to
this
context.
Parameter
in
this
context,
parameter
you
can
see
it's
an
authentication
state
object,
that's
just
contextual!
It's
flowing
floating.
We
can
take
a
look
at
it.
All
it
has
is
the
access
to
the
claims
principle
for
the
current
user.
Now,
where
does
this
authentication
state
come
from?
E
Well,
if
we
look
at
the
root
component
for
this
app,
which
is
in
this
app
dot
razor
file,
this
is
where
the
router
is
being
set
up
and
you'll
see
that
in
this
template
the
router
is
actually
wrapped
in
this
other
built-in
component,
which
is
this
cascading
authentication
state
component.
What
that's
doing
is
setting
up
the
authentication
State.
Look.
It
actually
will
look
in
the
DI
container
to
find
a
particular
service
that
provides
the
current
user.
It
then
sets
up
the
authentication
State
and
then
provides
it
as
a
cascading
value
throughout
the
component
hierarchy.
E
A
cascading
value
is
something
that
components
can
then
opt
into
binding
to
so
that
they
can
get
access
to
it,
which
is
what
that
authorized
view.
Then.
Does
this
authorized
view
binds
to
that
cascading
value
which
gives
it
access
to
this
authentication
State
which
then
you
then
use
this
to
decide
what
to
render?
So
that's
the
underlying
infrastructure
of
how
this
is
all
working.
This
component
basically
gives
you
a
way
to
render
or
not
render
a
content
based
on
whether
the
user
is
logged
in.
E
But
if
you
want
to
do
like
a
whole
page,
you
can
also
do
that.
For
example,
if
we
go
to
our
fetch
data
page-
and
we
want
to
say
you
know-
you
can't
see
this
page
unless
you're
you're
logged
in
and
authorized
well,
we
can
do
that.
Well,
how
do
you
do
that?
Well,
you
use
the
normal
authorized
attribute
that
you
would
use
in
the
like
signal,
bar
or
in
MBC
or
in
raiser
pages,
but
with
components.
You
don't
typically
have
a
code
behind
file
like
the
class.
E
That's
generated
for
the
component
is
actually
compiled
from
the
dot
RAZR
file,
so
we
have
a
new
razor
language
feature.
I'm
gonna
go
ahead
and
add
I'm
just
going
to
using
statement
here
real
fast,
so
Microsoft
is
net
core,
often
authorization
authorization
and
then
we
can
use
at
attribute
at
attribute
says.
Please
add
this
attribute
to
the
generated
class
that
gets
compiled
from
this
dot
RAZR
file.
But
then
here
we
can
just
go
ahead
and
sauce
for
this
component.
E
If
we
save
this
and
go
back
to
the
app
now
you'll
notice
that
the
app
has
its
in
this
disconnected
State
like
we,
we
we've
lost
our
connection
to
the
server.
What
just
happened
there
well
with
server-side
Blaser
apps,
remember
the
whole
UI
is
being
driven
by
a
signal,
our
connection,
which
has
been
set
up
from
the
browser
to
the
server
to
some
state,
where
all
the
components
are
running,
and
so
every
UI
event
goes
to
the
server.
The
component
runs
it
rent.
E
E
If
we
had
this
feature
for
a
while,
we
lost
it
for
a
little
bit
when
we
did
the
in
process
hosting
with
is
which
is
that
when
you
edit
your
code,
Visual
Studio,
will
once
again
see
that
code
has
changed,
kill
is
Express,
restarted,
rebuild
your
app
and
get
it
up
and
running
again,
so
you
can
have
that
edit
save
refresh
workflow.
So
if
I
go
back
to
the
browser,
I
can
just
refresh
I
don't
have
to
rebuild,
and
everything
was
is
good.
E
If
I
go
to
my
fetch
data
page
after
I
log
out,
let
me
log
out.
First,
that's
go
to
fetch
data
and
we
can
see
oh
yeah
I'm
not
authorized.
I
can't
see
this
particular
page
so
what's
happening
there
is.
The
router
is
detecting
that
there's
an
authorized
attribute
on
the
that
particular
page
and
it's
preventing
the
the
content
from
being
rendered.
It's
putting
a
little
placeholder
content.
Instead,
there
is
also
infrastructure
in
place
that,
if
you
want
to
like
automatically
redirect
to
the
login
page,
you
can
do
that.
E
I
think
there
may
be
some
issues
with
that
in
preview
6,
but
we're
getting
that
addressed
in
the
next
update
in
preview
7,
which
will
it's
just
a
few
weeks
away
honestly.
So
that's
the
other
way
that
you
can
authorize.
Some
content
is
by
just
slapping
on
the
the
normal
authorized
attribute
on
to
your
your
pages.
So
at
attribute
that's
a
new
feature.
What
other
new
razor
features
do
we
have?
Well,
if
you
remember
in
Emblaze,
are
typically
when
you
want
to
add
some
code
to
a
component.
You
use
this
function.
Spock.
E
Let
me
type
functions
like
this,
and
then
you
type
your
code
in
here
like
daytime
daytime
date,
equals
date/time
dot.
Now
right-
and
this
is
where
you
have
like
fields
and
methods
that
you're
adding
to
the
generated
class,
we've
always
felt
that
this
functions
name
was
a
little
awkward
like
you.
Don't
always
you
know
it's
not
just
functions
right,
you're,
typing
methods
and
maybe
even
inline
classes
and
stuff
like
that,
so
we
actually
added
a
new
alias
for
this
razor
Directive,
that's
just
code.
E
B
D
B
E
In
fact,
functions
still
work,
so
if
you
have
functions
blocks,
don't
worry
you
can,
you
can
choose
to
still
leave
them,
but
for
to
make
the
experience
better
and
more
intuitive,
we
decided
to
add
that
code
as
a
new
razor
semantics.
What
else
is
new?
Okay?
Let's,
let's
look
at
attributes,
so
let
me
add
a
little
a
little
bit
of
markup
here,
I'm,
going
to
add
an
input
tag
now,
if
I
just
hit
space,
you'll
see
that
I'm
now
seeing
all
of
these
attributes
that
I
can
put
onto
this
input.
E
That
begin
with
the
@
sign,
and
we
call
these
now
directive
attributes.
We
have
razor
directives
which
are
these.
You
know
key
words
that
begin
with
an
@
sign.
In
racer.
Now
we
have
razor
directives.
What
our
razor
directives
well
razor
directives
are
attributes
that
can
be
applied
to
components
and
elements
that
impact
compilation
like
impact
how
the
razor
file
gets
turned
into
into
C
sharp
we've
had
a
bunch
of
attributes
for
a
long
time
and
Blazer
that
do
things
like
that.
E
Like
bind
and
onclick
all
the
event
handlers
RAF,
we
added
a
new
one
in
preview.
Six
called
key,
but
they
were
all
sort
of
organic
in
terms
of
their
syntax,
like
we
just
made
up
an
attribute
and
added
it
on
there
with
directive
attributes,
we've
standardized
the
syntax
for
what
these
things
look
like.
They
all
now
have
this
structure,
so
at
the
name
of
the
directive
attribute
and
then
you
can
have
an
optional
suffix
and
then
an
optional
key
and
then
the
value
all
the
directive.
Attributes
in
Blaser
now
follow
this
standard
syntax.
E
So
this
is
good
for
a
couple
of
reasons.
It
means
first
of
all
that
when
you're
typing
these
things,
you
you
have
a
structure
that
you
can
can
learn
and
know
like
not
every
attribute
is
different.
They
all
follow
this
just
general
pattern.
It's
also
good
because
it
means
that,
as
we
add
new
features
to
to
Blaser
into
the
the
compiler
for
turning
components
into
into
c-sharp
code,
we
have
a
built
in
structure
that
we
can
now
use.
You
know
a
pattern
that
we
can
extend
and
in
the
future.
E
Similarly,
if
I
want
to
change
the
format
of
how
the
date
is
bound,
you
notice,
if
I
add
a
colon
I,
can
optionally
add
this
sort
of
modifier
like
a
key
value
pair
to
the
bind
I'm
gonna
specify
in
this
case
the
format
and
the
format
I'm
gonna
say
is
gonna,
be
your
year
month,
month,
day
day
like
that,
and
then
just
the
show
that
that's
working
let's
go
ahead
and
render
out
also
the
date
as
a
separate
value.
So
we
can
should
be
able
to
save
that.
Oh
yeah
looks
looking
good.
E
Let's
refresh
the
browser
house,
it's
no
edit
save
refresh
flow
again.
Is
it's
really
nice
go
to
the
home
page,
okay!
So
now
we
see
our
input
and
we
can
see
the
rendered
value
below
the
rendered
value
is
just
basically
the
two
string
of
the
date,
but
the
input
is
using
that
format
using
the
year
month
date
format.
E
If
I
change
things,
you
can
see
that
the
date
the
the
date
time
value
got
changed
by
the
bind
and
it
actually
rendered
the
correct
value
we
can
even
switch
the
year
to
like
pretend
it's
1999
and
there
we
go
so
you
can
see
that
the
value
is
actually
updating.
So
that's
that's
directive,
attributes.
You
know
in
things
that
we
want
to
do
in
the
future.
What
this
enables
is
like,
for
example,
let's
say
we
want
to
prevent
default
like
prevent
the
default
action
of
an
event,
that's
happening
in
the
browser.
E
We
don't
have
a
convenient
way
to
do
that
today
in
Blazer.
We
want
to
add
it,
and
now
we
have
a
pattern
that
we
can
use
like.
You
could
just
say
like
bind,
you
know,
but
you
know
trigger
to
the
event
but
to
prevent
default.
This
is
not
an
attribute
that
exists
today,
but
in
the
future
we
hope
to
be
able
to
add
it.
If
that
makes
sense
or
similarly
like
you
know,
maybe
we
would
do
on
click
:
stop
propagation
for
like
stopping
the
propagation
of
the
event
of
the
the
Dom.
E
E
E
Take
this
C
sharp
value
when
the
component
renders
render
it
on
to
this
element
using
this
particular
attribute
like
in
this
in
the
case
of
an
input,
it'll
be
the
value
attribute,
and
then
it
will
also
wire
up
a
particular
event
like
in
the
case
of
input,
it'll
be
the
on
change
event,
and
it
will
say
when
the
on
change
event
occurs,
then
set
the
C
sharp
value
to
that
new
new
value
and
then
rerender.
The
component
C.
E
B
E
E
Go
and
show
off
files
and
we'll
go
into
our
obj
folder
debug,
Rio,
razor
pages
and
I
think
added
it
to
fetch
data
right.
So
in
the
fetched
million.
This
is
this
is
hideous
generated
code
right,
it's
really
hard
to
read.
But
if
we
scroll
down
it's
a
little
bit,
we
should
see
a
class
okay.
We
found
the
class
and
then
up
above
see,
there's
the
authorized
attribute,
that's
just
being
added
to
the
class.
E
E
B
E
A
great
question,
so
this
this
I'm
disconnected
state
the
UI
has
no.
It
is
a
source
of
some
concern
because,
like
this
will
happen
anytime,
like
the
server
restarts
like
and
you
could
this
retry
but
you're
like
it's,
not
working,
it's
not
doing
anything
what's
happening
there.
Well,
the
this
UI
is
intended
to
represent
two
things.
One
is
the.
E
If
the
connection
gets
lost
to
the
server,
then
you
see
this
UI
and
then
once
if
the
server
comes
back
up
and
you're
able
to
then
connect
to
it
over
the
network,
but
the
state
that
you
were
originally
connected
to
is
gone,
which
typically
happens
after
a
server
reboot.
Then
you
still
won't
be
able
to
reconnect,
because
the
state
for
this
particular
user
session
is
no
longer
available
to
be
had
and
this
retry
button.
E
All
it's
trying
to
do
is
just
trying
to
reconnect
to
back
to
that
state,
but
it's
not
there,
and
so
it
doesn't
do
anything.
In
this
case,
you
actually
need
to
hit
f5
to
refresh
the
browser
to
establish
new
state
on
the
server.
That's
a
problem.
You
obviously
don't
want
to
your
users
if
they're
like
in
the
middle
of
like
ordering
their
pizza
and
they
put
all
their
toppings
and
they
have
it
perfect
and
they're
just
about
to
click
order,
and
then
someone
pushes
a
patch
to
the
server
and
restarts
the
server.
E
Then
you
all
the
users,
a
user
session
gets,
gets
reset
and
they
see
that
ugly
UI.
By
the
way
you
can
customize
that
UI
to
do
other
things
and
we
do
plan
to
make
some
improvements
to
it.
So
the
prop
the
way
to
solve
that
is.
You
need
to
have
some
way
to
persist
the
state
on
the
server
and
rehydrate
it
again,
so
that
when
the
server
comes
back
up
the
users
browser
can
actually
we
can
connect
back
to
the
original
state.
E
Now
we
are
going
to
provide
the
extensibility
hooks
in
the
framework
so
that
you
can
persist
and
you
can
rehydrate.
We
will
provide
documentation
and
guidance
for
how
you
should
do
that.
Those
are
things
that
we
are
actually
actually
working
on
right
now:
they're
there,
if
you're
curious
to
go
dig
around
a
little
bit
on
the
infrastructure
that
that's
there
I
believe
the
type
is
the
circuit
factory
is
the
thing
that
handles
like
creation
of
circuits
and
that's
probably
where
I
would
start
looking
to.
E
F
F
E
A
cover
that
giving
a
warning
some
of
the
improvements
we
plan
to
do
to
that
UI,
like
one
thing
is,
we
might
add
some
logic
that
actually
detects
like
okay,
I'm
able
to
connect
back
to
the
server.
But
my
state
is
no
longer
there
no
point
and
keep
on
trying,
I'm
just
gonna,
actually
refresh
the
browser
for
the
user
and
say
sorry,
you
know
a
server
crashed
or
whatever
summer
went
down.
We
have
to
restart
also
probably
de-emphasize
the
retry
button.
E
E
G
E
E
What
this
enables
is
the
the
pixels
from
the
client-side
blazer
up
get
pre-rendered
on
the
server
they
get
sent
down
to
the
browser
really
fast
and
then,
while
the
webassembly
runtimes
being
downloaded
in
the
background
and
then
fires
it
up
as
soon
as
it's
downloaded
and
then
sets
up
the
app
for
interactivity.
This
is
something
you
can
do
today
and
go
check
out
this
sample
if
you're
interested
in
doing
that.
Okay,.
B
E
Attribute
naming
can
you
have
prefixes
I
assume
for
absolute
naming
they're
talking
about
like
if
I
want
to
do
my
own
directive,
attributes
I,
think
so
yeah!
That's
that
okay
yeah,
that's
interesting!
I
mean
the
core.
Syntax
is
what
you
saw.
There's
no
like
built-in
prefix
notion.
We
might
need
to
establish
some
sort
of
like
convention
or
something
that,
when
you
bring
in,
if
libraries
bring
in
an
extensible
set
of
directive,
attributes
like
how
they
can
avoid
collisions
yeah.
E
It's
interesting
problem
that
for
three:
oh,
we
don't
plan
to
actually
open
up
extensibility
for
directive
attributes
in
that
time
frame
we're
just
basically
trying
to
lay
the
right
foundations
so
that
when
we
are
ready
to
do
that,
that
we
have
the
right,
you
know
underlying
pieces
in
place,
but
don't
expect
that
the
directive
active
you
extensibility
anytime,
soon
we're
just
trying
to
lay
the
groundwork.
Okay,.
B
E
The
ones
that
we've
implemented
for
Blaser
ourselves
and
see
how
we
blend
that,
but
it's
not
something,
that's
an
open,
extensibility
point.
Yet
it's
just
we're
just
trying
to
explain
why.
Why
do
we
do
this,
like
we
change
the
syntax
in
producing
some
people
like
you
broke
my
app
like
why,
and
the
reason
is,
is
because
we're
trying
to
set
blazer
up
for
future
extensibility
cool.
B
F
E
What
you
can
do
today
is
there
are
I
believe
there
are
two
options.
One
is
you
can
take
the
signal,
our
JavaScript
client
and
you
can
shrink
wrap
it
with
JavaScript
Interop
code
and
call
it
call
into
it
as
if
it
were
c-sharp.
There
are
community
projects
that
already
have
set
that
up
for
you
today
that
you
can
just
go
grab
their
new
get
packaged,
downloaded
install
it.
There
is
also
the
possibility
of
using
the.net
signal
our
client
inside
a
blazar.
A
pieman
blazer
is
running
net
code.
E
Then
the
mono
folks
have
actually
done
the
work
in
the
runtime,
but
we
haven't
done
the
work
in
blazer
yet
to
enable
all
of
the
mono
bindings
so
that
we
can
just
call
in
to
the
normal
system
that
whatever
WebSocket
call
there
is
someone
who
took
the
net
signal
our
client
and
ripped
out
the
underlying
transport
layer
and
plumbed
in
some
JavaScript
Interop
code
to
talk
to
the
browser
web
socket
API
is.
That
is
a
second
option
that
you
can
use
for.
Using
signal
are
in
client-side
blazer
today,
yeah.
F
And
just
so
that
the
reason
you
might
want
to
proxy
your
server-side
blazer
signal
are
like
RPC
calls
through
your
browser
is
one
for
like
things
like
cookies
and
so
forth
might
get
proxy
better
that
way.
Another
consideration
is,
if
you
have
a
bunch
of
different
clients
connecting
to
the
same
server,
they
might
already
have
that
connection
and
having
a
bunch
of
client
machines.
Connect
to
a
single
server
tends
to
not
run
into
issues
like
port
exhaustion,
as
opposed
to
having
your
server
make
all
those
connections
on
the
client
that
clients
back
I
think.
E
F
E
Client-Side
blazer,
like
your
the
signal,
our
pattern
would
be
the
same
as
if
you're
running
an
angular
app
or
a
react
app.
If
you're
writing
a
server-side,
blazar
app
or
your
components
literally,
are
already
on
the
server
for
a
bunch
of
cases.
You
can
leverage
the
existing
signal.
Connection
for
getting
a
real-time
feel
for
things
already
like
you.
If
you
have
like
a
back
a
background
process,
that's
one
that
you
want
to
use
to
update
the
UI.
E
You
can
just
have
the
components
state
get
updated
by
that
background
process
and
then
say:
state
has
changed,
the
component
will
be
render
and
then
the
UI
and
the
client
will
go
ahead
and
rerender.
So
some
of
these,
like
I,
wanted
to
you
know
push
some
UI
updates
from
the
server
to
the
client
are
actually
very
straightforward
in
server-side
blaze
or
without
any
writing
any
signal
our
code
at
all,
but
there
are
still
cases
where
you
might
want
to
ride
explicit
signal.
Our
code
yourself.
We
do.
E
Yeah,
cool,
okay,
yeah,
so
great
any
more
questions
was
that
was
that
did
I
get.
E
Mono
Azzam
assembly
did
shrink
in
preview
six,
which
was
great.
Thank
you,
mono
folks,
for
all
the
hard
work
they
did
to
do
that,
and
then
we
pulled
in
some
additional
dependencies
in
the
blazer
side
and
brought
it
right
back
up
to
where
it
was
so.
One
of
the
things
we
did
in
preview
6
is
we
switched
from
using
this
sort
of
one.
E
We
had
a
specialized
Jason
serialization
stack
in
in
blazer
that
we
were
using
it's
a
simple
Jason,
which
is
a
derivative
of
I,
believe
it
was
originally
from
Facebook
and
we
switched
over
to
using
system
text
Jason
in
in
preview
6,
which
is
the
the
new
serialize
er
comment.
That's
coming
from
the
our
friends
on
the
the
dotnet
core
team
that
unfortunately
did
pull
in
and
I
think
there
were
some
other
changes
may
be
in
the
auth
world
that
pulled
in
some
additional
dependencies
that
bloated
the
app
size
up
a
bit.
E
Now
one
thing
that
we
need
to
do
that
we
haven't
done
yet
is
we
only
run
the
linker,
the
isle
linker?
On
the
like
bcl
types
that
come
from
from
our
friends
on
the
mono
team?
We
don't
actually
run
the
linker
on
anything
else
like
none
of
the
Blazer
assemblies
or
anything
like
that,
but
there
is
a
good
chance
that
once
we,
if
we
start
playing
around
a
little
bit
with
our
linker
config,
that
we'll
be
able
to
link
out
a
bunch
of
the
stuff
that
got
pulled
down
in
preview
6.
E
If
anyone
wants
to
play
around
with
that
and
beat
us
to
that
investigation,
that
would
be
great
right
now
we
are
pretty
heavily
focused
on
getting
server-side
blazer
ready
to
ship.
Well,
you
may
notice
that
client-side
blazer
is
kind
of
slowing
down
a
little
bit
in
terms
of
its
pace
of
development.
We
are
keeping
it
up-to-date
with
each
dotnet
core
3,
oh
release,
but
not
as
much.
You
know.
B
D
B
B
E
Happened:
I,
don't
think
I
did
anything
anyway,
I'm
gonna
get
going.
So
let's
say
you
want
to
change
the
namespace
of
a
component
like
so
this
counter
component
I
can
add
a
counter
component
to
my
to
my
app
here
and
you'll.
See
that
there's
two
syntaxes
right,
you
can
add
it
by
name
because
I
have
a
using
statement
in
place
or
you
can
do
the
fully
full
name
of
the
type
right
and
the
the
namespace
for
my
counter
is
blaze,
our
preview
six
demo
dot
pages.
What,
if
I
want
to
change
that?
E
So,
let's,
let's
go
ahead,
add
the
full
lane
long
version
counter
yeah.
Let's
do
this
one
so
that
that
adds
a
counter.
Now,
if
I
go
back
to
my
counter
component,
I
can
add
the
at
namespace
directive
up
here
and
switch
the
namespace
to
something.
That's
like
my
name
space,
save
that
if
we
go
back
to
index
now,
we
should
see
that
hopefully
there
goes
yeah.
So
now
it's
no
longer
purple
the
purple
is
gone.
That
means
this
type
isn't
being
recognized
anymore.
Why
is
that?
E
Well,
if
we
look
at
doing
a
counter
now,
you
can
see
the
namespace
of
the
counter
is
now
my
namespace
counter,
so
you
can
control
the
namespace
of
your
components
now.
This
is
important,
of
course,
because
for
components
to
be
in
scope
you
need
to
have
the
namespace
in
scope,
and
so,
if
you
want
to
have
all
your
components
be
in
the
same
namespace,
this
is
a
convenient
way
that
you
can
now
do
that
with
a
razor
directives.
E
I
think
I
think
they're
gonna,
stop
that
that
was
that
was
the
last
one.
The
the
other
demo
I
think
they're
gonna
I'm,
just
gonna
talk
briefly
to
is
a
you
know,
publishing
your
app
your
server-side
blaze,
our
app
to
Azure,
there's
some
really
nice
tooling.
Now
in
Visual
Studio,
where
it
will
help
you
add
the
azure
signal
our
service
to
your
server-side
blaze.
Their
app
that'll
be
really
important
when
you
want
to
scale-
and
you
know,
get
WebSockets
going
and
scale
out
to
lots
and
lots
of
client
connections.
E
So
the
azure
signal,
our
service
is
really
important
for
doing
that
and
works
great
with
server-side
blazer.
So
when
you
go
to
publish
your
server-side
blazer
app,
the
the
visuals
to
we'll
say,
hey,
we
recommend
using
the
azure
signal
our
service.
You
can
just
add
it
as
a
dependency.
It'll,
add
a
single
package
to
your
app.
You
don't
have
to
change
a
line
of
code
and
you're
ready
to
publish
you,
publish
your
app
and
it
just
works.
You
should
give
it
a
try,
check,
check
it
out.
That's
alright!.
B
Awesome,
alright!
Well,
that's
it
for
this
week,
so
we
have
the
links,
I've
been
updating
them,
as
we've
been
going
there
they're
going
to
be
in
the
show,
description
and
we've
chatted
them
out
and
they're
on
the
Twitter's
and
everything
so
awesome
and
congrats
on
shipping
preview,
6
and
looking
forward
to
well
so
what's
next,
is
there
a
guy?
Are
we
looking
at
preview
7
or
is
this
sort
of
what
happened?
Maybe.