Merge pull request #97 from GerardSmit/feature/alternate-equality-comparer

xoofx · web-flow · commit eb0ebb42517a · 2024-12-05T09:49:32.000+01:00
Reduce allocations in .NET 9
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -24,10 +24,10 @@ jobs:
         submodules: true
         fetch-depth: 0
 
-    - name: Install .NET 8.0
+    - name: Install .NET 9.0
       uses: actions/setup-dotnet@v3
       with:
-        dotnet-version: '8.0.x'
+        dotnet-version: '9.0.x'
 
     - name: Build, Test, Pack, Publish
       if: matrix.os == 'windows-latest'
diff --git a/src/Zio.Tests/TestSearchPattern.cs b/src/Zio.Tests/TestSearchPattern.cs
@@ -91,7 +91,7 @@ public void TestExpectedExceptions()
         {
             var searchPattern = "*";
             var search = SearchPattern.Parse(ref path, ref searchPattern);
-            Assert.Throws<ArgumentNullException>(() => search.Match(null));
+            Assert.Throws<ArgumentNullException>(() => search.Match(((string)null)!));
         }
     }
 
diff --git a/src/Zio.Tests/TestUPath.cs b/src/Zio.Tests/TestUPath.cs
@@ -267,6 +267,22 @@ public void TestGetDirectory(string path1, string expectedDir)
         Assert.Equal(expectedDir, result);
     }
 
+    [Theory]
+    [InlineData("", "")]
+    [InlineData("/", "")]
+    [InlineData("/a", "/")]
+    [InlineData("/a/b", "/a")]
+    [InlineData("/a/b/c.txt", "/a/b")]
+    [InlineData("a", "")]
+    [InlineData("../a", "..")]
+    [InlineData("../../a/b", "../../a")]
+    public void TestGetDirectoryAsSpan(string path1, string expectedDir)
+    {
+        var path = (UPath)path1;
+        var result = path.GetDirectoryAsSpan().ToString();
+        Assert.Equal(expectedDir, result);
+    }
+
     [Theory]
     [InlineData("", ".txt", "")]
     [InlineData("/", ".txt", "/.txt")]
@@ -324,6 +340,34 @@ public void TestSplit()
         Assert.Equal(new List<string>() { "a", "b", "c" }, ((UPath)"a/b/c").Split());
     }
 
+    [Fact]
+    public void TestSplitSpan()
+    {
+        Assert.Equal(new List<string>(), ToList((UPath)""));
+        Assert.Equal(new List<string>(), ToList((UPath)"/"));
+        Assert.Equal(new List<string>() { "a" }, ToList((UPath)"/a"));
+        Assert.Equal(new List<string>() {"a", "b", "c"}, ToList((UPath) "/a/b/c"));
+        Assert.Equal(new List<string>() { "a" }, ToList((UPath)"a"));
+        Assert.Equal(new List<string>() { "a", "b" }, ToList((UPath)"a/b"));
+        Assert.Equal(new List<string>() { "a", "b", "c" }, ToList((UPath)"a/b/c"));
+        return;
+
+        List<string> ToList(UPath path)
+        {
+            var enumerator = path.SpanSplit();
+            var list = new List<string>(enumerator.Count);
+
+            foreach (var span in enumerator)
+            {
+                list.Add(span.ToString());
+            }
+
+            Assert.Equal(enumerator.Count, list.Count);
+
+            return list;
+        }
+    }
+
 
     [Fact]
     public void TestExpectedException()
diff --git a/src/Zio.Tests/Zio.Tests.csproj b/src/Zio.Tests/Zio.Tests.csproj
@@ -1,7 +1,7 @@
 ﻿<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net8.0;net472</TargetFrameworks>
+    <TargetFrameworks>net8.0;net9.0;net472</TargetFrameworks>
     <IsPackable>false</IsPackable>
     <LangVersion>10</LangVersion>
   </PropertyGroup>
