C'è un modo per verificare se un file è in uso?

Sto scrivendo un programma in C # che deve accedere ripetutamente a 1 file di immagine. Il più delle volte funziona, ma se il mio computer sta funzionando velocemente, proverà ad accedere al file prima che sia stato salvato nel file system e genererà un errore: "File in uso da un altro processo" .

Vorrei trovare un modo per aggirare questo problema, ma tutto il mio Google ha ceduto alla creazione di controlli utilizzando la gestione delle eccezioni. Questo è contro la mia religione, quindi mi chiedevo se qualcuno ha un modo migliore di farlo?

NOTA aggiornata su questa soluzione : la verifica con FileAccess.ReadWritenon riuscirà per i file di sola lettura, quindi la soluzione è stata modificata per verificare FileAccess.Read. Mentre questa soluzione funziona perché prova a verificareFileAccess.Read fallirà se il file ha un blocco di scrittura o lettura, tuttavia, questa soluzione non funzionerà se il file non ha un blocco di scrittura o lettura, ovvero è stato aperto (per leggere o scrivere) con accesso a FileShare.Read o FileShare.Write.

ORIGINALE: ho usato questo codice negli ultimi anni e non ho avuto problemi con esso.

Comprendi la tua esitazione sull'uso delle eccezioni, ma non puoi evitarle tutte le volte:

protected virtual bool IsFileLocked(FileInfo file)
{
    try
    {
        using(FileStream stream = file.Open(FileMode.Open, FileAccess.Read, FileShare.None))
        {
            stream.Close();
        }
    }
    catch (IOException)
    {
        //the file is unavailable because it is:
        //still being written to
        //or being processed by another thread
        //or does not exist (has already been processed)
        return true;
    }

    //file is not locked
    return false;
}

Puoi soffrire di una condizione di competizione di thread su questo che ci sono esempi documentati di questo usato come vulnerabilità di sicurezza. Se controlli che il file sia disponibile, ma poi prova a usarlo, potresti lanciarlo a quel punto, che un utente malintenzionato potrebbe usare per forzare e sfruttare il tuo codice.

La tua scommessa migliore è un tentativo di cattura / finalmente che cerca di ottenere l'handle del file.

try
{
   using (Stream stream = new FileStream("MyFilename.txt", FileMode.Open))
   {
        // File/Stream manipulating code here
   }
} catch {
  //check here why it failed and ask user to retry if the file is in use.
}

Usa questo per verificare se un file è bloccato:

using System.IO;
using System.Runtime.InteropServices;
internal static class Helper
{
const int ERROR_SHARING_VIOLATION = 32;
const int ERROR_LOCK_VIOLATION = 33;

private static bool IsFileLocked(Exception exception)
{
    int errorCode = Marshal.GetHRForException(exception) & ((1 << 16) - 1);
    return errorCode == ERROR_SHARING_VIOLATION || errorCode == ERROR_LOCK_VIOLATION;
}

internal static bool CanReadFile(string filePath)
{
    //Try-Catch so we dont crash the program and can check the exception
    try {
        //The "using" is important because FileStream implements IDisposable and
        //"using" will avoid a heap exhaustion situation when too many handles  
        //are left undisposed.
        using (FileStream fileStream = File.Open(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.None)) {
            if (fileStream != null) fileStream.Close();  //This line is me being overly cautious, fileStream will never be null unless an exception occurs... and I know the "using" does it but its helpful to be explicit - especially when we encounter errors - at least for me anyway!
        }
    }
    catch (IOException ex) {
        //THE FUNKY MAGIC - TO SEE IF THIS FILE REALLY IS LOCKED!!!
        if (IsFileLocked(ex)) {
            // do something, eg File.Copy or present the user with a MsgBox - I do not recommend Killing the process that is locking the file
            return false;
        }
    }
    finally
    { }
    return true;
}
}

Per motivi di prestazioni, ti consiglio di leggere il contenuto del file nella stessa operazione. Ecco alcuni esempi:

