IOException: el proceso no puede acceder al archivo 'ruta de archivo' porque está siendo utilizado por otro proceso

Tengo un código y cuando se ejecuta, arroja un IOException, diciendo que

El proceso no puede acceder al archivo 'nombre de archivo' porque otro proceso lo está utilizando

¿Qué significa esto y qué puedo hacer al respecto?

¿Cual es la causa?

El mensaje de error es bastante claro: está intentando acceder a un archivo y no es accesible porque otro proceso (o incluso el mismo proceso) está haciendo algo con él (y no permitió compartirlo).

Depuración

Puede ser bastante fácil de resolver (o bastante difícil de entender), dependiendo de su escenario específico. A ver algunos.

Su proceso es el único que accede a ese archivo.
Está seguro de que el otro proceso es suyo. Si sabe que abre ese archivo en otra parte de su programa, antes que nada debe verificar que cierre correctamente el identificador de archivo después de cada uso. Aquí hay un ejemplo de código con este error:

var stream = new FileStream(path, FileAccess.Read);
var reader = new StreamReader(stream);
// Read data from this file, when I'm done I don't need it any more
File.Delete(path); // IOException: file is in use

Afortunadamente se FileStreamimplementa IDisposable, por lo que es fácil envolver todo su código dentro de una usingdeclaración:

using (var stream = File.Open("myfile.txt", FileMode.Open)) {
    // Use stream
}

// Here stream is not accessible and it has been closed (also if
// an exception is thrown and stack unrolled

Este patrón también asegurará que el archivo no se dejará abierto en caso de excepciones (puede ser la razón por la que el archivo está en uso: algo salió mal y nadie lo cerró; consulte esta publicación para ver un ejemplo).

Si todo parece estar bien (está seguro de que siempre cierra todos los archivos que abre, incluso en caso de excepciones) y tiene múltiples hilos de trabajo, entonces tiene dos opciones: reelaborar su código para serializar el acceso al archivo (no siempre factible y no siempre deseado) o aplicar un patrón de reintento . Es un patrón bastante común para las operaciones de E / S: intenta hacer algo y, en caso de error, espera e intenta nuevamente (¿se preguntó por qué, por ejemplo, Windows Shell tarda un tiempo en informarle que un archivo está en uso? y no se puede eliminar?). En C # es bastante fácil de implementar (vea también mejores ejemplos sobre E / S de disco , redes y acceso a bases de datos ).

private const int NumberOfRetries = 3;
private const int DelayOnRetry = 1000;

for (int i=1; i <= NumberOfRetries; ++i) {
    try {
        // Do stuff with file
        break; // When done we can break loop
    }
    catch (IOException e) when (i <= NumberOfRetries) {
        // You may check error code to filter some exceptions, not every error
        // can be recovered.
        Thread.Sleep(DelayOnRetry);
    }
}

Tenga en cuenta un error común que vemos muy a menudo en StackOverflow:

var stream = File.Open(path, FileOpen.Read);
var content = File.ReadAllText(path);

En este caso ReadAllText()fallará porque el archivo está en uso ( File.Open()en la línea anterior). Abrir el archivo de antemano no solo es innecesario sino también incorrecto. Lo mismo se aplica a todas las Filefunciones que no devuelven un mango para el archivo que está trabajando: File.ReadAllText(), File.WriteAllText(), File.ReadAllLines(), File.WriteAllLines()y otros (como File.AppendAllXyz()funciones) hará todo lo abren y cierran el archivo por sí mismos.

Su proceso no es el único que accede a ese archivo
Si su proceso no es el único que accede a ese archivo, la interacción puede ser más difícil. Un patrón de reintento ayudará (si el archivo no debe ser abierto por otra persona pero lo es, entonces necesita una utilidad como Process Explorer para verificar quién está haciendo qué ).

Formas de evitar

