web-dev-qa-db-fra.com

Vérifier si un fichier exe spécifique est en cours d'exécution

Je veux savoir comment je peux vérifier un programme dans un emplacement spécifique s'il est en cours d'exécution. Par exemple, il existe deux emplacements pour test.exe dans c:\loc1\test.exe et c:\loc2\test.exe. Je voulais seulement savoir si c:\loc1\test.exe est en cours d'exécution et non toutes les instances de test.exe.

c#process-management
33
murasaki5
bool isRunning = Process.GetProcessesByName("test")
                .FirstOrDefault(p => p.MainModule.FileName.StartsWith(@"c:\loc1")) != default(Process);
51
bruno conde

Ceci est ma fonction améliorée:

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

et l'utiliser comme:

ProgramIsRunning(@"c:\loc1\test.exe");
6
Pishgaman.org

essayez ceci ... Je l'utilise pour déterminer au démarrage si un autre processus est déjà en cours d'exécution avec le même nom que l'exécutable que je tente de démarrer, puis placez-le au premier plan (et à se concentrer) s'il est déjà en cours d'exécution ... Vous pouvez le modifier pour prendre un nom de processus et tester ce nom spécifique ... Ceci vous indiquera si un processus s'exécute avec un certain nom, mais pas d'où ce processus a été chargé ... 

Si un processus s'exécute avec le nom spécifié, si ce processus avait une méthode accessible exposée qui retourne où il a été chargé, vous pouvez appeler cette méthode sur le processus en cours d'exécution, sinon, je ne sais pas. 

Mais juste par curiosité, pourquoi vous en souciez-vous, à moins qu’elles ne soient différentes? Et s’ils sont différents d’une manière ou d’une autre, codez pour utiliser cette différence (quelle qu’elle soit) pour détecter lequel est chargé. Mais si elles sont identiques, quelle importance peut avoir l'image sur disque utilisée pour la charger?

    [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;
    }
5
Charles Bretana

Vous devriez parcourir tous les processus existants, puis vérifier que leur propriété MainModule correspond au nom de fichier recherché. Quelque chose comme ça

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...
   }
}
4
Frank Bollack

Cette fonction peut aider:

using System.Diagnostics;

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

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

3
dreikanter

Quelque chose comme ça. GetMainModuleFileName permet d’accéder au processus x64 à partir de 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;
}
0
vik_78

Vous pouvez utiliser un nommé mutex , nommé en dehors de la structure de répertoires dans laquelle le programme est exécuté.

0
JustLoren