public static byte[] ReadFileBytes(string filePath)
{
    byte[] buffer = null;
    try
    {
        using (FileStream fileStream = File.Open(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
        {
            int length = (int)fileStream.Length;  // get file length
            buffer = new byte[length];            // create buffer
            int count;                            // actual number of bytes read
            int sum = 0;                          // total number of bytes read

            // read until Read method returns 0 (end of the stream has been reached)
            while ((count = fileStream.Read(buffer, sum, length - sum)) > 0)
                sum += count;  // sum is a buffer offset for next reading

            fileStream.Close(); //This is not needed, just me being paranoid and explicitly releasing resources ASAP
        }
    }
    catch (IOException ex)
    {
        //THE FUNKY MAGIC - TO SEE IF THIS FILE REALLY IS LOCKED!!!
        if (IsFileLocked(ex))
        {
            // do something? 
        }
    }
    catch (Exception ex)
    {
    }
    finally
    {
    }
    return buffer;
}

public static string ReadFileTextWithEncoding(string filePath)
{
    string fileContents = string.Empty;
    byte[] buffer;
    try
    {
        using (FileStream fileStream = File.Open(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
        {
            int length = (int)fileStream.Length;  // get file length
            buffer = new byte[length];            // create buffer
            int count;                            // actual number of bytes read
            int sum = 0;                          // total number of bytes read

            // read until Read method returns 0 (end of the stream has been reached)
            while ((count = fileStream.Read(buffer, sum, length - sum)) > 0)
            {
                sum += count;  // sum is a buffer offset for next reading
            }

            fileStream.Close(); //Again - this is not needed, just me being paranoid and explicitly releasing resources ASAP

            //Depending on the encoding you wish to use - I'll leave that up to you
            fileContents = System.Text.Encoding.Default.GetString(buffer);
        }
    }
    catch (IOException ex)
    {
        //THE FUNKY MAGIC - TO SEE IF THIS FILE REALLY IS LOCKED!!!
        if (IsFileLocked(ex))
        {
            // do something? 
        }
    }
    catch (Exception ex)
    {
    }
    finally
    { }     
    return fileContents;
}

public static string ReadFileTextNoEncoding(string filePath)
{
    string fileContents = string.Empty;
    byte[] buffer;
    try
    {
        using (FileStream fileStream = File.Open(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
        {
            int length = (int)fileStream.Length;  // get file length
            buffer = new byte[length];            // create buffer
            int count;                            // actual number of bytes read
            int sum = 0;                          // total number of bytes read

            // read until Read method returns 0 (end of the stream has been reached)
            while ((count = fileStream.Read(buffer, sum, length - sum)) > 0) 
            {
                sum += count;  // sum is a buffer offset for next reading
            }

            fileStream.Close(); //Again - this is not needed, just me being paranoid and explicitly releasing resources ASAP

            char[] chars = new char[buffer.Length / sizeof(char) + 1];
            System.Buffer.BlockCopy(buffer, 0, chars, 0, buffer.Length);
            fileContents = new string(chars);
        }
    }
    catch (IOException ex)
    {
        //THE FUNKY MAGIC - TO SEE IF THIS FILE REALLY IS LOCKED!!!
        if (IsFileLocked(ex))
        {
            // do something? 
        }
    }
    catch (Exception ex)
    {
    }
    finally
    {
    }

    return fileContents;
}

Provalo tu stesso:

byte[] output1 = Helper.ReadFileBytes(@"c:\temp\test.txt");
string output2 = Helper.ReadFileTextWithEncoding(@"c:\temp\test.txt");
string output3 = Helper.ReadFileTextNoEncoding(@"c:\temp\test.txt");

Usa l'eccezione come previsto. Accettare che il file sia in uso e riprovare, ripetutamente fino al completamento dell'azione. Questo è anche il più efficace perché non sprechi alcun ciclo controllando lo stato prima di agire.

Utilizzare la funzione seguente, ad esempio

TimeoutFileAction(() => { System.IO.File.etc...; return null; } );

Metodo riutilizzabile che scade dopo 2 secondi

private T TimeoutFileAction<T>(Func<T> func)
{
    var started = DateTime.UtcNow;
    while ((DateTime.UtcNow - started).TotalMilliseconds < 2000)
    {
        try
        {
            return func();                    
        }
        catch (System.IO.IOException exception)
        {
            //ignore, or log somewhere if you want to
        }
    }
    return default(T);
}

Forse potresti usare un FileSystemWatcher e guardare l'evento Changed.

Non l'ho usato da solo, ma potrebbe valere la pena provare. Se il filesystemwatcher risulta essere un po 'pesante per questo caso, sceglierei il ciclo try / catch / sleep.

Puoi restituire un'attività che ti dà uno stream non appena diventa disponibile. È una soluzione semplificata, ma è un buon punto di partenza. È thread-safe.

private async Task<Stream> GetStreamAsync()
{
    try
    {
        return new FileStream("sample.mp3", FileMode.Open, FileAccess.Write);
    }
    catch (IOException)
    {
        await Task.Delay(TimeSpan.FromSeconds(1));
        return await GetStreamAsync();
    }
}

Puoi usare questo stream come al solito:

using (var stream = await FileStreamGetter.GetStreamAsync())
{
    Console.WriteLine(stream.Length);
}

l'unico modo che conosco è usare l'API di blocco esclusivo Win32 che non è troppo veloce, ma esistono esempi.

Molte persone, per una semplice soluzione a questo, semplicemente per provare / catturare / dormire loop.

static bool FileInUse(string path)
    {
        try
        {
            using (FileStream fs = new FileStream(path, FileMode.OpenOrCreate))
            {
                fs.CanWrite
            }
            return false;
        }
        catch (IOException ex)
        {
            return true;
        }
    }

string filePath = "C:\\Documents And Settings\\yourfilename";
bool isFileInUse;

isFileInUse = FileInUse(filePath);

// Then you can do some checking
if (isFileInUse)
   Console.WriteLine("File is in use");
else
   Console.WriteLine("File is not in use");

Spero che sia di aiuto!

Le risposte accettate sopra presentano un problema in cui se il file è stato aperto per la scrittura con una modalità FileShare.Read o se il file ha un attributo di sola lettura il codice non funzionerà. Questa soluzione modificata funziona in modo più affidabile, con due cose da tenere a mente (vero anche per la soluzione accettata):

1. Non funzionerà per i file che sono stati aperti con una modalità di condivisione in scrittura
2. Ciò non tiene conto dei problemi di threading, quindi sarà necessario bloccarlo o gestirli separatamente.

Tenendo presente quanto sopra, questo controlla se il file è bloccato per la scrittura o bloccato per impedire la lettura :

public static bool FileLocked(string FileName)
{
    FileStream fs = null;

    try
    {
        // NOTE: This doesn't handle situations where file is opened for writing by another process but put into write shared mode, it will not throw an exception and won't show it as write locked
        fs = File.Open(FileName, FileMode.Open, FileAccess.ReadWrite, FileShare.None); // If we can't open file for reading and writing then it's locked by another process for writing
    }
    catch (UnauthorizedAccessException) // https://msdn.microsoft.com/en-us/library/y973b725(v=vs.110).aspx
    {
        // This is because the file is Read-Only and we tried to open in ReadWrite mode, now try to open in Read only mode
        try
        {
            fs = File.Open(FileName, FileMode.Open, FileAccess.Read, FileShare.None);
        }
        catch (Exception)
        {
            return true; // This file has been locked, we can't even open it to read
        }
    }
    catch (Exception)
    {
        return true; // This file has been locked
    }
    finally
    {
        if (fs != null)
            fs.Close();
    }
    return false;
}

Oltre a lavorare con 3 righe e solo per riferimento: se vuoi le informazioni complete , c'è un piccolo progetto su Microsoft Dev Center:

https://code.msdn.microsoft.com/windowsapps/How-to-know-the-process-704839f4

Dall'introduzione:

Il codice di esempio C # sviluppato in .NET Framework 4.0 aiuterebbe a scoprire qual è il processo che ha un blocco su un file. La funzione RmStartSession inclusa in rstrtmgr.dll è stata utilizzata per creare una sessione del gestore riavvio e, in base al risultato restituito, viene creata una nuova istanza dell'oggetto Win32Exception. Dopo aver registrato le risorse per una sessione di Gestione riavvio via RmRegisterRescources funzione, RmGetList funzione viene richiamata per verificare quali sono le applicazioni utilizzano un particolare file enumerando il RM_PROCESS_INFO array.

Funziona connettendosi alla "Restart Manager Session".

Restart Manager utilizza l'elenco delle risorse registrate con la sessione per determinare quali applicazioni e servizi devono essere chiusi e riavviati. Le risorse possono essere identificate da nomi di file, nomi abbreviati del servizio o strutture RM_UNIQUE_PROCESS che descrivono le applicazioni in esecuzione.

Potrebbe essere un po 'troppo ingegnerizzato per le tue esigenze particolari ... Ma se è quello che vuoi, vai avanti e prendi il vs-project.

Nella mia esperienza, di solito vuoi farlo, quindi "proteggere" i tuoi file per fare qualcosa di elegante e quindi utilizzare i file "protetti". Se hai un solo file che vuoi usare in questo modo, puoi usare il trucco spiegato nella risposta di Jeremy Thompson. Tuttavia, se si tenta di eseguire questa operazione su molti file (ad esempio, quando si scrive un programma di installazione), ci si sente un po 'feriti.

Un modo molto elegante che può essere risolto è usando il fatto che il tuo file system non ti permetterà di cambiare il nome di una cartella se uno dei file lì viene utilizzato. Mantieni la cartella nello stesso file system e funzionerà come un incantesimo.

Nota che dovresti essere consapevole dei modi ovvi in ​​cui questo può essere sfruttato. Dopotutto, i file non saranno bloccati. Inoltre, tenere presente che esistono altri motivi per cui l' Moveoperazione potrebbe non riuscire. Ovviamente la corretta gestione degli errori (MSDN) può essere d'aiuto qui.

var originalFolder = @"c:\myHugeCollectionOfFiles"; // your folder name here
var someFolder = Path.Combine(originalFolder, "..", Guid.NewGuid().ToString("N"));

try
{
    Directory.Move(originalFolder, someFolder);

    // Use files
}
catch // TODO: proper exception handling
{
    // Inform user, take action
}
finally
{
    Directory.Move(someFolder, originalFolder);
}

Per i singoli file rimarrei con il suggerimento di blocco pubblicato da Jeremy Thompson.

Ecco un po 'di codice che, per quanto posso dire, fa la stessa cosa della risposta accettata ma con meno codice:

    public static bool IsFileLocked(string file)
    {
        try
        {
            using (var stream = File.OpenRead(file))
                return false;
        }
        catch (IOException)
        {
            return true;
        }        
    }

Tuttavia, penso che sia più robusto farlo nel modo seguente:

    public static void TryToDoWithFileStream(string file, Action<FileStream> action, 
        int count, int msecTimeOut)
    {
        FileStream stream = null;
        for (var i = 0; i < count; ++i)
        {
            try
            {
                stream = File.OpenRead(file);
                break;
            }
            catch (IOException)
            {
                Thread.Sleep(msecTimeOut);
            }
        }
        action(stream);
    }

Puoi utilizzare la mia libreria per accedere ai file da più app.

Puoi installarlo dal nuget: Install-Package Xabe.FileLock

Se vuoi maggiori informazioni a riguardo controlla https://github.com/tomaszzmuda/Xabe.FileLock

ILock fileLock = new FileLock(file);
if(fileLock.Acquire(TimeSpan.FromSeconds(15), true))
{
    using(fileLock)
    {
        // file operations here
    }
}

Il metodo fileLock.Acquire restituirà true solo se è possibile bloccare il file esclusivo per questo oggetto. Ma l'app che carica il file deve farlo anche nel blocco dei file. Se l'oggetto è inaccessibile, il metodo restituisce false.

Una volta avevo bisogno di caricare PDF in un archivio di backup online. Ma il backup fallirebbe se l'utente avesse il file aperto in un altro programma (come un lettore PDF). Nella mia fretta, ho provato alcune delle risposte migliori in questa discussione ma non sono riuscito a farle funzionare. Quello che ha funzionato per me è stato cercare di spostare il file PDF nella sua directory . Ho scoperto che ciò non avrebbe esito positivo se il file fosse stato aperto in un altro programma e se lo spostamento avesse esito positivo non sarebbe stata necessaria alcuna operazione di ripristino come se fosse stata spostata in una directory separata. Voglio pubblicare la mia soluzione di base nel caso in cui possa essere utile per casi d'uso specifici di altri.

string str_path_and_name = str_path + '\\' + str_filename;
FileInfo fInfo = new FileInfo(str_path_and_name);
bool open_elsewhere = false;
try
{
    fInfo.MoveTo(str_path_and_name);
}
catch (Exception ex)
{
    open_elsewhere = true;
}

if (open_elsewhere)
{
    //handle case
}

Sono interessato a vedere se questo innesca eventuali riflessi WTF. Ho un processo che crea e successivamente avvia un documento PDF da un'app console. Tuttavia, avevo a che fare con una fragilità in cui se l'utente dovesse eseguire il processo più volte, generando lo stesso file senza prima chiudere il file generato in precedenza, l'app genererebbe un'eccezione e morirà. Ciò si è verificato piuttosto frequentemente perché i nomi dei file si basano sui numeri delle offerte di vendita.

Invece di fallire in un modo così ingrato, ho deciso di fare affidamento sul controllo delle versioni dei file con incremento automatico:

private static string WriteFileToDisk(byte[] data, string fileName, int version = 0)
{
    try
    {
        var versionExtension = version > 0 ? $"_{version:000}" : string.Empty;
        var filePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $"{fileName}{versionExtension}.pdf");
        using (var writer = new FileStream(filePath, FileMode.Create))
        {
            writer.Write(data, 0, data.Length);
        }
        return filePath;
    }
    catch (IOException)
    {
        return WriteFileToDisk(data, fileName, ++version);
    }
}

Probabilmente un po 'più di attenzione può essere data al catchblocco per assicurarsi che stia rilevando le IOException corrette. Probabilmente cancellerò anche l'archiviazione dell'app all'avvio poiché questi file devono comunque essere temporanei.

Mi rendo conto che questo va oltre lo scopo della questione del PO di controllare semplicemente se il file è in uso, ma questo era davvero il problema che stavo cercando di risolvere quando sono arrivato qui, quindi forse sarà utile a qualcun altro.

Qualcosa del genere sarebbe di aiuto?

var fileWasWrittenSuccessfully = false;
while (fileWasWrittenSuccessfully == false)
{
    try
    {
        lock (new Object())
        {
            using (StreamWriter streamWriter = new StreamWriter(filepath.txt"), true))
            {
                streamWriter.WriteLine("text");
            }
        }

        fileWasWrittenSuccessfully = true;
    }
    catch (Exception)
    {

    }
}

Prova a spostare / copiare il file in una directory temporanea. Se puoi, non ha blocchi e puoi tranquillamente lavorare nella directory temporanea senza ottenere blocchi. Altrimenti prova a spostarlo di nuovo in x secondi.

Uso questa soluzione alternativa, ma ho un intervallo di tempo tra quando controllo il blocco dei file con la funzione IsFileLocked e quando apro il file. In questo periodo di tempo alcuni altri thread possono aprire il file, quindi otterrò IOException.

Quindi, ho aggiunto un codice aggiuntivo per questo. Nel mio caso voglio caricare XDocument:

        XDocument xDoc = null;

        while (xDoc == null)
        {
            while (IsFileBeingUsed(_interactionXMLPath))
            {
                Logger.WriteMessage(Logger.LogPrioritet.Warning, "Deserialize can not open XML file. is being used by another process. wait...");
                Thread.Sleep(100);
            }
            try
            {
                xDoc = XDocument.Load(_interactionXMLPath);
            }
            catch
            {
                Logger.WriteMessage(Logger.LogPrioritet.Error, "Load working!!!!!");
            }
        }

Cosa ne pensi? Posso cambiare qualcosa? Forse non ho dovuto usare la funzione IsFileBeingUsed?

Grazie