►
From YouTube: .NET Design Review: Nullable Annotations
Description
We're trying to finish reviewing the nullable annotations for System.Runtime.
C
E
E
B
B
I
C
B
C
E
B
J
J
J
B
C
C
B
C
I
mean
the
attributes
that
that
we
have
that
are
you
know
that
are
currently
being
buzzed
the
compiler
and
that
we
plumb
through
core
lab
they're
all
sort
of
top
level.
We
don't
have
anything
that
deals
with
annotating
the
T.
That's
part
of
you
know
an
array
or
whatever
other
than
constraints
like
that.
F
You
only
only
want
to
entity
because
you
can
already
imma
take
the
outer
arrays
right,
so
only
the
T
is
actually
relevant.
So
probably
a
long
move,
type
of
tea
or
something
I
mean
that's
what
I'm
thinking
but
I
you
know
have
to
think
about
so
much
cases.
That's
probably
worth
philocan
languages.
Anything
right
this
having
this
horse
injury
in
it.
So
far,
I.
A
G
C
C
We
have
we
have
a
few
attributes
that
we
can
apply
in
these
situations
and
for
generics
generally,
when
you
have
a
generic
out,
t
will
apply
if
any
in
a
try.
Pattern
will
apply
an
attribute,
maybe
know
when
false,
but
which
basically
actually
I,
just
realized.
It's
not
gonna
work
here
the
attributes
bogus
because
this
doesn't
return
this
returns
in
it.
L
G
C
C
F
F
C
G
A
C
C
N
C
Might
return,
and
so
today,
you're
just
always
gonna
have
to
null
check
the
result.
This
is
very
similar
right.
This
is
regardless
of
what
this
returns.
You're
gonna
have
to
know,
check
the
results.
Alternatively,
if
we
made
it
oblivious,
you
won't
have
to
know
check
the
results,
but
you
also
might
try
and
dereference
a
when
it's
done.
J
G
G
B
C
C
Things
I
mean
we
yeah.
We
had
talked
about
having
a
changing,
maybe
no
when
won't
to
instead
be
maybe
no
when
object,
and
the
compiler
would
allow
you
to
use
any
cause,
any
constant
expression
that
you
could
put
in
there,
the
Union
metadata
and
then,
if
the
compiler
saw
that
value
used
as
a
constant
in
comparison
like.
C
If
try
take
from
any
equals
negative
one,
then
it
would
be
able
to
compare
that
against
the
constant
that
was
in
the
attribute,
and
so
it
would
apply
not
just
to
true
and
false,
but
to
things
like
negative
one,
and
so
that
was
scoped
out.
But
you
could
imagine
that
being
added
subsequently
and
then
it
should
be
a
non-breaking
change
to
update
the
the
attributes
in
that
direction,
because
it
would
just
mean
that
people
have
more
exclamation
points
than
they
need
right.
C
I'm
actually
interested
to
see
we
have
a
PR
I,
just
finished
are
about
to
finish
absorbing
the
compiler
changes
that
enable
most
of
the
attributes
in
core
lip
I'm
about
to
do
the
same
in
core
FX
that
I'm
curious
to
see
if
it
Flags
these
mistakes,
I
made
with
maybe
no
and
false
on
something
that
doesn't
return.
A
bool.
L
B
F
L
K
K
I
I
G
G
E
E
L
G
J
O
B
By
the
way,
regarding
the
variance
thing
that
I
mentioned
earlier,
in
theory,
things
like
add
value,
Factory
and
update
value
Factory,
the
T
key
argument
could
be
to
keep
pushing
more
because,
in
theory,
nosal
out
there,
because
it's
no,
it's
not
a
key
is
constrained
to
be
not
no,
no
no
I
mean
add
value
Factory,
not
a
value
Factory.
Why
shouldn't
I
be
able
to
pass
a
delegate
that
has
T
key
kept
question
mark
as
its
input
perimeter
right,
because
once
it's
gone.
G
B
G
C
B
G
G
G
C
G
C
P
P
C
P
I
A
A
G
G
A
G
J
D
G
J
H
A
We
talked
about
this
when
we
looked
at
the
a
transit
it's
impossible
to
design
that
in
such
a
way
because
it
because
inheritance
doesn't
work
in
that
way
because
imagine,
for
example,
you
have
like
three
arguments
and
you
want
to
change
the
behavior
of
one
of
them
like
how
do
we
express
that
point?
We
have
to
copy
everything
down,
but
now
now,
if
you
need
to
copy
everything
down,
what
does
omission
know
mean?
A
Do
you
inherit
for
the
parameter
from
the
previous
one,
or
do
you
just
this
is
not
being
there
in
our
statement
of
is
not
being
there
yeah?
It's
not
it's
not
something
that
you
can
easily
express,
I,
think
in
general,
like
I'm,
ok
with
them
having
to
be
copy
and
paste
it
down.
It's
just
thinking
my
gosh.
It.
F
A
G
In
the
other
cases,
if
your
propagating
and
then
your
reference
assembly
changes
and
they
decided
to
change
something
upstream,
then
like
you
now
get
it
you,
you
may
get
a
silent
change
in
behavior
or
you
may
get
a
warning
depending
on
what
exactly
changed.
You
probably
want
to
be
number
five
most
of
the
time.
This
sounds
like
a
complicated.
G
F
A
L
A
A
L
A
G
Q
B
C
E
A
A
G
E
C
For
generating
code
attribute,
I
looked
through
a
bunch
of
uses
and
I
found
a
bunch.
More
version
is
null
so
that
one
I
think
made
a
lot
of
sense
to
be
string.
Question
mark
I
couldn't
find
anywhere
tool
was
null
but
I
sort
of
imagined
places
where
someone
might
want
to
slap,
generate
a
code
onto
it
and
not
be
specific
about
what
created
it.
So,
what.
C
It's
a
question:
this
has
been
out
here
for
20
years,
so
it's
it's
a
question
of
not
necessarily
what
we
want,
but
what
have
people
done
and
I
don't
know?
I
I
only
looked
at
our
own
code,
so
I
in
our
own
code,
I
found
cases
where
version
was
no
I
didn't
find
any
our
own
code
where
tool
is
known,
but
that
doesn't
mean
that
doesn't
exist.
Yeah.
G
E
E
Good
document
we
could
think
the
property,
the
out
position,
say
it's
nullable
and
make
the
parameter
say
that
it's
non
knowable,
but
that
seems
artificial.
You
know
and
I
think
that
most
people
who
are
using
generated
crowd
attribute
are
just
you
know,
generating
their
generated
code
attribute,
so
they
probably
wouldn't
even
notice
the
decoration
when
they
reach.
A
B
B
A
B
A
F
B
I
B
B
It
looks
like
when
it's
being
written
to
the
event
source.
There
is
a
metadata
property
on
the
counter,
payload
object
and
that
property
is
just
a
string
and
it
gets
the
the
metadata
dictionary
gets
serialized.
As
for
every
key
value,
two
people
get
serialized
as
key
colon
value,
comma
and
Nolan.
Empty
values
are
just
empty
string
normalized,
so
it
becomes
a
bunch
of
a
colon
B,
comma
C,
colon
D,
comma
dadada,
and
that
gets
written
out
somewhere.
I,
say.
E
C
E
Already,
what
that's?
What
knowing
you're
both
gonna
do
right,
since
it's
null
works
and
has
a
behavior
that
you
can't
distinguish
from
the
next
best
thing,
which
is
the
empty
string,
but
I
think
saying
that
they're,
both
not
null
with
just
a
few
people
if
they
felt
that
they
wanted
to
add
null
they
grant
that
they
wouldn't
be
able
to
get
it
back
from.
B
A
D
J
D
D
A
B
J
G
E
E
I
G
B
E
I
E
E
F
E
C
This,
this
might
be
a
case
where
we
to
assert
intent
but
event
source
not
send
command,
which
is
public,
takes
a
command
arguments.
It
doesn't
do
any
validation
on
it
and
it
just
passes
it
all.
The
way
through
that's
passed
into
the
event
command
args
event
convey
its
constructor
and
it's
soared
into
the
property,
know
that
it
could
be
that
we're
just
you
know
what
are
the
many
cases
where
we
hadn't
done
public
argument
validation,
even
though
we
expect
it
to
be
not
null.
C
E
F
D
G
G
G
G
G
C
A
A
A
E
C
Q
Q
F
J
E
L
B
A
A
B
C
E
Tobacco,
but
on
the
whatever
things
were
thinking,
the
nullable
array
is
params.
I
can't
find
any
reason
that
it's
not
a
array
of
string.
Question
marks,
I,
don't
see
anything,
that's
walking
through
a
value
unsafely
wears
a
those
events
force
constructor,
you
mean
the
trades.
Yes,
I
got
that
this
tunnel.
C
E
E
C
A
Api
and
then
show
the
sample
code.
I
think
I
gave
I'm
half
way
in
because
it
was
a
bit
weird
in
the
in
the
way
the
trades
were
posited
because
yeah
they
were
basically
key
radio
chemokine.
What's
a
bit,
it
was
a
bit
odd,
so
that
might
not
be
actually
an
encoding
that
actually
represents
intent
to
goddess
over
there.
No.
F
A
C
A
F
A
A
A
P
L
J
A
N
A
C
E
C
A
A
F
B
A
A
A
A
O
C
A
C
A
F
D
A
A
A
B
L
G
G
The
scope
or
they're,
not
oh
yeah,
make
sense
yeah,
so
I
think
several
of
these.
You
should
be
of
DIC
posteriori,
all
right
right,
yeah
at
least
for
the
ones
that
take
values,
because
you
you
have
no
clue
whether
or
not
the
thing
allows
null
generic
and
then
presumably
the
thing
that
the
constructor
you're
calling
will
throw
it.
The
inputs
Nolan
doesn't
allow
yeah
well,
actually
it
won't
because
it's
an
attribute-
and
we
said
those
don't
throw
so
so.
G
K
A
B
A
E
Yeah,
so
we
I
mean
as
long
as
if
we
believe
this
one
has
been
done
already,
then
we
already
have
to
feed
back
that
custom,
attribute
builders,
property
values
and
constructor
args
and
presumably
whatever's
after
field
info
array
named
fields.
Theoretically,
all
of
those
should
accept
null
inputs
because
I
guess
it
says
there
is
some
change
here.
So
maybe
that
was
just
missed
doesn't
to
make
sure
we
didn't
have
a
that.
We
were
looking
at
a
thing
that
actually
hadn't
been
crossed.
A
A
I
G
So
so,
in
the
custom
attribute,
we
said
you
didn't
allow
no
on
the
bike
parameter
names
or
on
the
parameter,
names
and
stuff,
because
we
required
you
to
call
the
constructor
that
didn't
have
that
parameter.
But
for
this
one
it
looks
like
we
were
allowing
me
to
pass
a
null
and
we
just
treat
it
as
the
same
as
the
add
argument,
one
that
doesn't,
it
seems
like
it
would
be
good
for
a
consistent
for
consistency,
sake
to
update
the
former
to
allow
passing
in
null
potentially
and
then
just
forwarding
it
down.