Case sensitive-Verzeichnis.Existiert / - Datei.Existiert

Basiert auf der Lösung von diese Frage, schrieb ich den folgenden code die groß - /Kleinschreibung ist für die ganzen Weg außer der Windows-Laufwerksbuchstabe:

 static void Main(string[] args)
    {
        string file1 = @"D:\tESt\Test.txt";
        string file2 = @"d:\Test\test.txt";
        string file3 = @"d:\test\notexists.txt";

        bool exists1 = Case_Sensitive_File_Exists(file1);
        bool exists2 = Case_Sensitive_File_Exists(file2);
        bool exists3 = Case_Sensitive_File_Exists(file3);

        Console.WriteLine("\n\nPress any key...");
        Console.ReadKey();
    }

   static bool Case_Sensitive_File_Exists(string filepath)
   {
        string physicalPath = GetWindowsPhysicalPath(filepath);
        if (physicalPath == null) return false;
        if (filepath != physicalPath) return false;
        else return true;
   }

Kopierte ich den code für GetWindowsPhysicalPath(string path) aus die Frage

  [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
    static extern uint GetLongPathName(string ShortPath, StringBuilder sb, int buffer);

    [DllImport("kernel32.dll")]
    static extern uint GetShortPathName(string longpath, StringBuilder sb, int buffer);

    protected static string GetWindowsPhysicalPath(string path)
    {
        StringBuilder builder = new StringBuilder(255);

        //names with long extension can cause the short name to be actually larger than
        //the long name.
        GetShortPathName(path, builder, builder.Capacity);

        path = builder.ToString();

        uint result = GetLongPathName(path, builder, builder.Capacity);

        if (result > 0 && result < builder.Capacity)
        {
            //Success retrieved long file name
            builder[0] = char.ToLower(builder[0]);
            return builder.ToString(0, (int)result);
        }

        if (result > 0)
        {
            //Need more capacity in the buffer
            //specified in the result variable
            builder = new StringBuilder((int)result);
            result = GetLongPathName(path, builder, builder.Capacity);
            builder[0] = char.ToLower(builder[0]);
            return builder.ToString(0, (int)result);
        }

        return null;
    }

Hinweis das einzige problem fand ich mit dieser Funktion wird der Laufwerksbuchstabe scheint immer in Kleinbuchstaben. Beispiel: Der physikalische Pfad auf Windows: D:\Test\test.txt, die GetWindowsPhysicalPath(string path)Funktion gibt d:\Test\test.txt

Versuchen Sie, diese 2 einfachere Möglichkeiten, die Sie nicht verwenden müssen PInvoke und zurück eine null-Boolean (bool?). Ich bin kein Fach-Experte, damit ich weiß, ob dies der effizienteste code, aber es funktioniert für mich.

Pass einfach in einen Pfad, und wenn das Ergebnis null ist (HasValue = false) keine übereinstimmung gefunden wird, wenn das Ergebnis false es ist eine exakte übereinstimmung, ansonsten, wenn es wahr ist, ein match mit einem Unterschied Fall.

Methoden GetFiles, GetDirectories und GetDrives alle Rückkehr der genaue Fall als gespeichert auf Ihrem Datei-system, so können Sie zwischen groß-und Kleinschreibung Methode vergleichen.

NB: für den Fall, wo der Pfad eine genaue Laufwerk (z.B. @"C:\"), ich habe mit einem etwas anderen Ansatz.

using System.IO;
class MyFolderFileHelper {
    public static bool? FileExistsWithDifferentCase(string fileName)
    {
        bool? result = null;
        if (File.Exists(fileName))
        {
            result = false;
            string directory = Path.GetDirectoryName(fileName);
            string fileTitle = Path.GetFileName(fileName);
            string[] files = Directory.GetFiles(directory, fileTitle);
            if (String.Compare(files[0], fileName, false) != 0)
                result = true;                
        }
        return result;
    }

    public static bool? DirectoryExistsWithDifferentCase(string directoryName)
    {
        bool? result = null;
        if (Directory.Exists(directoryName))
        {
            result = false;
            directoryName = directoryName.TrimEnd(Path.DirectorySeparatorChar);

            int lastPathSeparatorIndex = directoryName.LastIndexOf(Path.DirectorySeparatorChar);
            if (lastPathSeparatorIndex >= 0)
            {                       
                string baseDirectory = directoryName.Substring(lastPathSeparatorIndex + 1);
                string parentDirectory = directoryName.Substring(0, lastPathSeparatorIndex);

                string[] directories = Directory.GetDirectories(parentDirectory, baseDirectory);
                if (String.Compare(directories[0], directoryName, false) != 0)
                    result = true;
            }
            else
            {
                //if directory is a drive
                directoryName += Path.DirectorySeparatorChar.ToString();
                DriveInfo[] drives = DriveInfo.GetDrives();
                foreach(DriveInfo driveInfo in drives)
                {
                    if (String.Compare(driveInfo.Name, directoryName, true) == 0)
                    {
                        if (String.Compare(driveInfo.Name, directoryName, false) != 0)
                            result = true;
                        break;
                    }
                }

            }
        }
        return result;
    }
}