Vérifiez si un fichier/répertoire existe: existe-t-il un meilleur moyen?

Question

Je me retrouve souvent à faire cela juste pour m'assurer que le nom de fichier n'est pas utilisé. Y a-t-il un meilleur moyen?

Directory.Exists(name) || File.Exists(name) 

Answer 1

Bien sûr :)

internal static bool FileOrDirectoryExists(string name) 
{ 
    return (Directory.Exists(name) || File.Exists(name)); 
} 

Answer 2

Je pense que c'est la seule façon. J'ai généralement une classe "FileManager" qui possède des méthodes statiques encapsulant les méthodes d'E/S, y compris celles que vous avez indiquées, puis utilise ce "FileManager" dans toutes les applications en tant que bibliothèque.

Answer 3

Une autre façon de vérifier si le fichier existe.

FileInfo file = new FileInfo("file.txt"); 

if (file.Exists) 
{ 
    // TO DO 
} 

Answer 4

Notez que le fait que vous utilisez exists() pour vérifier le nom du fichier ou un répertoire utilisé est soumis à des conditions course.

À tout moment après que votre Exists() test est passé, quelque chose aurait pu créer un fichier portant ce nom avant que votre code n'atteigne le point où vous créez un fichier, par exemple.

(Je suppose que c'est une condition exceptionnelle pour que le fichier existe déjà).

Il est plus fiable d'ouvrir simplement le fichier en spécifiant un paramètre FileShare approprié.

Exemple:

using System; 
using System.IO; 

static class FileNameInUse 
{ 
    static void Main(string[] args) 
    { 
     string path = args[0]; 
     using (var stream = File.Open(path, FileMode.CreateNew, FileAccess.Write, FileShare.None)) 
     { 
      // Write to file 
     } 
    } 
} 

Donc manipulation simplement le IOException en cas d'échec peut entraîner un code plus simple moins sujette à des conditions de race, parce que maintenant:

• Si quelque chose a d'autre déjà créé le fichier , FileMode.CreateNew provoque un IOException être lancé
• Si votre ouvrir et créer réussit, à cause de FileShare.None, aucun autre processus ne peut accéder au fichier tant que vous ne le fermez pas.

Malheureusement, il est impossible de vérifier si un fichier est actuellement utilisé, et ne pas jeter une exception, sans une vilaine P/Invoke:

bool IsFileInUse(string fileName) 
    { 
      IntPtr hFile = Win32.CreateFile(fileName, Win32.FILE_READ_DATA, 0, IntPtr.Zero, Win32.OPEN_EXISTING, Win32.FILE_ATTRIBUTE_NORMAL, IntPtr.Zero); 
      if (hFile.ToInt32() == Win32.INVALID_HANDLE_VALUE) 
       return true; 

      Win32.CloseHandle(hFile); 
      return false; 
    } 

    class Win32 
    { 
     const uint FILE_READ_DATA = 0x0001; 
     const uint FILE_SHARE_NONE = 0x00000000; 
     const uint FILE_ATTRIBUTE_NORMAL = 0x00000080; 
     const uint OPEN_EXISTING = 3; 
     const int INVALID_HANDLE_VALUE = -1; 

     [DllImport("kernel32.dll", SetLastError=true)] 
     internal static extern IntPtr CreateFile(string lpFileName, 
               uint dwDesiredAccess, 
               uint dwShareMode, 
               IntPtr lpSecurityAttributes, 
               uint dwCreationDisposition, 
               uint dwFlagsAndAttributes, 
               IntPtr hTemplateFile); 

     [DllImport("kernel32.dll")] 
     internal static extern bool CloseHandle(IntPtr hObject); 
    } 

Et cette vérification rapide est également est vulnérable aux conditions de concurrence, sauf si vous lui renvoyez le handle de fichier et le transmettez au constructeur FileStream correspondant.

Answer 5

Ma façon de vérifier ce utilise le FileSystemInfo, voici mon code:

FileSystemInfo info = 
    File.GetAttributes(data.Path).HasFlag(FileAttributes.Directory) ? 
    new DirectoryInfo(data.Path) : (FileSystemInfo)new FileInfo(data.Path); 

return info.Exists;