►
From YouTube: .NET Core Design Reviews: MAX_PATH Review
Description
In this meeting we'll take a look at a more concrete proposal to address the MAX_PATH issues in .NET.
A
C
C
Slapping
on
the
extended
syntax,
when
we
actually
invoke
the
windows
api's,
with
some
notable
exceptions
that
one
of
the
ones
we're
using
for
getting
full
path,
we
don't
have
to
do
that.
It's
one
that
actually
supports
arbitrary
length
cows.
So
you
know
the
general
gist
is
by
not
forcing
people
down
the
road
of
actually
putting
long
path.
Syntax
on
you
get
the
the
legacy
normalization
to
pass,
which
is
actually
more
compatible
for
things
than
trying
to
force
people
down
the
other
route.
So
you.
A
C
All
the
windows
api
is
to
take
a
buffer
size
so
well,
it
is
plot
possible.
You
know
that
you
could
be
calling
someone
managed
code
somewhere
that
takes
a
max
path,
that
you
have
a
dependency
on.
There's
no
guarantee
that,
like
you're
not
going
to
leak
in
a
string,
that's
more
than
that,
you
really
should
be
checking
it.
Always
on
your
own
case.
You
know
when
you
actually
go
out,
you
may
get
lucky
and
have
like
path,
get
full
path
and
pro
for
you
at
some
point
by
the
time.
C
C
You
want
to
walk
us
through
it,
so
this
one
is
just
talking
about
like
how
we
deal
with
relative
paths.
This
is
the
happy
to
laugh
he's
one
of
the
other
limitations
it's
in
Windows
is
that
at
least
currently,
you
know,
set
current
directory
and
get
current
directory
are
limited
to
Mac
path.
There
is
no
way
to
get
it
beyond
that,
and
that's
not
likely
to
change
anytime
soon.
C
On
top
of
that,
you
know,
it's
also
recommended
that
you
don't
rely
on
get
words
that
current
directory,
because
it
is
a
process
wide
setting,
and
you
know
it's
not
friendly
for
multi-threaded
applications,
which
is
everything
these
days.
Even
if
you
only
have
a
single
thread
in
your
own
code,
there
is
lots
of
other
code
running
at
the
same
time
as
well.
C
So
we
need
to
deal
with
that
for
those
two
reasons,
one
of
the
things
that
we
want
to
offer
and
there
are
similar
things
that
are
already
available
on
the
shell
at
least
the
most
current
shell
api's
is
first
like
Windows,
a
to
say
an
overload
that
lets
you
specify
what
the
base
path
is
going
to
be
so
that
you
can
deal
about
yourself.
You
can
get
around
the
problem
completely
and
also
it's
like
of
threading
the
process,
life
issue
and
also
get
around
the
problem
of
the
long
pass.
C
Er,
no,
no,
the
shell
of
the
eyes
do
the
same
sort
of
behavior,
so
this
will
be
available
all
the
way
from
the
bottom
of
this
behaviour
been
there
since
at
least
windows
XP
at
least
the
full
path
name.
Is
the
underlying
windows?
Api
doesn
t
end
up
calling
one
of
them
so
from
a
from
a
an
API
surface
area
perspective,
it's
only
through
me.
C
D
C
D
We
actually
had
an
argument
exception
for
the
path
such
that
we
shouldn't
love
them,
as
absolute
paths
in
the
second
perimeter
seems
a
little
counter
into.
Sometimes
you
get
will
do
something
fancy,
sometimes
it
won't.
What
should
we
make?
It
basically
make
a
statement.
It
says
path
must
always
be
relative.
The
second
parameter
they
know.
C
Conceptually
conceptual
II,
this
is
meant
to
mimic.
The
same
thing
is
setting
the
current
directory
and
then
resolving
the
path,
so
otherwise
users
gonna
have
to
figure
that
out
on
their
own
and
there's
not
really
a
current
behavior.
When
you
read
solve
a
path,
it
doesn't
matter
whether
it's
relative
or
not.
What
matters
I
mean
that
the
api's
don't
care.
It's
like
what
happens
to
it
is
is
what
changes
right
you
know.
If
it
is
happen
to
be
fixed,
then
it
will
actually
use
the
base
path
of
it.
C
Isn't
it
moment
will
call
that
out
very
explicitly
and
also
call
it
so
there's
quite
a
few
details
in
here
look
about
how
the
behavior
works
and
like
why
you
might
want
to
use
path
combine
instead
in
certain
scenarios.
So
what
was
the
next
question
so
and
clarify
also
as
well
and
I?
Have
that
in
here,
like
it's,
a
call
out
in
the
design
and
other
considerations,
and
that's
really
where
we
should
be
spending
most
of
our
time?
From
this
point,
beautiful.
B
C
B
C
That
crazy,
no
no
so
he's
talking
about
dr
relatives
and
I
again
I
talked
about
this
in
the
design
and
considerations
piece
like
want
to
go
into
that
because
it's
actually
are
going
to
be
pressed
for
now.
Let's
start
actually,
without
with
just
basic
paths,
will
talk
about
extended
paths
after
we
talked
about
like
non
extended
or
the
using
that
the
extended
pathak
reset
prefix,
because
that's
a
lot
more
complicated
so.
C
So
some
of
did
the
remarks
here,
just
actually
a
combination
of
a
few
extra
pieces
within
the
existing
remarks.
I
called
out
the
new
content,
but
the
design
considerations
are
there.
So
you
know,
as
I
say
here,
it's
intended
to
be
functionally
similar
to
setting
the
current
directory
and
then
calling
in
full
path
without
actually
setting
the
current
directory-
and
you
know,
generally
speaking,
this
path
should
not
actually
touch
the
disk
ever
now,
I
mean
this
is
like
what,
when
you're
getting
an
absolute
path.
This
is
kind
of
the
convention.
C
That's
out
there
right,
like
the
idea
is
that
you're
not
doing
disk
I/o.
This
is
meant
to
be
a
string
manipulation.
Now
on
the
windows
side,
we
have
one
caveat
to
that:
that's
we
try
to
normalize
short
pass
and
that
can't
be
done
without
actually
seeing
if
there
is
a
short
path,
so
that
behavior
will
be
in
there
that
that
would
be
the
one
the
one
piece
outside
of
us.
So
there
are
other
things
that
you
don't
want
to.
Do.
We
don't
want
to
follow
links.
C
D
C
Normalized,
in
the
sense
that
like
there
are
like
relative
pieces,
are
taken
out
and
as
far
as
legacy
windows,
the
things
or
certain
pieces
are
taken
out
right,
so
trailing
periods,
spaces
things
like
that.
If
I
call
into
those
details,
that's
the
same
stuff
that
that
full
pathname
does
on
windows,
which
is
collapse.
The
the
relative
segments
and
two
minor
cleanup
of
the
individual
segments,
which
is
again
like
a
training
period
and
few
other
cases.
I
call
it
out
loud,
but
yet.
C
B
C
B
C
Not
it's
not
absolute
in
the
fact
that
it
still
has
relative
segments,
that's
not
considered
absolute,
it
is
rooted,
that's
the
difference,
so
it's
subtle,
but
that's
rooted,
they're,
both
rooted
absolute,
is
only
what
you
get
from
get
it
might
be
worth
defining.
What
absolute
best
maintain
absolute
path
means:
there's
no
there's
no
relative
segments
in
it
any
longer,
and
it's
rooted.