Verifica se esiste un file/directory: c'è un modo migliore?

Question

Mi trovo molto a fare questo solo per assicurarmi che il nome del file non sia in uso. C'è un modo migliore?

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

Answer 1

Certo :)

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

Answer 2

penso che sia l'unico modo. Generalmente ho una classe "FileManager" che ha metodi statici che incapsulano i metodi di I/O compresi quelli che hai indicato e poi li usano come "FileManager" su tutte le applicazioni come una libreria.

Answer 3

Un altro modo per verificare se il file esiste.

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

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

Answer 4

Nota che il fatto che si sta utilizzando esiste() per verificare la presenza di file o directory nome in uso è soggetto a condizioni di gara.

In qualsiasi momento dopo il test Exists(), è possibile che sia stato creato un file con quel nome prima che il codice raggiunga il punto in cui si crea un file, ad esempio.

(suppongo che sia una condizione eccezionale per il file già esistente).

È più semplice aprire semplicemente il file, specificando un parametro FileShare appropriato.

Esempio:

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

Così semplicemente gestire la IOException in caso di fallimento potrebbe causare codice più semplice meno soggetto a condizioni di gara, perché ora:

• Se qualcosa ha già creato il file , FileMode.CreateNew causerà il lancio di IOException
• Se l'apertura e la creazione hanno esito positivo, a causa di FileShare.None, nessun altro processo può accedere al file finché non lo si chiude.

Purtroppo, non è possibile verificare se un file è attualmente in uso, e non un'eccezione, senza qualche brutta 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); 
    } 

E questo controllo veloce è anche soggetto a condizioni di gara, a meno che non si restituisca l'handle del file da esso e lo si passi al relativo costruttore FileStream.

Answer 5

Il mio modo di controllare questo sta usando il FileSystemInfo, qui è il mio codice:

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

return info.Exists;