c# - saber - Comprueba si se está ejecutando un archivo exe específico

vb6 saber si un programa se esta ejecutando

Question

Quiero saber cómo puedo verificar un programa en una ubicación específica si se está ejecutando. Por ejemplo, hay dos ubicaciones para test.exe en c: / loc1 / test.exe yc: / loc2 / test.exe. Solo quería saber si se está ejecutando c: / loc1 / test.exe y no todas las instancias de test.exe.

Answer 1

Algo como esto. GetMainModuleFileName ayuda a acceder al proceso x64 desde x86.

  [DllImport("kernel32.dll")]
  public static extern bool QueryFullProcessImageName(IntPtr hprocess, int dwFlags, StringBuilder lpExeName, out int size);

  private bool CheckRunningProcess(string processName, string path) {

  Process[] processes = Process.GetProcessesByName(processName);
  foreach(Process p in processes) {
    var name = GetMainModuleFileName(p);
    if (name == null)
      continue;
    if (string.Equals(name, path, StringComparison.InvariantCultureIgnoreCase)) {
      return true;
    }
  }
  return false;
}

// Get x64 process module name from x86 process
private static string GetMainModuleFileName(Process process, int buffer = 1024) {

  var fileNameBuilder = new StringBuilder(buffer);
  int bufferLength = fileNameBuilder.Capacity + 1;
  return QueryFullProcessImageName(process.Handle, 0, fileNameBuilder, out bufferLength) ?
      fileNameBuilder.ToString() :
      null;
}

Answer 2

Debería iterar sobre todos los procesos existentes y luego verificar su propiedad MainModule para el nombre de archivo que está buscando. Algo como esto

using System.Diagnostics;
using System.IO;

//...

string fileNameToFilter = Path.GetFullPath("c://loc1//test.exe");

foreach (Process p in Process.GetProcesses())
{
   string fileName = Path.GetFullPath(p.MainModule.FileName);

   //cehck for equality (case insensitive)
   if (string.Compare(fileNameToFilter, fileName, true) == 0)
   {
      //matching...
   }
}

Answer 3

Esta es mi función mejorada:

private bool ProgramIsRunning(string FullPath)
{
    string FilePath =  Path.GetDirectoryName(FullPath);
    string FileName = Path.GetFileNameWithoutExtension(FullPath).ToLower();
    bool isRunning = false;

    Process[] pList = Process.GetProcessesByName(FileName);

    foreach (Process p in pList) {
        if (p.MainModule.FileName.StartsWith(FilePath, StringComparison.InvariantCultureIgnoreCase))
        {
            isRunning = true;
            break;
        }
    }

    return isRunning;
}

y usarlo como:

ProgramIsRunning(@"c:/loc1/test.exe");

Answer 4

Esta función puede ayudar:

using System.Diagnostics;

public bool IsProcessOpen(string name)
{
    foreach (Process clsProcess in Process.GetProcesses()) {
        if (clsProcess.ProcessName.Contains(name))
        {
            return true;
        }
    }
    return false;
} 

Fuente: http://www.dreamincode.net/code/snippet1541.htm

Answer 5

Puede usar un mutex con nombre , que se llama fuera de la estructura de directorio en la que se ejecuta el programa.

Answer 6

intente esto ... Lo uso para determinar al inicio si ya se está ejecutando otro proceso con el mismo nombre que el que estoy tratando de iniciar, y luego simplemente poner ese en primer plano, (y enfocar) si ya está ejecutándose ... Podría modificarlo para tomar un nombre de proceso y probar ese nombre específico ... Esto le dirá si hay un proceso ejecutándose con un nombre determinado, pero no desde dónde se cargó ese proceso desde ...

Si hay un proceso ejecutándose con el nombre especificado, entonces, si ese proceso tenía un método accesible que muestra el lugar desde donde se cargó, puede llamar a ese método en el proceso en ejecución; de lo contrario, no sé ...

Pero solo por curiosidad, ¿por qué te importa, a menos que sean diferentes? Y si son diferentes de alguna manera, codifique para usar esa diferencia (lo que sea) para detectar cuál se carga. Pero si son lo mismo, ¿cómo puede importar qué imagen en el disco se utilizó para cargarlo?

    [DllImport("user32.dll")]
    private static extern bool SetForegroundWindow(IntPtr hWnd);
    [DllImport("user32.dll")]
    private static extern bool ShowWindowAsync(IntPtr hWnd, int nCmdShow);
    [DllImport("user32.dll")]
    private static extern bool IsIconic(IntPtr hWnd);

    private const int SW_HIDE = 0;
    private const int SW_SHOWNORMAL = 1;
    private const int SW_SHOWMINIMIZED = 2;
    private const int SW_SHOWMAXIMIZED = 3;
    private const int SW_SHOWNOACTIVATE = 4;
    private const int SW_RESTORE = 9;
    private const int SW_SHOWDEFAULT = 10;

 private static bool IsAlreadyRunning()
    {
        // get all processes by Current Process name
        Process[] processes = 
            Process.GetProcessesByName(
                Process.GetCurrentProcess().ProcessName);

        // if there is more than one process...
        if (processes.Length > 1) 
        {
            // if other process id is OUR process ID...
            // then the other process is at index 1
            // otherwise other process is at index 0
            int n = (processes[0].Id == Process.GetCurrentProcess().Id) ? 1 : 0;

            // get the window handle
            IntPtr hWnd = processes[n].MainWindowHandle;

            // if iconic, we need to restore the window
            if (IsIconic(hWnd)) ShowWindowAsync(hWnd, SW_RESTORE);

            // Bring it to the foreground
            SetForegroundWindow(hWnd);
            return true;
        }
        return false;
    }

Answer 7

System.Reflection.Assembly.GetEntryAssembly()

Esto le brindará mucha información sobre el ensamblaje de entrada, como por ejemplo:

System.Reflection.Assembly.GetEntryAssembly().CodeBase;

Esto indicará la ubicación del ensamblaje en ejecución.

Answer 8

bool isRunning = Process.GetProcessesByName("test")
                .FirstOrDefault(p => p.MainModule.FileName.StartsWith(@"c:/loc1")) != default(Process);