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

Question

Je veux savoir comment je peux vérifier un programme dans un endroit précis si elle est en cours d'exécution. Par exemple, il y a deux endroits pour test.exe dans c: \ loc1 \ test.exe et c: \ loc2 \ test.exe. Je ne voulais savoir si c: \ loc1 \ test.exe est en cours d'exécution et non toutes les instances de test.exe

.

Answer 1

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

Answer 2

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

Answer 3

essayer ... Je l'utilise pour déterminer au démarrage si un autre processus est déjà en cours avec le même nom que l'exe que je suis en train de commencer, et puis juste faire que l'un au premier plan, (et de se concentrer) si il est déjà en cours d'exécution ... vous pouvez le modifier à prendre un nom de processus et d'essai pour ce nom spécifique ... Cela vous dira s'il y a un processus en cours d'exécution avec un nom, mais pas où ce processus a été chargé .. .

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

Mais par curiosité, pourquoi ça peut vous faire, à moins qu'ils sont différents? Et si elles sont différentes d'une certaine façon, le code à utiliser cette différence (quel qu'il soit) pour détecter qui est chargé. Mais si elles sont les mêmes comment peut-il important pour le charger? A été utilisé image sur le disque

    [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 4

Vous devez itérer sur tous les processus existants et vérifier leur propriété MainModule le nom du fichier que vous recherchez. Quelque chose comme ceci

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 5

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

Answer 6

Quelque chose comme ça. GetMainModuleFileName aide à accéder processus x64 x86 à partir.

  [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 7

Vous pouvez utiliser un nommé mutex , c'est nommé hors de la structure de répertoire du programme est en cours d'exécution dans.

Answer 8

System.Reflection.Assembly.GetEntryAssembly()

signifieront pour vous beaucoup d'informations sur l'ensemble d'entrée, tels que:

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

Ceci indiquera l'emplacement de l'assemblage en cours d'exécution.