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

Aktualisiert HINWEIS auf diese Lösung: Prüfung mit FileAccess.ReadWrite Fehler für Nur-Lese-Dateien, so dass die Lösung wurde geändert, um zu überprüfen, mit FileAccess.Read. Obwohl diese Lösung funktioniert, weil die versuchen zu prüfen, mit FileAccess.Read fehl, wenn die Datei hat eine Schreib-oder Lesesperre auf es, aber diese Lösung wird nicht funktionieren, wenn die Datei nicht Schreib-oder Lese-Sperre auf es, D. H. es wurde geöffnet (gelesen oder schreiben) mit FileShare.Lesen oder FileShare.Schreibzugriff.

ORIGINAL:
Ich habe diesen code für die Vergangenheit einige Jahre, und ich habe keine Probleme mit ihm.

Verstehe Ihre Bedenken über die Verwendung von Ausnahmen, aber Sie können nicht vermeiden, dass Sie alle von der Zeit:

protected virtual bool IsFileLocked(FileInfo file)
{
    FileStream stream = null;

    try
    {
        stream = file.Open(FileMode.Open, FileAccess.Read, FileShare.None);
    }
    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;
    }
    finally
    {
        if (stream != null)
            stream.Close();
    }

    //file is not locked
    return false;
}

Verwenden, um zu überprü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 performance-Gründen empfehle ich Ihnen, Lesen Sie den Inhalt der Datei in dem gleichen Betrieb. 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:

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

Verwenden Sie einfach die Ausnahme als gedacht. Akzeptieren Sie, dass die Datei in Gebrauch ist und versuchen Sie es erneut, immer wieder, bis Sie Ihre Aktion abgeschlossen ist. Dies ist auch der effizienteste, weil Sie verschwenden Sie keine Zyklen prüfen den Zustand, bevor Sie handeln.

Verwenden Sie die Funktion beispielsweise für folgenden

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

Wiederverwendbare Methode, die mal nach 2 Sekunden

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

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

Hoffe, das hilft!

Akzeptierten Antworten über leiden, ein Problem, wo, wenn die Datei geöffnet wurde, die für das schreiben mit einem FileShare.Lese-Modus oder, wenn die Datei ein Nur-Lese-Attribut wird der code nicht funktionieren. Diese modifizierte Lösung arbeitet höchst zuverlässig, mit zwei Dinge im Auge zu behalten (gilt für die akzeptierte Lösung auch):

1. Es funktioniert nicht für Dateien, die geöffnet wurde, mit einem schreiben share mode
2. Dies nicht berücksichtigen, threading Probleme, also müssen Sie es sperren, um es nach unten oder Griff threading-Probleme getrennt.

Halten die oben genannten im Verstand, diese überprüft, ob die Datei entweder gesperrt zum schreiben oder gesperrt, um zu verhindern, dass Lesen:

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

Hier ist etwas code, wie ich das am besten sagen, macht das gleiche wie die akzeptierte Antwort, aber mit weniger code:

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

Aber ich denke, es ist robuster, es zu tun, in der folgenden Weise:

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

In meiner Erfahrung, werden Sie in der Regel wollen, um dies zu tun, und dann zu 'schützen' Ihre Dateien zu tun, etwas ausgefallenes und verwenden Sie dann die "geschützten" Dateien. Wenn Sie nur eine Datei, die Sie verwenden möchten, wie diese, können Sie den trick, der erklärt, in der Antwort von Jeremy Thompson. Allerdings, wenn Sie versuchen, tun dies auf sehr viele Dateien (sagen wir, zum Beispiel, wenn Sie schreiben eine installer), sind Sie in für ein bisschen weh.

Einen sehr eleganten Weg, dieses Problem kann gelöst werden durch Verwendung der Tatsache, dass Ihre Datei-system wird nicht zulassen, dass Sie einen Ordner-Namen ändern, wenn eine der Dateien, die es verwendet wird. Halten Sie die Ordner in der selben Datei-system und es funktioniert wie ein Charme.

Tun, beachten Sie, dass Sie sollten sich bewusst sein, die offensichtlichen Möglichkeiten, wie diese genutzt werden können. Nachdem alle, die Dateien nicht gesperrt werden. Beachten Sie auch, dass es andere Gründe können dazu führen, dass Ihre Move operation scheitern. Offensichtlich ordnungsgemäße Fehlerbehandlung (MSDN) können hier helfen.

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

Für einzelne Dateien würd ich mich mit der Verriegelung Vorschlag gepostet von Jeremy Thompson.

Würde so etwas helfen?

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)
    {

    }
}

Ich diese Problemumgehung verwenden, aber ich habe eine Zeit zwischen, wenn ich die Datei sperren mit IsFileLocked Funktion und wenn ich die Datei öffnen. In dieser Zeitspanne einige andere Threads können die Datei öffnen, also werde ich bekommen IOException.

So, ich habe extra code für diese. In meinem Fall möchte ich laden 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!!!!!");
            }
        }

Was denkst du? Kann ich das ändern, was? Vielleicht habe ich nicht IsFileBeingUsed Funktion überhaupt?

Dank