►
From YouTube: .NET Design Review: GitHub Quick Reviews
Description
00:00:00 - Approved: MemoryMarshal.GetRawArrayData https://github.com/dotnet/corefx/issues/36133#issuecomment-566723424
01:49:09 - Approved: API request : CompressionLevel.Highest https://github.com/dotnet/corefx/issues/36348#issuecomment-566725990
A
What
this
table
tries
to
convey,
because
even
if
you
ignore
span
and
memory
entirely,
if
you
just
look
at
erase,
we
already
have
rules
for
race
who
basically
owns
the
contents
of
the
array
at
any
given
point
in
time.
Right.
That
is
clearly
a
GC
managed
object
but
like
if
you
give
somebody
an
array
after
the.
C
You
know
documentation
every
time
you
want
to
use
an
API
that
takes
an
array
or
memory
or
span
you
have
to
eat.
Dogs
and
I
said
no.
No
to
me,
it
should
be
like
anything
else.
In
our
framework,
which
is
there
are
default
rules,
you
don't
need
to
read
right
for
those
and
then
there
are
exceptions
or
you
know
many
like
level
performance-oriented
api's
and
they
should
have
a
warning.
Sometimes
we
had
the
warning
to
the
net
method.
Name,
we
say
dangerous
or
sometimes.
C
C
F
Synchronous
set
method
where
you're
giving
something
as
an
input
parameter.
Like
classically,
we've
always
said,
we
expect
that
junior
developer,
collars
or
just
people
who
figured
out
the
way
the
things
they're
already
working
are
going
to
modify
the
array
after
they
pass
it
in
and
that's
probably
not
what
they
meant.
So
most
of
our
things
have
taken
array
as
a
form
of
a
setter.
We
said.
E
F
A
C
I
F
Case
I'm
also
including
properties
that
are
arrayed
properties
and
what
we
do
in
the
centers
of
those
which
again,
we've
really
hit
on
everything.
That
is,
a
property
that
is
returning
an
array.
It
almost
certainly
shouldn't
have
been
a
property
because,
most
of
them,
their
gifts,
are
returning
copies,
which
means
they're
not
extending.
F
A
F
If
we
took
a
span,
we
would
say
we're
taking
the
data.
Really,
that's
fine,
I
guess
the
memory
is
well
again
in
a
constructor.
If
you
could
have
taken,
if
you
were
making
a
copy,
you
should
have
taken
spam.
If
you're
taking
a
memory,
then
the
type
system
you
were
using
that
to
convey
I
am
holding
a
reference
to
your
left
interesting.
C
Even
discussed
in
education
I
think
some
api's
do
make
a
copy,
but
it's
because
the
backers
are
small
and
it
like.
Nobody
was
thinking
about
birth.
That
I
can
vote
here
and
like
hey.
Let's
just
make
a
copy,
it's
probably
safer.
I
would
say
the
main
expectation
I
think
the
father's
is
that
they're
elected
they.
F
But
the
question
is
it
like
who
owns
free
memory?
The
question
is:
is
that
is
the
caller
allowed
to
make
a
modification
to
the
array
after
they
call
the
method?
And
if
you
know,
is
that
or
in
when
they
do
make
it
such
a
modification?
Does
that
modify
the
state
of
the
object
so
and
I
think
in
most
places
that
we
have
set
data?
So
maybe
it
depends
on
the
type
of
array,
but
I
think
anything
is
a
byte
array.
If
it's
set
data
yeah,
we
say
we're
taking
the
data
out
of
so.
B
B
F
B
F
C
C
C
It
will
be
using
yes
same
thing
with
property
when
you
call
the
property
setter
and
you
pass
an
array.
The
data
will
be
used,
crabapples
for
the
lifetime
of
this
off.
No
one
ever
writes
in
that
array.
Again,
everything
is
clear,
since
the
color
of
the
constructor
of
the
second
pass,
the
array
for
the
constructor
for
the
property
is
not
the
screen,
but
for
the
constructor,
the
caller
owns
of
the
array
and
the.
F
C
So
I
think
that
it's
what
you
said
that
it's
a
always
copy
and
it's
a
de
facto
standard
I'm,
not
I'm,
questioning
the
debate,
I
think
for
very
small
payloads
that,
like
represented
you
know
some
training
or
something
you
know
like
very
small
one.
Yes,
we
copy,
because
it's
kind
of
opportunistic
and
we
like
whatever,
because
not
just
copy
it
small,
do
we
have
many
API
is
just
truly
operating
on
backwards.
They
like
they
operate
on
backers
and
they
copy
I
will
be
sure.
This
is
such
a
stupid
thing
to
do.
C
C
B
C
F
F
C
F
B
F
I
F
I
C
C
C
E
F
Are
not
common
right
like
from
properties,
we
have
the
guidance
that
don't
return.
You
mutable
privacy
right
good,
so
like
that's
where
all
these,
like,
oh
the
key
being
used
by
this,
you
know
a
subject.
Well,
that's
part
of
its
private
state,
so
I
can't
return
the
field,
so
I
have
to
make
the
copy
so
Jeremy.
What
do.
C
F
E
E
F
X.509
certificate
to
constructor
we
take
by
the
way
we
pass
it
into
Windows
Windows
read
the
data,
so
it's
constructor
could
have
been
other
than
Spanish,
so
it
reads
the
data
it
stores
it
in
some
state.
You
cannot
like
it's
done.
You
cannot
change
that
anyway,
there's
a
way
that
you
can
get
that
data
back,
but
it's
Windows
like
we
are
now
giving
you
our
private
copy,
because
you
cannot
modify
this
one
so
that
the
object
that's
nicely
different
I
mean.
G
O
F
So
I
mean
like
the
question
on
you
know:
if
we
take
a
thing
as
input
in
a
action
that
not
a
setter
just
like
go,
do
some
work,
we
don't
think
none
of
them.
We
take
copies
on
and
we
shouldn't
have
taken
the
memory
in
these
because
and
then
the
question
is:
when
we
look
at
anything
that
is
a
set
is,
do
we
believe
that
for
a
raise
they
have
arrays
and
then
byte
buffers?
F
F
D
F
So
now
we
have
satellites
and
constructors
and
that
there
and
again
I
was
probably
thinking
of
constructors.
They
said
property
and
the
constructor
is
the
same
case
which
will
kept
on
different
cases,
but
according
to
David,
the
despot
checking
says
constructors
copy
and
set
methods
that
they
set
up.
That's.
C
F
I
I
I
F
I
Yeah,
keep
in
mind,
I
believe
that
guideline
was
talking
about
EAP.
Is
he
wants
to
make
approachable
to
a
wider
developer
audience
I
think
if
we're
talking
about
something,
that's
like
very
low
level
like
something
that
only
a
small
handful
of
people
will
ever
use.
I.
Think
Jeremy
wasn't
our
guideline.
That's
something
like
standard
memory
by
itself
would
be
appropriate
there.
If
you're
yeah.
F
A
I
think
I
never
a
lot
of
it's,
not
the
high
order.
It's
more
about.
Do
you
have
an
alternative
right,
because
I
mean
some
of
our
API
is
that
we
ever
introduced
recently
are
effectively
we
implementation
of
API,
as
we
had
since
v1
I
mean
had
encoding
API
sensitive
one.
They
all
take
arrays
they're,
all
not
performance.
We
have
new
API.
Is
that
don't
do
that
and
they
only
take
span
and
that's
fine,
because
if
you
only
be
able
to
raise,
you
can
still
call
the
old
encoding.
Api
is
right
same
the
streams
there.
A
Many
API
has
to
take
streams
and
that's
fine
like
you,
don't
have
to
have
all
of
them,
but
I
think
they're.
The
fundamental
problem.
There's
high
level
versus
low
level.
You
can't
have
it
on
an
API
baby,
PI
boundary
right,
because
then
you
have
this
like.
Oh
no,
we
have
on
a
new
encoding
API,
as
you
have
to
have
array
alternatives,
which
makes
no
sense,
because
it's
very
hard
to
relative
some
of
the
stuff
right
yeah,
but
it,
but
the
one
mine
is
for
a
given
scenario.
A
A
person
that
uses
the
language
that
cannot
deal
with
spans
have
to
be
able
to
write
code.
That
does
that.
Now,
if
that
port
is
not
fast,
that's
fine,
but
at
least
you
can
write
the
code
right
like
we
had
one
example
where
we
had
the
new
path
to
join
a
piace
behave
differently
for
how
they
combine
paths,
they're,
basically
different
way
from
you
know.
We
have
path,
don't
combine,
which
is
the
old
API,
and
we
had
a
path
toward
join
that
has
the
better
behavior
that
one
only
took
span
through
your
Lee.
A
So
we
just
added
it
over
the
only
text
that
also
takes
drink,
so
you
can
just
call
it,
and
so
like
that
slices
the
idea,
like
sometimes
you
have
an
API
by
API
to
valancy,
and
sometimes
it's
just
yep.
This
tag
is
not
for
you
use
the
other
take
over
there,
yep
that
take
a
slower,
but
your
language
sucks.
Oh
I'm,
sorry.
F
A
B
A
B
D
C
I'll
tell
you
how
I
do
they
consider
it's
basically
and
it's
related
to
because
I
think
it's
for
their
language.
It's
like
information,
evn
Cabo
needs,
like
the
CLS
rule
that
we
have.
If
you
don't
have
any
other
alternative,
you
should
provide.
A
key
is
that
all
basically
frame
of
should
have
a
key
is
that
all
languages
can
call
so,
let's
say,
don't
have
encoding
the
things
byte
arrays?
Yes,
we
do
awesome.
C
F
You
can
work
with
is
erase
the
scenario
should
be
a
comment,
pretending
you
can't
say
new
span,
because
you
can't
pretend
you
can
say
like
pretend
you,
your
language
or
the
universe,
you're
in
says,
I,
understand
the
mod
wreck
for
hreflang
types
in
that
I
understand
what
my
graph
means.
But
I
don't
understand
this
one.
So
I
can't
talk
about
this.
Then
it
shouldn't
be
a
case
where
you
know.
C
A
A
So,
like
the
the
amount
of
applications
that
we
created,
I,
just
throw
away
application
to
just
test,
something
is
staggeringly
high
right
and
if
every
single
time
you
I
provide
20
lines
of
code
to
just
call
this
one
method,
it
takes
a
span
like.
Why
would
you
bother-
and
you
don't
have
to
because,
like.
A
P
B
A
It's
a
continuum
I
like
to
lick
more
rule.
Do
you
have
right
the
more
complicated
it
gets
right?
Leg,
dad's
fundamental
mean
the
the
span
API
is
by
and
large
are
harder
to
use
than
the
older
neurons
right,
and
that
is
something
you
can't
completely
abstract
away
right,
I
mean
some
things
are
just
faster
because
we
made
it
faster.
That's
that's
that's
goodness,
but
by
and
large
I
think,
if
you,
if
you
want
to
have
code
that
has
fewer
locations,
it's
not
going
to
be
as
straightforward.
C
C
C
C
F
C
I
think
like
there's
some
things
that,
like
almost
no,
it
makes
sense
to
me
I'm
thinking.
We
should
have
something,
but
then
I
read
them
I
try
to
apply
them.
I
like
this
doesn't
make
any
sense
whatsoever.
I
just
instantiate.
This
object,
I
passed
my
right.
The
guidelines
tell
me
that
I
have
to
keep
copy
today.
That
doesn't
make
any
sense
to.
A
C
A
That's
that
I
think
that's
it
I
think
that's
a
that's
a
separate
issue,
but
I
think
the
the
the
matter
concern
was
right,
like
we
do
have
a
set
of
like
defaults
that
give
them
an
API
shape.
We
can
reason
about
those
or
what
happens
if
it
comes
I
think
that
you
all
agree
with
that
now.
The
question
is:
what
are
those
rules
but
I
think
the
other
thing
we
have
to
keep
in
mind
is
that
the
API
shape
and
the
names
also
matter
right.
If
you
have
an
API
call
the
right
segment.
A
Well,
of
course,
the
properties
that
aren't
going
to
copy
the
array
that
will
be
done
right.
The
whole
point
of
this
type
is
to
hold
on
you're
right
right.
So,
let's
elected
something
like
okay.
What
expectation
does
a
person
have
using
that
API
right,
memoir
stream,
maybe
on
the
fringe,
but
again
same
thing,
you
logically
right
into
something
in
memory,
so
it
kind
of
makes
sense
that
you
don't
expect
it
to
copy
the
array
right,
but
I
think
they're
boobs
cases
well.
A
F
F
Had
to
switch
back
to
framework
following
the
chain
of
method
calls
for
this
thing
in
core
eventually
ended
up
with
be
NSE,
so
this
is
obviously
something
we
broke
up
with.
This
is
the
first
example
that
I
found
so
I'm
just
like
we.
That
is
an
example
of
a
non
crypto
thing
that
took
a
buffer
that
made
a
copy.
Q
B
F
F
C
C
C
D
C
F
E
C
C
A
C
C
Have
to
read
documentation
if
it's
very
clear
from
the
lab,
like
the
level
of
the
API,
that
the
Jaypee
one
of
those
you
don't
have
to
name
it
will
be,
and
if
it's
like,
you
can
imagine
that
some
people
would
get
confused
like
they
are
using
MEDLINE
scenario,
ap
ice
and
suddenly
run
into
them.
You
call
them
dangerous
or
something
like
this.
Basically,
somehow
we
try
to
communicate
to
the
developer
that
they
need
to
read
or
start
this
night
yeah.
F
F
Memory,
and
so
so
with
memory
you
actually
just
like
you
can't
have
a
like
implicit.
Where
did
this
go
because,
as
it
starts
flowing
back,
you've
lost
the
dangerous
you've
lost
that,
like
you,
you
have
created
C
memory
problems
in
net,
which
we
try
to
avoid.
That's
pretty
fine!
So
really
it's.
If
you
return
something
as
a
memory,
you
can't
fool
the
memory
you
can't,
but
like
it's
gone.
C
A
D
A
B
D
I
I
B
I
B
R
F
I
F
If
you're
looking
at
any
particular
method,
you
can't
tell
it
once
we
start
doing
that.
You
cannot
tell
looking
at
this
method
if
it's
safe,
to
read
the
memory
because
of
each
read
the
memory,
they
call
a
helper
method,
passing
argument
in
it.
You
don't
know
if
that
disposed.
The
often
you
now
can't
reason
about
the
memory,
because
you've
left
the
state
escaped
a
little
better,
so
no
code
reviewer
can
ever
review
this
for
accurate.
They
need
too
much.
They
need
the
entire
universe
of
data.
Yes,
so
I
think
we
want
to
avoid
that.
C
C
F
B
F
B
I
I
D
I
You
can't
tell
the
developer
the
consumer
of
the
memory
of
T
hey
by
the
way
you
can
always
make
the
assumption
that
it's
backed
by
an
array
or
some
other
GC
thing
like
you.
You
can't
say
that
if
what
you're
giving
them
is
an
obstruction
right,
it
was
intended
to
support
all
these
different
types
of
snare.
I.
B
C
If
you,
if
you
don't
know
anything
about
the
memories
that
you
got
right,
it's
very
unsafe
and
you
don't
know
I
would
say
the
guidance
in
my
opinion
should
be.
When
you
expose
memory,
it
should
be
safe
memory.
It
should
not
be
back,
but
by
native
memory
and
therefore
the
rules
that
we
gonna
write
out,
write
down
the
Graduate.
C
C
E
C
G
B
B
R
R
H
B
I
C
C
B
F
C
C
C
C
C
C
F
B
I
Actually-
and
this
was
a
question
that
actually
just
came
up
in
chat-
something
that
I
don't
think
our
customer
base
really
understands
all
that
much
like
Stan
of
T
and
memory
of
T
literally
can
be
backed
by
effectively
a
raw
pointer
like
once
the
underlying
object
gets
disposed.
The
pointer
is
still
a
pointer
like
if
you
try
to
use
it
now,
things
will
happen
because
we
don't
really
have
the
ability
to
track
that
access
and
say.
F
Very
iffy
about
having
span
as
a
return
on
something
because
it's
the
same
argument
of
you
capture
the
span
here
you
want
this.
The
span
factory
leave
your
sight
for
a
minute.
Now
you
have
no
idea
if
that
span
is
safe
or
not,
and
and
if
we
tried
writing
an
analyzer
for
that,
it's
going
to
be
false,
positive
after
false
positive.
Thank
you.
It's
even
the
same
issue
with
the
rare
pool
sort.
M
F
C
Yeah
then
we
would
have
to
document.
We
would
be
basting
down
same
pattern,
a
packet
we
would
have
to
document
the
api's
people
who
use
german
have
to
be
aware
of
many
things
what's
going
on.
We
just
don't
want
to
do
it,
so
we
don't
pull
this
memory,
but
we
want
to
slice
it.
We
want
to
communicate
that
it's
read-only
that
there's
no
reason
to
modify
it
and
so
on
its
own,
but.
A
World
I
think
it
is
fair
to
say
that,
given
the
way
the
website
is
built
or
given,
given
the
way
about
pipeline
works,
you
would
have
to
do
really
unnatural
acts
of
our
let
that
lifetime,
like
you
I,
mean
at
that
point,
I
would
say.
Well,
if
you
stash
in
a
random
object
into
a
static
variable
X.
Is
it
formatted
from
some
other
thread
that
runs
simultaneously
yeah,
okay,
but
that?
But
at
that.
A
C
The
way
all
disposable
objects
he
doesn't
train
was
you
kind
of,
cannot
share
them.
If
you,
if
your
barn
for
safety
is
something
will
go
wrong
with
the
program
because
not
everybody
knows
I
cannot
review.
Is
that
you
were
you
giving
this
argument?
Oh
I'm,
reviewing
the
code.
I
cannot
tell
whether
it's
correct
or
not,
therefore,
I
rejected.
Well,
that's
true
for
all
disposable
objects
that
are
shared
yep.
R
I
Necessarily
true,
but
the
bar
that
we've
been
holding
ourselves
to
is,
if
you
misuse
an
instance
API
on
a
type
that
you
could
end
up
with
corruption
on
that
pipe
or
on
that
particular
instance.
Okay,
whatever
we
haven't
really
wanted
to
open
up
the
can
of
worms,
which
is
we
misuse
this,
for
instance,
of
the
type.
C
F
F
I
D
I
It
doesn't
make
sense
for
certain
scenarios,
as
you
pointed
out,
for
people
to
be
able
to
do
the
unsafe,
high
performance
things.
But
what
we've
seen,
unfortunately,
especially
with
regard
to
span
and
memory,
is
that
people
naturally
gravitate
towards
those
unsafe
things,
because
they
don't
realize
that
they're
unsafe.
F
I
A
B
C
B
B
C
C
Something
yeah,
then
it's
unsafe
and
frankly,
I,
don't
know
what
the
API
actually
is
called,
but
that
maybe
we
just
call
it
unsafe,
because
it's
like
one
IP
I
did
sunset
in
a
sea
of
IP
is
that
are
meant
to
be
for
mainland
scenarios
and
safe.
If
it's
like
a
feature
area,
it's
unsafe,
well,
unsafe,
yeah,
okay,.
A
F
C
F
C
F
Then,
but
like,
and
that's
easy
to
convey
in
your
choice
of
taking
them
like
if
you're
a
set
and
you're
taking
the
memory
that
says
I'm
keeping
me
I'm
keeping
this
buffer,
the
one
that's
weird
is
asynchronous
methods.
They
have
to
take
any
way
they
can
to
this
family,
but
what
they're
saying
is
I'm
keeping
your
buffer
until
the.
F
S
F
F
F
B
F
F
Did
we
gave
it
to
ya,
but
our
guidance,
the
guidance
that
Levi
wrote,
that
Matt
was
looking
at
and
trying
to
reason
about
whether
you
can
save
this
memory
is
really
for
if
you've
passed
a
memory
into
that
call
directly
and
then
the
promise
on
that
one
is
you
won't
let
go
of
it
when
the
task
finishes.
You
won't
be
saving
that
one
and
that's
where
I
have
a
synchronous
set
method.
This
confuses
me
and
I
refuse
to
have
any
opinion
of
what
that
does.
B
D
B
C
The
issue
is
cancellation,
token
and
timeouts.
We
often
have
to
tell
we
have
to
tell
be
able
to
tell
the
difference.
We
feel
like
our
customers
need
to
be
able
to
tell
the
difference
whether
something
can
send
an
operation
or
it
was
canceled
because
of
time
out.
You
know
today
we
just
throw
in
or
say
something
about
cancer.
Now
you
know
tasks
cancelled
and
it
was
cancelled
either
because
of
time
out
or
somebody
cancelled.
There
is
a.
C
C
C
C
T
Multiple
inheritance,
what.
C
A
D
F
B
F
F
H
F
F
B
U
V
A
D
D
A
H
A
D
This
ACL
changes
a
bit
different
to
the
other
ones,
because
we
don't
have
enough
a
public
API
surface
area
to
to
resolve
the
problem.
So
the
only
way
we
could
figure
out
to
make
the
correct
calls.
What
the
main
issue
here
is
that
there
we're
involving
two
different
assemblies
and
defining
the
new
classes
in
sister
Maya
file
system
access
control,
but
calling
it
from
system
are
your
memory,
mapped
files.
D
D
D
F
F
Right
now,
it's
implemented
as
certain
tables
not
null.
So
now
it's
going
to
do
a
check
or
argument
no
attached
and
it's
asserting
it's
not
closed.
It's
asserting
it's
not
valid,
but
but
you
have
to
decide
now
if
it
becomes
public.
Is
this
going
to
internally
call
duplicate
handle,
make
its
own
instance
of
the
same
memory
back
to
500
and
the
caller
can
call
this
place
without
the
invalidating
this
object?
F
A
H
A
D
R
I
I
F
It's
it
should
be
consistent
with
something
and
if,
if
file
straining
Marty
has
taking
a
safe
file
handle,
we
should
do
the
same
thing
and
if
that's
different
than
storing
the
handle,
then
now
you
need.
You
probably
want
to
account
for
the
semantic
changes
of
whatever
is
calling
this
now,
whether
it's
you
have
another
private
constructor
that
has
private
memory,
mapped
file
safe
to
handle
comma
bool.
Am
I
inside
this
assembly
I,
don't
care
what
this
value
is,
but
you've
called
a
private
constructor
now,
so
we're
happy
like
that.
F
F
F
H
D
All
the
security
changes
that
I've
made
before
already
have
classes
like
this
design
and
they
allow
modifying
the
security
properties.
Are
you
defining
it
exactly
as
it's
finding
about
the
framework?
That's
the
thing
they
did
not
exist
in
framework,
so
we
have
I,
have
I,
am
defining
the
security
of
it
for
memory
map
file
for
the
first
time,
and
the
class
needs
to
have
two
properties
defined.
F
F
F
D
Whenever
we
create
a
security
object,
we
are,
we
can
modify
the
access,
control
and
the
right
via
these
rules.
We
can
also
retrieve
them
from
the
security
object
and
get
a
list
of
access
rules
and
outlet
rules
right
and
since
I'm,
defining
the
security
class
for
the
first
time
for
memory,
mapped
files
well,
I
needed
access.
Rules
are
now
the
truth.
F
Right,
so
it's
really
just
it
like.
If
we,
let's
start
with,
can
we
use
file
access,
rule
and
file
on
it
rule
and
okay
there's
if
they
are
somehow
incompatible
in
a
way
that
doesn't
make
sense
for
just
an
argument
exception
of
like
you
can't
create
an
access
rule,
remember,
wrap
file
that
specifies
synchronizer.
F
S
F
D
D
F
D
A
I
mean
like
be
exposing
the
echo
concept.
The
dotnet
framework
has
like
the
only
reason
we
don't
put
them
on
directly
on
memory.
Mapped
file
is
because
we
want
to
keep
a
close
on
top
of
memory
mapped
file.
So
what
I'm
asking
is
like
what?
What
in
our
architecture
requires
us
to
define
new
ties?
Why
can't
we
just
take
whatever
the
shape?
Dotnet
framework
has
and
basically
just
take
it,
as
is
that's
the
part
I
don't
understand,
because
for
the
most
part
we
try
to
basically
take
the
occurred
concept.
A
A
So
originally,
we
also
talked
about
whether
we
can
just
expose
the
Constructors
rather
than
the
extension
methods
right
in
the
answer
was
what
we
could,
but
that
will
bring
in
like
six
new
assemblies
to
to
to
call
it,
which
we
didn't
want
to
do
so
like
that.
That's
why
I'm
not
sure
why
we
need
new
types.
If
the
conv
already
exists
and
got
infirm
or
whatever
api
shape,
they
have,
it
would
just
keep
yeah.
X
F
D
A
Like
I
mean,
if
you
port,
an
existing
API
is,
is
the
only
thing
we
really
care
about.
Is
the
layering
and
thank
you
like
you,
don't
want
to
add
this
thing
to
call
up
and
then
transitively
pulling
12
new
zombies
right
that
something
we
don't
we
we
try
to
avoid
right,
but
as
far
as
the
API
ship
goes,
the
reason
we
add
these
API
is
from
don't
and
framework.
F
O
F
O
F
F
And
so
like
that,
all
got
approved
on
how
we're
handling
the
concept
port
from
frame
up
decor.
If
these
types
don't
exist
in
framework
work,
either
adding
a
new
concept
or
we
were
missing
something
in
there
in
that
port,
and
it
sounds
like
we're
adding
a
completely
new
concept
and
that
that's
not
this
issue.
The
API
approved
that
this
is
having
that
you're
requesting
an
amendment
to
is
just
taking
the
security
concept
that
we
had
in
frameworks
moving
into
for.
If
this
is
a
new
feature,
that's
different,
so
a
different
API
proposal,
a
different.
We.
D
A
I
Right,
so
this
was
basically
what
people
want
to
do
here
is
they
want
to
give
it
an
array,
get
a
reference
to
where
the
element
at
index
zero
would
have
been
in
that
array.
Interesting
aspect
to
this
is:
if
the
array
is
empty,
it
will
return
a
reference
to
basically
just
passing
into
the
array
which
is
totally
valid
in
il
and
the
CLR.
H
I
I
There
was
some
discussion
on
this
and
folks
like
yada
and
others
more
intimately
familiar
with
the
runtime
did
come
up
with
scenarios
where
it
would
be
useful.
We
already
have
this
as
an
internal
level
that
we
make
you
so
very
frequently
in
our
hot
code.
Hats,
but
because
it's
internal
means
no
one
else.
I
I
I
You
get
is
totally
fine
like
you
can
you
can
lose
the
unsafe
API
for
that
to
a
certain
extent
as
well
things
like
on
what
does
it
like
get?
What
is
it's
panicky?
Don't
get
raw
get
reference
whatever
it
is
that
extension
method.
We
added
that
will
do
the
same
thing.
It
will
give
you
a
reference
for
an
empty
span,
the
points
after
the
end
of
the
span-
and
it's
totally
legal
to
do
that.
I
C
I
Know
there,
so
there
are
three
traps
that
are
performed
by
the
runtime.
The
first
is
a
typical
null
check,
which
is
still
going
to
be
performed
regardless.
We
can't
lie
to
us
out.
The
second
is
a
link
check
which
we
now
are
bypassing,
and
the
third
is
in
an
array
variance
check
which
we're
also
bypassing.
I
I
Array
variance
check
could
fail
at
runtime.
So
if
I
have
a
string
array
which
I
hit
the
downcast
to
an
object
array
of
Cass,
County
I,
don't
know
which
I
could
cast
to
an
object
array
and
then
I
tried.
Turning
that
into
a
span
of
object,
the
span
of
object,
constructor
will
actually
throw
saying
hey.
This
array
is
actually
of
type.
I
I,
don't
necessarily
care
what
the
API
name
is
I
think
there
was
some
debate
on
whether
there
should
go
on
unsafe
or
memory
Marshall
there
in
the
thread
there
was
some
discussion
that
unsafe
doesn't
really
make
sense,
since
there
aren't
any
other
array
asked.
Api
is
own
unsafe,
so
memory
marshals,
probably
the
best
place
for
I.
A
O
I
I
C
I
Y
I
E
I
Z
V
I
A
F
A
F
M
C
C
O
I
So
this
is
specifically
for
rice,
because
for
a
raise
being
that
there
are
contiguous
sequences
of
elements,
it's
meaningful
to
ask
things
about
like
how
are
these
two
addresses
related
to
each
other
for
regular
objects?
It's
not
really
meaningful
to
ask
those
questions
occasionally,
if
you're
getting
the
raw
data
for
an
object.
It's
probably
because
you
wanted
to
reinterpret
trust.
That
object
is
something
else,
and
at
that
point
we
really
should
provide
specific
api's
for
what
you're
trying
to
do.
H
I
A
F
A
F
H
M
I
F
F
M
A
I
V
H
C
S
I
C
P
A
X
P
P
Q
F
F
F
C
Because
people
who
know
that
these
eighty
ice
underneath
actually
take
is
we
think
that
it
has
something
to
do
with.
You
know
as
Matthew's
to
see
them
value
to
the
instance.
We
probably
will
well
except
the
highest,
may
not
be
the
highest
end.
Right
like
we
should
express
the
intent
the
highest
might
be
actually
the
lowest
in.
F
E
D
F
O
D
D
A
Don't
have
to
assume
a
QB
makes
me
know
we
have
data,
don't
do
that
in
fact,
I
will
do
this
in
an
hour
from
now.
Well,
I
am
participating
in
the
WinForms
API
use
rate
to
study,
so
I
will
not
be
the
new
dogs.
I
will
just
sum
up
my
way
to
intellisense
and
then
maybe
something
will
happen
we'll
find
out.