Comment obtenir le chemin complet du processus en cours?

J'ai une application qui modifie certains paramètres d'une autre application (c'est une simple application C # qui s'exécute en double-cliquant (aucune configuration requise)).

Après avoir modifié les paramètres, je dois redémarrer l'autre application afin qu'elle reflète les paramètres modifiés.

Donc, pour ce faire, je dois tuer le processus en cours et recommencer le processus, mais le problème est qu'après avoir tué, je ne parviens pas à trouver le processus. (La raison est que le système ne sait pas où se trouve le fichier exe.)

Existe-t-il un moyen de trouver le chemin du processus en cours d'exécution ou de l'exe, s'il est en cours d'exécution?

Je ne veux pas donner le chemin manuellement, c'est-à-dire que s'il est en cours d'exécution, récupérez le chemin, tuez le processus et recommencez sinon .... Je traiterai plus tard

 using System.Diagnostics;
 var process = Process.GetCurrentProcess(); // Or whatever method you are using
 string fullPath = process.MainModule.FileName;
 //fullPath has the path to exe.

Il y a un problème avec cette API, si vous exécutez ce code dans une application 32 bits, vous ne pourrez pas accéder aux chemins d'application 64 bits, vous devrez donc compiler et exécuter votre application en tant qu'application 64 bits ( Propriétés du projet → Construire → Cible de la plateforme → x64).

Ce que vous pouvez faire, c'est utiliser WMI pour obtenir les chemins. Cela vous permettra d'obtenir le chemin, qu'il s'agisse d'une application 32 bits ou 64 bits. Voici un exemple montrant comment vous pouvez l'obtenir:

// include the namespace
using System.Management;

var wmiQueryString = "SELECT ProcessId, ExecutablePath, CommandLine FROM Win32_Process";
using (var searcher = new ManagementObjectSearcher(wmiQueryString))
using (var results = searcher.Get())
{
    var query = from p in Process.GetProcesses()
                join mo in results.Cast<ManagementObject>()
                on p.Id equals (int)(uint)mo["ProcessId"]
                select new
                {
                    Process = p,
                    Path = (string)mo["ExecutablePath"],
                    CommandLine = (string)mo["CommandLine"],
                };
    foreach (var item in query)
    {
        // Do what you want with the Process, Path, and CommandLine
    }
}

Notez que vous devrez référencer l' System.Management.dllassembly et utiliser l' System.Managementespace de noms.

Pour plus d'informations sur les autres informations que vous pouvez extraire de ces processus, telles que la ligne de commande utilisée pour démarrer le programme ( CommandLine), consultez la classe Win32_Process et WMI .NET pour plus d'informations.

Je suppose que vous avez déjà l'objet de processus du processus en cours (par exemple par GetProcessesByName ()). Vous pouvez ensuite obtenir le nom du fichier exécutable en utilisant

Process p;
string filename = p.MainModule.FileName;

Une solution pour:

• Processus 32 bits ET 64 bits
• System.Diagnostics uniquement (pas de System.Management)

J'ai utilisé la solution de Russell Gantman et l' ai réécrite comme une méthode d'extension que vous pouvez utiliser comme ceci:

var process = Process.GetProcessesByName("explorer").First();
string path = process.GetMainModuleFileName();
// C:\Windows\explorer.exe

Avec cette implémentation:

internal static class Extensions {
    [DllImport("Kernel32.dll")]
    private static extern bool QueryFullProcessImageName([In] IntPtr hProcess, [In] uint dwFlags, [Out] StringBuilder lpExeName, [In, Out] ref uint lpdwSize);

    public static string GetMainModuleFileName(this Process process, int buffer = 1024) {
        var fileNameBuilder = new StringBuilder(buffer);
        uint bufferLength = (uint)fileNameBuilder.Capacity + 1;
        return QueryFullProcessImageName(process.Handle, 0, fileNameBuilder, ref bufferLength) ?
            fileNameBuilder.ToString() :
            null;
    }
}

En combinant les réponses de Sanjeevakumar Hiremath et de Jeff Mercado, vous pouvez en fait contourner le problème lors de la récupération de l'icône à partir d'un processus 64 bits dans un processus 32 bits.

using System;
using System.Management;
using System.Diagnostics;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            int processID = 6680;   // Change for the process you would like to use
            Process process = Process.GetProcessById(processID);
            string path = ProcessExecutablePath(process);
        }

        static private string ProcessExecutablePath(Process process)
        {
            try
            {
                return process.MainModule.FileName;
            }
            catch
            {
                string query = "SELECT ExecutablePath, ProcessID FROM Win32_Process";
                ManagementObjectSearcher searcher = new ManagementObjectSearcher(query);

                foreach (ManagementObject item in searcher.Get())
                {
                    object id = item["ProcessID"];
                    object path = item["ExecutablePath"];

                    if (path != null && id.ToString() == process.Id.ToString())
                    {
                        return path.ToString();
                    }
                }
            }

            return "";
        }
    }
}

