¿Hay alguna manera de verificar si un archivo está en uso?

Estoy escribiendo un programa en C # que necesita acceder repetidamente a 1 archivo de imagen. La mayoría de las veces funciona, pero si mi computadora está funcionando rápidamente, intentará acceder al archivo antes de que se guarde nuevamente en el sistema de archivos y arrojará un error: "Archivo en uso por otro proceso" .

Me gustaría encontrar una forma de evitar esto, pero todos mis Google solo han dado lugar a la creación de controles mediante el manejo de excepciones. Esto va en contra de mi religión, así que me preguntaba si alguien tiene una mejor manera de hacerlo.

NOTA actualizada sobre esta solución : la verificación con FileAccess.ReadWritefallará para los archivos de solo lectura, por lo que la solución se ha modificado para verificar conFileAccess.Read . Si bien esta solución funciona porque al intentar verificar FileAccess.Readfallará si el archivo tiene un bloqueo de Escritura o Lectura, sin embargo, esta solución no funcionará si el archivo no tiene un bloqueo de Escritura o Lectura, es decir, se ha abierto (para leer o escribir) con acceso FileShare.Read o FileShare.Write.

ORIGINAL: He usado este código durante los últimos años, y no he tenido ningún problema con él.

Comprenda sus dudas sobre el uso de excepciones, pero no puede evitarlas todo el tiempo:

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

Puede sufrir una condición de carrera de hilo en esto, que hay ejemplos documentados de que esto se utiliza como una vulnerabilidad de seguridad. Si comprueba que el archivo está disponible, pero luego intenta usarlo, podría lanzarlo en ese punto, que un usuario malintencionado podría usar para forzar y explotar su código.

Su mejor opción es intentar capturar / finalmente, que intenta obtener el identificador de archivo.

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 esto para verificar si un archivo 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 razones de rendimiento, le recomiendo que lea el contenido del archivo en la misma operación. Aquí hay unos ejemplos:

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

Pruébalo tú mismo:

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

Solo use la excepción según lo previsto. Acepte que el archivo está en uso e intente nuevamente, varias veces hasta que se complete su acción. Este también es el más eficiente porque no desperdicia ningún ciclo verificando el estado antes de actuar.

Use la función a continuación, por ejemplo

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

Método reutilizable que agota el tiempo de espera después de 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);
}

Quizás podría usar un FileSystemWatcher y observar el evento Modificado.

No lo he usado yo mismo, pero podría valer la pena intentarlo. Si el sistema de archivos resulta ser un poco pesado para este caso, iría al bucle try / catch / sleep.

Puede devolver una tarea que le proporciona una secuencia tan pronto como esté disponible. Es una solución simplificada, pero es un buen punto de partida. Es seguro para hilos.

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

Puede usar esta transmisión como de costumbre:

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

Lo único que sé es utilizar la API de bloqueo exclusiva de Win32, que no es demasiado rápida, pero existen ejemplos.

La mayoría de las personas, para una solución simple a esto, simplemente para probar / atrapar / dormir bucles.

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 esto ayude!

Las respuestas aceptadas anteriormente sufren un problema en el que si el archivo se abrió para escribir con un modo FileShare.Read o si el archivo tiene un atributo de solo lectura, el código no funcionará. Esta solución modificada funciona de manera más confiable, con dos cosas a tener en cuenta (como también es cierto para la solución aceptada):

1. No funcionará para archivos que se han abierto con un modo de escritura compartida
2. Esto no tiene en cuenta los problemas de subprocesos, por lo que deberá bloquearlo o manejarlos por separado.

Teniendo en cuenta lo anterior, esto verifica si el archivo está bloqueado para escritura o bloqueado para evitar la lectura :

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

Además de trabajar 3 líneas y solo como referencia: si desea la información completa , hay un pequeño proyecto en Microsoft Dev Center:

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

De la Introducción:

El código de muestra C # desarrollado en .NET Framework 4.0 ayudaría a descubrir cuál es el proceso que tiene un bloqueo en un archivo. La función RmStartSession que se incluye en rstrtmgr.dll se ha utilizado para crear una sesión de administrador de reinicio y, según el resultado de la devolución, se crea una nueva instancia del objeto Win32Exception. Después de registrar los recursos para una sesión de Administrador de reinicio a través RmRegisterRescources función, RmGetList función se invoca para comprobar cuáles son las aplicaciones están utilizando un archivo en particular mediante la enumeración de la RM_PROCESS_INFO matriz.

Funciona conectándose a la "Reiniciar sesión del administrador".

