Improve CreateDirectory on Windows

src/libraries/Common/src/Interop/Windows/Kernel32/Interop.CreateDirectory.cs

@@ -1,7 +1,6 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Microsoft.Win32.SafeHandles;
 using System.IO;
 using System.Runtime.InteropServices;
 
@@ -20,8 +19,9 @@ private static partial bool CreateDirectoryPrivate(
 
         internal static bool CreateDirectory(string path, ref SECURITY_ATTRIBUTES lpSecurityAttributes)
         {
-            // We always want to add for CreateDirectory to get around the legacy 248 character limitation
-            path = PathInternal.EnsureExtendedPrefix(path);
+            // If length is greater than `MaxShortDirectoryPath` we add a extended prefix to get around the legacy character limitation
+            path = PathInternal.EnsureExtendedPrefixIfNeeded(path);
+
             return CreateDirectoryPrivate(path, ref lpSecurityAttributes);
         }
     }

src/libraries/Common/src/Interop/Windows/Kernel32/Interop.FindFirstFileEx.cs

@@ -20,6 +20,11 @@ internal static SafeFindHandle FindFirstFile(string fileName, ref WIN32_FIND_DAT
         {
             fileName = PathInternal.EnsureExtendedPrefixIfNeeded(fileName);
 
+            // use FindExInfoBasic since we don't care about short name and it has better perf
+            return FindFirstFilePrefixed(fileName, ref data);
+        }
+        internal static SafeFindHandle FindFirstFilePrefixed(string fileName, ref WIN32_FIND_DATA data)
+        {
             // use FindExInfoBasic since we don't care about short name and it has better perf
             return FindFirstFileExPrivate(fileName, FINDEX_INFO_LEVELS.FindExInfoBasic, ref data, FINDEX_SEARCH_OPS.FindExSearchNameMatch, IntPtr.Zero, 0);
         }

src/libraries/Common/src/Interop/Windows/Kernel32/Interop.GetFileAttributesEx.cs

@@ -21,6 +21,10 @@ private static partial bool GetFileAttributesExPrivate(
         internal static bool GetFileAttributesEx(string? name, GET_FILEEX_INFO_LEVELS fileInfoLevel, ref WIN32_FILE_ATTRIBUTE_DATA lpFileInformation)
         {
             name = PathInternal.EnsureExtendedPrefixIfNeeded(name);
+            return GetFileAttributesExPrefixed(name, fileInfoLevel, ref lpFileInformation);
+        }
+        internal static bool GetFileAttributesExPrefixed(string? name, GET_FILEEX_INFO_LEVELS fileInfoLevel, ref WIN32_FILE_ATTRIBUTE_DATA lpFileInformation)
+        {
             return GetFileAttributesExPrivate(name, fileInfoLevel, ref lpFileInformation);
         }
     }

src/libraries/Common/src/System/IO/FileSystem.Attributes.Windows.cs

@@ -29,6 +29,17 @@ private static bool DirectoryExists(string? path, out int lastError)
                 ((data.dwFileAttributes & Interop.Kernel32.FileAttributes.FILE_ATTRIBUTE_DIRECTORY) != 0);
         }
 