En su caso, utilizar siempre el uso de declaraciones a los archivos abiertos. Como se dijo en el párrafo anterior, lo ayudará activamente a evitar muchos errores comunes (consulte esta publicación para ver un ejemplo sobre cómo no usarlo ).

Si es posible, intente decidir quién posee el acceso a un archivo específico y centralice el acceso a través de algunos métodos conocidos. Si, por ejemplo, tiene un archivo de datos donde su programa lee y escribe, entonces debe colocar todo el código de E / S dentro de una sola clase. Facilitará la depuración (porque siempre puede poner un punto de interrupción allí y ver quién está haciendo qué) y también será un punto de sincronización (si es necesario) para acceso múltiple.

No olvide que las operaciones de E / S siempre pueden fallar, un ejemplo común es este:

if (File.Exists(path))
    File.Delete(path);

Si alguien elimina el archivo después, File.Exists()pero antes File.Delete(), lo arrojará IOExceptiona un lugar en el que puede sentirse incorrectamente seguro.

Siempre que sea posible, aplique un patrón de reintento , y si está utilizando FileSystemWatcher, considere posponer la acción (porque recibirá una notificación, pero una aplicación aún puede estar funcionando exclusivamente con ese archivo).

Escenarios avanzados
No siempre es tan fácil, por lo que es posible que deba compartir el acceso con otra persona. Si, por ejemplo, está leyendo desde el principio y escribiendo hasta el final, tiene al menos dos opciones.

1) compartir lo mismo FileStreamcon las funciones de sincronización adecuadas (porque no es seguro para subprocesos ). Vea esto y esto publicaciones para un ejemplo.

2) utilice la FileShareenumeración para indicar al sistema operativo que permita que otros procesos (u otras partes de su propio proceso) accedan al mismo archivo simultáneamente.

using (var stream = File.Open(path, FileMode.Open, FileAccess.Write, FileShare.Read))
{
}

En este ejemplo, mostré cómo abrir un archivo para escribir y compartir para leer; tenga en cuenta que al leer y escribir superposiciones, se obtienen datos no definidos o no válidos. Es una situación que debe manejarse al leer. También tenga en cuenta que esto no hace que el acceso sea streamseguro para subprocesos, por lo que este objeto no se puede compartir con varios subprocesos a menos que el acceso esté sincronizado de alguna manera (ver enlaces anteriores). Hay otras opciones para compartir disponibles y abren escenarios más complejos. Consulte MSDN para más detalles.

En general, N procesos pueden leer del mismo archivo todos juntos, pero solo uno debe escribir, en un escenario controlado, incluso puede habilitar escrituras concurrentes, pero esto no puede generalizarse en pocos párrafos de texto dentro de esta respuesta.

¿Es posible desbloquear un archivo utilizado por otro proceso? No siempre es seguro y no es tan fácil, pero sí, es posible .

El uso de FileShare solucionó mi problema de abrir el archivo incluso si lo abre otro proceso.

using (var stream = File.Open(path, FileMode.Open, FileAccess.Write, FileShare.ReadWrite))
{
}

Tuve un problema al subir una imagen y no pude eliminarlo y encontré una solución. gl hf

//C# .NET
var image = Image.FromFile(filePath);

image.Dispose(); // this removes all resources

//later...

File.Delete(filePath); //now works

Recibí este error porque estaba haciendo File.Move a una ruta de archivo sin un nombre de archivo, necesito especificar la ruta completa en el destino.

El error indica que otro proceso está intentando acceder al archivo. Tal vez usted o alguien más lo tiene abierto mientras intenta escribirle. "Leer" o "Copiar" generalmente no causa esto, pero escribir o llamar a eliminar en él sí lo haría.

Hay algunas cosas básicas para evitar esto, como han mencionado otras respuestas:

