¿Cómo puedo saber qué proceso está bloqueando un archivo usando .NET?


154

He visto varias respuestas sobre el uso de Handle o Process Monitor , pero me gustaría poder averiguar en mi propio código (C #) qué proceso está bloqueando un archivo.

Tengo la desagradable sensación de que voy a tener que dar vueltas en la API win32, pero si alguien ya ha hecho esto y puede ponerme en el camino correcto, realmente agradecería la ayuda.

Actualizar

Enlaces a preguntas similares


Respuestas:


37

Una de las ventajas handle.exees que puede ejecutarlo como un subproceso y analizar la salida.

Hacemos esto en nuestro script de implementación: funciona de maravilla.


21
pero handle.exe no se puede distribuir con su software
torpederos

1
Buen punto. Esto no fue un problema con el script de implementación (utilizado internamente), pero lo sería en otros escenarios.
orip

2
alguna muestra de código fuente completo en C #? válido también para obtener proceso es bloquear una CARPETA?
Kiquenet

3
Vea mi respuesta para una solución que no requiere handle.exe stackoverflow.com/a/20623311/141172
Eric J.

"Debe tener privilegios administrativos para ejecutar Handle".
Uwe Keim

135

Hace mucho tiempo era imposible obtener de manera confiable la lista de procesos que bloquean un archivo porque Windows simplemente no rastreó esa información. Para admitir la API de Restart Manager , ahora se realiza un seguimiento de esa información.

Arme el código que toma la ruta de un archivo y devuelve uno List<Process>de todos los procesos que están bloqueando ese archivo.

using System.Runtime.InteropServices;
using System.Diagnostics;
using System;
using System.Collections.Generic;

static public class FileUtil
{
    [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;
    }
}

Uso de permiso limitado (por ejemplo, IIS)

Esta llamada accede al registro. Si el proceso no tiene permiso para hacerlo, obtendrá ERROR_WRITE_FAULT, que significa An operation was unable to read or write to the registry . Usted podría conceder el permiso de forma selectiva a su cuenta restringida a la parte necesaria para el registro. Sin embargo, es más seguro que su proceso de acceso limitado establezca un indicador (por ejemplo, en la base de datos o el sistema de archivos, o mediante el uso de un mecanismo de comunicación entre procesos, como cola o canalización con nombre) y que un segundo proceso llame a la API del Administrador de reinicio.

Otorgar permisos distintos al mínimo para el usuario de IIS es un riesgo de seguridad.


¿Alguien ha intentado eso, parece que realmente podría funcionar (para Windows por encima de Vista y srv 2008)
Daniel Mošmondor

1
@Blagoh: No creo que el Administrador de reinicio esté disponible en Windows XP. Tendría que recurrir a uno de los otros métodos menos precisos publicados aquí.
Eric J.

44
@Blagoh: si solo desea saber quién está bloqueando una DLL específica, puede usar tasklist /m YourDllName.dlly analizar la salida. Ver stackoverflow.com/questions/152506/…
Eric J.

19
Única solución que no requiere herramientas de terceros o llamadas API no documentadas. Bien debería ser la respuesta aceptada.
Inspectable

44
He probado esto (y funciona) en Windows 2008R2, Windows 2012R2, Windows 7 y Windows 10. Descubrí que tenía que ejecutarse con privilegios elevados en muchas circunstancias; de lo contrario, falla al intentar obtener la lista de Procesos de bloqueo de un archivo.
Jay

60

Es muy complejo invocar Win32 desde C #.

Debe usar la herramienta Handle.exe .

Después de eso, su código C # debe ser el siguiente:

string fileName = @"c:\aaa.doc";//Path to locked file

Process tool = new Process();
tool.StartInfo.FileName = "handle.exe";
tool.StartInfo.Arguments = fileName+" /accepteula";
tool.StartInfo.UseShellExecute = false;
tool.StartInfo.RedirectStandardOutput = true;
tool.Start();           
tool.WaitForExit();
string outputTool = tool.StandardOutput.ReadToEnd();

string matchPattern = @"(?<=\s+pid:\s+)\b(\d+)\b(?=\s+)";
foreach(Match match in Regex.Matches(outputTool, matchPattern))
{
    Process.GetProcessById(int.Parse(match.Value)).Kill();
}

1
buen ejemplo, pero que yo sepa, handle.exe ahora muestra un mensaje desagradable para aceptar algunas condiciones cuando lo ejecuta en una máquina cliente por primera vez, lo que en mi opinión, lo descalifica
Arsen Zahray

13
@Arsen Zahray: puede aceptar el eula automáticamente pasando una opción de línea de comando de /accepteula. He actualizado la respuesta de Gennady con el cambio.
Jon Cage

¿Qué versión de Handle.exe usaste? El nuevo V4 parece haber cambiado de una manera rota. / acceptteula y Filename ya no son compatibles
Venson

3
No se puede redistribuirhandle.exe
básico el

44
No estoy de acuerdo: no tiene complejidad al invocar win32 api desde c #.
Idan

10

Tuve problemas con la solución de stefan . A continuación se muestra una versión modificada que parece funcionar bien.

using System;
using System.Collections;
using System.Diagnostics;
using System.Management;
using System.IO;

static class Module1
{
    static internal ArrayList myProcessArray = new ArrayList();
    private static Process myProcess;

    public static void Main()
    {
        string strFile = "c:\\windows\\system32\\msi.dll";
        ArrayList a = getFileProcesses(strFile);
        foreach (Process p in a)
        {
            Debug.Print(p.ProcessName);
        }
    }

    private static ArrayList getFileProcesses(string strFile)
    {
        myProcessArray.Clear();
        Process[] processes = Process.GetProcesses();
        int i = 0;
        for (i = 0; i <= processes.GetUpperBound(0) - 1; i++)
        {
            myProcess = processes[i];
            //if (!myProcess.HasExited) //This will cause an "Access is denied" error
            if (myProcess.Threads.Count > 0)
            {
                try
                {
                    ProcessModuleCollection modules = myProcess.Modules;
                    int j = 0;
                    for (j = 0; j <= modules.Count - 1; j++)
                    {
                        if ((modules[j].FileName.ToLower().CompareTo(strFile.ToLower()) == 0))
                        {
                            myProcessArray.Add(myProcess);
                            break;
                            // TODO: might not be correct. Was : Exit For
                        }
                    }
                }
                catch (Exception exception)
                {
                    //MsgBox(("Error : " & exception.Message)) 
                }
            }
        }

        return myProcessArray;
    }
}

ACTUALIZAR

Si solo desea saber qué procesos están bloqueando una DLL en particular, puede ejecutar y analizar la salida de tasklist /m YourDllName.dll. Funciona en Windows XP y versiones posteriores. Ver

¿Qué hace esto? lista de tareas / m "mscor *"


No entiendo por qué myProcessArrayes un miembro de la clase (pero también regresó de getFileProcesses ()? Lo mismo ocurre myProcess.)
Oskar Berggren

7

Esto funciona para archivos DLL bloqueados por otros procesos. Esta rutina no descubrirá, por ejemplo, que un archivo de texto está bloqueado por un proceso de texto.

C#:

using System.Management; 
using System.IO;   

static class Module1 
{ 
static internal ArrayList myProcessArray = new ArrayList(); 
private static Process myProcess; 

public static void Main() 
{ 

    string strFile = "c:\\windows\\system32\\msi.dll"; 
    ArrayList a = getFileProcesses(strFile); 
    foreach (Process p in a) { 
        Debug.Print(p.ProcessName); 
    } 
} 


private static ArrayList getFileProcesses(string strFile) 
{ 
    myProcessArray.Clear(); 
    Process[] processes = Process.GetProcesses; 
    int i = 0; 
    for (i = 0; i <= processes.GetUpperBound(0) - 1; i++) { 
        myProcess = processes(i); 
        if (!myProcess.HasExited) { 
            try { 
                ProcessModuleCollection modules = myProcess.Modules; 
                int j = 0; 
                for (j = 0; j <= modules.Count - 1; j++) { 
                    if ((modules.Item(j).FileName.ToLower.CompareTo(strFile.ToLower) == 0)) { 
                        myProcessArray.Add(myProcess); 
                        break; // TODO: might not be correct. Was : Exit For 
                    } 
                } 
            } 
            catch (Exception exception) { 
            } 
            //MsgBox(("Error : " & exception.Message)) 
        } 
    } 
    return myProcessArray; 
} 
} 

VB.Net:

Imports System.Management
Imports System.IO

Module Module1
Friend myProcessArray As New ArrayList
Private myProcess As Process

Sub Main()

    Dim strFile As String = "c:\windows\system32\msi.dll"
    Dim a As ArrayList = getFileProcesses(strFile)
    For Each p As Process In a
        Debug.Print(p.ProcessName)
    Next
End Sub


Private Function getFileProcesses(ByVal strFile As String) As ArrayList
    myProcessArray.Clear()
    Dim processes As Process() = Process.GetProcesses
    Dim i As Integer
    For i = 0 To processes.GetUpperBound(0) - 1
        myProcess = processes(i)
        If Not myProcess.HasExited Then
            Try
                Dim modules As ProcessModuleCollection = myProcess.Modules
                Dim j As Integer
                For j = 0 To modules.Count - 1
                    If (modules.Item(j).FileName.ToLower.CompareTo(strFile.ToLower) = 0) Then
                        myProcessArray.Add(myProcess)
                        Exit For
                    End If
                Next j
            Catch exception As Exception
                'MsgBox(("Error : " & exception.Message))
            End Try
        End If
    Next i
    Return myProcessArray
End Function
End Module

En mi ejemplo, uso msi.dll que no es una DLL .Net.
Stefan

0

más simple con linq:

public void KillProcessesAssociatedToFile(string file)
    {
        GetProcessesAssociatedToFile(file).ForEach(x =>
        {
            x.Kill();
            x.WaitForExit(10000);
        });
    }

    public List<Process> GetProcessesAssociatedToFile(string file)
    {
        return Process.GetProcesses()
            .Where(x => !x.HasExited
                && x.Modules.Cast<ProcessModule>().ToList()
                    .Exists(y => y.FileName.ToLowerInvariant() == file.ToLowerInvariant())
                ).ToList();
    }

parece volver a lanzar la misma excepción
Sinaesthetic

Dando el error. un proceso de 32 bits no puede acceder al módulo del proceso de 64 bits.
ajinkya
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.