►
From YouTube: .NET Design Reviews: GitHub Triage
Description
00:00:00 - Approved: Productizing APIs for {ReadOnly}Memory(T) and friends https://github.com/dotnet/corefx/issues/23862#issuecomment-335543258
00:02:25 - Needs Work: Add protected {Unmanaged}MemoryStream.Read/WriteSpan method https://github.com/dotnet/corefx/issues/24039#issuecomment-335544053
00:04:53 - Approved: Add ProcessStartInfo.ArgumentList https://github.com/dotnet/corefx/issues/23592#issuecomment-335552652
00:36:32 - Rejected: Add Array.Sort(T)(T[], int, int, Comparison(T)) overload https://github.com/dotnet/corefx/issues/24115#issuecomment-335553699
00:40:21 - Approved: Change ReadOnlySpan indexer to return ref readonly https://github.com/dotnet/corefx/issues/24105
00:41:00 - Needs Work: StreamWriter .ctor pooling overloads https://github.com/dotnet/corefx/issues/23874#issuecomment-335568547
A
A
B
C
B
B
A
A
F
A
J
A
J
D
A
F
J
A
Well,
I
mean
no,
sometimes
it
would
be
that
people
give
you
an
API
or
it's
a
path.
You
could
say,
combine
arguments
or
something
you
provide
a
bunch
of
things
either
as
an
array
or
something,
and
then
it
would
give
you
back
a
combined
string
that
has
the
codes
in
the
right
spots
well,
I.
Think
part
of
the
proposal
problem.
E
A
J
I
A
H
H
E
Yeah
I
mean
I,
think
I
think
it
would
be
fine
to
assign
arguments
on
UNIX.
That's
what
people
would
be
using
a
fusing
process
right
now,
we'll
do
our
we'll
do
our
existing
parts,
but
if
you've
already
assigned
arguments-
and
you
assign
argument
lists,
then
I
think
we
would
throw
of
you.
You
have
to
pick
one
of
the
other
and
then
vice
versa.
Yeah.
E
A
E
B
E
A
E
E
H
A
L
A
Think
people
will
not
expect
it
to
be
set
up
or
honestly,
because
we
don't
use
that
parent
anywhere.
Usually
you
can
say
I'll
keep
in
started.
Add
you
know
it's
populate,
yeah
and
I.
Think
the
challenge
is
now.
If
you
want
to,
you
know
track
that
somebody
did
something
you
basically
have
to
have.
You
know
something
where
you
can't
essentially
like
subscribe
to
the
event,
and
then
you
would
have
to
say
somebody
actually
did
something
to
the
collection
that
I.
E
E
A
Then
we
could
just
say
you
don't
have
to
like
really
crazy
domestics
intercept
it
I
think.
The
only
question
is
what
type
will
be
exposed
to
the
argument
system.
I
think
we
just
had
this
discussion.
I
usually
use
something
that
collection
of
something
we
usually
don't
expose.
You
know
I
some
things,
but
well.
A
E
D
E
H
A
F
H
A
E
A
E
K
B
D
E
A
M
M
D
E
A
Maybe
no
look
most
of
the
guidance
and
ephemera
came
originally
being
around.
Do
not
expose
implementation
types
and
then
so
don't
don't
expose
things
physically
as
lists
of
T
and
then
the
problem
is
also
making
the
v1
of
the
family.
There
was
no
tightening
right,
so
everything
was
I'm
tired.
So
if
you
want
to
turn
strongly-typed
collections,
you
had
to
create
your
own
collection.
That's
a
matter
of
Xtreme
collection,
for
example,
when
the
guidance
here
is
vetoing,
collection.
A
A
Is
that
you
can't
divide
over
she
ever
had
you
do
the
same
thing
for
viola
stuff,
but
let
then
they
have
to
like
you
over
the
next
I.
Don't
I,
don't
quite
know
what
the
benefit
would
be
one
over
the
other
year
like
I.
Think
that's
something
we
should
what
we
discuss
it
jump
on,
because
it's
unclear
to
me
what
the
guys
actually
should
be
at
this
point,
I
mean
personally
I'm
kind
of
I,
this
or
I'm
fine
protection
of
T.
E
A
E
Riley,
if
we
want
to
make
it
opaque
type
that
they
can't
cast
anything
so
it
is
I
collect,
it
is
I
list,
but
it's
not
list
right.
That's
that's
we're
saying
these
are
the
list
of
things
you
can
do
to
it
and
no
casting
this
and
doing
sneaky
Nick
with
it.
Yes,
but
I
think
if
we
would
just
initialize
the
backing
field
to
this,
to
you
know
new
collection
of
shrink
or
new
list
of
string
that
that
we
shouldn't
throw
the
interface
out
there,
because
we
have
a
lot
or
so.
E
H
B
A
Like
I
think
it's
one
example:
baby
didn't
do
it
on
for
fair.
We
try
them
if
they're
always
was
a
new
mobile
directive.
You
move
that
empty
used
to
return
you
after
you're
a
and
then
we
said
up
great
now.
Let's
actually
return
it
to
something
else.
Just
implements
ienumerable
and
doesn't
allocate
when
you
actually
do
the
the
enumeration
right.
So
we
change
the
type
to
some
private
implementation.
A
Roka
shield
among
people,
because
we're
ends
up
happening
is
that
construct
objects
in
memory.
The
telephone
initialization
say,
remove
old
on
empty
and
they
happen
to
get
an
array
instance
and
it's
utilize.
The
containing
type,
the
key
lies
in
containing
type
codifies
the
fact
that
it
was
an
empty
array
and
you're
wrong.
So
then
it's
a
great
no
that's
I
can.
A
M
A
Try
the
try-works
now
and
try
cocktails
small.
We
go
through
difficult
pattern
and
bad
things
happening.
I
think
in
fact,
is
like
I
would
say
that
for
framework,
because
it
implies
updates
like
it's
too
hard
and
even
on
core
I
mean
depending
on
how
bad
the
impact
is,
you
might
not
do
it
as
well
like
that's.
J
I'm,
not
I'm,
not
collection
of
tea.
Isn't
sealed,
though
right
so
what's
the
difference
between
that
and
an
interface,
we
generally
make
a
copy
of
that
when
we
have
a
question
you're
saying,
every
access
to
the
property
is
gonna,
make
I
mean
but
like,
if
someone's
doing
a
cast
they
can
cast
to
whatever
they.
A
J
Whatever
I
mean,
if,
if
we
were
to
return
a
cool
internal
collection,
that
derived
from
collection
of
tea
or
if
we
were
to
return,
some
I
mean
there
must
be
some
class
in
the
framework
that
derives
from
collection
right.
There's,
there's
like
a
bunch
of
them
binding
list,
heat
collection
that
are
all
public
like
if
we
were
to
return
one
of
those
someone
could
actually
cast
to
that,
and
we
would
break
them
if
we
change
what
derive
type.
It's
a
similar
thing
to
the
interface
we're
just
saying
it's
less
likely
in
this
case.
A
You
would
if
it
would
return
you
in
the
future,
a
motorized
type
of
collection
of
string.
Then,
yes,
you
could
imagine
cases
where
this
breaks
people,
but
in
practice
I
think
it
happens.
More
of
like
the
primitive
types
of
people
specialize
right
like
list
of
T
arrays
I
mean,
let's
you
do
the
thing
right
with
breaks.
A
I
think
the
I
think
the
meta
point
is
if
the
weight
collection
of
key
verbs
is
that
you
do
not
have
to
would
arrive
time,
usually
because
you're
do
you
have
to
you,
know
the
the
semantics
in
place
to
to
remove
somebody
to
the
underlying
collection
correctly,
but
I
suppose
you
have
to
derive
from
it
anyway.
If
you
want
to
just
have
any
answer
so
I
guess
it's
still.
There.
A
A
We
should
pull.
They
have
a
more
broader
discussion
about
the
diets
forward,
because
I
think
they're,
the
primary
talents
of
a
collection
of
tea
and
only
a
collection
of
tea,
is
that
they're
pretty
heavy-handed
things
because
they
in
these
require
two
instances
right,
because
you
wrap
another
instance
which
makes
them
know
to
be
suitable
in
cases
where
you
care
about
applications
of
components.
I
would
say
this
is
one
instance
of
that,
but
I
mean
I
can
think
the
points
the
holds.
If
you
want
to
do
it
in
other
places,
I
don't
think
you.
E
A
H
D
E
I
think
that
having
it
is
public
API
makes
sense.
If
we
were
going
to
do
the
each
one
updates,
the
other,
because
then
we
were
effectively
giving
you
that
as
a
side
effect
of
using
pasta
started
cook,
but
if
we've
said
we'll
just
verify
it
at
process
that
start
you
can
haven't
done
both
things.
Then
it
doesn't.
It
doesn't
make
sense
anymore.
I
doubt
it's
a
completely
a
feature
of
us.
O
E
O
E
O
E
E
O
C
O
H
E
A
Can
probably
starting
Windows
to
just
do
the
cloning
and,
like
you
know,
example,
etiquette
reading
space
or
the
rules
that's
kind
of
what
Mark
very
quickly?
Why?
Because
I
mean
it's
effectively
what
I
miss
both
and
other
things
are
doing
with
their
construct
process
it's
serving
today
and
you
have
the
bastard
New
York
string
shop.
Well,
no
I
mean
the
admissible.
Does.
K
O
C
A
A
J
So
array,
dot
sort
has
a
few
overloads
today.
The
only
overloads
that
there
there
are
two
overloads
that
take
array
offset
and
count
one
that
just
takes
a
rate
offset
and
count,
and
one
that
takes
an
icomparer
of
tea.
You
know
the
interface
for
comparison,
there's
no
overload
that
takes
the
comparison
of
tea
delegate,
even
though
the
implementation
was
changed
such
that
it
actually
works
in
terms
of
a
delegate.
O
E
A
A
P
D
N
A
M
I
E
J
B
B
A
A
M
B
A
A
We're
going
to
be
landing
our
discussion
back
in
the
day
where
they
talked
about
using
us
using
a
rape,
immunity,
VCO
I,
can
remember
the
discussion
exactly
what
you
just
said
that
we
feel
like,
if
we're
all,
to
use
the
same
study
instance
of
the
array
pool.
What
ends
up
happening
is
that
what
customer
misuse
is
one
API,
an
area,
one
like
spectacularly
bad
things
can
happen
in
a
completely
unrelated
area
because
they
happen
to
use
the
same
pool.
You.
J
J
J
J
You,
rather
than
ever,
a
pool
being
an
implementation
detail
that
we
could
change.
It
will
yeah
we're
we're
tying
it
very
close
to
the
type
now
that
said,
there
are
certainly
benefits
of
being
able
to
control
what
the
pool
is
that
you
want
to
use.
If
you
don't
want
to
use
the
shared
one,
you
can
maintain
your
own
pool
and
provide
that
I
am
slightly
concerned
that
we're
gonna
find
ourselves
with
array
pool
too
in
the
future.
J
Or
you
know,
memory
pool
or
someone's
gonna
want
to
use
streamwriter
with
their
own
native
block
of
memory
and
they're
gonna.
You
know
or
their
own
memory
things
and
so
they're
gonna
want
to
be
handing
out
memories
from
own
memories
and
stuff
like
that,
and
we
will
have
sort
of
tied
ourselves
to
array
pool
specifically,
but
these.
A
H
A
Usually,
keeping
that
I
think
it's
safer
to
do
that,
to
which
I
don't
think
so
what
Stephen
was
saying,
I
think
the
fundamental
problem
that
we
have
is
that,
whether
you
possibly
distance
yourself
or
not,
like
Alice,
you
actually
maintain
the
pool
yourself.
You
still
have
the
spooky
action
of
all
right,
yeah.
H
Yeah,
if
you're
misusing
the
pool
but
the
bigger
deal,
is
that
like,
if
we're
implicitly
doing
that
for
people
and
actually
using
the
pool,
you're,
suddenly
dependent
on
all
these
all
your
dependencies
actually
using
streamwriter
correctly,
and
that
that
that's
my
part
of
it?
It's
like
you
want
to
get
into
the
advanced
usages
and
pass
your
own
pool
in
this
case,
because
it's
a
little
bit
more
dangerous
than
find
by
all
means.
H
Do
it
and
if
we're
gonna
do
that,
might
as
well
open
up
the
scenarios
that,
like
hey,
you
know
all
I
want
for
this
array,
pools
that,
like
I,
just
wanted
to
and
I
think
I
gave
an
example
down.
There
is
I
want
to
have
the
same
buffer
for
on
a
thread-local
right,
and
it
doesn't
do
any
extra
logic
or
whatever
else,
and
it's
highly
tuned
for
this
particular
server
scenario
or
whatever.
E
If
we,
if
we
think
that
a
ray
pool,
there's
a
chance
that
we're
going
to
want
to
mutate,
it
soon
in
place,
put
it
in
a
constructor
boolean,
taking
the
boolean
proposal
and
turning
it
into
a
default
argument
thing.
So
we
can
solve
the
thing
where
people
want
to
specify
leave
open,
but
don't
know
with
the
default
buffer
sizes
like
that
seems
fine.
If
we
think
of
a
pool
is
going
to
be
stable,
I'm
actually
wanted
using
it.
It's
markup
and
do
it
I've
been
wondering
if
we
just
call
a
wrinkle
shared
everywhere?
B
H
A
A
J
F
A
H
E
K
Q
C
A
J
J
H
J
H
J
H
E
E
E
Don't
don't
repeat
it
because
everybody's
guys
hope
I
can
so
my
I
was
pointing
out
that
we've
made
this
be
a
type
that
people
can
create
their
own.
Oh
and
at
some
point
people
being
able
to
create
a
custom
pool
with
custom
characteristics
and
are
using
pools
and
places.
Those
two
things
are
gonna
need
to
meet
and
if
nobody's
asking
for
it
now,
they
will
eventually.
So
we
will
eventually
need
to
decide
how
we're
going
to
let
people
control
our
pool
characteristics.
H
M
H
And
we
want
to
try
and
encourage
the
other
things,
but
there
are
very
specific
scenarios,
like
the
ones
I'm
talking
about
where,
like
you,
don't
need
the
overhead
you're
like
spin
up
them
like
four
or
five
threads
that
are
all
working
like
kind
of
serially.
You
know
write
on
writing
stuff,
put
on
multiple
files.
Write
in
a
row
like
no
need
to
like
put
any
extra
overhead
on
it,
keep
reusing
the
same
pool
for
that
particular
I
mean
the
same
buffer
for
that
thread.
That
allows
you
to
do
that
right.
J
A
A
Have
to
have
this
API
an
API
service
right,
and
so
it
seems
to
me
like
if
you
were
going
down
the
rule
path
like
basically,
what
we
would
say
is
like
it's
often
because
you
have
to
pass
through
and
because
we
don't
actually
expose
the
time
it's
potentially
possible
for
us
to
change
the
way
we
do
the
pool
it
could
either
change
the
memory
pool.
That
means
eternally
or
it
could
be.
You
know
a
pool
or
could
be
some
homegrown
custom
thing
just
for
streamwriter
right.
A
A
So
that
to
me
indicates
that
I
mean
I
understand
what
Jeremy
was
saying,
that
it's
more
advanced
and
also
more
advanced
in
has
to
pass
in
the
pool.
But
it
seems,
like
you
know,
the
more
conservative
starting
for
movies
just
expose
it
as
a
pool
and
then
us
either.
We
come
up
with
a
better
abstraction
for
a
pool
in
the
future,
like
memory
pool
that
can
give
you
basically
a
memory
which
could
be
big
by
race
or
by
by
you
know,.
E
A
E
Only
primary
one
is
the
named
parameters:
everything's,
fine
yeah,
there's,
probably
one
that
takes
justice
straight,
but
as
long
as
all
of
our
default
optionals
at
the
same
is
what
that
constructor
would
do.
The
compiler
will
take
the
exact
match
is
a
better
target
and
then
there's
not
runtime
acuity.
P
David,
are
you
introducing
the
dependency?
That's
like
it's
really
hard
to
reason
about,
like
a
clear
opportunity
fall
term
like
in
the
constructor,
you
have
to
remember
to
go
change
the
value
of
the
default
like
the
default
value
of
the
parameter
match.
Otherwise
you
just
create
a
minute
next
next
to
each
other
right
next
to
each
other.
E
A
P
A
P
A
A
Smart
choice:
you
can
make
her
now
I
seek
another
job
like
run
away
before
the
affected.
All
right,
so
I
can
think
of
jellies.
Think
maybe
did
talk
about
default
parameters
before
it
seems
to
me
that
this
one
at
least
avoids
the
overload
explosion
that
we
would
add
with
this
one
yep
Steven
brings
up
a
good
point
of
like
you
was
a
beauty
like,
but
I.
Think
if
you
would
say
you
know
like
stuff
like
this
prophesize
I,
don't
think
you
would
hit
ambiguity
because
you.
M
E
A
H
A
N
A
Think
my
general
principle
would
be
like
I
mean
if
it's
I
don't
know
like,
if
you
believe
in
past
being
could
be,
and
then
we
should
just
follow
the
same
thing
and
it
seems
like
there
is
not
an
ambiguity
problem
with
this
pattern
to
do
that,
and
it
just
means.
If
we
have
to
add
more
parameters,
we
always
have
to
add
them
in
pairs.
But.
K
A
I
can
see
the
problem
that
we
have
in
cases
like
this
is
that
you
don't
have
like
a
single
kind
of
overload,
basically
have
just
over
loads
that
are
effectively
identified
by
you,
equip
X
or
gate
like
path
versus
screen.
But
you
know
as
long
as
that's
the
case,
why
not
medic,
when
you
have
like
optionality
with.
A
But
in
the
general
case,
we
just
you
know,
have
essentially
one
kind
of
nested.
You
just
add
more
arguments
over
time
like
everything,
make
everything
option
essentially
and
then
on
the
old
one
you
make
everything
required.
I
see.
This
is
the
way
you,
okay,
like
so
I,
think
jhemini
bit,
because
the
one
that
you
will
try
to
avoid
is
you
know
this
max
why
we
have
to
always
add
like
five
over
those
because
they're
a
net
one
thing
like.
A
H
A
J
A
J
H
J
H
J
H
J
To
provide
either
we
would
have
to
have
desktop,
be
opt-in
via
quark
or
we'd
have
to
provide
an
opt-out.
I
am
a
hundred
percent
sure
they'll,
be
code.
Broken
by
this
I
mean
that
that's
sort
of
not
my
concern.
My
concern
is
we're
sort
of
codifying
the
notion
that,
because
code
might
have
bugs,
you
have
to
call
new
api's
right.
H
J
N
J
A
Leaning
towards
the
board
at
the
same
time,
you
still
don't
know
quite
what
it
would
look
like
would
be
nice
to
think
and
because
I
can't
agree
with
you
that
feels
even
but
I
mean
at
the
same
time,
I'm
not
sure
we
can
do.
The
Napster
gave
you.
It
seems
almost
like
something.
We
should
run
an
experiment
on
where
we
turn
on
buffer
pulling
across
the
video.
A
For
like
some
cream
you
build
and
see
how
bad
things
are
with
me
do
that
and
if
the
world
is
going
to
end
well,
let
me
know
the
world
is
not
going
to
end
for
me
not
to,
but,
like
it's
I,
think
it's
a
more
complicated
question
of
like
you
know
how
people
use
our
API
as
in
practice,
you
know
what
does
it
look
like
when
you
compose
stuff
across
libraries
that
do
people
you
know
crash
other,
like
you
know
this
movie?
Actually
this
is.
A
A
It's
certainly
not
a
scientific
experiment,
isn't
like
novocaine
universal
coverage,
but
if
you
get
like
10
bucks,
positive
video
that
may
be
bad
for
you
would
take
core
FX
and
we
would
take
you
know:
stream
riders,
all
the
other
API
and
silently
turn
on
using
a
rain
forest.
I
see
completely
didn't
see.
Okay,
how
many
times
do
people
like
symptoms
of
spooky
action
at
a
distance
and
I
mean
that
terminal?
A
J
Can
you
guys
selearis
yep
cool,
so
one
of
the
other
things
we
discussed
on
the
the
relevant
thread
was
there
are
variations
to
how
much
protection
the
code
can
take,
so
it's
possible
to
make
a
stream
writer
safe
against
all
of
this
possibility
of
misuse.
But
it
comes
at
run.
Time
costs
it's
possible
to
have
a
middle
ground
where
it
protects
to
get
some
things
with
a
little
bit
of
runtime
cost,
but
probably
not
prohibitive
and
shield
yourself
against
kind
of
the
worst
possible
misuses.
J
That
would
have
the
worst
possible
effects,
but
you
know
not
protect
against
all
possible
misuses,
and
so
we
could
do
experiments
if
we
have
the
ability
to
experiments
where
we
we
pick
whatever.
We
think
the
right
middle
ground
is
or
the
extreme,
and
we
run
with
that
and
then
we,
you
know,
change
the
dial.
A
H
B
A
A
matter
of
because
I
think
we
know
everything
you
can
know
abstract
it,
I
can
think
we
all
feel
like
oh
yeah,
that
could
be
bad.
It's
just
the
tip
on
the
team
have
a
different
God
feel
for
how
bad
that
is,
and
I
hope
her
base.
If
that
thing
is
I,
don't
think
we
can
do
to
get
that
data
by
just
spending
more
time.
Thinking
about
it,
I
think
this
is
almost
like
something
where
we
actually
have
to
do
something
completely
gather
data
and
see
what
happens.
I.
A
Think
fundamentally,
like
this
whole
idea
of
us,
for
example,
using
bullying-
and
you
know,
exposing
buffers
is
relatively
new.
We
have
not
done
this
yet
moving
on
that
level
of,
like
you,
know,
performance
optimizations
in
a
mainline,
API
and
so
I'm
not
feeling
entirely
guilty
for
saying
this
API.
You
know
it's
blocked
for
now,
because
it's
a
new
area.
We
want
to
take
our
time
to
get
it
right,
but
at
the
same
time
it's
taking
it
to
be
an
actionable
item
on
somebody's
plate
to
say,
okay
run
an
experiment.
Oh
you
mean.
A
Because
I
think
that's
I
think
so
I
think
the
matter
of
concern
here
is
like
okay,
let's
say
the
ante
on
streamwriter
right
next
week:
somebody's
asking
close
Geneva
next
week,
somebody's
asking
for-
and
it's
suddenly
like
over
time.
We
built
up
massive
sharing
on
the
same
array,
for
instance,
and
suddenly
the
symptoms
of
you
know
you
know
spooky
action.
It
is
and
start
to
get
you
unfortunate
that,
or
you
are
done
like
you
already
have
the
api's
people
use
it
another
problem,
that's
what
you
bear
with
it.
A
If
you
only
take
bullets
everywhere,
you
could
potentially
now
create
like
isolated
islands
of
tools,
but
then
I'm
not
sure,
like
the
vertical
as
well,
is
actually
helping
you,
because
it's
still
on
lighted
stream
readers
that
could
interfere
Sumeet
white
as
equity
this
year
right.
So
it
seems
like
it's
almost
like.
Let's
just
turn
it
on.
A
You
know,
as
far
as
we
can
think
of
doing
this
in
the
VCR
and
see
them
in
every
one
of
our
tests
and
we
ship
it
to
customers
and
get
feedback,
see
like
how
many
instances
do
we
see
where
things
are
actually
corrupting
unrelated,
State
and
I.
Think
you
kind
of
have
to
try
it
in
the
real
world,
like
both
customers
right
I,
think
test
coverage
is
always
not
good.
J
H
H
Well,
I'd
like
to
unblock
the
I
mean
there.
You
know
there
was
a
bit
Ben
Adams
had
a
huge
change
related
to
this
right.
That's
where
the
discussion
came
through
I'd
like
to
see
those
parfum
provements
come
in
just
wondering
if
that's
possible
and
then
like
actually
adding
the
the
then
turning
it
off
afterwards.
I
guess
by
adding
these
api's
by
default.
B
You
know,
Ben's,
you
know
options,
we
can
tell
Ben.
No
sorry,
you
know
we
don't
want
to
take
it
right
now.
Another
option
is
I
should
take
his
original
stuff
without
the
octane,
which
means
default,
and
that's
what
we
have
been
talking
about
here
right.
You
know
so
so
I
think
that
trying
it
out
that
maybe
option
with
the
you
know
with
the
caveat
that
hey
you
know,
if
you
found
out
it
breaks
stuff
too
much,
we
will
back
it
out.
Then.
A
P
A
Let's
say:
let's
improve
the
API
for
now,
let's
get
the
performance
improvement
in
that
particular
area.
Let's
do
the
gathering
of
like
the
more
pervasive
buffer
pulling
some
and
then
we
need
the
only
any
little
screenwriter
for
now
else.
I
think
it's
not
too
bad,
like
I'm,
more
concerned
of
the
slippery
slope
kind
of
thing,
maybe
maybe
sprinkle
this
before
pulling
across
a
bunch
of
times
and
then
that's
the
point
where
we
get
hit
and
but
that's
then
also
the
primary
can
do
these
about
this
whole
thing.
A
For
stream,
a
little
stream
writer,
but
if
there's
extra
life
more
requests
for
adding
this
thing
across
the
board,
I
would
say:
okay,
that's
you
know.
Are
you
talking
about?
The
change
for
I
took
him
out
the
pool
in
API
I'm
talking
about
the
pool,
okay
I
would
have
fooled
the
wall.
Our
implementation
will
probably
use
the
shared
array
pool
right,
and
then
you
get
the
performance
improvements
in
this
particular
area.
A
We
get
Homans
data
that
you
want,
but
if
you
know
service
sprinkle
this
thing
across
more
times,
I
get
that
you
know
next
week
been
closet
for
streamreader
and
then
the
week
after.
It's
for
you
know,
I,
don't
know
some
other
Iowa
pee
I
said
we
have
at
some
point.
I
think
need
to
be
sure
we
should
say:
okay,
okay,
we're
not
doing
that.
Many
things
into
one,
because
if
you
like
I,
don't
have
enough
coverage
to
know
how
that
this
spooky
action
at
a
distance
kind
of
thing
may
become
so.
B
J
H
B
A
So
it
is
still
three
to
say
that
I'm,
certainly
a
little
bit
lost
in
like
what
you
guys
think
about
the
inverses
opt
out
like
it's
what's
true.
What's
even
just
sales
like
if
we
can
make
it
mostly
safe,
Miami
opting
out
is
good
enough
because
I'm
desktop
we
can
quirky
that
we
can
say
force.
You
know
whatever
7x
series
gets,
you
know
they're,
not
fully
behavior
and
as
soon
as
you
become
pod,
against
the
thing
where
this
you
know.
With
this
thing,
ships
is
like
you're
walking
buddy
for
running
on
the
pool,
so.
J
Here's
here's
here's
my
my
preference
I
would
love
to
see
if
we
could
come
up
with
a
solution
allowed
us
to
get
90%
of
the
wins
with
90%
of
the
safety
without
an
API,
and
if
you
know
it
would
protect
against
you
doing
an
async
operation
and
then
disposing,
but
it
wouldn't
protect
against
you
having
multiple
threads,
all
accessing
the
same
stream
writer.
At
the
same
time,
for
example,
because
you
know
one
of
those
is
potentially
a
common
mistake
in
one
of
those,
is
you
kind
of
have
to
work
hard
to
make
that
mistake?
J
H
J
J
90%
of
the
perf
gains
with
90%
of
the
safety
I'm
waiting
my
hands,
and
we
could
do
it
without
adding
API,
and
so
we
could
kind
of
Bank.
These
benefits
now
and
concurrently
have
discussions
about
adding
a
ray
pool
or
some
other
pool
to
signatures
to
kind
of
make
sure
we're
comfortable
with
it.
To
me,
that's
sort
of
the
right
way
forward
and
also
then,
if
necessary,
if
we're
concerned
about
that
last
10%
of
safety
having
some
kind
of
quirk
to
allow
you
to
get
out
of
it.
J
P
J
A
So
I've
mocked,
eg
I
know
it
needs
work
because
it
seems
like
Stevens
might
have
point
of
like.
Can
we
get
most
of
the
wins
about
making
it
to
unset
because
look
at
if
I'm
not
making
any
weight
the
either
would
I
complete
me
better,
of
course,
hinges
on
the
fact
that
we
get
it
right.
I
did
say
sure.
H
H
You
want
to
like
comment
on
the
thing
on
to
like
addressing
that
that
one
scenario-
yes,
sir,
I
think
that's
the
only.
I
think.
That's
the
only
one
that
like
I'm
super
concerned
about
I,
don't
like
the
others,
but
they're
I,
agree
that
they're
pretty
they're
getting
more
vanishing
layer
mode.
So,
if
that
one,
because
we
already
addressed
the
similar
to
like
the
double
the
double
returns,
we
did
that
already
yeah.
J
H
And
I
think
I'm,
partly
it's
like.
If
we,
if
we
call
those
two
out,
it's
like
we
don't
want
double
returns.
We
always
guarantee
about
that
great
honest
on
a
single
thread
or
even
a
multiple
threads,
because
that's
easy
to
do
right,
yeah
that
one's
an
easy
one
to
guard
for
right,
cuz,
that's
just
on
the
dispose
so.