Sensible à la casse Répertoire.Existe / Fichier.Existe

Basé sur la solution de cette question, j'ai écrit le code ci-dessous qui est sensible à la casse pour les tout le chemin à l'exception de la lettre au Lecteur sous Windows:

 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;
   }

J'ai copié le code pour GetWindowsPhysicalPath(string path) de la question

  [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;
    }

Note le seul problème que j'ai trouvé avec cette fonction, la lettre de lecteur semble être toujours en minuscules. Exemple: Le chemin d'accès physique sur Windows: D:\Test\test.txt, le GetWindowsPhysicalPath(string path)fonction renvoie d:\Test\test.txt

OriginalL'auteur A-Sharabiani

Essayer ces 2 options plus simples qui n'ont pas besoin d'utiliser PInvoke et retour nullable Booléen (bool?). Je ne suis pas un spécialiste en la matière donc je ne sais si c'est le code le plus efficace, mais cela fonctionne pour moi.

Il suffit de passer un chemin d'accès et si le résultat est nul (HasValue = false) aucune correspondance n'est trouvée, si le résultat est faux il y a une correspondance exacte, sinon si c'est vrai il y a un match avec une différence de cas.

Les méthodes GetFiles, GetDirectories et GetDrives tous les restituer les cas enregistré sur votre système de fichiers, vous pouvez utiliser un cas sensible à la méthode de comparaison.

NB: pour le cas où le chemin est une exacte dans le lecteur (par exemple, @"C:\"), je dois utiliser une approche légèrement différente.

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;
}
}

OriginalL'auteur Glen