►
From YouTube: GitHub Quick Reviews
Description
Powered by Restream https://restream.io/
A
A
Hello,
everyone
welcome
to
yet
more
overflow
sessions
of
api
review.
Where
today
we
started
with
a
pure
vision
of
we
were
going
to
get
through
the
analyzer's
backlog,
but
we
have
a
blocking
thing
that
we
have
a
promise
that
it's
quick
and
to
keep
us
honest.
I
will
start
a
stopwatch
all
right:
update
for
non-validated
http,
headers
enumeration
three
five
one,
two
six,
mr
tobe
yeah.
B
B
Tad
just
to
bring
it
fully
interview,
jeremy
yeah
so
for
hp,
headers
non-validated,
implemented
by
innumerable
my
request
is
that
we
not
only
make
them
innumerable
but
basically
allow
you
to
look
things
for
each
painters,
not
valid,
be
able
to
look
things
up
so
implement
our
read-only
dictionary.
B
Instead
of
just
I
enumerable
it's
sitting.
This
is
really
just
a
wrapper
on
top
of
something
that
is
already
a
dictionary
effectively.
So
it's
just
implementing
the
interface
delegating
to
the
rob
and
stuff
under
the
covers
and
then
exposing
the
most
valuable
members
of
the
interface
and
in
a
couple
cases
with
a
slightly
different
name.
So
adding
a
count.
So
you
know
how
many
things
are
in
it
exposing
contains
because
that's
useful,
exposing
the
dictionaries
try
get
value
but
exposing
it
with
a
different
name.
B
Try
get
values
since
that's
the
same
name:
that's
used
on
http,
headers
and
you're,
getting
potentially
multiple
values
out,
and
then
also
the
indexer,
with
typical
index
or
semantics,
and
then
for
the
values
that
you
get
out.
Instead
of
by
innumerable
implementing
our
read-only
collection,
which
is
just
I
enumerable,
plus
account
so
I've
added
a
public
count.
I
also
overwrote
two
string,
it's
largely
an
implementation
detail,
but
I
figured
I'd
call
it
out
and
I
removed
the
two
constructors
in
particular.
B
The
implementation
doesn't
actually
need
to
work
with.
I
enumerable
of
string
and
adding
a
constructor
that
takes
90
rule
of
string
just
adds
more
complexity
to
the
implementation
unnecessarily,
and
as
long
as
it
was
getting
rid
of
that,
I
also
got
rid
of
the
other
one.
So
this
is
what
I
would
like
to
the
tweaks
that
I
would
like
to
make.
B
A
And
then
http
headers
non-validated.count
is
the
count
of
keys,
correct
yeah.
E
B
B
I
mean
if
we
wanted
to
add
constructors,
we
would
add
a
string
constructor
and
a
string
array
constructor,
since
those
are
the
two
things
it
works
with
today.
My
hesitancy
is
those
are
the
two
things
that
it
works
with
today,
based
on
its
current
implementation,
but
there'd
be
nothing
like.
We
could
change
the
implementation
to
target
the
header
store
item
info
object
that
is
actually
what's
stored
inside
hdb
headers,
at
which
point
accepting
a
string
or
a
string
array,
would
just
again
be
this
extra
stuff
that
it
would
have
to
manage.
B
If
we
really
think
it's
important
that
someone
can
construct
one
of
these
from
a
string
or
a
string
array
like
we
can
do
that
or
from
an
innumerable
string
for
that
matter,
it
just
seemed
like
we'd
be
doing
it
for
completeness,
but
no
one
would
ever
use
them.
C
Yes,
I
mean
the
reason
why
I
asked
on
the
github
issue
was
because
people
when
they
write
test
code,
they
probably
want
to
at
least
have
some
methods
that
take
this
had
a
string
values
thing.
But
I
I
take
your
point
as
in,
like
we
add
these
trucks,
in
order
to
make
the
I
mean
you
can
already
do
some
of
the
stuff
already
it's
just
that
this
is
a
more
efficient
version
of
that
and
it
seems
a
bit
backwards
if
we
basically
prevent
ourselves
from
making
that
as
efficient
as
possible
by
adding
conveniences.
C
That
are
arguably
not
that
important,
because
realistically
this
type
doesn't
give
you
any
expressiveness
that
you
don't
already
have
right.
I
mean
you,
can
trivially
use
a
key
value
appear.
You
can
use
a
tuple.
You
know
a
string,
comma
string
array
like
it's,
not
that
this
type
does
something
that
you
can't
do.
It
would
just
be
a
tiny
tit,
more
convenient
for
some
people,
but
I
also
really
don't
foresee
this
becoming
this
major
exchange
type
right.
It's
just
the
free
construct
that
holds
two
things
right,
so
we
already
have
plenty
of
ways
to
do
that.
A
And
presumably
from
the
http
headers
class,
which
is
public
and
it's
in
fact
public
abstract,
presumably
if
you're
doing
tests
it's
just
you
have
to
this
is
the
test
route.
You
have
to
go
make
one
of
these
guys
and
fill
it
with
data.
B
And
now
you
can
get
these
two
hold
down.
Jeremy,
so,
like
you
can
create.
You
know
you
could
write
this
little
helper
function.
A
A
B
A
test
perspective,
so
my
I
mean
I
will
bend
to
the
will
of
the
group.
My
preference
would
be
not
to
add
the
constructors
unless
we've
actually
got
people
asking
for
them
in
a
meaningful
way.
But
you
know
if
folks
really
feel
strongly
about
it.
We
can
add
them,
and
it
just
means
if
we
were
to
change
the
implementation
to
the
future,
such
that
we
didn't
care
to
work
with,
you
know,
string
or
string
array
or
whatever
we
would
just
be
carrying
that
that
baggage
around.
G
I
see
it's
written
in
the
issue,
but
I
missed
the
conversation
assuming
it
happened.
Why
not
microsoft
printed
string,
values.
E
A
C
I
mean
we,
could
I
mean
if
you
really
felt
like
the
type
is
super
key.
I
mean
we
could
just
type
forward
down
this
one
type,
but
I
agree
that
it
seems
odd
to
do
that
and
same
argument
is
with
the
constructor
right.
I
mean
this
thing.
Is
not
this
major
exchange
tab?
I
hope
right
because
it
fundamentally
it's
just
you
know
effectively
a
key
and
a
comma
separated
list
right.
H
Yeah,
but
by
the
way,
speaking
of
keys,
I
I
assume
that
you're
going
to
use
a
consistent,
compare
between
the
enumerator
and
the
try
get
values
method
like
either
case
sensitive
or
case
insensitive.
G
String
values
is
like
in
our
I
header
dictionary
and
so
forth,
like
yeah,
you
needed
to
implement
abstractions
like
you're,
already
talking
about
it
for
testing
and
stuff
the.
C
G
G
H
Right
to
be
honest,
any
any
type
that
we
have
in
the
bcl,
that
is
string,
values
or
string
segment
both
from
the
extensions
library.
We
would
probably
have
different
behavior
than
those
two
types
already
have,
because
those
types
were
meant
specifically
for
the
di
and
extension
scenarios
and
don't
necessarily
follow
the
same
behaviors
that
we
would
want
inside
the
bcl.
C
I
C
But
even
then
you
could
get
away
with
a
one-way
conversion
right
potentially,
but
if,
if
your
goal
is
to
get
the
system
that
http
headers
into
the
asp.net
one,
then
you
don't
need
a
constructor
here,
it's
only
when
you
wanted
the
other
way
around
right,
so
we
could
still,
depending
on
what
the
scenario
is.
Maybe
you
get
away
with
one-way
street
right.
A
All
right
and
we
have
exceeded
our
time
box.
I
think
that
we
were
approved
of
steve's
amendments
and
the
rest
of
the
stuff
can
go
offline
or
to
a
different
issue.
Yep.
J
B
G
Point
on
that,
I
I
hesitate
to
commit,
especially
if
we're
trying
to
do
it
for
six
but
yeah
I'll
I'll.
Do
that,
since
no
one
else
charlie's
that
interested
I'll
at
least
bring
it
up
with
the
wider
team
and
see
you
know
how
important
we
think
it
is
on
the
asp.net
side
to
try
to
consolidate
and
we
can
get
something
started.
A
A
C
Sorry,
I
almost
muted,
I
filed
them
all,
but
I
didn't
write
most
of
them.
I
think
most
of
them
were
written
by
steven.
Actually,
okay,
can
you.
J
C
J
There
are
a
few
examples
to
help
clarify
the
suggested
analyzer
it
so
whenever
there
are
operations
that
involve
date
times
where
the
type
or
the
kind
is
clearly
known,
we
have
to
flag
them.
J
J
I
believe
there
is
no
fixer
yeah,
no,
no,
no
fixer
applicable,
it
has
to
be
manually
addressed
by
the
user.
B
So
I
guess
I
I'm
confused
by
the
examples,
because
by
the
title
of
this
I
thought
it
was
about
concerns
with,
like
I've
got
a
local
time,
a
local
time
zone,
and
I,
you
know,
add
an
hour
and
I
run
a
foul
of
you
know:
what's
it
called
happens
twice
a
year,
daylight
saving.
Thank
you.
That's
it
daylight
savings
or
something,
but
these
examples
seem
to
all
be
around.
B
J
Yeah,
that's
how
we
limited
the
examples.
Are
you
talking
about
the
analyzer
that
you
linked
in
a
comment
above.
J
J
All
right,
so
maybe
we
can
continue
addressing
investigating
this
one,
a
bit
more.
J
Yeah
I
say
we
skip
this
one.
We
continue
with
the
others
just
to
clarify
to
make
sure
we
clarify
what
math
math
means.
The
title
stated.
C
I
mean
you,
I
mean
you
have
an
example.
You
have
one
where
you
actually
do
subtractions
right,
so
I
I
think
the
spirit
of
this
is
basically
the
idea
that
you
shouldn't
mix
local
time
with
utc
time
right
and
so
it's
kind
of.
Basically,
if
we
know
the
kind,
then
any
sort
of
comparison
or
math
between
them
is
basically
bad
right.
A
I
guess
but
like
I,
you
know
to
steve's
thing
of
you
have
a
local
date
time
and
you
add
an
hour
and
daylight
saving
kicks
in,
like
I
think
the
date
time
handles
that
and
can
be
what
you
want,
and
so
I
think
that
that
if
that's
the
thing
we're
flagging
that
feels
like
it
would
be
too
noisy.
So
I
think
that
whatever
the.
A
Are
in
the
and
the
title
are
should
match,
so
we
understand
what
we're
talking
about.
L
A
L
L
A
C
L
C
Well,
even
ignoring
flow
right.
Most
of
the
time
you
don't
do
specified
kind
like
you
just
you
have
a
method
that
takes
two
day
times,
so
how
the
heck
would
we
know
where
they
came
from?
So
it's
a
I.
I
don't
know
that
like
in
practice.
It
will,
I
don't
think
we'll
actually
catch
the
bugs,
because
unless
you
can
inspect
the
object
like,
I
don't
think
you
can
do
anything
meaningful.
C
If
that
makes
sense,
I
mean
I
think
this
was
one
of
those
examples
where
maybe
thinking
of
longing
or
something
where
we
actually
tell
you
at
one
time:
hey,
we
just
noticed
you
did
a
operation
involving
two
day
times
with
you
know.
Mismatches
would
be
more
useful
than
trying
to
do
an
analyzer,
because
I
don't
think
you
actually
statically
know
enough.
Most
of
the
time
to
actually
help
you,
I
mean
sure,
there's
examples
where
you
can,
but
the
daytime.utc
now
dot
and
then
something
sure.
A
I
just
went
for
skipping
over
it
and
I'm
hoping
that
it'll
just
get
marked
as
no
longer
ready
for
review
until
it
gets
a
more
clear
purpose,
but
I
can
you
know,
do
more,
I
guess
actually
exactly
what
we
did
is.
I
should
mark
it
as
needs
work
of.
C
C
C
B
Is
this?
Is
this
specific
to
utf-8
jason
reader,
or
is
it
more
like
any
ref
struct.
H
K
H
We
had
an
idea
that
we
were
batting
around
earlier
regarding
move
only
types,
but
that
would
be
like
kind
of
a
wider
language
feature.
If
we
had
that
feature,
I
think
we
wouldn't
need
this
particular
rule,
because
we
would
just
mark
utf-8
json
radar
as
a
move-only
type
same
same
thing,
that
we
would
do
for
like
value
string
builder.
A
And
so
on
I
mean
that
one's
a
little
different.
It
depends
on
how
we
would
do
move
only
if
it
became
like
a
c
sharp
language
feature.
We
wouldn't
want
it
to
be
one.
If
it
became
an
analyzer
thing,
then
we
would,
because
there
are
times
that
it's
very
useful
to
intentionally
clone
the
reader
by
just.
H
A
It
into
a
new
local,
yes,.
H
A
Right
so
it
yes,
the
general
idea
is:
if
you've
passed
a
reader
into
a
method
by
value.
You
probably
have
a
bug
this.
I.
B
C
B
C
B
A
Because
the
reader
is
this
came
out
of
when
people
first
started
using
it,
they
were
making
this
mistake
because
you
know
why
would
there
be
a
mutable
struct
and
and
then
we
were
seeing
all
sorts
of
complaints
of
it's?
You
know
cycling
and
and
other
things
like
that,
it's
like
well,
I'm
in
an
infinite
loop.
Now
it's
like
well
yeah
because
see
this
step
right
here
you
had
an
implicit
rewind.
B
A
Sorry,
I
I
agree
with
your
your
point
that
we
should
that
this
should
be:
do
not
pass
mutable
value
types
by
value
and
then
somewhere
there
needs
to
be
a
list
like,
I
think,
that's
totally
cool
the,
and
I
think
that
the
fixer
would
be
the
same
on
all
of
them,
which
is
the
the
call
site
should
change
to
by
ref.
B
How
noisy
it
would
be
to
flag
refstructs
passed
by
value
rather
than
read
only
or
referee,
only
strucks.
A
I
L
C
L
C
L
The
the
issue
ends
up
being
that,
if
or
I
think
the
issue
ends
up
being
whether
or
not
it's
a
breaking
change
to
go
from
the
analyzer
to
the
language
feature,
because
the
language
feature
will
likely
start
reporting
as
an
error.
That
is
non-disabled
rather
than
as
a
warning.
C
But
that's
irrelevant
because
the
types
already
shipped
so
it
it
so
the
question
is:
could
we
make
utf.json
reader
later
on
use
the
language
feature
right,
but
that's
a
completely
orthogonal
thing,
whether
we
ship
an
analyzer
now
that
tells
you
that
you're
doing
it
wrong
because
the
time
is
already
shipped
so
like
the
the
the
the
damage
has
already
been
done.
Adjusted
users
can't
know
that
right.
So
I
think
our
analyzer,
whether
we
ship
one
or
not,
does
not
increase
that
footprint.
C
It
would
be
more
interesting,
maybe
design
mutable
structs
right
and
that's
why
we
haven't
shipped,
for
example,
mutable
string
builder,
yet
or
sorry
value
string
builder
right,
but
I
think
that's
our
general
problem
in
the
bcr
that
when
the
language
feature
comes
online
very
often
we
can't
make
the
bcl
types
use
the
language
feature
right.
So
we
can't
make
key
value
pair.
For
example,
a
record
right
for
the
same
reasons
right,
but
that
that
to
me
is
an
orthogonal
problem.
C
A
Yeah
and
with
jason
in
particular,
being
you
know,
a
net
standard
targeted
semi-ube
like
putting
an
attribute
on
the
type
wouldn't
necessarily
help,
because
if
your
package
closure
has
an
older
version,
it
wouldn't
have
the
attribute
on
it
right.
So.
A
Yeah,
so
I
think
it's
that
we
can
start
in
with
you
know
a
hard-coded
default,
and
then
I
think
that
config
has
a
way
that
you
can
merge
things
in
and
that
we
want
anything
that
we
think
is
problematic,
or
I
don't
know
if
we
can
teach
it
to
get
things
heuristically.
So
the
struct-based
enumerators
are
probably
all
end
in
the
word:
enumerator
our
value
types
and
our
nested
types,
and
that
like
it
can
just
say
you
know
what.
If
I
see
this
pattern
like
you
shouldn't
just
pass
this
by
value
yeah.
C
I
think
that's,
that's
why
I
said
I
think
the
one
thing
I
agree
with
tanner
is
that
we
should
not
invent
an
analyzer
to
basically
build
something
like
radio
stream
builder.
That
does
seem
wrong.
That's
something
that
we
should
talk
to
the
language
first
and
say
hey.
We
would
like
to
do
these
things.
C
What
would
language
feature
for
this
look
like,
so
that
we
don't
do
this
hack
with
an
analyzer
right,
because
the
the
thing
that
jared
has
said
many
times
is
that
we
can't
reliably
detect
when
copies
are
being
made,
and
so
just
passing
into
a
method
is
just
one
of
those
examples
where
copy
would
happen.
But
there
are
many
other
cases
like
you
know.
You
invoke
a
method
on
a
property
or
something,
and
then
the
compiler
introduces
a
copy
right,
so
it
gets.
C
C
Like
okay,
we
already
have
a
mutable
video
type
people
it
up
all
the
time,
because
with
readers
it
makes
sense
to
have
methods
right
where
you
have
a
method,
read
person
or
read
something,
and
you
want
to
take
a
reader
right,
and
that
seems
common
enough
that
it
seems
okay
to
flag
that
until
people
don't
do
that,
because
it's
just
a
it's
really
confusing
when
your
reader
doesn't
advance.
Would
this.
L
C
L
Flag,
you
past
utf-8
jason
reader
by
in,
and
then
you
try
to
call
a
a
method
that
mutates
on
it,
because
that
also
creates
a
copy,
which
is
also
problematic,
it's
still
being
passed
by
reference.
But
it's
not
going
to
mutate.
The
state,
like
you,
expect.
A
Yeah
but
the
at
least
on
that
one
anytime,
you
call
read
on
it
like
you,
haven't
changed
the
one
in
your
method
and
like
the
next
time
you
call
read
you
get
the
same
thing
like
wait
a
minute.
The
problem
is
when
you
do
complex
work
through
a
call
chain
and
then
pop
back
up
and
now
now
you
don't
understand
where
the
rewind
happened,
because
you
don't
you
don't
see
a
thing
that
didn't
get
modified.
L
A
But
I
mean
I
agree
like
in
kind
of
shipped
before
it
was
ready.
I
think
that
really
it
should
have
been
a
compile
error
to
call
a
non-read-only
thing
on
a
thing
pass
by
in,
but
you
know.
C
L
And
so
are,
are
we
going
to
say
from
the
start,
utf-8
jason
reader
and
what's
the
other
one
spin
lock
or
whatever.
C
Well,
the
way
I
would
do
it
is
what
jeremy
just
suggested.
I
would
probably
hard
code
all
the
enumerators
by
just
saying
it's
a
nested
thing.
It's
a
structure,
it
has
numerator
in
the
name,
I
mean
it's
going
to
be
mutable.
We
know
that
and
passing
that
pervader
is
bad.
You
know
that
too,
and
then
the
error
message
should
basically
say
something
like
do
not
pass
quote
type
name
quote
by
value
because
it's
yeah,
you
know
mutations,
aren't,
observed
or
something
to
that
extent
right.
L
C
A
Again,
the
attribute
has
the
problem
of
if
they're,
targeting
that
standard.
There
are
no
actions.
That's
true
well
for
like
spin
lock,
assuming
that's
a
net
standard
that
version
of
spinlock
wouldn't
have
had
the
attribute
on
it,
so
we'd
still
have
to
either
say
we
only
care
if
you're
targeting
net
in
or
higher,
or
we
have
to
say
that
there's
a
list
in
addition
to
an
attribute.
C
A
It's
fair
all
right,
so
I
think
that
there's
some
interesting
room
for
where
what
are
we
actually
reporting?
I
think
probably
the
best
thing
would
be
the
parameter
declaration.
C
So,
if
you
just
flag
parameters
of
these
types
that
are
non-ref,
which
would
include
in
we
just
flag
those
and
say
regular
or
in
don't
do
that,
you
should
pause
it
by
ref.
L
So
we
we'd
only
flag
the
parameter.
We
would
not
try
to
see
the
common
case
of
of
I'm
consuming
someone
else's
library
and
they've
authored
it
incorrectly,
not
to
take
it
by
ref.
L
C
L
Right,
I
I
definitely.
I
definitely
agree
on
that
when
it's
all
your
own
code,
but
I'm
thinking
of
the
case
like
let's
say
that
newton's
off
jason
shipped
and
they
accidentally
forgot
to
put
ref
on
one
locate,
location
and
you're
you're,
calling
that
method
as
a
library
implementer,
and
you
have
no
clue
that
the
bug's
going
to
be
there
and
you're
going
to
be
dependent
on
newtonsoft,
a
recompiling
with
the
analyzer
on
and
b,
actually
picking
that
new
thing
up
and
c.
C
C
I
I
think
the
problem
is,
if
you,
if
you
take
your
idea
to
the
extreme,
I
think
the
problem
is
you
drown
the
user
in
unactionable
things.
I
think,
that's
generally,
not
better,
because
realistically,
the
idea
is
that
the
guy
that
wrote
jason.net
also
at
some
point,
updates
his
tools
right
and
then
he
gets
the
diagnostic.
C
A
Yeah
so
for
the
fixer,
the
fixer
can
easily
see
that
the
there
was
the
parameter
that
wasn't
passed
by
ref
and
change
it
to
pass
by
ref.
But
it
can't
now
find
all
the
usages,
because
those
lines
of
code
would
have
themselves
had
to
have
already
had
a
diagnostic
painted
on
them.
Right.
C
Well,
it's
basically
different
passes
right.
You
can
either
have
an
analyzer
that
walks
over
the
symbols
that
the
user
defined
or
you
base
the
different
another
that
walks
over
the
the
operations
right.
And
so
then
you
know
it's
just
a
different
kind
of
path,
you're
doing
and
then
how
the
diagnostic
gets.
There
is
not
important
right.
You
just
the
fixer
then
refers
to
the
diagnostic,
and
then
you
fix
it
gets
invoked
or
whatever
the
diagnostic
you
put
in
there.
A
A
I
mean
like
you,
could
maybe
get
a
return,
but
your
that
one
feels
easier
to
figure
out
and
understand
because,
like
right,
hey,
I
returned
this
reader
and
then
I
used
it
and
like
it
didn't
change
my
state,
oh
because
it's
it's
torn
state,
so
I
think
the
one
that's
that
creates
the
subtle
problems
is,
as
you
said,
the
extract
method
and
you
end
up
passing
a
thing
in
by
value
and
and
it's
like
well
I'm
sorry,
but
that
doesn't
do
what
you
think
it
does.
C
A
Okay,
I
mean
that
would
be
a
a
diagnostic
with
no
fixer,
because.
N
L
L
A
C
A
Okay,
anyone
want
to
give
a
grunt
of
ascent
to
my
notes.
J
I
have
a
question:
what
does
it
mean
to
also
support
loading?
Other
types
from
config,
you
mean
from
a
config
file.
B
Analyzers
have
the
ability
to
load
additional
configuration
for
things
like
the
dot
editor
config
file,
so
you
can
specify
details
about
the
rule
and
have
it
load.
Data
from
there
like
existing
rules,
allow
you
to
control
whether
it
applies
only
to
public
methods
or
to
public
and
internal.
And
if
you
look
in
the
editor
config,
it
will
be
like
dot,
net
dot,
ca,
1345,
dot,
visibility,
equals
public
comment,
internal,
comma,
whatever
and
the
rule
can
load
from
there.
So
this
is
about
doing
the
same.
A
C
C
M
C
M
C
I
mean
I'm
personally,
I
don't
know
what
the
russian
bar
is,
but
my
understanding
is,
you
can
totally
have
pictures
that
gets
you
halfway
there
and
then
the
other
half
you
have
to
do
manually.
I
mean
that's,
how
rename
works
right.
You
can
totally
rename
stuff
into
something
that
has
conflicts,
and
then
you
just
get
compiler
errors
and
they
yeah.
You
have
to
deal
with
that
right.
C
A
That's
fair,
like
again,
I
you
mentioned
you
know
catch
it
in
multiple
passes,
and
so
maybe
there's
already
enough
infrastructure
there
that
it
can
be
done
of
the
first
pass,
puts
diagnostics
on
the
methods
and
then
the
second
pass
looks
for
calls
to
any
method
that
it's
already
put
the
diagnostic
on
and
puts
a
diagnostic
on
those
to
then
make
the
analyzer
understand
what
to
fix.
But
sorry
the
fixer
understand
what
to
fix.
But
if
it's
not
possible,
then
sure.
C
Is
I
mean
imagine
what
the
call
set
is
right
if
the
call
set
is
an
expression
like
one
plus
b,
for
example.
Right
then
sure
you
have
to
extract
it
into
a
local
which
you
may
not
be
easily
be
able
to
do,
because
the
whole
thing
is
an
expression
or
something
so
like
the
rewrite
might
be
fairly
contributing
on
the
call
side
right.
So
the
yeah.
That's
why
I
said
like
I'm,
okay
with
saying
yeah
exercise
left
to
the
reader
right
you
just
like
I
mean
I
think
to
me.
C
The
bigger
problem
with
a
fixer
is
if
the
fixer
changes
half
of
it,
the
code
compiles,
but
the
other
half
isn't
done.
That
seems
pretty
bad
because
then
you
just
find
out
at
one
time
that
stuff
doesn't
work,
but
this
one
is
yeah,
it
does
half
of
it,
but
the
other
half
null
definitely
doesn't
compile,
and
so
the
user
has
to
walk
it.
Before
anything
happens,
so
you
basically
get
at
least
a
to-do
list
from
the
compiler
right
and
so
that
that
to
me
is
generally
or
acceptable.
C
I
think
that's
generally
what
we
do
ryan.
I
think
we
generally
don't
do
arrows.
F
C
A
C
C
A
B
There's
an
issue
open
in
the
repo
in
in
the
runtime
repo
to
add
an
api
that
would
then
in
turn,
allow
the
compiler
to
do
it
for
everything.
So,
if
we
add
a
rule
here,
we
want
to
make
it
general
enough,
such
that
in
time
we
could
update
it
to
support
all
types
and
not
just
the
ones
that
are
currently
supported,
but
start
with
just
the
ones
that
are
currently
supported.
B
So
basically
the
rule
would
say
if
you
have
a
private
static,
read-only
byte
array
equals
new
byte
array
and
it's
all
constants,
and
it's
only
every
you
passed
basically
to
something
that
can
take
a
span.
A
read-only
span
of
byte
or
we'd
only
span
it.
Whatever
the
type
is,
then
we
could
transform
the
field
to
be
a
property
and
avoid
that
array
entirely.
L
So
the
the
actual,
the
actual
support
for
directly
returning
a
read-only
span
is
for
single
bytes
only,
but
there
is
the
support
for
efficiently
creating
an
array
such
as
a
static,
read-only,
uint
array
via
all
constant
or
partial
constants.
Would
this
also
flag
that
case
like
if
you're
locally
doing
locally,
declaring
those
the
other
primitive
types
as
well.
B
B
B
I
mean,
presumably
in
that
case,
well,
whether
or
not
it's
storing
the
data
in
in
what
portion
of
the
the
assembly,
it's
still
allocating
a
new
array
every
time,
so
you
know,
for
other
reasons,
you'd
want
to
move
it
to
it
into
a
field.
E
B
L
A
Brain's
not
working.
I
was
like
if
you
have
uint
bracket
bracket,
local,
equal,
new
uint
or
new,
open
curly,
and
then
a
bunch
of
things
closed
curly
semicolon
I
mean
maybe
the
I
was
like.
Does
the
compiler?
Do
this
array
never
got
passed
to
anybody,
so
it
doesn't
matter
that
it
had
an
instance
like
I
don't
think.
C
A
B
Yeah,
there's
there's
also
the
inverse
of
this,
which
I
don't
think
we've
mentioned
a
rule
for,
but
it
would
be
nice
until
we
get
that
additional
support
in
the
runtime
and
the
compiler
for
doing
any
type.
You
know
once
a
month
we'll
get
a
pr
that
someone
does
the
new
pattern.
They'll
do
like
private
static,
read-only
span
of
char,
my
prop
arrow
new
char,
whatever
thinking
that
the
compiler
is
doing
the
right
thing
and
it's
not
and
so
they're
actually
significantly
de-optimizing
their
code
by
doing
that,
it'd
be
nice.
L
I
was
going
to
say
the
the
the
proposal,
so
so
the
way
the
way
the
other
types
work
today
is
there's
a
a
method
in
runtime
helpers
called
initialize
array,
and
so,
if
you're
declaring
a
static,
read
only
byte
array,
for
example,
then
the
runtime
initializes
that
as
a
new
byte
of
appropriate
size
and
then
initialize
array,
the
the
created
array
and
then
a
runtime
field
handle
to
the
static
read-only
data.
That's
been
embedded
into
your
pe
file
and
that's
effectively
how
for
the
read-only
span
version.
L
It
does
the
same
thing
except
instead
of
creating
an
array
and
then
copying
the
data
it
just
bit
blitz
the
pointer
to
the
read-only
data
into
the
span
as
the
ref
field.
L
The
proposal
is
for
a
runtime
helpers,
initialize
initialize
read-only
span
equivalent,
which
will
do
the
indian-ness
fix
up
one
time
and
then
just
split
the
blit,
the
pointer
into
the
span
david
wrighton
had
a
prototype,
but
then
there
wasn't
enough
push
from
the
language
or
libraries
to
to
finish
that,
and
so
I
think
it's
just
waiting
for
another
push
from
us
to
say:
hey
we'd,
really
like
this.
L
A
I
was
gonna
say:
basically,
it
would
get
the
it
would
get
the
data
pointer
or
code
pointer.
I
don't
know
what
these
things
actually
look
like
in
in
libraries,
but
it
would
get
the
pointer
to
the
static
data
and
it
would
say,
hey
it's
a
little
indian
pe
file
and
I'm
little
indian
return,
the
pointer
and
otherwise
it
would
be
like
fine
go
make
a
copy.
F
L
L
So
if,
if
you're
targeting
library,
where
runtime
features
dot,
you
know,
blittable
constants
exists
or
whatever
we're
going
to
call
it,
then
you
you
light
up
the
analyzer
for
the
other,
the
other
types,
okay,.
A
I
like
it,
it
could
have
been
depending
on
like
fast
span
or
some
other
thing.
We
had
encore
so.
L
A
Okay,
so
then
the
question
I
have
about
feasibility
on
this
is
this
basically
requires
finding
all
literal
declared
static
fields-
or
I
guess
read-only
fields,
because
it
could
be
read-only
instance
as
well.
I
think
maybe
the
pattern
doesn't
work
for
that,
but
find
all
literally
declared
arrays
and
then
now
find
all
the
usages
to
make
sure
that
they
would
be
compatible
with
span.
L
A
L
B
L
Yeah,
but
I,
if
it
if
it's
info
level
rather
than
warning
level,
then
the
user
has
the
ability
to
decide.
Is
this
one
appropriate
or
not.
B
L
B
Which
is
still
better,
that's
a
I
think,
you're
talking
about
a
different
potential
rule,
which
is
I've,
got
some
array
that
I'm
allocating
locally
in
an
instance
field,
but
it's
always
constant,
and
I
find
that
I
I'm
never
mutating
it.
So
then
I
want
to
promote
it
to
a
static.
Read
only
is
that
right.
B
B
J
A
Yeah
well
and
then
the
note
that
for
now
it
also
has
to
filter
it
down
to
these
three
types.
And
then
then
it
needs
to
do
a
candidate
elimination
pass
to
to
see
if
they
were
always
coerced
into
span
in
their
usage.
B
Yeah
and
I
think,
and
that's
the
part
where
it
becomes
like
the
first
part
is
trivial.
The
second
part
is
where
it
becomes
complicated
and
more
concerning
is
potentially
expensive,
and
so
we
have
to
weigh
the
benefits
versus
the
cost
to
the.
A
A
Right
because
public
things,
you're
you're,
if
it's
protected
or
I
mean
technically
protected-
would
work
if
the
type
is
internal.
I
guess
internal
also
would
be
valid.
A
A
L
I
I
think
it
should
be
any
visibility,
not
just
private
private,
protected
internal.
If
you've
got
a
field,
that's
a
that's
a
you
know,
static,
read
only
and
it's
any
visibility.
You
likely
want
this
optimization.
It's
if.
A
A
A
L
Maybe
there's
a
different
diagnostic.
We
can
put
on
that
on
public
static,
read-only
ones,
and
you
can
have
it
be
something
like
because
the
the
right
fix
in
that
case
would
be
have
public
static,
read
only
x
equals
and
then
the
the
property
or
I
guess,
no,
that
wouldn't
work
as
the
property
return
span.
C
C
A
C
Sure
yeah,
like
it
just
seems
to
me,
like
I
don't
know,
I
mean
we
generally
don't
have
visibility
filters
for
anything
that
has
to
do
with
api
shape
right
because
we
don't
know
whether
the
api
was
shipped
or
not
right,
like
the
api
was
literally
you
know,
written
10
seconds
ago.
Well,
now
is
the
time
to
fix
your
api
because
you
haven't
shipped
it
yet.
C
But
I
think
the
diagnostic
id
doesn't
help
you
here,
because
it's
not
a
diagnostic,
it's
not
like
you,
you
suppress
one
or
the
other
right.
It's
the
you
would
have
to
suppress
specific
apis
because
you
don't
know
yet
I
mean
we
don't
know
which
ones
were
shipped
and
which
ones
weren't
shipped
right.
That's.
C
C
Things
honestly
perfect
options,
I
mean
the
problem
is
the
analyzer
is
probably
not
going
to
help
you
much
because
it's
like
the
sad
thing
is
like
this
whole
comparison
with
the
previous
one.
You
can't
quite
do
as
a
rosin
analyzer,
because
you
need
to
do
it
after
the
multi-targeted
build
is
finished,
and
then
you
have
to
compare
horizontally
across
your
builds,
which,
within
the
bosnian
analyzer,
you
basically
only
have
access
to
the
current
compilation,
which
is
only
one
of
the
four
you're
building.
A
C
A
Haven't
done
that
yet
yeah
and
since
we
generally
discourage
people
from
having
visible
fields,
be
they
static
or
instance,
it
probably
wouldn't
have
too
much
noise.
So
yeah,
just
yeah,
ignoring
the
visibility,
seems
sound,
and
if
we
get
a
lot
of
pushback,
then
we
can
tweak
it.
A
Yeah,
so
I
guess
that's
the
last
two
pieces
is
default
visibility
and
I
guess
there's
default
visibility
default
enabled
and
category.
So
I
agree
category
performance.
L
C
C
L
That
was
going
to
be
my
basic
statements
last
question
as
well.
My
assumption
is
that
most
performance
fixes
because
they're
not
like
reliability
or
correctness,
or
I
want
to
opt
into
seeing
like
what
can
I
do
to
make
my
perf
better,
because
that
can
be
like
really
really
noisy,
depending
on
what
analysis
we're
doing.
C
Yeah,
that's
the
other
question
that
I
actually
don't
remember.
The
answer
to
like
I
I
feel
like
based
on
my
exploration
yesterday.
It
seems
info
is
very
mundane
right
now,
like
I
have
like
50
violations
in
the
solution
or
something
which
kind
of
tells
me
that
I
don't
think
everything
is
info
by
default.
We
must
have
some
subsetting
there
as
well.
C
A
A
If
you
care
to
listen,
but
that
the
command
line
compile
would
never
report
it
at
all
info's
similar,
I
think
ide
suggestion
you
can't
ask
what
are
all
the
things
in
the
solution
that
has
this?
I
could
be
wrong.
C
A
Yeah
I
mean:
do
you
have
thoughts,
steve.
A
Are
you
still
with
us
sorry,
I
stepped
away
for
a
second.
What
was
the
question?
The
the
default
level
for
this
analyzer?
Oh
info,
okay,
so
info
ide,
suggestion
and
off
are
the
the
three
candidates.
B
Yeah
I
mean,
I
think
it
would
either
be-
I
I
don't
think
it
would
be
off
unless
there
was
a
perf
issue
or
we
had
a
bug
in
the
analyzer
that
made
it
very
noisy
it's,
but
it
shouldn't
be
noisy
if
we
do
our
job
right
at
that
point,
it
would
only
be
off
if
it
was
just
too
inefficient
for
it
to
be
on
in
general,
and
at
that
point
then,
I
think
it
ends
up
being
either
info
or,
if
we're
concerned
about
it
being
too
low
level
for
the
vast
majority
of
folks,
which
is
a
valid
concern,
then
we
would
make
it
hidden
instead,
which
in
the
ide
basically
means
it,
doesn't
show
up
in
suggestions.
B
But
if
your
cursor
is
in
the
right
place,
it
shows
up
as
a
dot
dot
and
you
can
fix
it
for
that
line
and
you
apply
it
to.
You
know
all
fixes
for
the
whole
solution.
Okay,.
J
Yeah
it's.
The
idea
is
to
offer
optimizations
to
simplify
whenever
you
have
to
concatenate
strings.
J
L
J
L
C
Well,
it's
also
the
opposite
right
when
you,
when
you
concatenate
unconditionally
before
and
then
you
have
a
condition
after
right.
That's
the
example
that
is
right
now
at
the
top
of
the
screen.
If
you
scroll
up
a
little
bit
right,
it's
the
you
first
do
result
as
s1
to
sn,
and
then
you
have
a
condition
and
then,
depending
on
that,
you
concatenate
something
onto
it.
I.
C
C
A
Wonderful,
if
it
does
it
to
your
code,
you're
now
destroyed,
because
now
you.
C
L
L
There's
also
times
where
you
want
to
have
it
in
local,
so
it's
easier
to
debug
or
other
things,
and
I
would
think
that
the
fix
here
is
not
to
inline
the
concatenation's
effectively,
but
rather
to
go
use
string
builder
so
that
you're
not
doing
multiple
string
copies,
because
this
is
going
to
do
in-string
copies.
Where
n
is
the
number
of
concatenations
mine
minus
one.
L
C
I
think
the
problem
is
that
if
you
split
them
across
lines
right,
that's
why
the
compiler
can
can
optimize
the
result,
one
and
the
result
one
plus
equals
x,
because
now
you
wrote
the
code
in
such
a
way
that
you
have
multiple
comcat
calls
right.
But
if
you
write
it
as
one
giant
thing,
then
the
compiler
can
basically
emit
one
one
call
to
string
or
concat,
but
I
kind
of
agree
with
tanner.
It's
like
I
don't
know
like,
depending
on
the
number
of
arguments,
I
think
think
concat
just
does
a
string
builder
effectively
right.
D
L
C
I
mean,
I
don't
know,
like
the
I
think,
to
jeremy's
earlier
concerns,
like
you
know,
I'll,
be
creating
better
code
or
verse
code
right
and
that
kind
of
depends
on
the
length
of
the
string.
So
literally
s1
s2
is
not
so
bad,
but
if
they
are
like
you
know
sizeable
literals,
then
yeah
you
can
totally
create
a
mask
that
might
be
slightly
more
optimized.
But
now
it's
like
completely
unreal
unreadable
right.
A
C
C
If
you
have,
I
think
if
the
literals
are
all
on
the
right-hand
side
and
the
left-hand
side
starts,
there
are
cases
where
the
tree
is
structured
in
such
a
way
that
both
arguments
aren't
legible
and
the
compiler
doesn't
do
the
looking
across
thing,
and
basically,
if
s1
and
s3,
for
example,
are
literals,
you
would
think
that
s1
and
s3
were
folded,
but
the
compiler
doesn't
even
do
that
right.
It's.
C
C
That
problem
doesn't
seem
to
be
something
that
is
super
optimizing
for,
because
it's
generally
never
going
to
be
very
efficient.
C
I
mean
depending
what
you're
doing,
but
I
mean
I'm
just
saying
like
I
mean
if
you
write
code
like
that,
like
me,
meaning
like
a
plus
b
plus
c
right,
that's
not
code!
That
will
be
very
efficient
right
if
you
build
like
something
like
a
razer
view,
engine
sure
it's
string,
concatenation
that
you
don't
find
a
plus,
b,
plus
c
plus
d
in
the
implementation
right
like
it,
will
look
extremely
different
from
that.
C
Well,
it
will
be
more
like
you
know,
multiple
buffers
with
holes
and,
like
you,
don't
actually
see
the
you
know,
it's
all
kind
of
generated,
trees
or
whatever
right.
So
I
think
that
I
think
the
question
is
really
like.
If
we,
if
we
ship
this
analyzer
right
like
are
we
doing
the
user
a
service
or
a
disservice.
D
Do
we
have
like
a
tier
of
analyzer,
so
maybe
someone
can
say
I
always
want
to
enable
this
thing,
because
99
of
the
time
it
gives
me
a
good
recommendation,
whereas
something
like
this,
maybe
we
can
say,
put
it
in
the
in
the
next
tier
of
like
you're,
looking
for
some
optimization
and
20
of
the
time,
it'll
give
you
something
really
useful.
A
C
B
You
go
and
you
turn
on
the
ones
you
care
about.
I
don't
believe
there's
any
way
to
date
is
to
kind
of
have
predefined
groups
of
analyzers
like
this
is
the
your
board
on
a
saturday
afternoon,
and
you
want
to
go
explore
what
you
can
improve
category.
A
A
C
I
mean
this
is
kind
of
my.
I
think
my
meta
questions,
like
I
kind
of
agree
with
like
what
jeremy
said
earlier.
It's
like
if
the
analyzer
actually
gives
me
this
particular
fix.
I
would
be
unhappy-
maybe
there's
other
here
that
I
don't
mind,
but
this
particular
one
that
is
right
now
in
the
middle
of
the
screen
seems
not
great
yeah.
A
Like
as
with
you
know,
many
things
if
this
was
in
code
that
had
not
changed
in
20
years
and
you
anticipate
no
change
ever
again
then.
Yes,
this
is
arguably
better,
but
you
know
if
it's
code
that
ever
stands
or
ever
needs
to
be
debugged
or
ever
stands
a
chance
of
changing.
This
is
code
that
expresses
its
intent,
and
this
is
code
that
runs
faster
and
so
yeah.
I
would
not.
I
would
not
put
this
fix,
which
is
maybe
just
a
line,
length
and
style
thing,
and
this
in
the
same
bucket.
D
C
L
Well,
and
with
with
string
builder,
if
you
have
a
lot
of
non-string
inputs,
like
ins
like
you're,
doing
in
dot
2
string,
then
string
builder
itself
uses
the
the
span
formattable
overloads
to
try
and
write
directly
to
its
internal
char
buffer.
Whereas
string
can
cat
just
calls,
two
string
gets
the
length
of
that
and
decide
and
says
this
is
how
big
the
total
buffer
needs
to
be.
B
A
But
it
can
once
we
add
the
the
interface
that
tanner
needed
for
generic
math.
The
ispan
formattable
thing.
B
Well,
that's
already
in
yeah,
but
the
question
is,
you
know:
do
do
we
do
the
do?
We
pay
the
cost
for
an
arbitrary
object
of
of
the
type
check.
C
B
B
You
know
obvious
to
us,
and
then
there
are
other
things
that
are
in
you
know
it's
the
eye
of
the
beholder
like
we
have
a
bunch
of
cases
where
your
your
allocate
it's
not
s1
s2,
dot,
dot,
sn,
it's
it's
a
conditional
with
it's
either
s1
plus
s2,
or
it's
s1,
plus
colon
plus
s2
right,
and
that's
that's
very
easy
to
read
in
that
form,
and
so
it
makes
sense
to
do
that.
That
change.
B
It's
arguably
easier
to
read
that
then
string
result
equals
ask
s1
if
needs
conditional,
plus
equals
colon,
then
plus
equals
you
know
s2,
but
the
moment
you
get
into
more
complicated
things
or
those
are
large
expressions
or
whatever.
Then
it
becomes
hard
to
read
so
right.
This
is
this
is
all
very
difficult
for
an
analyzer
to
determine
with
high
accuracy
whether
it's,
whether
the
developer
will
appreciate
it
or
not.
C
C
Like
if
you're
sensitive
to
perf,
I
mean
you
kind
of
know,
if
you
write
super
big
expressions
with
a
plus
b
plus
c
plus
d,
that
you
probably
need
to
rethink
your
problem
like
it's,
usually
not
a
way,
it's
a
problem,
it's
really
not
the
way.
You
write
it
right,
it's
the
it's,
the
the
fact
that
you
do
concatenate
these
you
know
multiple
strings
might
not
be
the
right
answer
and
that's
something
like
I
can't
help
you
with
right.
That's
just
rethinking
your
data
structure,
maybe
not
needing
the
strings.
In
the
first
place,.
A
B
True,
at
the
same
time,
it's
again
degrees
you
know:
do
you
do
not
optimize
it
at
all,
because
you
couldn't
go
all
the
way
or
is
it
better
to
eliminate
half
your
allocation
yeah.
A
C
C
C
B
I
think
I
think
the
next
steps
here
are
for
someone.
If
we
care
to
split
apart
the
one
that
we
feel
like
you
know,
is
there
something
that
is
non-controversial
from
the
rest
of
it
and
then
focus
on
the
non-controversial
parts
and
if.
C
C
A
Yeah,
all
right
so
before.
C
A
All
right,
yeah,
so
yeah,
it's
am
I
hitting
close
or
needs
work.
C
A
Override
stream
read
bite
and
write
bite:
three
three:
seven,
eight,
eight,
oh
yeah,
you're
a
stream
and
you
didn't
override
these
members.
You
should
do
so.
A
D
H
Oh
yeah
yeah
they're
used
they're
used
by
things
like
binary
reader
under
the
covers
because
they
need
to
do
a
bite
by
bite.
Read
from
the
underlying
stream
yeah.
B
Yeah
the
flip
side,
the
other
thing
we've
been
hesitant
to
do,
but
we
could
consider
doing,
is
change,
read
byte
and
right.
Byte
to
delegate
to
the
span
based
read:
we've
been
hesitant
because
any
time
we
change
order
of
virtual
delegation,
it
potentially
causes
issues,
but
the
main
problem
with
these
today
is
they
allocate
a
new
every
call
in
the
base.
Implementation
is
new,
byte
one
and
then
call
the
array
based
method.
B
If
we
were
to
just
delegate
to
the
span
based
one
and
the
stream
properly
implemented
that,
then
we
wouldn't
have
to
do
that.
What
if
you.
B
B
B
A
I
was
going
to
say,
have
a
lazy,
initialized
field
for
the
single
byte
read
and
the
single
byte
right
yeah,
but
then
you're
increasing
the
size.
B
B
Right,
the
teal
there
was,
we've
discussed,
the
tls
thing
in
the
past
and
I'd
raise
concerns
around
recursion.
B
You
know
if
it's
on
the
base
stream,
then
yeah,
it's
not
just
renting
it,
it's
not
just
using
it,
but
you
actually,
you
take
it
out
and
you
null
it
out
and
then
you
call
to
you
know
another
stream,
which
isn't
unheard
of
like
stream,
read
by
delegates
to
another
streams,
read
bite
and
it
tries
to
get
the
array
and
then
you're
back
into
the
world
of
allocating.
H
Because
it
couldn't
find
it
true,
you
you've
prevented
one
allocation
yeah,
but
you're
you're,
saying
that
recursion
might
be
frequent
enough,
where
it's
not
a
winning
proposition.
That's.
B
My
concern
just
because
rapping
streams
are
common.
That
said,
maybe
I'm
wrong.
That's
certainly
possible.
H
It's
not
that
it's
wrong
per
se,
sometimes
it's
necessary
in
the
sense
that
again
I
go
back
to
the
binary
reader
example.
Like
I'm
I'm
reading
data
from
the
wire
like
I
I
need
to
read
a
I
need
to
read
like
a
7-bit
encoded
integer
like
I,
I
can't
risk
reading
ahead
because
as
soon
as
I've
read
a
byte
off
of
the
wire
like,
I
can't
go
back
and
unread
it.
That
might
not
might
not
belong
to
me
like
it
might
belong
to
someone
else,
and
now
I've
corrupted
their
data.
A
C
A
So,
especially
if
you're
net
standard
2o,
it's
hey
you,
you
might
be
able
to
do
something
way
fancier
here
than
we
can,
because
we
can't
even
see
if
you
know
you're
in
a
in
a
potentially
more
interesting
universe.
So
I
think
it's
reasonable
to
have
a
performance
analyzer.
That's
like
hey
these
methods.
A
If
they
get
called
by
somebody
who
uses
your
stream,
which
is
not
a
thing
you
control,
unless
you're
an
internal
class
do
or
they're
you
know
they
show
up
on
a
lot
of
people's
perf
traces,
so
performance
info,
hey,
you
should
override
these
methods
seems
reasonable
to
me.
D
H
J
A
A
I
mean
this
one
seems
a.
This
is
a
little
different
because
it's
talking
about
the
old
async
pattern
and
it's
saying
if
you
wrote
the
old
async
pattern,
you
should
at
least
move
up
to
the
new
async
pattern,
but
that's
yeah.
The
the
span
and
memory
ones
then
are
harder
because
again
that
standard
2o.
C
I
mean,
I
think,
that's
generally
the
right
idea,
though,
because
I
feel
like
when
you
derive
from
a
type
overriding
everything
it
might
not
be
necessary
right
if
you,
for
example,
implement
a
stream
that
can
only
read
I
never
care
about
rights.
So
why
would
I
get
flagged
to
override
all
the
right
methods
right?
C
C
C
C
The
only
thing
you
must
override
is
the
one
that
outputs,
the
char
and
because
everything
else
calls
to
that
one,
which
is
a
valid
implementation,
but
extremely
inefficient.
So
if
you
really
want
an
efficient
version
of
that,
you
should
override
all
the
methods,
not
just
the
one
that
opens
a
single
char
and
it's
kind
of
in
the
same
category.
C
D
C
G
Exercise
because
most
people,
like
not
talking
about
you,
know
pipe
reader
stream,
which
I
mentioned
in
chat,
doesn't
implement
this.
But
most
people
are
not
creating,
like
general
purpose
streams,
right,
they're,
just
creating
it
for
use
with
like
one
api
or
whatever,
and
they
want
a
minimal
thing
that
works.
A
Yeah
but
the
but
the
trouble,
stefan
with
you
know,
like
great
you
made
a
stream
to
interact
with
one
api.
Is
you
don't
know
what
that
api
is
calling?
If
it's
calling
read
byte
and
you
could
have
made
a
more
efficient,
read
byte,
then
you
definitely
wanted
to
overwrite
it.
If
you
care
about
performance,
that's.
J
G
C
B
G
Yeah
I
mean
and
that's
how
all
of
asp.net
streams
are
in
general
yeah,
because
ultimately,
due
to
our
abstractions,
it's
gonna
be
sync
over
async.
Anyway,
if
you
go
that
route,
so
it's
already
in
a
really
bad
place,
but
don't
you
throw
anyway?
I
thought
your
throat
when
somebody
does
the
synchronous
reading.
C
G
A
And
is
the
if
you're
making
a
new
stream?
This
is
the
stream
to
override,
because
now
we
have,
you
know
the
considering
span
and
task
likes
to
be
the
primitives
and
rewriting
everything
else
in
terms
of
those.
A
C
No,
that's
what
I'm
saying
it
would
be
worthwhile,
like
figuring
out
what
the
scenarios
are,
that
people
want
to
go
for
and
then
ask
ourselves.
Is
that
just
a
case
of
a
missing
base
type
or
is
that
just
something
where
we
should
have
a
better
analyzer
that
helps
people
to
do
these
things,
because
I
mean,
like
I
mean
basically,
my
concern
is
deriving
from
stream.
Is
super
difficult
today
right,
it
just
is
right
and
I
feel
like
this
is
just
an
example
where
yeah
you
should
probably
do
that.
C
C
It's
not
super
difficult
to
implement
them
right,
but
on
stream,
depending
on
what
you
do,
it
might
actually
be
fairly
difficult
to
do
these
things
and
that
kind
of
goes
back
to
what
do
people
want
to
do
with
that
right?
If
they
want
to
do
something
trivial,
then
maybe
we
should
just
let
them
do
the
trivial
thing
and
not
ask
them
to
overwrite
20
methods.
B
E
B
A
B
C
That's
what
I'm
saying
to
me,
the
the
yes.
I
think
it
is
the
same
problem,
I'm
just
saying
on
stream,
writer
or
sort
of
text,
whether
you're
these
have
to
be
like
implementing
those
is
relatively
trivial
because
they're
all
sync
methods,
you
know
you
they
all
take,
basically
an
indoor
float
or
whatever
and
then
most
of
the
time,
whatever
your
underlying
thing
is,
has
an
ability
to
write
those
already,
but
on
stream
the
problem
is,
you
have
different,
you
know,
fdf
the
old
async
model.
C
A
You
know
stream
2021
because
coming
up
with
a
name
of
why
it's
the
better
stream,
we'll
in
five
years,
we'll
have
a
new
primitive
that
we
wish
we'd
based
stream
off
of
and
that
it
implements
all
of
the
methods
in
terms
of
the
the
span
based
read
and
the
memory
based,
read
async
and
it
makes
those
as
abstract,
read
core
and
read:
async
core
and
great
override
that
implement
these
two
members.
Everything
else
was
declared
sealed
and
you're
done
like
you
now
have
the.
What
did
you
actually
have
to
write?
A
Oh,
I
think
you
also
need
to
do,
can
read
and
can
you
need
to
do
the
can
things
and
the
seeks,
but
just
make
it
default
to
non-seekable
and
now
you're
done,
but
that's
a
thing
that
would
then
we
would
rat
hole
on
for
you
know
four
hours
in
a
design
review
meeting
so.
C
C
That
might
be
a
better
first
step
than
the
analyzer
right,
because
then,
as
we're
doing
that
we
might
actually
take
a
deep,
deep
enough
look
to
even
understand
like
okay.
Maybe
there
is
a
general
analyzer
that
you
want
to
have,
or
maybe
there
isn't
right?
Maybe
it's
just
you
know
just
let's:
let's
fix
the
api
shape
as
much
as
we
can
all
right.
So.
A
I
mean
our
it
sounds
like
there's
either
two
easy
answers
for
this
one
is
it's
a
reasonable
info
performance
suggestion
and
the
other
is
overriding
stream
is
already
hard
enough.
C
Me,
I
think,
yeah.
I
think
my
problem
is
that
in
my
experience
every
time
I
see
derivative
of
stream
people
don't
do
it
because
they
do
something
fundamental.
Usually
it's
just
some
heck
or
work
workaround
or
some
testing
stuff.
So
they
don't
care
about
perv.
They
just
care
about
that.
It
works
right
and
then
to
stephen's
point.
C
They
pass
the
implementation
to
one
api,
they
throw
from
all
the
implementations
and
then
they
fill
in
the
gaps
until
it
stops
flowing
right
and
then
they
call
it
a
day
and
at
the
end,
if
the
framework
implementation
all
starts
calling
different
virtuals,
it's
not
too
bad
and
that's
exactly
it
email
and
I
think
that's
kind
of
the
way
most
people
do
it
and
that's
kind
of
why
I
don't
think
they
would
care
that
read,
buy.
Oh,
it's
inefficient.
C
It
should
not
be,
and
I'm
wondering
whether
we
can
fix
it,
at
least
for
some
of
the
scenarios
right.
You
probably
can't
fix
everything,
but
but
I
like
your
idea
of
just
you
know
a
new
base
type
that
seals
almost
everything
and
then
only
has
a
few
worker
methods,
and
then
we
can
reason
about
who's
delegating
to
whom
right
and
then
you
just
tell
people
like
derive
from
that
guy.
You
have
to
implement
two
methods
and
then
that's
it.
D
A
I
mean
I
get,
that
is
true.
I
don't
know
it
feels
like
you'd
need.
A
special
debug
or
you'd
need
a
special
build
that
did
override
everything
and
call
base.
Just
so
you
could
see
the
the
the
fact
that
you
called
your
stream
dot,
read
byte
to
show
up
in
the
profiler,
because
you
wrote
a
stream
and
stream.readbyte
got
called.
A
We
don't
know.
That
was
that
your
stream
was
the
type
at
the
time.
I
don't
think,
but
I
I
agree.
I
completely
agree
with
that.
If
you
have
profiler
data
that
says
read,
byte
is
causing
you
a
problem,
and
this
says
you
know
you
could
probably
override
it
and
solve
it.
That
would
be
great.
So
all
right,
it.
G
G
C
G
I
see
this
is
fairly
low
value
like
yes,
this
would
have
highlighted
things
and,
like
you
know,
pipe
reader
stream
and
so
forth.
You
know
customers
aren't
coming
to
down
our
door
like
you
know,
we
haven't
gotten
yards
to
fix
it.
Yet
you
know,
and
people
know
how
to
use
profiles
like
they
can
see
it
like
if
something's
actually
calling
read
by
like
they
could
see
it
like.
There
are
people
in
our
community
who
are
very
concerned
about
perk
they're,
apparently
not
calling
this
api
at
least.
C
I
would
agree
with
that,
I
would
say,
as
as
notes,
I
would
probably
say
we
should
look
into
deriving
from
stream
in
general-
maybe
reviving
the
idea
of
delegating
stream
for
some
of
the
users
and
then
just
say
that
the
remaining
bucket
of
people
that
you
know
actually
cares
about
streams,
they're,
probably
already
profile,
and
they
already
they
already
go
through
so
much
trouble
to
get
their
stuff
to
work
that
they
probably
either
override
these
methods
or
like
asp.net.
They
don't
care
because
nobody
ever
calls.
C
F
A
A
H
Oh
yeah,
this
was
this
was
the
one
where
we
were
talking
earlier
about.
If
you
have
an
api
that
takes
an
int
overload,
sorry
that
takes
an
end
parameter
and
you
pass
a
char
that
will
be
implicitly
coerced
into
that
parameter.
You
might
be
calling
the
api
incorrectly.
I
think
it
was
a
general
case
of
that
right.
C
C
C
H
A
Okay,
having
had
a
motion
to
close
or
adjourn,
and
it
was
seconded
and
as
the
chair
I
call
the
meeting
to
a
close
so
see
everyone
regularly
scheduled
time,
tuesday,
10
a.m,
redmond
time
where
we
will
be
back
on
the
general
backlog
in
the
order
that
they
got
proposed
and
as
all
these
things
are
marked
future
we'll
get
back
to
it
at
some
point
that
emo
thinks
is
appropriate.