+        private static bool DirectoryExistsSlim(string? path, out int lastError)
+        {
+            Interop.Kernel32.WIN32_FILE_ATTRIBUTE_DATA data = default;
+            lastError = FillAttributeInfoSlim(path, ref data, returnErrorOnNotFound: true);
+
+            return
+                (lastError == 0) &&
+                (data.dwFileAttributes != -1) &&
+                ((data.dwFileAttributes & Interop.Kernel32.FileAttributes.FILE_ATTRIBUTE_DIRECTORY) != 0);
+        }
+
         public static bool FileExists(string fullPath)
         {
             Interop.Kernel32.WIN32_FILE_ATTRIBUTE_DATA data = default;
@@ -49,53 +60,64 @@ public static bool FileExists(string fullPath)
         /// <param name="returnErrorOnNotFound">Return the error code for not found errors?</param>
         internal static int FillAttributeInfo(string? path, ref Interop.Kernel32.WIN32_FILE_ATTRIBUTE_DATA data, bool returnErrorOnNotFound)
         {
-            int errorCode = Interop.Errors.ERROR_SUCCESS;
-
             // Neither GetFileAttributes or FindFirstFile like trailing separators
             path = PathInternal.TrimEndingDirectorySeparator(path);
 
             using (DisableMediaInsertionPrompt.Create())
             {
-                if (!Interop.Kernel32.GetFileAttributesEx(path, Interop.Kernel32.GET_FILEEX_INFO_LEVELS.GetFileExInfoStandard, ref data))
+                return FillAttributeInfoSlim(path, ref data, returnErrorOnNotFound);
+            }
+        }
+
+        /// <summary>
+        /// Same as <see cref="FillAttributeInfo"/> without separator-trimming and media-insertion blocking
+        /// </summary>
+        /// <param name="path">The file path from which the file attribute information will be filled.</param>
+        /// <param name="data">A struct that will contain the attribute information.</param>
+        /// <param name="returnErrorOnNotFound">Return the error code for not found errors?</param>
+        internal static int FillAttributeInfoSlim(string? path, ref Interop.Kernel32.WIN32_FILE_ATTRIBUTE_DATA data, bool returnErrorOnNotFound)
+        {
+            int errorCode = Interop.Errors.ERROR_SUCCESS;
+            string? prefixedString = PathInternal.EnsureExtendedPrefixIfNeeded(path);
+
+            if (!Interop.Kernel32.GetFileAttributesExPrefixed(prefixedString, Interop.Kernel32.GET_FILEEX_INFO_LEVELS.GetFileExInfoStandard, ref data))
+            {
+                errorCode = Marshal.GetLastWin32Error();
+
+                Interop.Kernel32.WIN32_FIND_DATA findData = default;
+                if (!IsPathUnreachableError(errorCode))
                 {
-                    errorCode = Marshal.GetLastWin32Error();
+                    // Assert so we can track down other cases (if any) to add to our test suite
+                    Debug.Assert(errorCode is Interop.Errors.ERROR_ACCESS_DENIED or Interop.Errors.ERROR_SHARING_VIOLATION or Interop.Errors.ERROR_SEM_TIMEOUT,
+                        $"Unexpected error code getting attributes {errorCode} from path {path}");
+
+                    // Files that are marked for deletion will not let you GetFileAttributes,
+                    // ERROR_ACCESS_DENIED is given back without filling out the data struct.
+                    // FindFirstFile, however, will. Historically we always gave back attributes
+                    // for marked-for-deletion files.
+                    //
+                    // Another case where enumeration works is with special system files such as
+                    // pagefile.sys that give back ERROR_SHARING_VIOLATION on GetAttributes.
+                    //
+                    // Ideally we'd only try again for known cases due to the potential performance
+                    // hit. The last attempt to do so baked for nearly a year before we found the
+                    // pagefile.sys case. As such we're probably stuck filtering out specific
+                    // cases that we know we don't want to retry on.
 
-                    if (!IsPathUnreachableError(errorCode))
+                    using SafeFindHandle handle = Interop.Kernel32.FindFirstFilePrefixed(prefixedString!, ref findData);
+                    if (handle.IsInvalid)
                     {
-                        // Assert so we can track down other cases (if any) to add to our test suite
-                        Debug.Assert(errorCode == Interop.Errors.ERROR_ACCESS_DENIED || errorCode == Interop.Errors.ERROR_SHARING_VIOLATION || errorCode == Interop.Errors.ERROR_SEM_TIMEOUT,
-                            $"Unexpected error code getting attributes {errorCode} from path {path}");
-
-                        // Files that are marked for deletion will not let you GetFileAttributes,
-                        // ERROR_ACCESS_DENIED is given back without filling out the data struct.
-                        // FindFirstFile, however, will. Historically we always gave back attributes
-                        // for marked-for-deletion files.
-                        //
-                        // Another case where enumeration works is with special system files such as
-                        // pagefile.sys that give back ERROR_SHARING_VIOLATION on GetAttributes.
-                        //
-                        // Ideally we'd only try again for known cases due to the potential performance
-                        // hit. The last attempt to do so baked for nearly a year before we found the
-                        // pagefile.sys case. As such we're probably stuck filtering out specific
-                        // cases that we know we don't want to retry on.
-
-                        Interop.Kernel32.WIN32_FIND_DATA findData = default;
-                        using (SafeFindHandle handle = Interop.Kernel32.FindFirstFile(path!, ref findData))
-                        {
-                            if (handle.IsInvalid)
-                            {
-                                errorCode = Marshal.GetLastWin32Error();
-                            }
-                            else
-                            {
-                                errorCode = Interop.Errors.ERROR_SUCCESS;
-                                data.PopulateFrom(ref findData);
-                            }
-                        }
+                        errorCode = Marshal.GetLastWin32Error();
+                    }
+                    else
+                    {
+                        errorCode = Interop.Errors.ERROR_SUCCESS;
+                        data.PopulateFrom(ref findData);
                     }
                 }
             }
 
+
             if (errorCode != Interop.Errors.ERROR_SUCCESS && !returnErrorOnNotFound)
             {
                 switch (errorCode)

src/libraries/Common/src/System/IO/FileSystem.DirectoryCreation.Windows.cs

@@ -34,39 +34,49 @@ public static unsafe void CreateDirectory(string fullPath, byte[]? securityDescr
             // isn't threadsafe.
 
             bool somepathexists = false;
-            int length = fullPath.Length;
+
+            ReadOnlySpan<char> fullPathSpan = fullPath;
+            int length = fullPathSpan.Length;
 
             // We need to trim the trailing slash or the code will try to create 2 directories of the same name.
-            if (length >= 2 && PathInternal.EndsInDirectorySeparator(fullPath.AsSpan()))
+            if (length >= 2 && PathInternal.EndsInDirectorySeparatorUnchecked(fullPathSpan))
             {
                 length--;
             }
 
-            int lengthRoot = PathInternal.GetRootLength(fullPath.AsSpan());
+            int lengthRoot = PathInternal.GetRootLength(fullPathSpan);
 
-            if (length > lengthRoot)
+            using (DisableMediaInsertionPrompt.Create())
             {
-                // Special case root (fullpath = X:\\)
-                int i = length - 1;
-                while (i >= lengthRoot && !somepathexists)
+                if (length > lengthRoot)
                 {
-                    string dir = fullPath.Substring(0, i + 1);
-
-                    if (!DirectoryExists(dir)) // Create only the ones missing
+                    // Special case root (fullpath = X:\\)
+                    int i = length - 1;
+                    while (i >= lengthRoot && !somepathexists)
                     {
-                        stackDir.Add(dir);
-                    }
-                    else
-                    {
-                        somepathexists = true;
-                    }
+                        ReadOnlySpan<char> dir = fullPathSpan[..(i + 1)];
+
+                        // Neither GetFileAttributes or FindFirstFile like trailing separators
+                        dir = PathInternal.TrimEndingDirectorySeparator(dir);
+
+                        string dirString = new(dir);
+
+                        if (!DirectoryExistsSlim(dirString, out _)) // Create only the ones missing
+                        {
+                            stackDir.Add(dirString);
+                        }
+                        else
+                        {
+                            somepathexists = true;
+                        }
+
+                        while (i > lengthRoot && !PathInternal.IsDirectorySeparator(fullPath[i]))
+                        {
+                            i--;
+                        }
 
-                    while (i > lengthRoot && !PathInternal.IsDirectorySeparator(fullPath[i]))
-                    {
                         i--;
                     }
-
-                    i--;
                 }
             }
 
@@ -83,10 +93,9 @@ public static unsafe void CreateDirectory(string fullPath, byte[]? securityDescr
                     lpSecurityDescriptor = (IntPtr)pSecurityDescriptor
                 };
 
-                while (stackDir.Count > 0)
+                for (int i = count - 1; i >= 0; i--)
                 {
-                    string name = stackDir[stackDir.Count - 1];
-                    stackDir.RemoveAt(stackDir.Count - 1);
+                    string name = stackDir[i];
 
                     r = Interop.Kernel32.CreateDirectory(name, ref secAttrs);
                     if (!r && (firstError == 0))
@@ -121,11 +130,12 @@ public static unsafe void CreateDirectory(string fullPath, byte[]? securityDescr
             // Handle CreateDirectory("X:\\") when X: doesn't exist. Similarly for n/w paths.
             if ((count == 0) && !somepathexists)
             {
-                string? root = Path.GetPathRoot(fullPath);
+                ReadOnlySpan<char> root = Path.GetPathRoot(fullPathSpan);
+                string rootString = new(root);
 
-                if (!DirectoryExists(root))
+                if (!DirectoryExists(rootString))
                 {
-                    throw Win32Marshal.GetExceptionForWin32Error(Interop.Errors.ERROR_PATH_NOT_FOUND, root);
+                    throw Win32Marshal.GetExceptionForWin32Error(Interop.Errors.ERROR_PATH_NOT_FOUND, rootString);
                 }
 
                 return;

src/libraries/Common/src/System/IO/PathInternal.Windows.cs

@@ -72,11 +72,11 @@ internal static bool IsValidDriveChar(char value)
             return (value >= 'A' && value <= 'Z') || (value >= 'a' && value <= 'z');
         }
 
-        internal static bool EndsWithPeriodOrSpace(string? path)
-        {
-            if (string.IsNullOrEmpty(path))
-                return false;
+        internal static bool EndsWithPeriodOrSpace(string? path) =>
+            !string.IsNullOrEmpty(path) && EndsWithPeriodOrSpaceSlim(path);
 
+        internal static bool EndsWithPeriodOrSpaceSlim(string path)
+        {
             char c = path[path.Length - 1];
             return c == ' ' || c == '.';
         }
@@ -91,7 +91,7 @@ internal static bool EndsWithPeriodOrSpace(string? path)
         [return: NotNullIfNotNull("path")]
         internal static string? EnsureExtendedPrefixIfNeeded(string? path)
         {
-            if (path != null && (path.Length >= MaxShortPath || EndsWithPeriodOrSpace(path)))
+            if (path != null && (path.Length >= MaxShortPath || EndsWithPeriodOrSpaceSlim(path)))
             {
                 return EnsureExtendedPrefix(path);
             }

src/libraries/Common/src/System/IO/PathInternal.cs

@@ -241,6 +241,12 @@ internal static ReadOnlySpan<char> TrimEndingDirectorySeparator(ReadOnlySpan<cha
         internal static bool EndsInDirectorySeparator(ReadOnlySpan<char> path) =>
             path.Length > 0 && IsDirectorySeparator(path[path.Length - 1]);
 
+        /// <summary>
+        /// Same as <see cref="EndsInDirectorySeparator(string?)"/> but without length check.
+        /// </summary>
+        internal static bool EndsInDirectorySeparatorUnchecked(ReadOnlySpan<char> path) =>
+            IsDirectorySeparator(path[^1]);
+
         internal static string GetLinkTargetFullPath(string path, string pathToTarget)
             => IsPartiallyQualified(pathToTarget.AsSpan()) ?
                 Path.Join(Path.GetDirectoryName(path.AsSpan()), pathToTarget.AsSpan()) : pathToTarget;