1. En FileStreamoperaciones, colóquelo en un usingbloque con un FileShare.ReadWritemodo de acceso.

   Por ejemplo:

   using (FileStream stream = File.Open(path, FileMode.Open, FileAccess.Write, FileShare.ReadWrite))
   {
   }
   

   Tenga en cuenta que FileAccess.ReadWriteno es posible si lo usa FileMode.Append.

2. Me encontré con este problema cuando estaba usando una secuencia de entrada para hacer File.SaveAscuando el archivo estaba en uso. En mi caso, descubrí que en realidad no necesitaba volver a guardarlo en el sistema de archivos, así que terminé eliminando eso, pero probablemente podría haber intentado crear un FileStream en una usingdeclaración FileAccess.ReadWrite, al igual que el código encima.

3. Guardar sus datos como un archivo diferente y volver a eliminar el antiguo cuando se descubra que ya no está en uso, luego cambiar el nombre del que se guardó correctamente al nombre del original es una opción. La forma en que se prueba el uso del archivo se realiza a través de

   List<Process> lstProcs = ProcessHandler.WhoIsLocking(file);

   en mi código a continuación, y podría hacerse en un servicio de Windows, en un bucle, si tiene un archivo en particular que desea ver y eliminar regularmente cuando desea reemplazarlo. Si no siempre tiene el mismo archivo, se puede actualizar un archivo de texto o una tabla de base de datos para que el servicio siempre verifique los nombres de los archivos, y luego realice esa verificación de los procesos y, posteriormente, realice el proceso de eliminación y eliminación, como describí en la siguiente opción Tenga en cuenta que necesitará un nombre de usuario y contraseña de cuenta que tenga privilegios de administrador en la computadora determinada, por supuesto, para realizar la eliminación y finalización de los procesos.

4. Cuando no sabe si un archivo estará en uso cuando intenta guardarlo, puede cerrar todos los procesos que podrían estar usándolo, como Word, si es un documento de Word, antes de guardarlo.

   Si es local, puede hacer esto:

   ProcessHandler.localProcessKill("winword.exe");

   Si es remoto, puede hacer esto:

   ProcessHandler.remoteProcessKill(computerName, txtUserName, txtPassword, "winword.exe");

   donde txtUserNameestá en la forma de DOMAIN\user.

