►
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.one-tab.com/page/CWgYVbN2QiSPdhpag4V_9Q
Suggest an idea for a standup: http://aka.ms/dotnet-standup-suggestion
B
A
A
B
B
A
A
B
A
B
A
B
B
A
Right
cool
so
keep
letting
us
know
on
the
on
the
audio
and
we'll
take
a
look
at
that.
So
here
we
go.
Andrew
Locke
here
he's
talking
about
validating
phone
numbers
using
Twilio
in
the
asp
net,
core
identity
and
razor
pages.
So
so
the
deal
here
is
that
there
is
some
basic
validation
for
phone
numbers,
just
regular
expression,
style
Twilio
offers
some
more
advanced
phone
validation
and
including
some
things
like.
If
you
provide
them
a
country,
they
will
tell
you
whether
that
phone
number
is
valid
for
that
country.
So
this
is
not
actually
like.
A
You
know,
making
a
phone
call
or
doing
any.
You
know
specific
validation,
that
the
phone,
actually
you
know
is,
is
there
or
receives
the
text,
but
it's
doing
kind
of
a
best
guess
so
so
what's
cool
here?
Is
he
digs
into
you
showing
actually
customizing
the
identity
pages
and
the
way
that
identity
changed
with
to
one
it
moved
over
to
using
razor
class
libraries?
So
before
you
had
just
a
bunch
of
files
on
disk
and
now
with
the
razor
class
libraries,
when
you
scaffold
identity,
it
only
puts
in
the
files
that
you
are.
A
Actually,
you
know
that
you
want
to
customize
on
disk
and
it's
pulling
the
rest
from
a
razor
class
library,
so
he
goes
through
and
you
know
polls
use
it
uses
the
dotnet
CLI
to
scaffold
identity
pages
and
shows
going
in
and
actually
customizing
specific
pages.
So
the
this
is
all
that
you
get
to
start
with.
You'll
look
you'll
see
here.
This
identity
area
only
has
the
view
start
and
it's
pulling
from
the
razor
class
library
since
he
wants
to
go
in
and
customize
how
its
operating
here
he's
pulling
in
some
additional.
B
A
I
love
the
way
that
it's
implemented
there,
so
here
he
shows
going
in
and
setting
it
up
with
with
the
Twilio
API
he's
using
a
country
drop-down
so
he's
showing
with
a
few
different
country,
so
I
think
I
believe
here
he
shows
you
know
three
different
countries
and
then
going
through
and
validating
so
calling
into
the
Twilio
API
and
saying
whether
or
not
they
the
phone
number
looks
valid
for
that
country.
So
you
know
this.
This
is
a.
This
is
kind
of
a
nice
start
on
it.
A
If
you
wanted
to
go
through
and
and
validate
for
more
countries
or
whatever
you
could
if
this
ends,
you
know,
this
is
also
a
neat
just
to
show
off
customizing
with
Razer
class
libraries.
Also
well,
not
commerce,
for
that
twenty
beta
is
released.
So
this
this
is
a
cool
commerce
package
for
asp
net
and
some
of
the
cool
features
that
they've
got
support
for
now,
as
it
is
running
in
Linux
and
docker.
So
so
some
neat
stuff.
This
is
this-
is
a
cool
project
that's
been
around
for
a
while.
A
It
has
a
great
great
community
and
stuff
so
great
to
see
that
moving
ahead.
All
right,
I
just
saw
this
come
in
this
morning.
This
is
view
net
alpha
and
so
view
is
a
popular
front-end
library,
and
so
what
they've
set
up
here
is
a
a
library
for
building
building
integration,
with
asp
net
core
on
the
back
end
and
view
on
the
front
end,
and
so
you
know
this
goes
through
and
explains
the
idea.
This
is
actually
you're.
A
Writing
your
application
code
in
c-sharp,
describing
the
difference
between
this
and
blazer
that
you're
actually
you're,
not
using
web
assembly
you're
just
shipping,
some
javascript
to
the
to
the
client
side.
So
you
know
just
kind
of
nice
explaining
what's
going
on
here
and
definitely
calling
out.
You
know
the
tiny
file
size
on
the
front
end.
B
A
Honestly,
I
don't
know
that's
actually,
let's
look
at
that
because
he
does
show
initializing
it
there.
It
is
ad
tech
helper,
it
is
yeah,
pretty
cool,
yeah,
I
love,
I
love
it.
When
you
know
people
are
you
making?
You
see
the
extensibility
points
and
you
know
not
writing
a
ton
of
stuff,
not
overriding
everything,
just
kind
of
plugging
in
at
the
right
level.
B
A
A
So
folks
that
are
watching,
can
you
hear
me
because
I
can
keep
going
through
these
links?
If
you
can
hear
me,
while
we
fix
Taylor's
audio,
but
if
you
can't
hear
me
either,
then
we
may
just
need
to
wait
until
that's
fixed,
so
let
me
know
on
chat
as
soon
as
possible.
If
you
can
hear
me
enough
to
keep
going
alright.
A
B
B
A
A
Thanks
for
all
the
feedback,
folks,
yeah,
okay,
cool
all
right.
Let's
keep
moving
on
with
these
links,
then,
so
this
is
really
cool.
Dodie
Dodie
had
seized
some
tons
of
samples
using
ASP
net
core,
so
these
are
just
tons
of
samples
that
he
keeps
up
to
date,
and
these
are
latest
ones
updated
now,
through
asp
net
core
3
o
preview
for
so
yeah.
A
This
is
great
and
so
the
kind
of
level
he
goes
through
on
the
inside,
for
instance,
here's
you
know
routing
showing
razor
page,
showing
you
know
just
all
kinds
of
stuff,
so,
for
instance,
I'm
just
clicking
into
one
here,
and
these
are
very
kind
of
targeted,
very
simple.
So
if
you
want
to
see
a
specific
demonstration
of
you
know,
one
tiny
feature
one
example:
the
this
is
a
great
way
to
see
that
so
and
I
love
how
he
keeps
these
updated,
he's
always
kind
of
going
through
and
updating
them
very
quickly.
B
A
Yeah
and
he's
been
doing
these
going
back
for
a
few
years
now
so
Wow,
but
you
know
yeah,
really
really
cool
resource
cool
ahead,
updating
a
his
weekly
series.
This
is
he
up
we're
doing
a
through
Z
and
we're
up
to
the
letter
Q
already,
so
this
is
looking
where
e
tags
for
a
is
peanut
core
Web
Apps.
So
this
is
a
new
feature
in
nad
framework
to,
and
what
this
allows
you
to
do
is
to
associate
a
link
query
with
the
sequel
query
so
yeah.
A
So,
as
he
pointed
out
here,
this
is
something
where
it
can
be
kind
of
difficult
to
debug.
You
know
what
why
is
as
an
abstraction
over
you
know:
data
access,
sometimes
that
abstraction
makes
it
difficult
to
figure
out
what's
going
on,
and
so
here
you
can
actually
associate.
You
can
say
hey
when
I'm
calling
this
or
when
I'm
doing
this
link
query.
A
This
is
actually
the
underlying
you
know
the
under
buying
sequel,
so
here
here
his
his
example
shows
this
dot
tagged
with
and
then,
as
you
go
through,
you
know
here
here
is
showing
the
results
of
the
query.
But
more
importantly,
as
you
go
into
your
sequel
logs,
you
can
see
here
that
it's
actually
adding
comments
to
your
sequel.
So
just
a
nice
little
utility
feature,
but
this
this
makes
it
possible.
Where
you
can,
you
can
kind
of
trace
through,
and
you
can
add
this
you
know
and
and
they're
just
they're
just
comments
in
your
sequel.
A
B
A
And
it's
one
of
those
things
where,
when
you
need
it,
you
really
need
it,
and
so
so
it's
it's
cool
to
see
that
oh,
this
is
what
I'm
kind
of
Tooting
our
own
horn.
Here.
This
is
a
dotnet
foundation.
This
morning
we
just
welcomed
in
dot
vvm,
so
the
dot
vvm
project
has
been
around
for
almost
five
years.
It's
a
cool,
mvvm
framework.
It's
of
course
both
asp
net
core
and
owen.
A
A
So
I
thought
that
was
pretty
cool
and
welcome
to
the
foundation
and
my
last
my
last
link
to
share
for
this
week
so
ZD
is
writing
about
the
actual
release
of
the
signal.
Are
the
azure
signal
wire
service?
So
this
is
something
I
believe
a
year
ago
they
talked
about
the
you
know
preview,
and
so
this
is.
This
is
actually
the
one
o
release
talking
about.
A
B
B
B
You
alright,
let's
see
that's
the
right,
but
that
is
not
the
right
button.
Okay,
there
go
that's
my
box,
okay
cool!
So
today,
as
I
said,
I
do
a
lot
of
stuff
with
racer
and
with
tooling,
and
when
you
think
of
say,
asp
net
core
tooling,
you
can
think
of
working
in
visual
studio
where
you
get
all
this
beautiful
intellisense
and
this
beautiful
coloring
for
like
say
all
this,
yellow
goodness
or
whether
it
be
c-sharp
completion
or
whether
be
going
down
to
the
command
line
and
like.net
running
and
being
able
to
run
your
applications.
B
These
are
all
things
that
we
consider
tooling
and
for
me
in
particular,
I
work
specifically
on
razor,
but
razor
a
lot
of
aspects
to
it
and
some
of
those
aspects
are
hate
running
it.
So
it's
like
if
I
run
it.
Of
course
you
now
can
hit
that
website.
There's
a
lot
of
code
going
on
behind
the
scenes,
though,
that
make
this
possible
like.
If
you
have
ever
looked
at
the
output
of
a
razor
page,
you
can
start
to
see
some
little
hints
of
like
a
razor
off'
occation.
B
So
an
example
here
is
see
these
little
indentations
of
these
script
tags.
This
is
an
indication
that
hey
razor
has
done
stuff
a
little
bit
differently
and
in
in
this
case,
this
is
there's
no
script
tags
in
our
index
page,
but
there
are
in
our
layout,
and
so,
if
I
go
over
here,
we
can
see
some
of
the
indentation
differences
to
kind
of,
say,
Oh.
Something
happened
and
razor
has
parsed
our
file
and
generated
a
certain
way.
B
So
I
have
I,
have
a
few
slides
lots
of
demos
and
honestly,
probably
will
not
get
through
everything
but
we'll
see,
and
so
I
always
love
to
start
like
a
razor
tooling
talk
with
this
slide,
because
I
love
just
memes
in
general,
but
anyhow
so
razor
to
link
a
general
agenda.
I
think
it
is
kind
of
described
that
is
we're
gonna
go
through
what
it
means
to
build
tooling
like
this,
and
some
of
the
concerns
that
we
have
wind
building
tooling
like
this.
B
So
if
we
talk
about
support
today,
there's
a
newcomer
to
this
list,
which
is
vs
code
which
we'll
get
into
today,
we
support
visual
studio,
which
means
when
I
say
your
support.
Visual
studio
means
being
able
to
get
this
nice
little
colored
yellowness
in
the
editor
and
means
being
able
to
have
C
sharp
completion,
it
means
being
able
to
have
HTML
completion
tag
helpers
or
even
go
as
far
as
saying
having
JavaScript,
where
it's
like,
you
could
do.
B
Alert
I
always
tell
people
that
razor
is
one
of
the
most
complex
languages
that
we
own,
because
it's
actually
five
languages
in
one
kind
of
working
seamlessly
amongst
each
other.
In
our
case,
we
have
JavaScript
HTML,
CSS,
c-sharp
and,
of
course,
razor.
Where
razor
is
this?
All
this
good,
yellow
text
here
and
razor
is
very
complex
because
it
tries
to
make
all
of
those
languages
kind
of
work
seamlessly
together.
B
We
also
have
support
for
vs
code.
So,
if
I
jump
over
to
vias,
could
we
have
like
the
same
little
things
where
if
we
can
go
ahead
and
get
c-sharp
completion,
we
have
tag
helper
completion?
We
have
HTML,
we
have
JavaScript
all
the
various
things
that
you
would
expect
of
a
nice
editor
now,
when
building
out
actually
I'm,
not
gonna,
show
vs
or
Mac,
because
I
don't
actually
have
a
Mac
on
me
today,
but
trust
me.
B
It
works
a
lot
like
vs,
Windows
and
I've,
put
a
ton
of
time
and
actually
making
it
work
as
consistently
as
possible.
So
when
building
out
support
for
tooling,
you
obviously
want
to
share
as
much
code
as
humanly
possible.
So
the
first
thing
I
want
to
talk
about
is
compiler
and
tooling
layering
when
I
say
compiler
I'm
talking
about
the
bits
that
parse
your
razor
file
and
generate
a
c-sharp
to
run
your
page.
So
what
I'm
saying
is
the
things
that
translate
this
index.html
into
this
page,
that
is
at
the
compiler
layer.
B
Tooling
is
what
happens
when
I'm
actually
typing
in
Visual
Studio,
because
you
can't
have
one
without
the
other,
so
incop,
Ayler,
tooling,
first
off
razor
actually
has
a
parser,
and
this
is
available
on
new,
georg,
as
microsoft,
asp
net
core
razor
language.
It's
a
super
minimal
set
of
dependencies
and
we've
seen
people
use
this
for
everything
from
generating
email
templates
to
actually
envious
or
Mac.
A
B
Then,
of
course,
this
has
a
highly
extensible
IR
phase,
and
it's
kind
of
interesting
Blaser
probably
would
not
be
in
existence.
At
least
it
wouldn't
be
on
Razer.
If
it
wasn't
for
this
highly
extensible
IR
phase,
I
are
meaning
intermediate
representation,
they
went
ahead
in,
they
actually
be
Steve,
went
ahead
and
took
Razer.
In
said,
how
can
I
change
this
to
generate
something
that
can
work
in
the
browser
on
webassembly,
and
so
he
took
our
intermediate
representation
phase
and
made
it
spit
out
compatible
code
that
couldn't
work
can.
A
B
Usually,
in
a
parser
there's
multiple
as
multiple
steps
to
understanding
a
file,
so
there's
the
syntactic
understanding
of
the
file
where
it
goes
ahead
and
it
parses
it
and
saying:
okay.
Well,
this
@
symbol
obviously
has
a
specific
meaning
to
raise
res
as
syntactic
understanding
a
tag
has
a
syntactic
understanding
as
well.
We
know
this
is
HTML
if
you
put
stuff
after
this
@
symbol.
Well,
it's
probably
c-sharp.
However,
we
have
some
reserved
key
words
that
make
them
what
we
call
these
directives.
So
that's
the
syntactic
phase
of
a
parser.
B
At
that
point
you
can't
just
say:
okay
from
that
syntactic
understanding,
let
me
just
go
ahead
and
generate
c-sharp.
That
is
the
result
of
a
razor
file.
So
you
then
translate
that
syntactic
understanding
into
an
intermediate
phase
is
what
their
intermediate
representation.
So
this
is
things
saying
that
well,
there
is
a
class
and
then
that
class
has
a
method
and
we're
trying
to
render
HTML
at
this
location.
B
So
we
translate
syntactic
understanding
into
actual
understanding
where
this
means
go
ahead
and
render
the
HTML
element
div
with
a
tributo
head
and
render
its
content
go
ahead
and
render
c-sharp
all
the
various
things
that
I
mean
that
you
can't
get
just
from
syntactic
understanding,
so
maybe
I'll
dive
into
this
in
a
little
bit.
Actually,
some
welcome
to
hopefully
kind
of
aid
in
the
clarity
with
that
by
the
way
is
the
mic
going.
Okay,
is
this
working
out
all
right
for
people
yeah.
B
Cuz
I'm
kind
of
I'm
definitely
kind
of
leaning
to
the
left
here
to
try
and
make
sure
I'm
as
close
as
humanly
possible,
so
to
actually
kind
of
Aidan
showing
what
this
parser
is
I
steps
on
new
Georg,
so
of
course,
I
made
a
sample
for
it.
So
I
have
a
little
parser
here
where,
if
we
take
that
parser
from
new
org-
and
we
knew
it
up,
essentially
we
have
a
project
engine
and
this
project
engine
is
the
core
of
all
things.
Razor
razor.
B
Is
there
as
a
lot
of
inputs
that
are
determined
in
order
to
harsh
a
razor
file
successfully.
These
can
be
things
like
tag
helpers.
They
can
be
view
imports,
basically
files
impact
each
other
in
a
way.
So
we
have
a
project
engine
to
represent
that
the
product
engine
pulls
information
from
the
file
system.
We
have
a
specific
file
system
and
in
this
case
I
am
just
saying.
Instead
of
the
bin-debug
net
core
app
directory
just
go
ahead
and
use
my
project
directory.
B
We
have
a
file
here
and
we're
gonna
go
ahead
and
parse
this
file,
so
we
have
a
P
tag.
The
time
is
at
date,
time
now,
so
what
does
that
look
like
when
RAZR
parses
it?
So
if
I
run
this
I
get
this
nice
little
console
output,
where
it's
a
whole
bunch
of
c-sharp?
So
as
you
notice,
we
are
generating
a
namespace
for
Jinni,
generating
some
pragma
disables
because
remind
you.
B
This
is
all
auto-generated,
however,
like
if
we
go
down
a
little
further,
we
can
see
that
here's,
what
I'm
saying
is
we're
translating
the
syntactic
understanding
of
HTML
into
let's
go
ahead
and
render
this
to
the
browser,
so
all
Reaser
is
is
when
you
translate
it
from
a
document
that
we
see
here
here.
What
this
is
really
saying
is
render
this
to
the
browser,
execute
this
and
render
it
to
the
browser
then
render
this
to
the
browser
right.
So
that
is
what
this
all
translates
into.
Where
we're
saying.
B
Okay,
write
literal
render,
this
directly
to
the
browser,
run
the
c-sharp
and
take
the
out,
take
the
return
value
of
it
and
render
that
to
the
browser
and,
of
course,
we're
saying
by
the
way
this
exists
in
another
file.
It's
kind
of
an
interesting
way.
How
central
allows
you
to
do
that
and
the
thing
I
really
want
to
point
out
is
this
class
actually
doesn't
compile?
B
As
you
notice,
we
are
having
a
man
override
here,
but
there's
no
base
type
so
at
its
core,
the
parser
is
meant
to
generate
c-sharp
and
kind
of
be
semi
general-purpose,
but
you
need
to
customize
it.
You
need
to
extend
what
it's
able
to
do
in
order
to
make
something
compile
validly,
because
this
is
in
the
end.
This
is
just
a
string
like
if
we
go
ahead
and
we
look
at
the
output
of
this
parser
it
real
quickly.
We
have
the
c-sharp
document
and
the
c-sharp
document
has
generated
code,
which
is
just
a
string.
B
B
This
output
also
has
things
like
source
mappings,
so
remember
when
we
saw
that
right
date
time
now,
a
source
mapping
was
a
by
the
way
that
date
time
that
now
actually
belongs
in
another
file.
It's
from
another
file,
and
so
this
is
what
we're
telling.
This
is
how
we
can
tell
tooling
to
say
when
you
end
up
showing
this
date
time
right
now.
This
isn't
just
like
plain
text.
This
is
actually
C
sharp
and
back
associated.
So
we
do
things
like
that.
Okay,
so
that
is
the
parser
layer.
B
Next
layer,
we
added
a
feature
in
dotnet
core
200
that
required
us
to
understand
more
about
your
project
and
specifically
the
c-sharp
in
it
so
tackle.
Burs
tackle
burs
are
added
where
anything
that
implemented
the
attack,
help
or
interface.
We
would
then
pick
up
and
convert
into
an
html5
representation,
so
we
added
a
rosin
integration
layer.
This
depends
on
Rosen's
Microsoft
at
code
analysis,
c-sharp
bits,
and
this
again
also
available
on
nougat
org
and
just
like
the
other
one
I
went
ahead
and
wrote
a
little
sample
here
to
show
what
that
looks
like.
B
So,
let's
look
at
this.
We
have
a
tag
helper,
and
this
is
a
time
tag.
Helper,
tack
up
emerge
that
says,
let's
bind
to
the
time
tag.
So
whenever
we
see
the
time
tagging
document,
we're
gonna
go
ahead
and
run
this
code
at
runtime
and
if
I
look
at
our
file,
this
is
now
saying,
add
alt
tag
helpers
from
my
assembly
and
let's
go
ahead
and
have
a
tag.
Albert
called
time
now
mind
you.
There
is
no
tag:
helper
completion,
intellisense
coloring
and
console
apps.
So
this
does
not
actually
look
like
tech
helper.
B
How
to
convert
it
into
information
that
the
parser
understands
and
with
all
these
features?
If
we
go
ahead
and
run
it,
we
get
a
little
more
output
this
time.
Actually
it's
a
lot
of
them
are
out,
but
if
we
see
here
where
we
still
don't
have
our
validly
compiling
class
because
there
is
no
base
type,
we
still
have
our
override
method,
but
we
are
now
generating
a
whole
bunch
of
tackle
Peart
related
information,
things
that
are
required
to
run
tag
helpers.
So
if
I
scroll
down
we
see
the
time
is
it's
starting?
B
The
time
tag
knows
that
it
was
self
closing.
If
it's
it
able
to.
Let
me
scroll
to
the
right
here.
Let's
see,
oh
there,
it
is
self
closing
knows
that
it
was
self
closing.
We
create
the
instance
of
the
tag
helper
and
then
we
run
it
so
running.
It
is
equivalent
to
invoking
that
process
method
and
it's
basically
creating
a
set
of
output.
B
A
B
Absolutely
yeah
I
wish
there
was
a
simple
some
simple
things
that
oppai
the
way
just
go
ahead
and
create
this
tag
and
magically
make
it
do
what
it
can
do
without
zero
other
efforts,
and
this
be
a
one-liner
but
yeah
there's
a
lot
there
like,
for
instance,
if
I
would
have
added
attributes.
So
you
see
a
whole
bunch
of
things
here
that
we're
setting
up
all
the
attributes
in
between
these
two
lines
before
actually
running
it,
so
that
tackle
pers
could
see
the
attributes
that
were
available
on
it
to
make
runtime
based
decisions.
B
So
next
we
have
the
MVC
or
blazer
layer
as
I
like
to
call
it
and
again
on
nugatory
microsoft,
asp,
net
cord
and
BC
that
razor
extensions
and
this
customizes
the
parser
further
to
allow
to
enable
things
like
NBC
and
blazer.
This
is
what
sleeved
it
and
I
go
back
over
here.
I
have
one
more
demo
for
this,
and
I
now
have
a
parser
with
MBC,
so
we're
back
to
our
original
file
in
this
example.
So.
A
B
Model
binding
is
a
runtime
concerned.
This
is
more
so,
for
instance,
when
I
am
in
this
file.
If
I
were
to
do
at
URL,
we
have
a
URL
helper,
write
things
that
we
have
access
to
in
here.
So
this
is
adding
MVC
understandings.
It's
adding
things
like
the
model
directive,
so
I
think
here
since
leaving
work
out.
C
I
do
yeah,
like
the
model
directive,
page
directive,
all
the
various
things
that
our
MVC
isms
I've
got
to
mention,
making
it
so
it
compiles
correctly.
B
So
if
I
go
over
to
the
program,
note
CS
a
lot
of
the
same
stuff,
but
we
now
have
this
helper
method,
razor
extension,
dot
register
and
if
I
go
ahead
and
I
actually
go
to
this
I
have
the
output
of
what
this
actually
does.
So,
as
you
can
see,
it's
adding
things
like
the
inject
the
model,
the
namespace
directive,
we're
adding
some
of
our
tag.
Helper
is
PAC
helper
isms
that
we
have.
This
is
just
a
helper
method
to
add
everything.
A
B
Yeah,
so
this
makes
things
more
NBC
like
so
now.
If
I
run
this,
we
get
a
lot
more
code.
We
run
thing
that
I
ran
actually
hold
on.
Let's
do
this
guy,
alright,
so
a
lot
more
code.
Now,
as
you
see
here,
we
are
actually
starting
to
inherit
from
the
razor
page
dynamic
base
type.
We
are
now
in
a
compilable
state,
assuming
we
have
MVC
referenced.
B
So
if
I
scroll
down,
we
have
the
time
is
date
time
now
a
lot
more
extra
bits
here
surrounding
it
that
our
runtime
concerns,
but
how
it
is
showing
at
URL
and
at
HTML.
We
can
see
here
that
it
adds
those
properties
to
the
type.
So
when
you're
typing
in
Visual
Studio
or
when
you
are
running
your
application,
you
have
access
to
those
members
to
be
able
to
to
use
them.
Ok,
yeah
so,
and.
B
B
Ok,
so
obviously
that
is
a
requirement
for
tooling
to
use,
because
if
tooling
didn't
actually
parse
the
file,
it
could
never
generate
the
correct
c-sharp
to
give
you
a
good
experience.
So
this
all
this
yellow
stuff
here
is
the
compiler,
and
then
we
have
specific
flavors
of
MVC
blazer
on
so
1x
2x
NBC
latest
I
said,
is
also
supports
blazer
and
we
go
ahead
and
put
each
one
of
these
tops
on
top
of
the
compiler
in
order
to
run
different
versions
of
MVC.
B
B
Get
razor
pages
as
available
so
visuals
to
do,
has
the
understanding
to
differentiate
what
a1o
product
is.
What
a
tool
project
is
what
a
Rio
project
is
it
understands
how
to
do
that,
and
it's
not
necessarily
a
simple
thing
to
do,
which
we
can
I've
into
how
it
actually
does
that
in
a
bit.
But
this
is
why
we
go
ahead
in
order
to
share
as
much
code
as
humanly
possible.
B
A
B
A
B
This
actually
so,
if
you
used
the
model
directive
right,
this
actually
controls
the
base
type.
So
let's
do
something
really
ridiculous
and
say:
models
daytime:
okay,
yeah.
Let's
rerun
this
person
BC
here,
but
I
go
up
to
the
directive.
It's
now
razor
page
of
date/time.
So
this
is,
when
you
say,
like
see
app
model
dot.
This
controls
that
model
dot
value
or
that
model
dot
type
essentially
so
in
this
case
model
would
be
a
type
date
time,
I
think
in
razor
pages,
it's
a
little
different
where
it's
actually
the
class
itself,
but
that's
the
gist.
B
B
Alright,
so
let's
continue
undo
this
real,
quick
okay,
so
we
next
get
into
tooling
concerns.
So
with
all
those
different
layers,
we
need
to
be
able
to
interpret
each
one
of
the
compilers
features
differently
based
off
the
platform.
So
we
try
and
share
as
much
code
as
humanly
possible.
Roselyn
actually
has
something
called
workspaces
in
a
workspace
is
something
that
is
a
logical
collection
of
all
your
projects
and
all
the
documents.
B
So
imagine
you
had
a
poco
object
which
had
a
solution,
and
then
it
had
a
list
of
projects
in
this
case
five
projects,
and
then
each
one
of
those
projects
had
a
list
of
documents,
and
maybe
it
had
programmed
OCS
tooling
typically
does
things
like
have
these?
What
I
call
project
systems
in
a
way
works?
It's
a
little
different,
but
anyhow
system
lake
concepts
in
order
to
organize
where
things
are
and
how
to
interact
with
them.
B
So,
for
instance,
if
I
open
program,
CS
rosin
can
ask
their
workspace
well,
find
me
the
abstraction
that
represents
program.
Cs,
get
me
the
parse
tree
for
it
or
parse
it
on
demand
and
start
making
decisions
based
off
the
output
of
that.
So,
for
instance,
we
have
like
code
lines.
We
have
fine,
we
have
like
f12
support
like
fire
to
do.
F12
rosin
takes
care
of
understanding
all
the
various
things
that
are
in
a
workspace,
the
references,
the
other
types,
so
you
can
do
features
like
this,
so
we
need
to
integrate
with
that
as
well.
B
We
depend
on
that
and
this
layer
is
actually
dependent
on
by
vs
code.
Vs
code
understands
this
amount
of
Rozlyn.
Next
we
have
all
the
visual
studio
platforms
that
we
support
and
that
is
visual
studio
windows.
They're
just
did
you
Mac.
They
depend
on
a
visual
studio,
platform-agnostic
layer.
So
it's
a
lot
of
data
types,
so
d,
tos
galore,
you
could
imagine-
and
basically
it
enables
us
to
tie
into
the
editor
in
a
way
that
is
platform
agnostic.
So
we
don't
have
to
rewrite
the
code
granted.
So
so
that's
I'm
guessing.
B
So
actually
you
could
put
live
share
in
this
grouping
here
as
well.
Yeah
live
share
depends
on
this
vs
agnostic
layer.
In
order
to
do
that
currently
live
share
is
not
supported
in
visual
studio
Mac,
but
if
it
were,
we
would
be
in
really
good
shape
because
we
are
live
share.
Understanding
would
depend
on
that.
Well,
alright.
So
I
mentioned
that.
I
mentioned
rosin
workspaces
and
I
mentioned
that
project
systems
are
a
great
way
how
to
enable
editor
features.
So
razer
actually
has
a
project
system.
B
Much
like
how
rosin
understands
all
the
various
projects
and
solutions
in
the
world.
Razer
has
a
similar
thing.
Now.
Razer
ignores
things
like
the
program
CS,
because
it's
not
a
Razer
concept,
but
we
do
know
that
there
is
this
parser
only
project.
We
know
that
there's
a
file
dot
CS
HTML
available
to
it.
So
when
we
open
that
file,
we
can
go
ahead
and
ask
our
project
system
by
the
way
get
me
the
outputs
for
this
file,
so
I
can
start
making
good
tooling
decisions
on
it,
which
could
be
meaning.
This
is
c-sharp.
B
A
A
B
A
B
A
B
B
So
you
don't
end
up
needing
to
have
the
exact
file
associates
Association,
because
with
the
crazier
class
library,
you're,
basically
saying
if
this
path
is
requested
or
if
this
path
is
important
here
is
the
type
it
exhibit
its
width,
okay,
cool,
all
right,
hopefully-
and
hopefully
I
answered
your
question.
Yeah
yeah,
you
did
so
a
project
system
yeah.
So
like
I
was
saying
it's
just.
B
It
is
a
abstraction
that
contains
information
to
make
decisions
easier,
I'm
noticing
I'm
running
a
little
bit
short
in
time,
so
I'm
gonna,
speed
up
and
go
a
little
fast
here,
so
just
to
kind
of
give
a
little
brief
look
into
racers
project
system.
So
we
have
something
called
a
project
snapshot
manager
which
has
again
a
list
of
projects.
You
can
get
projects
out
of
it.
You
can
see
if
certain
documents
are
open.
Each
one
of
these
projects
has
their
list
own
list
of
documents.
B
B
Those
are
represented
by
different
razor
configurations
and,
of
course,
a
document.
This
is
like
represents
file,
dot,
CS
HTML,
where
we
have
things
like.
Is
it
a
component
file?
Is
it
a
regular
file?
Where
does
it
exist?
What
is
the
project
its
associated
with?
Let
me
go
ahead
and
get
the
generated
output
of
it.
So
this
is
what
I
was
showing
you.
This
generated
code
from
like
in
the
console,
apps,
that's
equivalently,
what
this
is
doing
and
then,
lastly,
we
need
and
tooling
to
be
able
to
understand
the
various
configurations.
B
Razr
can
be
1,
X,
2,
X
and
so
forth.
So
we
have
a
list
of
project
engine
factories
in
each
of
these
factories
kind
of
work,
on
building
out
a
product
engine
that
is
extended
in
a
way
to
support
a
one
over
G
of
MVC
or
a
two
o
version
of
MVC.
Now
it's
a
different
concern
for
how
our
project
system
knows
to
use
this
specific
engine
which
hopefully,
we
can
get
to
in
a
bit
but
yeah.
So
that
is
a
lot
of
a
project
systems
concerns
and
specifically
our
project
systems
concerns
so
design.
B
I
thought
this
would
be
kind
of
cool.
It's
okay,
you
kind
of
jump
into
how
things
are
designed
for
the
project
system.
This
is
got
I,
feel
very
passionate
about
this
side
of
it,
because
I
think
then
a
really
awesome
job
designing
something
that
can
work
across
platform.
So
here
we
have
our
razor
eye
pressure,
call
this
product
system,
project
manager-
and
this
is
what
we
were
just
showing
you
was
the
project
snapshot
manager.
Now
an
IDE
over
here
exists
where
it
could
be
like
visual
studio.
It
could
be
PS
code.
B
It
could
be
many
of
other
different
ideas
via
Cermak
and
it
has
several
different
concerns
in
order
to
populate
the
information
in
our
project
system,
because
we
get
magically
doesn't
know
what
the
project
are.
We
can't
magically
doesn't
know
what
the
Razr
files
are.
We
don't
magically
know
what
their
configuration
of
the
project
is
or
the
tag
helpers.
So
we
need
to
populate
with
information
based
off
the
ID
it's
running
here.
So
we
have
things
like.
B
Okay
is
a
document
open,
go
ahead
and
tell
our
project
system
it's
open
or
go
ahead
and
tell
a
document
exists.
Maybe
you
have
gone
ahead
and
you've
restored
him.
New
references
like
you've
gone
ahead
and
added
a
reference
to
Newton
soft
that
Jason
or
you've
added
a
reference
to
MVC.
So
we'll
tell
our
project
manager
by
the
way
a
project
has
changed.
B
This
representations
understanding
has
changed,
because
if
you
changed
your
version
of
MVC
from
200
to
300
well,
we
obviously
need
to
reflect
that
in
our
project
systems
we
parse
RAZR
files
in
the
correct
way.
We
mostly
do
this
through
msbuild,
actually
so
EMS
built
like
if
we're
looking
through
the
various
msbuild
of
your
project
in
the
output
of
it,
we
spit
out
little
property
groups.
That
say
by
the
way.
B
B
Rozlyn
kind
of
runs
in
each
different
IDE,
different
environment,
so
there's
Omni,
sharp
and
vs
code.
There
is
V
s
or
Mac
has
its
own
rosin
foundation,
vs
Windows
as
well,
and
so
we
have
to
know
maybe
something
rosin
specific.
So
we
need
to
read
discover
tag
helpers.
We
need
to
know
what
tacklers
are
available
in
the
system,
because,
if
you're
writing
your
own
tag
up
or
you
want
to
be
immediately
available
to
you,
otherwise
that
kind
of
suck
because
you'd
have
to
sit
there.
A
B
Say,
oh,
we
closed
an
open,
visual
studio,
nope.
We
take
care
of
that
for
you,
so
this
all
gets
turned
on
its
head
and
live
share.
So
let's
talk
about
live
she
real,
quick,
so
live
share
was
one
of
the
things
I
was
added
in
Visual,
Studio
2019
and
it's
a
pretty
cool,
pretty
cool
idea
where
you
can
have
a
host
visual
studio
and
a
guest
visual
studio.
So
if
we
see
this
live
share,
button
up
here,
I
go
ahead
and
click
share.
B
B
B
I
see
you
there
I
see
you
just
joined
and
let's
go
ahead,
and
if
you
move
around
this
document
a
bit,
we
can
kind
of
see
your
night.
Oh
there
we
go
I'm
gonna
type,
a
little
bit,
oh,
and
so
you
could
do
all
various
things
raiser
now.
The
interesting
thing
here
is
John
is
actually
showing.
Actually,
let's
do
this?
Do
you
mind
sharing
your
screen
to
show
I?
Don't.
B
A
B
A
A
A
B
A
B
B
And
I
will
go
ahead
and
do
a
page
as
you
can
see
here:
it's
not
yellow.
It
knows
it's
a
one,
Oh
app,
but
again
there's
no
project
file,
there's
not
information.
So
it's
remoting
this
over
the
wire
because
live
share,
works
in
a
remote
way.
Hence
you
are
obviously
not
in
the
room
with
me
or
very
far
away.
B
Okay,
this
is
amazing,
yeah,
so
live
share.
You
can
get
all
sorts
of
things
with
it,
which
is
pretty
cool
and
you
can
do
c-sharp
in
our
case,
we've
added
support
for
Razer.
It's
only
in
Visual,
Studio
Windows,
not
not
vs
code
and
I
went
ahead
and
ended.
The
live
show
session,
yeah
jump
back
to
me
here,
alright
and
so
to
support
this.
We
had
we
utilize
the
fact
that
we
had
a
project
system
and
then
put
it
over
a
network.
So
the
one
thing
I
didn't
mention
before
is
there
is
this
changed
event
here?
B
This
changed
event
says
when
something
happens
to
the
project
system,
whether
you
change
the
configuration
because
you're
updating,
MBC,
2
200
to
300
go
ahead
and
tell
the
world
tell
you,
ITU,
reparse
the
world
to
understand
the
new
version
of
the
document.
So
what
we
did
is
in
a
live
shirt
environment.
We
have
a
host
products
as
don't
we
have
a
guest
one.
I
was
the
host.
You
were
the
guest
and
over
the
network
we
go
ahead
and
remote
all
the
project
level.
Information,
I
remoted
it
to
you.
B
So
you
did
not
need
the
project
on
your
end,
because
I
was
telling
you
over
the
wire
what
it
was
and
if
I
were
to
say,
add
a
reference
to
something.
This
changed
event
would
fire
him.
You
would
didn't
see
all
your
files
get
updated,
so
we
could
update.
We
could've
upgraded
the
one-oh
project
to
a
to
one
project
and
so
forth.
This.
A
B
Exactly
honestly
live
stuff
is
super
fascinating
to
me
and
when
I
get
him
to
vs
code
in
a
bit
like
highly
inspired
from
some
of
the
stuff
that
was
live,
sure
related
so
yeah,
it's
really
really
cool
technology
all
right.
So
let's
talk
about
how
Visual
Studio
works,
so
we
work
off
of
a
thing
called
projected
documents
and
again
I
like
memes
and
projected
documents
like
okay,
you
can
see
all
this
good
is.
Basically
if
we
take
this
file
in
the
bottom
left,
this
gets
broken
down
into
mini
sub
documents.
B
I
said
razor
is
five
different
languages.
If
there
is
CSS
you'd
see
that
here
you
can
see
that
here
too.
So,
as
we
see
here,
the
HTML
buffer
has
the
script
tag
on.
It
does
not
have
the
alert,
because
the
alert
is
actually
JavaScript.
If
we
had
another
script
tag
above
this,
you
would
also
see
that
javascript
in
the
JavaScript
buffer
because
mind
you,
you
can
use
different
JavaScript.
B
You
can
use
JavaScript
from
other
script
tags,
so
we
generate
a
single
buffer
to
contain
all
the
various
jobs
as
if
you
were
editing
a
single
javascript
file,
c-sharp,
all
the
c-sharp.
We
just
saw
same
thing:
you
have
the
namespace
class,
everything
that
represents
the
c-sharp
of
the
view,
data
title
about
that
here
and
then,
of
course,
razor
all
of
that
gets
combined
to
be
brought
into
a
view
buffer.
It's
what
you
see
it's
what
we
see
here
now.
B
This
is
useful
because
it
enables
us
to
if
you're,
editing,
c-sharp
you
get
to
act
as
if
you're
editing
a
c-sharp
file
if
you're
editing,
HTML
same
thing
as
if
you're
editing
an
HTML
file.
So
we
use
these
projections
that
we
call
them
to
make
this
possible.
Now
it
has
some
caveats
so,
for
instance,
this
a
curly
brace,
is
a
razor
concept.
B
Yet
since
we
know
to
indent
the
C
sharp
as
if
it
was
in
AC
sharp
block,
but
it's
not
really
C
sharp
luck,
it's
a
razor
block,
so
we
do
some
magic
to
kind
of
intermingle
all
these
languages
together
to
make
things
work
so
projected
languages,
and
so,
when
edit
comes
in
so
this
individuals
to
you
edit,
we
end
up
doing
a
parse
on
the
file.
We
say:
is
it
significant,
so
I'll
get
into
what
the
significant
means
in
just
a
second,
we
apply
to
the
projected
document.
B
So
if
you
edit
in
c-sharp,
we
would
update
the
c-sharp
with
whatever
you
edit
it
and
then,
if
it
was
significant,
which
all
again
they'll
get
into
a
second,
maybe
we
need
to
reach
and
what
c-sharp
is
so
an
example
of
this
is
if
I
go
back
here.
If
I
were
to
delete
this,
this
curly
brace
right
here
this
up
and
curly
brace
it
would
instantly
become
c-sharp,
because
it's
no
longer
in
that
curly
brace
of
razor
you
might
need
to
reach
and
what
the
projections
are.
B
So
this
gets
altered
on
its
head.
When
you
talk
about
partial,
provisional
parsing
razor
was
designed
to
have
what
we
call
implicit
expressions
so
at
person
dot
first
name
dot
whatever,
where
you
did
not
need
to
be
explicit
about
where
an
expression
starts
and
where
one
ends
we
try
and
be
smart
about
it.
So
in
this
example,
we
have
the
dot
here
at
the
end,
which
is
actually
HTML.
As
you
see,
there's
no
coloring
here,
but
this
one
happens
to
be
c-sharp.
B
This
is
a
huge
concern
for
tooling
and
interest
in
general
for
parsing,
because
it
means
you
can
parse
the
same
document
twice
and
get
different
results,
which
is
unfortunate.
It's
C
sharp
because
of
the
fact
that
you're
editing
it.
So
if
I
were
so,
if
I
jump
over
to
this
over
here,
if
I
do
at
date
time
dot
I
have
C
sharp.
However,
if
I
go
ahead
and
night
close
at
my
completion
list,
you
can
see
three.
B
B
B
You
can
run
build
CMD
and
then
open
this
in
Visual
Studio,
and
if
you
run
this
razor
extension
project,
you
can
run
razor
in
Visual
Studio,
which
is
kind
of
cool,
so
I
have
it
running
right
here
and
if
I
go
ahead
and
turn
on
some
breakpoints,
we
can
kind
of
see
this
edit
flow
in
action.
So
I
will
just
do
an
angle
bracket,
so
Visual
Studio
text,
buffered
changed
so
Vigil
suit
is
saying:
hey
and
editors
come
through.
B
We
now
say:
well,
we
need
to
go
ahead
and
parse
that
at
it,
that
parse
is
what
we're
saying
is
rejected,
because
we've
now
typed
an
angle
bracket,
we're
saying
we
now
have
new
HTML
that
might
change
the
format
of
the
document.
So
this
is
a
is
it
significant
or
not
is
what
this
is
establishing
right
now.
So
we've
just
said:
yes,
it's
significant
to
an
angle
bracket
at
which
point.
B
B
Parsing
or
it,
it
means
that
when
we
tried
to
what
we
call
partial
person,
which
is,
we
tried
to
think,
are
we
in
a
situation
like
date/time
dot,
where
we
don't
actually
want
to
reevaluate
the
world
where
it's?
Okay?
If
something
does
not,
is
not
correct,
and
we
said
no,
it's
not
okay,
because
if
you're
doing
angle
bracket
you
might
want
to
have
a
tackleberry
you
might
want
to,
you
might
actually
change
the
hierarchy
of
the
document
itself.
B
So
in
our
case
we
said:
okay,
let's
go
ahead
and
cue,
a
change
which
means
queue,
a
parse,
and
then
we
notify
everyone.
Listening
that
the
basically
results
have
happened
and
if
I
jump
down
to
here
actually
I
can
look
at
the
c-sharp
before
the
for
the
result
in
Visual
Studio.
So
if
I
do
I
think
was
it
code
document?
That's
such
big
text.
B
Okay!
So
if
all
do
background,
parser
args
dot
code
document
and
just
like
how
are
we
doing
in
the
in
the
console
apps,
but
you
get
c-sharp
document
I,
get
this
generated
code
and
for
that
document.
Similarly,
I
have
all
of
the
Razr
c-sharp
that
is
being
put
out
to
Visual
Studio.
This
fills
in
the
c-sharp
projection.
So,
as
you
see
here,
we
have
our
Jason.
We
have
our
component.
We
have
our
URL
all
the
various
things
you
can
access
in
Visual
Studio,
so
that
is
a
Visual
Studio
edit
flow.
B
Let's
talk
obvious
code
real
quickly,
so
BS
code
is
based
off
of
a
language
server
protocol
model.
Now
language
server
protocols
are
the
new
and
hot
is
how
live
sure
works
where
they
define
a
set
of
contracts
where
it
could
be
completion,
hover,
good
or
diffident.
All
these
various
things.
This
is
actually
a
very
small
subset
of
all
the
stuff.
The
language
different
protocols
supports
and
it
allows
you
to
build
a
standalone
executable,
a
server
per
se
that
can
provide
responses.
So
you
can
ask
the
server
at
the
following
location
in
document
X.
B
What
is
the
completion
and
the
server
will
say?
Oh,
the
completion
is
XY
and
Z
and
all
show
will
debug
through
this
real
quickly
to
see
what
that
looks
like
so
one
of
the
nice
things
that
language
are
protocols
is
typically,
if
you
don't
have
a
language
server
protocol.
You
end
up,
depending
on
the
platform
that
you're
running
on,
which
is
what
Visual
Studio
windows
in
Visual,
Studio,
Mac
and
razor
do
today.
So
we
say:
okay!
Well,
we
understand
what
a
text
buffer
is.
B
That's
a
Visual
Studio
concept,
so
we'll
depend
on
Visual
Studio
in
order
to
understand
text
buffer
changes.
So
this
is
what
will
typically
happen.
Is
you'll
depend
on
each
of
the
various
editors
in
order
to
do
the
right
thing.
However,
if
you
just
depend
on
the
protocol
as
long
as
the
IDE
understands
the
protocol
as
well.
Well,
you
each
language
can
depend
on
the
protocol
and
then
each
IDE
can
implement
it,
and
so
you
kind
of
get
the
language
features
somewhat
for
free
or
at
least
a
lot
cheaper.
B
So
this
is
how
to
Razors
design
model
a
Razors
vs
code
design
model
actually
looks
like
so
this
is
a
razor
document
open
in
vs
code.
We
have
a
razor
extension,
which
is
a
typescript
extension
for
vs
code.
This
is
a
glorified
buffer
manager,
so
we
use
projected
documents
a
lot
like
in
Visual
Studio,
but
we
have
more
control
over
them,
so
we'll
generate
an
HTML
document
and
will
generate
a
c-sharp
document.
Each
one
of
those
virtual
documents
has
their
own
language
servers
that
understand
everything.
B
The
nice
thing
about
this
is:
it
means,
if
you
install
say
like
an
angular
extension
or
react
extension
or
your
HTML
editor.
You
get
that
for
free,
because
we
are
generating
actual
HTML
documents.
So
you
get
all
of
that.
We
have
our
own
language
server
up
here
and
then
we
have
a
project
system
that
exists
up
in
this
little
corner
here.
B
I'm
sure
that's
really
hard
to
read,
but
we
have
piece
that
ties
into
Omni
sharps
language
server
in
order
to
pull
things
out
like
what
version
of
race
are
using
and
it
pumps
all
that
information
back
up
into
the
language,
the
razor's
language
server
in
order
to
parse
things
the
correct
way.
Okay,
so
an
edit
flow
and
Visual
Studio
code
looks
like
you
get
an
edit.
The
Razr
extension
tells
the
language
server
hey
by
the
way,
and
it
happened
go
ahead
and
update
your
understanding
of
the
world
at
which
point
it
parses.
B
B
So
when
we
do
a
completion,
we're
not
giving
bad
completions
at
a
bad
location,
trying
to
say
what
language
am
I
operating
on
so,
for
instance,
if
I
do
this,
if
I
hit
control
space
here,
I
get
C
sharp
if
I
hit
control
space
here,
a
lot
by
oh
yeah,
yeah
there
I'm
an
HTML,
yeah
and
so
forth
right.
So
it's
smart
about
that.
Also
various
things
like
see,
I
get
racer
directors
I'm
in
don't
want
to
app
right
now.
I
just
realized
that.
B
So
that's
how
completion
events
might
happen.
So
we
can
actually
debug
through
this
to
kind
of
see.
Similarly,
how
vyas
code
works.
So
I
have
vs
code
running
right
now,
just
fullscreen.
This
I'll
turn
on
some
breakpoints
and
if
I
go
ahead
and
try
an
get
completion
here,
which
I
showed
was
c-sharp
before
this
is
a
method
that
Visual
Studio
code
is
calling
in
to
me
because
it
understands
the
completion
language
server
protocol,
so
I
said
I
can
help
you
out
with
completion.
Visual
Studio
code
is
saying:
okay,
a
completion
event
just
happened.
B
What
is
the
answer
so
razor
says?
Well,
I,
don't
know
what
language
you're
operating
in
first.
So
let
me
go
ahead
and
find
out
what
projection
that
is
so
I
didn't
ask
our
razor
language
server.
What
language
am
I
operating
on
I'm,
either
c-sharp
or
HTML?
At
this
point,
I
went
ahead,
Dennis
little
query
to
say
if
it's
c-sharp
use
the
c-sharp
projected
document,
if
it's
HTML
use
the
HTML
one
right
and
is
if
I
look
here
this
projected
document?
Actually
it's
virtual
c-sharp,
that's
razor.
B
This
is
our
C
sharp
projected
document
and
you
can
actually
even
see
a
little
bit
of
the
content
here.
This
should
look
a
lot
similar
to
what
you're
looking
like
in
Visual
Studio
and
in
our
console
app
the
c-sharp
backing
it.
We
synchronize
everything,
so
it's
in
the
correct
state
of
the
world
and
then
we
go
ahead
and
say:
okay
well
now
that
everything
is
synchronized
now
that
we
know
what
language
you're
operating
on,
let's
go
ahead
and
re
execute
completion
on
the
C
sharp
buffer.
B
B
B
We
get
a
list
of
items,
so
we
have
last
last
index
class
all
these
various
C
sharp
things
at
which
point
we
can
represent
them
and
razor
at
the
top
level
as
if
we
owned
it.
So
in
our
case,
if
I
turn
off
these
again
and
I
VOC
I
get
C
sharp
completion
in
razor
because
it
is
all
request,
response
driven
and
I
can
reinvent
it
as
if
it
was
our
own
right.
A
Okay,
so
you're
having
to
kind
of
map
back
and
forth
between
these,
because
the
actual
like
high-level,
I,
think
of
like
a
message
dot.
You
know,
of
course,
you're
completing
that,
but
you're
really
doing
your
completion
based
on
the
actual
generated
code,
when
there's
more
lines
of
code,
a
lot
more
behind
the
scenes,
yeah.
B
A
You
hear
we're
short
on
time.
I
think
this
would
be
great.
You
know
if
we
get
feedback
for
more
people,
definitely
like
seeing
you
know
what's
going
on
under
the
under
the
hood.
So
so
as
a
reminder
when
the
when
the
show
ends
there's
a
link
there
that
where
we
say
you
can
you
can
request,
you
know
you
can
request,
guess
you
can
request
content.
So
if
people
would
like
to
see,
you
dig
into
more
detail,
I
think
a
great
to
see
more
of
this
yeah.
B
A
B
So
this
is
something
that
we
know
is
missing
and
it
has
been
thought
about
honestly:
I'm,
probably
not
the
right
person
to
ask
where
it
is
along
the
line.
That's
a
little
bit
above
my
paygrade,
so
I
honestly
can't
give
you
an
answer
as
to
is,
if
that
is
something
ever
going
to
do
or
not,
because
it's
not
something
I
own.
Okay,
okay,.
A
B
B
B
What
other
ways,
if
it's
visual
studio,
specific,
there's,
a
great
little
feedback
item
and
all
those
things
and
make
their
way
to
us
as
well.
There
is
a
a
student
razor
dot
of
V
s
code,
get
repo
Gabourey
po
actually
today,
which
also
has
its
own
issue
tracking.
But
if
you
file
an
a
spinet
Gore
will
pick
it
up
there
as
well.
Yeah
I.