Cela peut être un peu lent et ne fonctionne pas sur tous les processus qui n'ont pas d'icône «valide».

Voici une solution fiable qui fonctionne à la fois avec 32 bits applications bits et 64 bits .

Ajoutez ces références:

en utilisant System.Diagnostics;

en utilisant System.Management;

Ajoutez cette méthode à votre projet:

public static string GetProcessPath(int processId)
{
    string MethodResult = "";
    try
    {
        string Query = "SELECT ExecutablePath FROM Win32_Process WHERE ProcessId = " + processId;

        using (ManagementObjectSearcher mos = new ManagementObjectSearcher(Query))
        {
            using (ManagementObjectCollection moc = mos.Get())
            {
                string ExecutablePath = (from mo in moc.Cast<ManagementObject>() select mo["ExecutablePath"]).First().ToString();

                MethodResult = ExecutablePath;

            }

        }

    }
    catch //(Exception ex)
    {
        //ex.HandleException();
    }
    return MethodResult;
}

Maintenant, utilisez-le comme ceci:

int RootProcessId = Process.GetCurrentProcess().Id;

GetProcessPath(RootProcessId);

Notez que si vous connaissez l'id du processus, cette méthode renverra l'ExecutePath correspondant.

Extra, pour ceux qui sont intéressés:

Process.GetProcesses() 

... vous donnera un tableau de tous les processus en cours d'exécution, et ...

Process.GetCurrentProcess()

... vous donnera le processus actuel, ainsi que leurs informations, par exemple Id, etc. et également un contrôle limité, par exemple Kill, etc. *

Vous pouvez utiliser pInvoke et un appel natif tel que le suivant. Cela ne semble pas avoir la limitation 32/64 bits (du moins dans mes tests)

Voici le code

using System.Runtime.InteropServices;

    [DllImport("Kernel32.dll")]
    static extern uint QueryFullProcessImageName(IntPtr hProcess, uint flags, StringBuilder text, out uint size);

    //Get the path to a process
    //proc = the process desired
    private string GetPathToApp (Process proc)
    {
        string pathToExe = string.Empty;

        if (null != proc)
        {
            uint nChars = 256;
            StringBuilder Buff = new StringBuilder((int)nChars);

            uint success = QueryFullProcessImageName(proc.Handle, 0, Buff, out nChars);

            if (0 != success)
            {
                pathToExe = Buff.ToString();
            }
            else
            {
                int error = Marshal.GetLastWin32Error();
                pathToExe = ("Error = " + error + " when calling GetProcessImageFileName");
            }
        }

        return pathToExe;
    }

Essayer:

using System.Diagnostics;

ProcessModuleCollection modules = Process.GetCurrentProcess().Modules;
string processpathfilename;
string processmodulename;
if (modules.Count > 0) {
    processpathfilename = modules[0].FileName;
    processmodulename= modules[0].ModuleName;
} else {
    throw new ExecutionEngineException("Something critical occurred with the running process.");
}

private void Test_Click(object sender, System.EventArgs e){
   string path;
   path = System.IO.Path.GetDirectoryName( 
      System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase );
    Console.WriiteLine( path );  
}

using System;
using System.Diagnostics;

class Program
{
    public static void printAllprocesses()
    {
        Process[] processlist = Process.GetProcesses();

        foreach (Process process in processlist)
        {
            try
            {
                String fileName = process.MainModule.FileName;
                String processName = process.ProcessName;

                Console.WriteLine("processName : {0},  fileName : {1}", processName, fileName);
            }catch(Exception e)
            {
                /* You will get access denied exception for system processes, We are skiping the system processes here */
            }

        }
    }

    static void Main()
    {
        printAllprocesses();
    }

}

Pour les autres, si vous souhaitez trouver un autre processus du même exécutable, vous pouvez utiliser:

public bool tryFindAnotherInstance(out Process process) {
    Process thisProcess = Process.GetCurrentProcess();
    string thisFilename = thisProcess.MainModule.FileName;
    int thisPId = thisProcess.Id;
    foreach (Process p in Process.GetProcesses())
    {
        try
        {
            if (p.MainModule.FileName == thisFilename && thisPId != p.Id)
            {
                process = p;
                return true;
            }
        }
        catch (Exception)
        {

        }
    }
    process = default;
    return false;
}

La Processclasse a un membre StartInfoque vous devriez vérifier:

• http://msdn.microsoft.com/en-us/library/system.diagnostics.processstartinfo_members(v=VS.71).aspx

Je suis arrivé à ce fil en recherchant le répertoire actuel d'un processus en cours d'exécution. Dans .net 1.1, Microsoft a introduit:

Directory.GetCurrentDirectory();

Semble bien fonctionner (mais ne renvoie pas le nom du processus lui-même).