5. Digamos que no conoce el nombre del proceso que bloquea el archivo. Entonces, puedes hacer esto:

   List<Process> lstProcs = new List<Process>();
   lstProcs = ProcessHandler.WhoIsLocking(file);
   
   foreach (Process p in lstProcs)
   {
       if (p.MachineName == ".")
           ProcessHandler.localProcessKill(p.ProcessName);
       else
           ProcessHandler.remoteProcessKill(p.MachineName, txtUserName, txtPassword, p.ProcessName);
   }
   

   Tenga en cuenta que filedebe ser la ruta UNC: \\computer\share\yourdoc.docxpara que el Processpueda averiguar en qué computadora está y p.MachineNameser válido.

   A continuación se muestra la clase que utilizan estas funciones, que requiere agregar una referencia System.Management. El código fue escrito originalmente por Eric J .:

   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
   using System.Threading.Tasks;
   using System.Runtime.InteropServices;
   using System.Diagnostics;
   using System.Management;
   
   namespace MyProject
   {
       public static class ProcessHandler
       {
           [StructLayout(LayoutKind.Sequential)]
           struct RM_UNIQUE_PROCESS
           {
               public int dwProcessId;
               public System.Runtime.InteropServices.ComTypes.FILETIME ProcessStartTime;
           }
   
           const int RmRebootReasonNone = 0;
           const int CCH_RM_MAX_APP_NAME = 255;
           const int CCH_RM_MAX_SVC_NAME = 63;
   
           enum RM_APP_TYPE
           {
               RmUnknownApp = 0,
               RmMainWindow = 1,
               RmOtherWindow = 2,
               RmService = 3,
               RmExplorer = 4,
               RmConsole = 5,
               RmCritical = 1000
           }
   
           [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
           struct RM_PROCESS_INFO
           {
               public RM_UNIQUE_PROCESS Process;
   
               [MarshalAs(UnmanagedType.ByValTStr, SizeConst = CCH_RM_MAX_APP_NAME + 1)]
               public string strAppName;
   
               [MarshalAs(UnmanagedType.ByValTStr, SizeConst = CCH_RM_MAX_SVC_NAME + 1)]
               public string strServiceShortName;
   
               public RM_APP_TYPE ApplicationType;
               public uint AppStatus;
               public uint TSSessionId;
               [MarshalAs(UnmanagedType.Bool)]
               public bool bRestartable;
           }
   
           [DllImport("rstrtmgr.dll", CharSet = CharSet.Unicode)]
           static extern int RmRegisterResources(uint pSessionHandle,
                                               UInt32 nFiles,
                                               string[] rgsFilenames,
                                               UInt32 nApplications,
                                               [In] RM_UNIQUE_PROCESS[] rgApplications,
                                               UInt32 nServices,
                                               string[] rgsServiceNames);
   
           [DllImport("rstrtmgr.dll", CharSet = CharSet.Auto)]
           static extern int RmStartSession(out uint pSessionHandle, int dwSessionFlags, string strSessionKey);
   
           [DllImport("rstrtmgr.dll")]
           static extern int RmEndSession(uint pSessionHandle);
   
           [DllImport("rstrtmgr.dll")]
           static extern int RmGetList(uint dwSessionHandle,
                                       out uint pnProcInfoNeeded,
                                       ref uint pnProcInfo,
                                       [In, Out] RM_PROCESS_INFO[] rgAffectedApps,
                                       ref uint lpdwRebootReasons);
   
           /// <summary>
           /// Find out what process(es) have a lock on the specified file.
           /// </summary>
           /// <param name="path">Path of the file.</param>
           /// <returns>Processes locking the file</returns>
           /// <remarks>See also:
           /// http://msdn.microsoft.com/en-us/library/windows/desktop/aa373661(v=vs.85).aspx
           /// http://wyupdate.googlecode.com/svn-history/r401/trunk/frmFilesInUse.cs (no copyright in code at time of viewing)
           /// 
           /// </remarks>
           static public List<Process> WhoIsLocking(string path)
           {
               uint handle;
               string key = Guid.NewGuid().ToString();
               List<Process> processes = new List<Process>();
   
               int res = RmStartSession(out handle, 0, key);
               if (res != 0) throw new Exception("Could not begin restart session.  Unable to determine file locker.");
   
               try
               {
                   const int ERROR_MORE_DATA = 234;
                   uint pnProcInfoNeeded = 0,
                       pnProcInfo = 0,
                       lpdwRebootReasons = RmRebootReasonNone;
   
                   string[] resources = new string[] { path }; // Just checking on one resource.
   
                   res = RmRegisterResources(handle, (uint)resources.Length, resources, 0, null, 0, null);
   
                   if (res != 0) throw new Exception("Could not register resource.");
   
                   //Note: there's a race condition here -- the first call to RmGetList() returns
                   //      the total number of process. However, when we call RmGetList() again to get
                   //      the actual processes this number may have increased.
                   res = RmGetList(handle, out pnProcInfoNeeded, ref pnProcInfo, null, ref lpdwRebootReasons);
   
                   if (res == ERROR_MORE_DATA)
                   {
                       // Create an array to store the process results
                       RM_PROCESS_INFO[] processInfo = new RM_PROCESS_INFO[pnProcInfoNeeded];
                       pnProcInfo = pnProcInfoNeeded;
   
                       // Get the list
                       res = RmGetList(handle, out pnProcInfoNeeded, ref pnProcInfo, processInfo, ref lpdwRebootReasons);
                       if (res == 0)
                       {
                           processes = new List<Process>((int)pnProcInfo);
   
                           // Enumerate all of the results and add them to the 
                           // list to be returned
                           for (int i = 0; i < pnProcInfo; i++)
                           {
                               try
                               {
                                   processes.Add(Process.GetProcessById(processInfo[i].Process.dwProcessId));
                               }
                               // catch the error -- in case the process is no longer running
                               catch (ArgumentException) { }
                           }
                       }
                       else throw new Exception("Could not list processes locking resource.");
                   }
                   else if (res != 0) throw new Exception("Could not list processes locking resource. Failed to get size of result.");
               }
               finally
               {
                   RmEndSession(handle);
               }
   
               return processes;
           }
   
           public static void remoteProcessKill(string computerName, string userName, string pword, string processName)
           {
               var connectoptions = new ConnectionOptions();
               connectoptions.Username = userName;
               connectoptions.Password = pword;
   
               ManagementScope scope = new ManagementScope(@"\\" + computerName + @"\root\cimv2", connectoptions);
   
               // WMI query
               var query = new SelectQuery("select * from Win32_process where name = '" + processName + "'");
   
               using (var searcher = new ManagementObjectSearcher(scope, query))
               {
                   foreach (ManagementObject process in searcher.Get()) 
                   {
                       process.InvokeMethod("Terminate", null);
                       process.Dispose();
                   }
               }            
           }
   
           public static void localProcessKill(string processName)
           {
               foreach (Process p in Process.GetProcessesByName(processName))
               {
                   p.Kill();
               }
           }
   
           [DllImport("kernel32.dll")]
           public static extern bool MoveFileEx(string lpExistingFileName, string lpNewFileName, int dwFlags);
   
           public const int MOVEFILE_DELAY_UNTIL_REBOOT = 0x4;
   
       }
   }
   

Como han señalado otras respuestas en este hilo, para resolver este error debe inspeccionar cuidadosamente el código, para comprender dónde se bloquea el archivo.

En mi caso, estaba enviando el archivo como un archivo adjunto de correo electrónico antes de realizar la operación de mover.

Entonces, el archivo se bloqueó durante un par de segundos hasta que el cliente SMTP terminó de enviar el correo electrónico.

La solución que adopté fue mover primero el archivo y luego enviar el correo electrónico. Esto resolvió mi problema.

Otra posible solución, como señaló Hudson anteriormente, habría sido deshacerse del objeto después de su uso.

public static SendEmail()
{
           MailMessage mMailMessage = new MailMessage();
           //setup other email stuff

            if (File.Exists(attachmentPath))
            {
                Attachment attachment = new Attachment(attachmentPath);
                mMailMessage.Attachments.Add(attachment);
                attachment.Dispose(); //disposing the Attachment object
            }
} 

Tuve el siguiente escenario que estaba causando el mismo error:

• Subir archivos al servidor
• Luego, elimine los archivos antiguos después de que se hayan cargado

La mayoría de los archivos eran pequeños, sin embargo, algunos eran grandes y, por lo tanto, al intentar eliminarlos, no se pudo acceder al archivo .

No fue fácil de encontrar, sin embargo, la solución fue tan simple como Esperar "a que la tarea complete la ejecución":

using (var wc = new WebClient())
{
   var tskResult = wc.UploadFileTaskAsync(_address, _fileName);
   tskResult.Wait(); 
}

El siguiente código resuelve este problema, pero le sugiero que, en primer lugar, necesite comprender qué está causando este problema y probar la solución que puede encontrar cambiando el código

Puedo dar otra forma de resolver este problema, pero una mejor solución es verificar su estructura de codificación e intentar analizar qué hace que esto suceda, si no encuentra ninguna solución, puede ir con este código a continuación

try{
Start:
///Put your file access code here


}catch (Exception ex)
 {
//by anyway you need to handle this error with below code
   if (ex.Message.StartsWith("The process cannot access the file"))
    {
         //Wait for 5 seconds to free that file and then start execution again
         Thread.Sleep(5000);
         goto Start;
    }
 }