Existe uma maneira de verificar se um arquivo está em uso?

Estou escrevendo um programa em c # que precisa acessar repetidamente 1 arquivo de imagem. Na maioria das vezes, ele funciona, mas se meu computador estiver executando rapidamente, ele tentará acessar o arquivo antes de ser salvo no sistema de arquivos e lançará um erro: "Arquivo em uso por outro processo" .

Gostaria de encontrar uma maneira de contornar isso, mas todo o meu Google apenas produziu verificações usando o tratamento de exceções. Isso é contra a minha religião, então eu queria saber se alguém tem uma maneira melhor de fazê-lo.

NOTA atualizada sobre esta solução : A verificação com FileAccess.ReadWritefalha de arquivos somente leitura, portanto a solução foi modificada para verificação FileAccess.Read. Embora esta solução funcione porque tentar verificar com FileAccess.Readele falhará se o arquivo tiver um bloqueio de gravação ou leitura, no entanto, esta solução não funcionará se o arquivo não tiver um bloqueio de gravação ou leitura, ou seja, foi aberto (para leitura ou gravação) com o acesso FileShare.Read ou FileShare.Write.

ORIGINAL: usei esse código nos últimos anos e não tive problemas com ele.

Entenda sua hesitação em usar exceções, mas você não pode evitá-las o tempo todo:

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

Você pode sofrer com uma condição de corrida de encadeamento, onde existem exemplos documentados disso sendo usado como uma vulnerabilidade de segurança. Se você verificar se o arquivo está disponível, mas tentar usá-lo, poderá lançar nesse ponto, que um usuário mal-intencionado pode usar para forçar e explorar seu código.

Sua melhor aposta é uma tentativa de captura / finalmente, que tenta entender o arquivo.

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

Use isto para verificar se um arquivo está bloqueado:

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

Por motivos de desempenho, recomendo que você leia o conteúdo do arquivo na mesma operação. aqui estão alguns exemplos:

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

Experimente você mesmo:

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

Basta usar a exceção como pretendido. Aceite que o arquivo esteja em uso e tente novamente várias vezes até que sua ação seja concluída. Isso também é o mais eficiente, porque você não perde nenhum ciclo verificando o estado antes de agir.

Use a função abaixo, por exemplo

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

Método reutilizável que atinge o tempo limite após 2 segundos

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

Talvez você possa usar um FileSystemWatcher e assistir ao evento Changed.

Eu não usei isso sozinho, mas pode valer a pena tentar. Se o file systemwatcher for um pouco pesado para este caso, eu usaria o loop try / catch / sleep.

Você pode retornar uma tarefa que fornece um fluxo assim que estiver disponível. É uma solução simplificada, mas é um bom ponto de partida. É 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();
    }
}

Você pode usar esse fluxo como de costume:

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

a única maneira que conheço é usar a API de bloqueio exclusivo do Win32, que não é muito rápida, mas existem exemplos.

A maioria das pessoas, para uma solução simples para isso, simplesmente tenta / pega / dorme os loops.

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

Espero que isto ajude!

As respostas aceitas acima sofrem um problema em que, se o arquivo tiver sido aberto para gravação no modo FileShare.Read ou se o arquivo tiver um atributo Somente Leitura, o código não funcionará. Essa solução modificada funciona de maneira mais confiável, com duas coisas a serem lembradas (como também é verdade para a solução aceita):

1. Não funcionará para arquivos que foram abertos com um modo de compartilhamento de gravação
2. Isso não leva em consideração os problemas de encadeamento, portanto, você precisará bloqueá-lo ou lidar com problemas de encadeamento separadamente.

Tendo em mente o acima exposto, isso verifica se o arquivo está bloqueado para gravação ou bloqueado para impedir a leitura :

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

Além de trabalhar com três linhas e apenas para referência: se você quiser informações completas - há um pequeno projeto no Microsoft Dev Center:

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

Da introdução:

O código de exemplo C # desenvolvido no .NET Framework 4.0 ajudaria a descobrir qual é o processo que está bloqueando um arquivo. A função RmStartSession incluída no rstrtmgr.dll foi usada para criar uma sessão do gerenciador de reinicialização e, de acordo com o resultado do retorno, uma nova instância do objeto Win32Exception é criada. Após registrar os recursos em uma sessão do Restart Manager por meio da função RmRegisterRescources , a função RmGetList é chamada para verificar o que os aplicativos estão usando em um arquivo específico, enumerando a matriz RM_PROCESS_INFO .

Funciona conectando-se à "Reiniciar sessão do gerenciador".

O Restart Manager usa a lista de recursos registrados com a sessão para determinar quais aplicativos e serviços devem ser desligados e reiniciados. Os recursos podem ser identificados por nomes de arquivos, nomes abreviados de serviço ou estruturas RM_UNIQUE_PROCESS que descrevem aplicativos em execução.

