Gibt es eine Möglichkeit zu überprüfen, ob eine Datei in Gebrauch ist?

Question

Ich schreibe ein Programm in C#, das wiederholt auf 1 Bilddatei zugreifen muss. Die meiste Zeit funktioniert es, aber wenn mein Computer schnell läuft, wird es versuchen, auf die Datei zuzugreifen, bevor es zurück in das Dateisystem gespeichert wurde und einen Fehler ausgeben:

"Datei wird von einem anderen Prozess verwendet"

Ich würde gerne einen Weg finden, dies zu umgehen, aber alles, was ich gegoogelt habe, hat nur die Erstellung von Prüfungen mit Hilfe der Ausnahmebehandlung ergeben. Dies ist gegen meine Religion, so ich frage mich, ob jemand einen besseren Weg, es zu tun hat?

Answer 1

Aktualisierter HINWEIS zu dieser Lösung : Prüfen mit FileAccess.ReadWrite schlägt bei schreibgeschützten Dateien fehl, daher wurde die Lösung so geändert, dass die Prüfung mit FileAccess.Read .

ORIGINAL: Ich verwende diesen Code schon seit mehreren Jahren und habe noch nie Probleme damit gehabt.

Ich verstehe, dass Sie zögern, Ausnahmen zu verwenden, aber Sie können sie nicht immer vermeiden:

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

Answer 2

Dabei kann es zu einer Thread-Race-Bedingung kommen, für die es dokumentierte Beispiele gibt, in denen dies als Sicherheitslücke genutzt wird. Wenn Sie prüfen, ob die Datei verfügbar ist, dann aber versuchen, sie zu verwenden, kann es an dieser Stelle zu einem Fehler kommen, den ein böswilliger Benutzer ausnutzen könnte, um eine Sicherheitslücke in Ihrem Code zu erzwingen und auszunutzen.

Die beste Lösung ist ein try catch / finally, das versucht, das Dateihandle zu erhalten.

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

Answer 3

Hiermit können Sie prüfen, ob eine Datei gesperrt ist:

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

Aus Leistungsgründen empfehle ich Ihnen, den Inhalt der Datei im selben Arbeitsgang zu lesen. Hier sind einige Beispiele:

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

Probieren Sie es selbst aus:

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

Answer 4

Ich bin vor kurzem auf dieses Thema gestoßen und habe Folgendes gefunden: https://learn.microsoft.com/en-us/dotnet/standard/io/handling-io-errors .

Hier beschreibt Microsoft die folgende Methode zur Überprüfung, ob ein IOException war auf eine gesperrte Datei zurückzuführen:

catch (IOException e) when ((e.HResult & 0x0000FFFF) == 32 ) {
    Console.WriteLine("There is a sharing violation.");
}

Answer 5

Verwenden Sie die Ausnahme einfach wie vorgesehen. Akzeptieren Sie, dass die Datei verwendet wird, und versuchen Sie es erneut, bis Ihre Aktion abgeschlossen ist. Dies ist auch am effizientesten, da Sie keine Zyklen verschwenden, um den Zustand zu prüfen, bevor Sie handeln.

Verwenden Sie zum Beispiel die folgende Funktion

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

Wiederverwendbare Methode, die nach 2 Sekunden abbricht

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