El Administrador de reinicio utiliza la lista de recursos registrados con la sesión para determinar qué aplicaciones y servicios deben cerrarse y reiniciarse. Los recursos se pueden identificar por nombres de archivo, nombres cortos de servicio o estructuras RM_UNIQUE_PROCESS que describen aplicaciones en ejecución.

Podría estar un poco diseñado para sus necesidades particulares ... Pero si eso es lo que desea, continúe y tome el proyecto vs.

En mi experiencia, generalmente desea hacer esto, luego 'proteger' sus archivos para hacer algo elegante y luego usar los archivos 'protegidos'. Si solo tiene un archivo que desea usar de esta manera, puede usar el truco que se explica en la respuesta de Jeremy Thompson. Sin embargo, si intentas hacer esto en muchos archivos (por ejemplo, cuando escribes un instalador), te dolerá un poco.

Una manera muy elegante de resolver esto es usando el hecho de que su sistema de archivos no le permitirá cambiar el nombre de una carpeta si se está usando uno de los archivos. Mantenga la carpeta en el mismo sistema de archivos y funcionará como un encanto.

Tenga en cuenta que debe tener en cuenta las formas obvias de explotar esto. Después de todo, los archivos no serán bloqueados. Además, tenga en cuenta que hay otras razones que pueden provocar que su Moveoperación falle. Obviamente, el manejo adecuado de errores (MSDN) puede ayudar aquí.

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 archivos individuales, me quedaría con la sugerencia de bloqueo publicada por Jeremy Thompson.

Aquí hay un código que, por lo que puedo decir mejor, hace lo mismo que la respuesta aceptada pero con menos código:

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

Sin embargo, creo que es más robusto hacerlo de la siguiente manera:

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

Puede usar mi biblioteca para acceder a archivos desde múltiples aplicaciones.

Puede instalarlo desde nuget: Install-Package Xabe.FileLock

Si desea obtener más información al respecto, consulte https://github.com/tomaszzmuda/Xabe.FileLock

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

El método fileLock.Acquire devolverá verdadero solo si puede bloquear el archivo exclusivo para este objeto. Pero la aplicación que carga el archivo también debe hacerlo en el bloqueo de archivos. Si el objeto es inaccesible, el método devuelve falso.

Una vez necesitaba subir archivos PDF a un archivo de respaldo en línea. Pero la copia de seguridad fallaría si el usuario tuviera el archivo abierto en otro programa (como un lector de PDF). En mi apuro, intenté algunas de las principales respuestas en este hilo, pero no pude hacer que funcionaran. Lo que funcionó para mí fue tratar de mover el archivo PDF a su propio directorio . Descubrí que esto fallaría si el archivo estuviera abierto en otro programa, y ​​si el movimiento fuera exitoso, no se requeriría una operación de restauración, ya que si se moviera a un directorio separado. Quiero publicar mi solución básica en caso de que pueda ser útil para los casos de uso específicos de otros.

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
}

Estoy interesado en ver si esto desencadena algún reflejo de WTF. Tengo un proceso que crea y luego lanza un documento PDF desde una aplicación de consola. Sin embargo, estaba lidiando con una fragilidad en la que si el usuario ejecutara el proceso varias veces, generando el mismo archivo sin cerrar primero el archivo generado anteriormente, la aplicación lanzaría una excepción y moriría. Este fue un hecho bastante frecuente porque los nombres de los archivos se basan en números de cotizaciones de ventas.

En lugar de fallar de una manera tan desagradable, decidí confiar en el versionado automático de archivos:

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

Probablemente se pueda prestar más atención al catchbloque para asegurarme de que estoy captando las IOException (s) correctas. Probablemente también borre el almacenamiento de la aplicación al inicio ya que estos archivos están destinados a ser temporales de todos modos.

Me doy cuenta de que esto va más allá del alcance de la pregunta del OP de simplemente verificar si el archivo está en uso, pero este fue el problema que estaba tratando de resolver cuando llegué aquí, por lo que tal vez sea útil para otra persona.

¿Algo como esto ayudaría?

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

    }
}

Intente mover / copiar el archivo a un directorio temporal. Si puede, no tiene bloqueo y puede trabajar de forma segura en el directorio temporal sin obtener bloqueos. De lo contrario, intenta moverlo nuevamente en x segundos.

Utilizo esta solución, pero tengo un intervalo de tiempo entre cuando verifico el bloqueo del archivo con la función IsFileLocked y cuando abro el archivo. En este intervalo de tiempo, algún otro hilo puede abrir el archivo, por lo que obtendré IOException.

Entonces, agregué código adicional para esto. En mi caso quiero cargar 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!!!!!");
            }
        }

¿Qué piensas? ¿Puedo cambiar algo? ¿Quizás no tuve que usar la función IsFileBeingUsed en absoluto?

Gracias