Pode ser um pouco complicado para suas necessidades específicas ... Mas se é isso que você deseja, vá em frente e pegue o vs-project.

Na minha experiência, você geralmente quer fazer isso, depois 'protege' seus arquivos para fazer algo sofisticado e depois usa os arquivos 'protegidos'. Se você tiver apenas um arquivo que queira usar assim, poderá usar o truque explicado na resposta de Jeremy Thompson. No entanto, se você tentar fazer isso em vários arquivos (por exemplo, quando estiver escrevendo um instalador), sofrerá bastante.

Uma maneira muito elegante de resolver isso é usar o fato de que seu sistema de arquivos não permitirá que você altere o nome de uma pasta se um dos arquivos lá estiver sendo usado. Mantenha a pasta no mesmo sistema de arquivos e funcionará como um encanto.

Observe que você deve estar ciente das maneiras óbvias de que isso possa ser explorado. Afinal, os arquivos não serão bloqueados. Além disso, esteja ciente de que existem outros motivos que podem resultar na Movefalha da sua operação. Obviamente, o tratamento adequado de erros (MSDN) pode ajudar aqui.

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

Para arquivos individuais, eu continuaria com a sugestão de bloqueio postada por Jeremy Thompson.

Aqui está um código que, tanto quanto eu posso dizer, faz a mesma coisa que a resposta aceita, mas com menos código:

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

No entanto, acho que é mais robusto fazê-lo da seguinte maneira:

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

Você pode usar minha biblioteca para acessar arquivos de vários aplicativos.

Você pode instalá-lo a partir do nuget: Install-Package Xabe.FileLock

Se você quiser obter mais informações, consulte https://github.com/tomaszzmuda/Xabe.FileLock

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

O método fileLock.Acquire retornará true somente se puder bloquear o arquivo exclusivo para esse objeto. Mas o aplicativo que carrega o arquivo também deve fazê-lo no bloqueio de arquivo. Se o objeto estiver inacessível, o método retornará false.

Uma vez eu precisei enviar PDFs para um arquivo de backup online. Mas o backup falharia se o usuário tivesse o arquivo aberto em outro programa (como o leitor de PDF). Na pressa, tentei algumas das principais respostas deste tópico, mas não consegui fazê-las funcionar. O que funcionou para mim foi tentar mover o arquivo PDF para seu próprio diretório . Descobri que isso falharia se o arquivo fosse aberto em outro programa e se a movimentação fosse bem-sucedida, não haveria operação de restauração necessária, como aconteceria se fosse movido para um diretório separado. Quero postar minha solução básica, caso seja útil para casos de uso específicos de outras pessoas.

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
}

Estou interessado em ver se isso desencadeia algum reflexo WTF. Eu tenho um processo que cria e, posteriormente, inicia um documento PDF a partir de um aplicativo de console. No entanto, eu estava lidando com uma fragilidade em que, se o usuário executasse o processo várias vezes, gerando o mesmo arquivo sem primeiro fechar o arquivo gerado anteriormente, o aplicativo lançaria uma exceção e morreria. Essa foi uma ocorrência bastante frequente, porque os nomes dos arquivos são baseados nos números das cotações de vendas.

Em vez de falhar de uma maneira tão desagradável, decidi confiar no versionamento de arquivo incrementado automaticamente:

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

Provavelmente, um pouco mais de cuidado pode ser dado ao catchbloco para garantir que eu esteja capturando as IOException (s) corretas. Provavelmente também limparei o armazenamento do aplicativo na inicialização, pois esses arquivos devem ser temporários de qualquer maneira.

Sei que isso vai além do escopo da questão do OP de simplesmente verificar se o arquivo está em uso, mas esse era realmente o problema que eu estava procurando resolver quando cheguei aqui; talvez seja útil para outra pessoa.

Algo assim ajudaria?

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

    }
}

Tente mover / copiar o arquivo para um diretório temporário. Se você puder, ele não tem bloqueio e você pode trabalhar com segurança no diretório temp sem obter bloqueios. Caso contrário, tente movê-lo novamente em x segundos.

Eu uso essa solução alternativa, mas tenho um intervalo de tempo entre quando eu verifico o bloqueio do arquivo com a função IsFileLocked e quando abro o arquivo. Nesse período, algum outro thread pode abrir o arquivo, então eu receberei IOException.

Então, eu adicionei um código extra para isso. No meu caso, quero carregar o 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!!!!!");
            }
        }

O que você acha? Posso mudar alguma coisa? Talvez eu não precise usar a função IsFileBeingUsed?

obrigado