Как найти путь процесса

Yennefer

5,6047 gold badges31 silver badges44 bronze badges

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

There is one catch with this API, if you are running this code in 32 bit application, you’ll not be able to access 64-bit application paths, so you’d have to compile and run you app as 64-bit application (Project Properties → Build → Platform Target → x64).

What you can do is use WMI to get the paths. This will allow you to get the path regardless it’s a 32-bit or 64-bit application. Here’s an example demonstrating how you can get it:

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

Note that you’ll have to reference the System.Management.dll assembly and use the System.Management namespace.

For more info on what other information you can grab out of these processes such as the command line used to start the program (CommandLine), see the Win32_Process class and WMI .NET for for more information.

answered Mar 31, 2011 at 8:51

A solution for:

• Both 32-bit AND 64-bit processes
• System.Diagnostics only (no System.Management)

I used the solution from Russell Gantman and rewritten it as an extension method you can use like this:

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

With this implementation:

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

answered Jan 18, 2018 at 11:09

I guess you already have the process object of the running process (e.g. by GetProcessesByName()).
You can then get the executable file name by using:

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

By combining Sanjeevakumar Hiremath’s and Jeff Mercado’s answers you can actually in a way get around the problem when retrieving the icon from a 64-bit process in a 32-bit process.

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

This may be a bit slow and doesn’t work on every process which lacks a “valid” icon.

answered Feb 3, 2013 at 0:20

Here is a reliable solution that works with both 32bit and 64bit applications.

Add these references:

using System.Diagnostics;

using System.Management;

Add this method to your project:

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

Now use it like so:

int RootProcessId = Process.GetCurrentProcess().Id;

GetProcessPath(RootProcessId);

Notice that if you know the id of the process, then this method will return the corresponding ExecutePath.

Extra, for those interested:

Process.GetProcesses() 

…will give you an array of all the currently running processes, and…

Process.GetCurrentProcess()

…will give you the current process, along with their information e.g. Id, etc. and also limited control e.g. Kill, etc.*

You can use pInvoke and a native call such as the following. This doesn’t seem to have the 32 / 64 bit limitation (at least in my testing)

Here is the 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;
    }

answered Oct 10, 2017 at 16:49

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

answered Mar 31, 2011 at 8:39

Lorenz Lo SauerLorenz Lo Sauer

23.4k16 gold badges84 silver badges87 bronze badges

Hari KrishnaHari Krishna

3,5781 gold badge35 silver badges57 bronze badges

mekbmekb

5348 silver badges22 bronze badges

ProgrammingLlamaProgrammingLlama

36k6 gold badges66 silver badges85 bronze badges

TarmoPikaroTarmoPikaro

4,7352 gold badges47 silver badges58 bronze badges

using System.Management;
ManagementObjectSearcher search = new ManagementObjectSearcher("SELECT * FROM 
Win32_Process");
        foreach (ManagementObject currentObj in search.Get())
        {
            if (currentObj["Caption"].ToString() == "sqlservr.exe")
            MessageBox.Show(currentObj["ExecutablePath"].ToString());
        }

answered Dec 7, 2022 at 21:43

Daren ThomasDaren Thomas

67.6k40 gold badges152 silver badges199 bronze badges

I got to this thread while looking for the current directory of an executing process. In .net 1.1 Microsoft introduced:

Directory.GetCurrentDirectory();

Seems to work well (but doesn’t return the name of the process itself).

В появившемся диспетчере задач пройдите на вкладку «Процессы». В списке выберите процесс, для которого вы хотите узнать путь к файлу, нажав по нему правой кнопкой мышки. После этого возникнет окно с информацией об объекте. В строке «Тип» будет, соответственно, информация о его типе, а чуть ниже – строка «Расположение». В ней и указывается полный путь к файлу. Также если нажать на вкладку «Подробно», то можно узнать дополнительную информацию о нем, например, его исходное имя,

авторские права

и др. При желании можно узнать о цифровых подписях объекта, для этого просто нужно перейти на вкладку, которая так и называется: «Цифровые подписи».