Performance optimization of FileSystem.CreateDirectory on windows

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

@@ -18,6 +18,14 @@ public static bool DirectoryExists(string? fullPath)
             return DirectoryExists(fullPath, out int lastError);
         }
 
+        private static Interop.Kernel32.WIN32_FILE_ATTRIBUTE_DATA GetAttributeData(string? path, out int lastError)
+        {
+            Interop.Kernel32.WIN32_FILE_ATTRIBUTE_DATA data = default;
+            lastError = FillAttributeInfo(path, ref data, true);
+
+            return data;
+        }
+
         private static bool DirectoryExists(string? path, out int lastError)
         {
             Interop.Kernel32.WIN32_FILE_ATTRIBUTE_DATA data = default;

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

@@ -1,13 +1,9 @@
 // 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;
 using System.Collections.Generic;
-using System.Diagnostics;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using System.IO;
-using System.Text;
 
 namespace System.IO
 {
@@ -26,39 +22,41 @@ public static unsafe void CreateDirectory(string fullPath, byte[]? securityDescr
                 return;
             }
 
-            List<string> stackDir = new List<string>();
+            List<string> stackDir = new();
 
             // Attempt to figure out which directories don't exist, and only
             // create the ones we need.  Note that FileExists may fail due
             // to Win32 ACL's preventing us from seeing a directory, and this
             // isn't threadsafe.
 
-            bool somepathexists = false;
-            int length = fullPath.Length;
+            bool somePathExists = false;
+
+            ReadOnlySpan<char> fullPathSpan = fullPath.AsSpan();
+            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.EndsInDirectorySeparator(fullPathSpan))
             {
                 length--;
             }
 
-            int lengthRoot = PathInternal.GetRootLength(fullPath.AsSpan());
+            int lengthRoot = PathInternal.GetRootLength(fullPathSpan);
 
             if (length > lengthRoot)
             {
                 // Special case root (fullpath = X:\\)
                 int i = length - 1;
-                while (i >= lengthRoot && !somepathexists)
+                while (i >= lengthRoot && !somePathExists)
                 {
-                    string dir = fullPath.Substring(0, i + 1);
+                    string dir = fullPath[..length];
 
                     if (!DirectoryExists(dir)) // Create only the ones missing
                     {
                         stackDir.Add(dir);
                     }
                     else
                     {
-                        somepathexists = true;
+                        somePathExists = true;
                     }
 
                     while (i > lengthRoot && !PathInternal.IsDirectorySeparator(fullPath[i]))
@@ -77,49 +75,64 @@ public static unsafe void CreateDirectory(string fullPath, byte[]? securityDescr
 
             fixed (byte* pSecurityDescriptor = securityDescriptor)
             {
-                Interop.Kernel32.SECURITY_ATTRIBUTES secAttrs = new Interop.Kernel32.SECURITY_ATTRIBUTES
+                Interop.Kernel32.SECURITY_ATTRIBUTES secAttrs = new()
                 {
                     nLength = (uint)sizeof(Interop.Kernel32.SECURITY_ATTRIBUTES),
                     lpSecurityDescriptor = (IntPtr)pSecurityDescriptor
                 };
 
                 while (stackDir.Count > 0)
                 {
-                    string name = stackDir[stackDir.Count - 1];
+                    string name = stackDir[^1];
                     stackDir.RemoveAt(stackDir.Count - 1);
 
                     r = Interop.Kernel32.CreateDirectory(name, ref secAttrs);
-                    if (!r && (firstError == 0))
+                    if (r || firstError != 0)
                     {
-                        int currentError = Marshal.GetLastWin32Error();
-                        // While we tried to avoid creating directories that don't
-                        // exist above, there are at least two cases that will
-                        // cause us to see ERROR_ALREADY_EXISTS here.  FileExists
-                        // can fail because we didn't have permission to the
-                        // directory.  Secondly, another thread or process could
-                        // create the directory between the time we check and the
-                        // time we try using the directory.  Thirdly, it could
-                        // fail because the target does exist, but is a file.
-                        if (currentError != Interop.Errors.ERROR_ALREADY_EXISTS)
-                        {
-                            firstError = currentError;
-                        }
-                        else
+                        continue;
+                    }
+
+                    int currentError = Marshal.GetLastWin32Error();
+                    // While we tried to avoid creating directories that don't
+                    // exist above, there are at least two cases that will
+                    // cause us to see ERROR_ALREADY_EXISTS here.  FileExists
+                    // can fail because we didn't have permission to the
+                    // directory.  Secondly, another thread or process could
+                    // create the directory between the time we check and the
+                    // time we try using the directory.  Thirdly, it could
+                    // fail because the target does exist, but is a file.
+                    if (currentError != Interop.Errors.ERROR_ALREADY_EXISTS)
+                    {
+                        firstError = currentError;
+                    }
+                    else
+                    {
+                        Interop.Kernel32.WIN32_FILE_ATTRIBUTE_DATA data = GetAttributeData(name, out currentError);
+                        int errorCode = FillAttributeInfo(fullPath, ref data, true);
+
+                        bool fileExists = errorCode == 0 &&
+                                          data.dwFileAttributes != -1 &&
+                                          (data.dwFileAttributes & Interop.Kernel32.FileAttributes.FILE_ATTRIBUTE_DIRECTORY) == 0;
+                        bool directoryExists = errorCode == 0 &&
+                                          data.dwFileAttributes != -1 &&
+                                          (data.dwFileAttributes & Interop.Kernel32.FileAttributes.FILE_ATTRIBUTE_DIRECTORY) != 0;
+
+                        // If there's a file in this directory's place, or if we have ERROR_ACCESS_DENIED when checking if the directory already exists throw.
+                        if (!fileExists && (directoryExists ||
+                                            currentError != Interop.Errors.ERROR_ACCESS_DENIED))
                         {
-                            // If there's a file in this directory's place, or if we have ERROR_ACCESS_DENIED when checking if the directory already exists throw.
-                            if (FileExists(name) || (!DirectoryExists(name, out currentError) && currentError == Interop.Errors.ERROR_ACCESS_DENIED))
-                            {
-                                firstError = currentError;
-                                errorString = name;
-                            }
+                            continue;
                         }
+
+                        firstError = currentError;
+                        errorString = name;
                     }
                 }
             }
 
             // We need this check to mask OS differences
             // Handle CreateDirectory("X:\\") when X: doesn't exist. Similarly for n/w paths.
-            if ((count == 0) && !somepathexists)
+            if (count == 0 && !somePathExists)
             {
                 string? root = Path.GetPathRoot(fullPath);
 
@@ -133,7 +146,7 @@ public static unsafe void CreateDirectory(string fullPath, byte[]? securityDescr
 
             // Only throw an exception if creating the exact directory we
             // wanted failed to work correctly.
-            if (!r && (firstError != 0))
+            if (!r && firstError != 0)
             {
                 throw Win32Marshal.GetExceptionForWin32Error(firstError, errorString);
             }

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

@@ -277,7 +277,7 @@ internal static bool IsPartiallyQualified(ReadOnlySpan<char> path)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal static bool IsDirectorySeparator(char c)
         {
-            return c == DirectorySeparatorChar || c == AltDirectorySeparatorChar;
+            return c is DirectorySeparatorChar or AltDirectorySeparatorChar;
         }
 
         /// <summary>

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

@@ -239,7 +239,7 @@ internal static ReadOnlySpan<char> TrimEndingDirectorySeparator(ReadOnlySpan<cha
         /// Returns true if the path ends in a directory separator.
         /// </summary>
         internal static bool EndsInDirectorySeparator(ReadOnlySpan<char> path) =>
-            path.Length > 0 && IsDirectorySeparator(path[path.Length - 1]);
+            path.Length > 0 && IsDirectorySeparator(path[^1]);
 
         internal static string GetLinkTargetFullPath(string path, string pathToTarget)
             => IsPartiallyQualified(pathToTarget.AsSpan()) ?