diff --git a/src/Zio/FileSystems/MemoryFileSystem.cs b/src/Zio/FileSystems/MemoryFileSystem.cs
@@ -1304,7 +1304,7 @@ private NodeResult EnterFindNode(UPath path, FindNodeFlags flags, FileShare? sha
         var isRequiringExclusiveLockForParent = (flags & (FindNodeFlags.CreatePathIfNotExist | FindNodeFlags.KeepParentNodeExclusive)) != 0;
 
         var parentNode = _rootDirectory;
-        var names = path.Split();
+        var names = path.SpanSplit();
 
         // Walking down the nodes in locking order:
         // /a/b/c.txt
@@ -1324,21 +1324,25 @@ private NodeResult EnterFindNode(UPath path, FindNodeFlags flags, FileShare? sha
             isParentLockTaken = true;
         }
 
-        for (var i = 0; i < names.Count && parentNode != null; i++)
+        for (var i = 0; names.MoveNext() && parentNode != null; i++)
         {
-            var name = names[i];
+            ReadOnlySpan<char> name = names.Current;
             bool isLast = i + 1 == names.Count;
 
             DirectoryNode? nextParent = null;
             bool isNextParentLockTaken = false;
             try
             {
                 FileSystemNode? subNode;
-                if (!parentNode.Children.TryGetValue(name, out subNode))
+#if HAS_ALTERNATEEQUALITYCOMPARER
+                if (!parentNode.Children.GetAlternateLookup<ReadOnlySpan<char>>().TryGetValue(name, out subNode))
+#else
+                if (!parentNode.Children.TryGetValue(name.ToString(), out subNode))
+#endif
                 {
                     if ((flags & FindNodeFlags.CreatePathIfNotExist) != 0)
                     {
-                        subNode = new DirectoryNode(this, parentNode, name);
+                        subNode = new DirectoryNode(this, parentNode, name.ToString());
                     }
                 }
                 else
@@ -1361,7 +1365,7 @@ private NodeResult EnterFindNode(UPath path, FindNodeFlags flags, FileShare? sha
                         flags &= ~(FindNodeFlags.KeepParentNodeExclusive | FindNodeFlags.KeepParentNodeShared);
                     }
 
-                    result = new NodeResult(parentNode, subNode, name, flags);
+                    result = new NodeResult(parentNode, subNode, name.ToString(), flags);
 
                     // The last subnode may be null but we still want to return a valid parent
                     // otherwise, lock the final node if necessary
diff --git a/src/Zio/FileSystems/ZipArchiveFileSystem.cs b/src/Zio/FileSystems/ZipArchiveFileSystem.cs
@@ -196,18 +196,18 @@ protected override void CopyFileImpl(UPath srcPath, UPath destPath, bool overwri
 
         if (srcEntry == null)
         {
-            if (!DirectoryExistsImpl(srcPath.GetDirectory()))
+            if (!DirectoryExistsImpl(srcPath.GetDirectoryAsSpan()))
             {
                 throw new DirectoryNotFoundException(srcPath.GetDirectory().FullName);
             }
 
             throw FileSystemExceptionHelper.NewFileNotFoundException(srcPath);
         }
 
-        var parentDirectory = destPath.GetDirectory();
+        var parentDirectory = destPath.GetDirectoryAsSpan();
         if (!DirectoryExistsImpl(parentDirectory))
         {
-            throw FileSystemExceptionHelper.NewDirectoryNotFoundException(parentDirectory);
+            throw FileSystemExceptionHelper.NewDirectoryNotFoundException(parentDirectory.ToString());
         }
 
         if (DirectoryExistsImpl(destPath))
@@ -261,12 +261,12 @@ protected override void CreateDirectoryImpl(UPath path)
             throw FileSystemExceptionHelper.NewDestinationDirectoryExistException(path);
         }
 
-        var parentPath = new UPath(GetParent(path.FullName));
-        if (parentPath != "")
+        var parentPath = GetParent(path.AsSpan());
+        if (!parentPath.IsEmpty)
         {
             if (!DirectoryExistsImpl(parentPath))
             {
-                CreateDirectoryImpl(parentPath);
+                CreateDirectoryImpl(parentPath.ToString());
             }
         }
 
@@ -405,7 +405,12 @@ protected override void DeleteFileImpl(UPath path)
     /// <inheritdoc />
     protected override bool DirectoryExistsImpl(UPath path)
     {
-        if (path.FullName is "/" or "\\" or "")
+        return DirectoryExistsImpl(path.FullName.AsSpan());
+    }
+
+    private bool DirectoryExistsImpl(ReadOnlySpan<char> path)
+    {
+        if (path is "/" or "\\" or "")
         {
             return true;
         }
@@ -414,7 +419,11 @@ protected override bool DirectoryExistsImpl(UPath path)
 
         try
         {
-            return _entries.TryGetValue(path, out var entry) && entry.IsDirectory;
+#if HAS_ALTERNATEEQUALITYCOMPARER
+            return _entries.GetAlternateLookup<ReadOnlySpan<char>>().TryGetValue(path, out var entry) && entry.IsDirectory;
+#else
+            return _entries.TryGetValue(path.ToString(), out var entry) && entry.IsDirectory;
+#endif
         }
         finally
         {
@@ -651,7 +660,7 @@ protected override void MoveFileImpl(UPath srcPath, UPath destPath)
     {
         var srcEntry = GetEntry(srcPath) ?? throw FileSystemExceptionHelper.NewFileNotFoundException(srcPath);
 
-        if (!DirectoryExistsImpl(destPath.GetDirectory()))
+        if (!DirectoryExistsImpl(destPath.GetDirectoryAsSpan()))
         {
             throw FileSystemExceptionHelper.NewDirectoryNotFoundException(destPath.GetDirectory());
         }
@@ -706,7 +715,7 @@ protected override Stream OpenFileImpl(UPath path, FileMode mode, FileAccess acc
             }
             else
             {
-                if (!DirectoryExistsImpl(path.GetDirectory()))
+                if (!DirectoryExistsImpl(path.GetDirectoryAsSpan()))
                 {
                     throw FileSystemExceptionHelper.NewDirectoryNotFoundException(path.GetDirectory());
                 }
@@ -911,18 +920,18 @@ private ZipArchiveEntry CreateEntry(UPath path, bool isDirectory = false)
 
     private static readonly char[] s_slashChars = { '/', '\\' };
 
-    private static string GetName(ZipArchiveEntry entry)
+    private static ReadOnlySpan<char> GetName(ZipArchiveEntry entry)
     {
         var name = entry.FullName.TrimEnd(s_slashChars);
         var index = name.LastIndexOfAny(s_slashChars);
-        return name.Substring(index + 1);
+        return index == -1 ? name.AsSpan() : name.AsSpan(index + 1);
     }
 
-    private static string GetParent(string path)
+    private static ReadOnlySpan<char> GetParent(ReadOnlySpan<char> path)
     {
         path = path.TrimEnd(s_slashChars);
         var lastIndex = path.LastIndexOfAny(s_slashChars);
-        return lastIndex == -1 ? "" : path.Substring(0, lastIndex);
+        return lastIndex == -1 ? ReadOnlySpan<char>.Empty : path.Slice(0, lastIndex);
     }
 
     private FileSystemEventDispatcher<FileSystemWatcher>? TryGetDispatcher()
diff --git a/src/Zio/SearchPattern.cs b/src/Zio/SearchPattern.cs
@@ -2,6 +2,7 @@
 // This file is licensed under the BSD-Clause 2 license. 
 // See the license.txt file in the project root for more information.
 
+using System.Linq;
 using System.Text;
 using System.Text.RegularExpressions;
 
@@ -43,6 +44,22 @@ public bool Match(string name)
         return _exactMatch != null ? _exactMatch == name : _regexMatch is null || _regexMatch.IsMatch(name);
     }
 
+    /// <summary>
+    /// Tries to match the specified path with this instance.
+    /// </summary>
+    /// <param name="name">The path to match.</param>
+    /// <returns><c>true</c> if the path was matched, <c>false</c> otherwise.</returns>
+    public bool Match(ReadOnlySpan<char> name)
+    {
+#if NET7_0_OR_GREATER
+        // if _execMatch is null and _regexMatch is null, we have a * match
+        return _exactMatch != null ? name.SequenceEqual(_exactMatch) : _regexMatch is null || _regexMatch.IsMatch(name);
+#else
+        // Regex.Match(ReadOnlySpan<char>) is only available starting from .NET
+        return Match(name.ToString());
+#endif
+    }
+
     /// <summary>
     /// Parses and normalize the specified path and <see cref="SearchPattern"/>.
     /// </summary>
diff --git a/src/Zio/UPath.cs b/src/Zio/UPath.cs
@@ -116,6 +116,16 @@ public static explicit operator string(UPath path)
         return path.FullName;
     }
 
+    /// <summary>
+    /// Performs an explicit conversion from <see cref="UPath"/> to <see cref="ReadOnlySpan{Char}"/>.
+    /// </summary>
+    /// <param name="path">The path.</param>
+    /// <returns>The result as a span of the conversion.</returns>
+    public static explicit operator ReadOnlySpan<char>(UPath path)
+    {
+        return path.FullName.AsSpan();
+    }
+
     /// <summary>
     /// Combines two paths into a new path.
     /// </summary>
@@ -322,6 +332,15 @@ public override string ToString()
         return FullName;
     }
 
+    /// <summary>
+    /// Creates a new readonly span from this path.
+    /// </summary>
+    /// <returns>A new readonly span from this path.</returns>
+    public ReadOnlySpan<char> AsSpan()
+    {
+        return FullName.AsSpan();
+    }
+
     /// <summary>
     /// Tries to parse the specified string into a <see cref="UPath"/>
     /// </summary>
diff --git a/src/Zio/UPathComparer.cs b/src/Zio/UPathComparer.cs
@@ -2,9 +2,14 @@
 // This file is licensed under the BSD-Clause 2 license.
 // See the license.txt file in the project root for more information.
 
+using System.Diagnostics;
+
 namespace Zio;
 
 public class UPathComparer : IComparer<UPath>, IEqualityComparer<UPath>
+#if HAS_ALTERNATEEQUALITYCOMPARER
+    , IAlternateEqualityComparer<ReadOnlySpan<char>, UPath>, IAlternateEqualityComparer<string, UPath>
+#endif
 {
     public static readonly UPathComparer Ordinal = new(StringComparer.Ordinal);
     public static readonly UPathComparer OrdinalIgnoreCase = new(StringComparer.OrdinalIgnoreCase);
@@ -16,6 +21,10 @@ public class UPathComparer : IComparer<UPath>, IEqualityComparer<UPath>
     private UPathComparer(StringComparer comparer)
     {
         _comparer = comparer;
+
+#if HAS_ALTERNATEEQUALITYCOMPARER
+        Debug.Assert(_comparer is IAlternateEqualityComparer<ReadOnlySpan<char>, string>);
+#endif
     }
 
     public int Compare(UPath x, UPath y)
@@ -32,4 +41,36 @@ public int GetHashCode(UPath obj)
     {
         return _comparer.GetHashCode(obj.FullName);
     }
+
+#if HAS_ALTERNATEEQUALITYCOMPARER
+    bool IAlternateEqualityComparer<ReadOnlySpan<char>, UPath>.Equals(ReadOnlySpan<char> alternate, UPath other)
+    {
+        return ((IAlternateEqualityComparer<ReadOnlySpan<char>, string>)_comparer).Equals(alternate, other.FullName);
+    }
+
+    int IAlternateEqualityComparer<ReadOnlySpan<char>, UPath>.GetHashCode(ReadOnlySpan<char> alternate)
+    {
+        return ((IAlternateEqualityComparer<ReadOnlySpan<char>, string>)_comparer).GetHashCode(alternate);
+    }
+
+    UPath IAlternateEqualityComparer<ReadOnlySpan<char>, UPath>.Create(ReadOnlySpan<char> alternate)
+    {
+        return ((IAlternateEqualityComparer<ReadOnlySpan<char>, string>)_comparer).Create(alternate);
+    }
+
+    bool IAlternateEqualityComparer<string, UPath>.Equals(string alternate, UPath other)
+    {
+        return _comparer.Equals(alternate, other.FullName);
+    }
+
+    int IAlternateEqualityComparer<string, UPath>.GetHashCode(string alternate)
+    {
+        return _comparer.GetHashCode(alternate);
+    }
+
+    UPath IAlternateEqualityComparer<string, UPath>.Create(string alternate)
+    {
+        return alternate;
+    }
+#endif
 }
diff --git a/src/Zio/UPathExtensions.cs b/src/Zio/UPathExtensions.cs
diff --git a/src/Zio/Zio.csproj b/src/Zio/Zio.csproj
diff --git a/src/global.json b/src/global.json

Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ public void TestExpectedExceptions()`
`91`	`91`	`{`
`92`	`92`	`var searchPattern = "*";`
`93`	`93`	`var search = SearchPattern.Parse(ref path, ref searchPattern);`
`94`		`- Assert.Throws<ArgumentNullException>(() => search.Match(null));`
	`94`	`+ Assert.Throws<ArgumentNullException>(() => search.Match(((string)null)!));`
`95`	`95`	`}`
`96`	`96`	`}`
`97`	`97`
Original file line number	Diff line number	Diff line change
`@@ -1304,7 +1304,7 @@ private NodeResult EnterFindNode(UPath path, FindNodeFlags flags, FileShare? sha`
`1304`	`1304`	`var isRequiringExclusiveLockForParent = (flags & (FindNodeFlags.CreatePathIfNotExist \| FindNodeFlags.KeepParentNodeExclusive)) != 0;`
`1305`	`1305`
`1306`	`1306`	`var parentNode = _rootDirectory;`
`1307`		`- var names = path.Split();`
	`1307`	`+ var names = path.SpanSplit();`
`1308`	`1308`
`1309`	`1309`	`// Walking down the nodes in locking order:`
`1310`	`1310`	`// /a/b/c.txt`
`@@ -1324,21 +1324,25 @@ private NodeResult EnterFindNode(UPath path, FindNodeFlags flags, FileShare? sha`
`1324`	`1324`	`isParentLockTaken = true;`
`1325`	`1325`	`}`
`1326`	`1326`
`1327`		`- for (var i = 0; i < names.Count && parentNode != null; i++)`
	`1327`	`+ for (var i = 0; names.MoveNext() && parentNode != null; i++)`
`1328`	`1328`	`{`
`1329`		`- var name = names[i];`
	`1329`	`+ ReadOnlySpan<char> name = names.Current;`
`1330`	`1330`	`bool isLast = i + 1 == names.Count;`
`1331`	`1331`
`1332`	`1332`	`DirectoryNode? nextParent = null;`
`1333`	`1333`	`bool isNextParentLockTaken = false;`
`1334`	`1334`	`try`
`1335`	`1335`	`{`
`1336`	`1336`	`FileSystemNode? subNode;`
`1337`		`- if (!parentNode.Children.TryGetValue(name, out subNode))`
	`1337`	`+#if HAS_ALTERNATEEQUALITYCOMPARER`
	`1338`	`+ if (!parentNode.Children.GetAlternateLookup<ReadOnlySpan<char>>().TryGetValue(name, out subNode))`
	`1339`	`+#else`
	`1340`	`+ if (!parentNode.Children.TryGetValue(name.ToString(), out subNode))`
	`1341`	`+#endif`
`1338`	`1342`	`{`
`1339`	`1343`	`if ((flags & FindNodeFlags.CreatePathIfNotExist) != 0)`
`1340`	`1344`	`{`
`1341`		`- subNode = new DirectoryNode(this, parentNode, name);`
	`1345`	`+ subNode = new DirectoryNode(this, parentNode, name.ToString());`
`1342`	`1346`	`}`
`1343`	`1347`	`}`
`1344`	`1348`	`else`
`@@ -1361,7 +1365,7 @@ private NodeResult EnterFindNode(UPath path, FindNodeFlags flags, FileShare? sha`
`1361`	`1365`	`flags &= ~(FindNodeFlags.KeepParentNodeExclusive \| FindNodeFlags.KeepParentNodeShared);`
`1362`	`1366`	`}`
`1363`	`1367`
`1364`		`- result = new NodeResult(parentNode, subNode, name, flags);`
	`1368`	`+ result = new NodeResult(parentNode, subNode, name.ToString(), flags);`
`1365`	`1369`
`1366`	`1370`	`// The last subnode may be null but we still want to return a valid parent`
`1367`	`1371`	`// otherwise, lock the final node if necessary`
Original file line number	Diff line number	Diff line change
`@@ -196,18 +196,18 @@ protected override void CopyFileImpl(UPath srcPath, UPath destPath, bool overwri`
`196`	`196`
`197`	`197`	`if (srcEntry == null)`
`198`	`198`	`{`
`199`		`- if (!DirectoryExistsImpl(srcPath.GetDirectory()))`
	`199`	`+ if (!DirectoryExistsImpl(srcPath.GetDirectoryAsSpan()))`
`200`	`200`	`{`
`201`	`201`	`throw new DirectoryNotFoundException(srcPath.GetDirectory().FullName);`
`202`	`202`	`}`
`203`	`203`
`204`	`204`	`throw FileSystemExceptionHelper.NewFileNotFoundException(srcPath);`
`205`	`205`	`}`
`206`	`206`
`207`		`- var parentDirectory = destPath.GetDirectory();`
	`207`	`+ var parentDirectory = destPath.GetDirectoryAsSpan();`
`208`	`208`	`if (!DirectoryExistsImpl(parentDirectory))`
`209`	`209`	`{`
`210`		`- throw FileSystemExceptionHelper.NewDirectoryNotFoundException(parentDirectory);`
	`210`	`+ throw FileSystemExceptionHelper.NewDirectoryNotFoundException(parentDirectory.ToString());`
`211`	`211`	`}`
`212`	`212`
`213`	`213`	`if (DirectoryExistsImpl(destPath))`
`@@ -261,12 +261,12 @@ protected override void CreateDirectoryImpl(UPath path)`
`261`	`261`	`throw FileSystemExceptionHelper.NewDestinationDirectoryExistException(path);`
`262`	`262`	`}`
`263`	`263`
`264`		`- var parentPath = new UPath(GetParent(path.FullName));`
`265`		`- if (parentPath != "")`
	`264`	`+ var parentPath = GetParent(path.AsSpan());`
	`265`	`+ if (!parentPath.IsEmpty)`
`266`	`266`	`{`
`267`	`267`	`if (!DirectoryExistsImpl(parentPath))`
`268`	`268`	`{`
`269`		`- CreateDirectoryImpl(parentPath);`
	`269`	`+ CreateDirectoryImpl(parentPath.ToString());`
`270`	`270`	`}`
`271`	`271`	`}`
`272`	`272`
`@@ -405,7 +405,12 @@ protected override void DeleteFileImpl(UPath path)`
`405`	`405`	`/// <inheritdoc />`
`406`	`406`	`protected override bool DirectoryExistsImpl(UPath path)`
`407`	`407`	`{`
`408`		`- if (path.FullName is "/" or "\\" or "")`
	`408`	`+ return DirectoryExistsImpl(path.FullName.AsSpan());`
	`409`	`+ }`
	`410`	`+`
	`411`	`+ private bool DirectoryExistsImpl(ReadOnlySpan<char> path)`
	`412`	`+ {`
	`413`	`+ if (path is "/" or "\\" or "")`
`409`	`414`	`{`
`410`	`415`	`return true;`
`411`	`416`	`}`
`@@ -414,7 +419,11 @@ protected override bool DirectoryExistsImpl(UPath path)`
`414`	`419`
`415`	`420`	`try`
`416`	`421`	`{`
`417`		`- return _entries.TryGetValue(path, out var entry) && entry.IsDirectory;`
	`422`	`+#if HAS_ALTERNATEEQUALITYCOMPARER`
	`423`	`+ return _entries.GetAlternateLookup<ReadOnlySpan<char>>().TryGetValue(path, out var entry) && entry.IsDirectory;`
	`424`	`+#else`
	`425`	`+ return _entries.TryGetValue(path.ToString(), out var entry) && entry.IsDirectory;`
	`426`	`+#endif`
`418`	`427`	`}`
`419`	`428`	`finally`
`420`	`429`	`{`
`@@ -651,7 +660,7 @@ protected override void MoveFileImpl(UPath srcPath, UPath destPath)`
`651`	`660`	`{`
`652`	`661`	`var srcEntry = GetEntry(srcPath) ?? throw FileSystemExceptionHelper.NewFileNotFoundException(srcPath);`
`653`	`662`
`654`		`- if (!DirectoryExistsImpl(destPath.GetDirectory()))`
	`663`	`+ if (!DirectoryExistsImpl(destPath.GetDirectoryAsSpan()))`
`655`	`664`	`{`
`656`	`665`	`throw FileSystemExceptionHelper.NewDirectoryNotFoundException(destPath.GetDirectory());`
`657`	`666`	`}`
`@@ -706,7 +715,7 @@ protected override Stream OpenFileImpl(UPath path, FileMode mode, FileAccess acc`
`706`	`715`	`}`
`707`	`716`	`else`
`708`	`717`	`{`
`709`		`- if (!DirectoryExistsImpl(path.GetDirectory()))`
	`718`	`+ if (!DirectoryExistsImpl(path.GetDirectoryAsSpan()))`
`710`	`719`	`{`
`711`	`720`	`throw FileSystemExceptionHelper.NewDirectoryNotFoundException(path.GetDirectory());`
`712`	`721`	`}`
`@@ -911,18 +920,18 @@ private ZipArchiveEntry CreateEntry(UPath path, bool isDirectory = false)`
`911`	`920`
`912`	`921`	`private static readonly char[] s_slashChars = { '/', '\\' };`
`913`	`922`
`914`		`- private static string GetName(ZipArchiveEntry entry)`
	`923`	`+ private static ReadOnlySpan<char> GetName(ZipArchiveEntry entry)`
`915`	`924`	`{`
`916`	`925`	`var name = entry.FullName.TrimEnd(s_slashChars);`
`917`	`926`	`var index = name.LastIndexOfAny(s_slashChars);`
`918`		`- return name.Substring(index + 1);`
	`927`	`+ return index == -1 ? name.AsSpan() : name.AsSpan(index + 1);`
`919`	`928`	`}`
`920`	`929`
`921`		`- private static string GetParent(string path)`
	`930`	`+ private static ReadOnlySpan<char> GetParent(ReadOnlySpan<char> path)`
`922`	`931`	`{`
`923`	`932`	`path = path.TrimEnd(s_slashChars);`
`924`	`933`	`var lastIndex = path.LastIndexOfAny(s_slashChars);`
`925`		`- return lastIndex == -1 ? "" : path.Substring(0, lastIndex);`
	`934`	`+ return lastIndex == -1 ? ReadOnlySpan<char>.Empty : path.Slice(0, lastIndex);`
`926`	`935`	`}`
`927`	`936`
`928`	`937`	`private FileSystemEventDispatcher<FileSystemWatcher>? TryGetDispatcher()`