Czy istnieje sposób sprawdzenia, czy plik jest w użyciu?

Piszę program w języku C #, który musi wielokrotnie uzyskiwać dostęp do 1 pliku obrazu. Przez większość czasu działa, ale jeśli mój komputer działa szybko, spróbuje uzyskać dostęp do pliku, zanim zostanie zapisany z powrotem w systemie plików, i zgłosi błąd: „Plik używany przez inny proces” .

Chciałbym znaleźć sposób na obejście tego, ale cały mój Googling dał tylko tworzenie czeków przy użyciu obsługi wyjątków. To jest sprzeczne z moją religią, więc zastanawiałem się, czy ktoś ma lepszy sposób na zrobienie tego?

Zaktualizowana UWAGA dotycząca tego rozwiązania : Sprawdzanie za pomocą FileAccess.ReadWritenie powiedzie się w przypadku plików tylko do odczytu, więc rozwiązanie zostało zmodyfikowane w celu sprawdzania za pomocą FileAccess.Read. Chociaż to rozwiązanie działa, ponieważ próba sprawdzenia za pomocą FileAccess.Readnie powiedzie się, jeśli plik ma blokadę zapisu lub odczytu, jednak to rozwiązanie nie będzie działać, jeśli plik nie ma blokady zapisu lub odczytu, tj. Został otwarty (do odczytu lub zapisu) za pomocą dostępu FileShare.Read lub FileShare.Write.

ORYGINALNY: Używam tego kodu od kilku lat i nie miałem z nim żadnych problemów.

Poznaj swoje wahanie dotyczące korzystania z wyjątków, ale nie możesz ich cały czas unikać:

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

Możesz cierpieć na warunek wyścigu wątków, który jest udokumentowany, przykłady wykorzystania tego jako luki w zabezpieczeniach. Jeśli sprawdzisz, czy plik jest dostępny, ale następnie spróbujesz go użyć, możesz w tym momencie rzucić, którego złośliwy użytkownik może użyć do wymuszenia i wykorzystania w kodzie.

Twój najlepszy zakład to try catch / wreszcie, który próbuje uzyskać uchwyt pliku.

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

Użyj tego, aby sprawdzić, czy plik jest zablokowany:

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

Ze względu na wydajność zalecam przeczytanie zawartości pliku podczas tej samej operacji. Oto kilka przykładów:

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

Wypróbuj sam:

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

Po prostu użyj wyjątku zgodnie z przeznaczeniem. Zaakceptuj, że plik jest w użyciu i spróbuj ponownie, aż do zakończenia działania. Jest to również najbardziej wydajne, ponieważ nie marnujesz żadnych cykli sprawdzania stanu przed działaniem.

Użyj na przykład poniższej funkcji

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

Metoda wielokrotnego użytku, która kończy się po 2 sekundach

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

Być może możesz użyć FileSystemWatcher i obserwować wydarzenie Zmienione.

Nie użyłem tego sam, ale może warto spróbować. Jeśli obserwator systemu plików okaże się nieco ciężki w tym przypadku, wybrałbym pętlę try / catch / sleep.

Możesz zwrócić zadanie, które daje strumień, gdy tylko będzie dostępny. To uproszczone rozwiązanie, ale dobry punkt wyjścia. Jest bezpieczny dla wątków.

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

Możesz użyć tego strumienia jak zwykle:

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

jedynym sposobem, jaki znam, jest użycie wyjątkowego interfejsu API blokady Win32, który nie jest zbyt szybki, ale istnieją przykłady.

Większość ludzi, dla prostego rozwiązania tego problemu, po prostu próbuje / łapie / śpi pętle.

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

Mam nadzieję że to pomoże!

W powyższych odpowiedziach występuje problem polegający na tym, że jeśli plik został otwarty do zapisu w trybie FileShare.Read lub jeśli plik ma atrybut tylko do odczytu, kod nie będzie działał. To zmodyfikowane rozwiązanie działa najbardziej niezawodnie, pamiętając o dwóch rzeczach (tak jak w przypadku przyjętego rozwiązania):

1. Nie będzie działać w przypadku plików otwartych w trybie udostępniania zapisu
2. Nie bierze to pod uwagę problemów z wątkami, więc trzeba będzie je zablokować lub osobno poradzić sobie z problemami z wątkami.

Mając powyższe na uwadze, sprawdza, czy plik jest zablokowany do zapisu lub zablokowany, aby uniemożliwić odczyt :

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

Poza działającymi 3 liniami i tylko w celach informacyjnych: Jeśli chcesz uzyskać pełne informacje - istnieje mały projekt w Microsoft Dev Center:

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

Ze wstępu:

Przykładowy kod C # opracowany w .NET Framework 4.0 pomógłby dowiedzieć się, który proces blokuje plik. Funkcja RmStartSession zawarta w pliku rstrtmgr.dll została użyta do utworzenia sesji menedżera restartu i zgodnie z wynikiem zwrotu tworzona jest nowa instancja obiektu Win32Exception. Po zarejestrowaniu zasobów w sesji Menedżera restartu za pomocą funkcji RmRegisterRescources wywoływana jest funkcja RmGetList w celu sprawdzenia, jakie aplikacje używają określonego pliku, poprzez wyliczenie tablicy RM_PROCESS_INFO .

Działa poprzez połączenie z „Restart Manager Session”.

