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




.net file (11)

Aparte de trabajar 3-liners y solo como referencia: si quieres la información completa , hay un pequeño proyecto en el Centro de desarrollo de Microsoft:

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

De la Introducción:

El código de muestra de 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 reinicio del administrador y, según el resultado devuelto, se crea una nueva instancia del objeto Win32Exception. Después de registrar los recursos en una sesión de Restart Manager a través de la función RmRegisterRescources , se invoca la función RmGetList para verificar qué aplicaciones están utilizando un archivo en particular al enumerar la matriz RM_PROCESS_INFO .

Funciona conectándose a la "Sesión de reinicio 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 archivos, nombres cortos de servicio o estructuras RM_UNIQUE_PROCESS que describen aplicaciones en ejecución.

Puede que esté un poco sobre diseñado para tus necesidades particulares ... Pero si eso es lo que quieres, sigue adelante y toma el proyecto vs.

https://code.i-harness.com

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ápido, intentará acceder al archivo antes de guardarlo nuevamente en el sistema de archivos y generará un error: "Archivo en uso por otro proceso" .

Me gustaría encontrar una forma de evitar esto, pero todas mis búsquedas en Google solo han permitido crear cheques 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.


Aquí hay un código que, por lo que puedo decir, 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);
    }

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

En lugar de fallar de una manera tan deshonrosa, decidí confiar en el control de versiones de archivos auto-incrementado:

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 le puede prestar más atención al bloque catch para asegurar que detecto las IOException (s) correctas. Probablemente también borraré el almacenamiento de la aplicación al iniciar, 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 buscaba resolver cuando llegué aquí, por lo que quizás sea útil para otra persona.


La única forma que conozco es usar la API de bloqueo exclusivo de Win32, que no es demasiado rápida, pero existen ejemplos.

La mayoría de la gente, para una solución simple a esto, simplemente intenta / atrapa / duerme los bucles.


Pruebe y mueva / copie el archivo a un directorio temporal. Si puede, no tiene bloqueo y puede trabajar de manera segura en el directorio temporal sin obtener bloqueos. Si no, intenta moverlo de nuevo en x segundos.


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

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

Puedes usar este flujo como de costumbre:

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

Puedes 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, visite 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 se puede bloquear el archivo exclusivo para este objeto. Pero la aplicación que carga el archivo debe hacerlo también en el bloqueo de archivos. Si el objeto es inaccesible, el método devuelve false.


Quizás podría usar un FileSystemWatcher y ver el evento Changed.

Yo no he usado esto, pero podría valer la pena intentarlo. Si el filesystemwatcher resulta ser un poco pesado para este caso, me gustaría ir al circuito try / catch / sleep.


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

Utilizo esta solución alternativa, pero tengo un intervalo de tiempo entre cuando compruebo el bloqueo de archivos con la función IsFileLocked y cuando abro el archivo. En este intervalo de tiempo, otro hilo puede abrir el archivo, así que obtendré IOException.

Entonces, agregué código extra 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


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!





file-locking