Menedżer ponownego uruchamiania korzysta z listy zasobów zarejestrowanych w sesji, aby określić, które aplikacje i usługi muszą zostać zamknięte i ponownie uruchomione. Zasoby można rozpoznać po nazwach plików, krótkich nazwach usług lub strukturach RM_UNIQUE_PROCESS opisujących uruchomione aplikacje.

To może być trochę overengineered do indywidualnych potrzeb ... Ale jeśli to, co ty chcesz, idź i chwyć VS-projekt.

Z mojego doświadczenia wynika, że ​​zwykle chcesz to zrobić, a następnie „chronić” swoje pliki, aby zrobić coś wymyślnego, a następnie użyć plików „chronionych”. Jeśli masz tylko jeden plik, którego chcesz użyć w ten sposób, możesz skorzystać ze sztuczki wyjaśnionej w odpowiedzi przez Jeremy'ego Thompsona. Jeśli jednak spróbujesz to zrobić na wielu plikach (powiedzmy na przykład podczas pisania instalatora), czeka cię sporo bólu.

Bardzo eleganckim sposobem na rozwiązanie tego problemu jest fakt, że twój system plików nie pozwoli ci zmienić nazwy folderu, jeśli jeden z plików tam używanych jest używany. Trzymaj folder w tym samym systemie plików, a będzie działał jak urok.

Pamiętaj, że powinieneś być świadomy oczywistych sposobów, w jakie można to wykorzystać. W końcu pliki nie zostaną zablokowane. Należy również pamiętać, że istnieją inne powody, które mogą spowodować Moveniepowodzenie operacji. Oczywiście może pomóc tutaj poprawna obsługa błędów (MSDN).

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

W przypadku pojedynczych plików trzymałbym się sugestii blokowania opublikowanej przez Jeremy'ego Thompsona.

Oto kod, który, o ile mogę najlepiej powiedzieć, robi to samo co zaakceptowana odpowiedź, ale z mniejszym kodem:

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

Myślę jednak, że bardziej niezawodne jest to zrobić w następujący sposób:

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

Możesz użyć mojej biblioteki do uzyskiwania dostępu do plików z wielu aplikacji.

Możesz go zainstalować z nuget: Install-Package Xabe.FileLock

Jeśli chcesz uzyskać więcej informacji na ten temat, sprawdź https://github.com/tomaszzmuda/Xabe.FileLock

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

Metoda fileLock.Acquire zwróci wartość true tylko wtedy, gdy można zablokować plik wyłączny dla tego obiektu. Ale aplikacja, która przesyła plik, musi to zrobić również w blokadzie plików. Jeśli obiekt jest niedostępny, metoda zwraca false.

Kiedyś musiałem przesyłać pliki PDF do archiwum kopii zapasowych online. Ale tworzenie kopii zapasowej nie powiedzie się, jeśli użytkownik otworzy plik w innym programie (np. Czytniku plików PDF). W pośpiechu spróbowałem kilka najlepszych odpowiedzi w tym wątku, ale nie udało mi się ich uruchomić. To, co zadziałało, to próba przeniesienia pliku PDF do własnego katalogu . Odkryłem, że to się nie powiedzie, jeśli plik zostanie otwarty w innym programie, a jeśli przeniesienie się powiedzie, operacja przywracania nie będzie wymagana, tak jak w przypadku przeniesienia do osobnego katalogu. Chcę opublikować moje podstawowe rozwiązanie na wypadek, gdyby okazało się przydatne w konkretnych przypadkach użycia przez innych.

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
}

Interesuje mnie, czy to uruchomi jakiś refleks WTF. Mam proces, który tworzy, a następnie uruchamia dokument PDF z aplikacji konsoli. Miałem jednak do czynienia z słabością, w której jeśli użytkownik miałby uruchomić proces wiele razy, generując ten sam plik bez uprzedniego zamknięcia wcześniej wygenerowanego pliku, aplikacja rzuciłaby wyjątek i zginęła. Było to dość częste zdarzenie, ponieważ nazwy plików oparte są na numerach ofert sprzedaży.

Zamiast zawieść w tak nieskromny sposób, postanowiłem polegać na automatycznie zwiększanej wersji plików:

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

Prawdopodobnie można poświęcić trochę więcej uwagi catchblokowi, aby upewnić się, że wychwytuję poprawne wyjątki IOException. Prawdopodobnie wyczyszczę również pamięć aplikacji podczas uruchamiania, ponieważ te pliki i tak mają być tymczasowe.

Zdaję sobie sprawę, że wykracza to poza kwestię PO polegającą na sprawdzeniu, czy plik jest w użyciu, ale to był problem, który chciałem rozwiązać, kiedy tu przybyłem, więc być może przyda się komuś innemu.

Czy coś takiego mogłoby pomóc?

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

    }
}

Spróbuj przenieść / skopiować plik do katalogu tymczasowego. Jeśli możesz, nie ma blokady i możesz bezpiecznie pracować w temp temp bez uzyskiwania blokad. W przeciwnym razie spróbuj przenieść go ponownie za x sekund.

Korzystam z tego obejścia, ale mam pewien przedział czasowy między momentem sprawdzenia blokady pliku za pomocą funkcji IsFileLocked a otwarciem pliku. W tym czasie jakiś inny wątek może otworzyć plik, więc otrzymam wyjątek IOException.

Dodałem do tego dodatkowy kod. W moim przypadku chcę załadować 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!!!!!");
            }
        }

Co myślisz? Czy mogę coś zmienić? Może wcale nie musiałem używać funkcji IsFileBeingUsed?

Dzięki