.NET 中 GetProcess 相关方法的性能

.NET 的 Process 类中提供了查找进程的若干方法，其中部分方法还比较消耗性能。如果你试图优化查找进程相关方法的性能，可能本文分享的一些耗时数据可以作为参考。

性能比较

Process 类中提供了四种查询进程的方法：

GetProcesses
- 获取当前计算机或远程计算机上运行的所有进程。
GetProcessById
- 获取当前计算机或远程计算机上 pid 为指定值的进程。
GetProcessesByName
- 根据进程的名字查找当前计算机或远程计算机上的进程。
GetCurrentProcess
- 获取当前进程的 Process 实例。

先给出我的实测数据（100 次执行耗时）：

Process.GetProcesses()
- 00:00:00.7254688
Process.GetProcessById(id)
- 00:00:01.3660640（实际数值取决于当前进程数）
Process.GetProcessesByName("Walterlv.Demo")
- 00:00:00.5604279
Process.GetCurrentProcess()
- 00:00:00.0000546

结果显示获取所有进程实例的 GetProcesses 方法速度竟然比获取单个进程实例的 GetProcessById 还要快得多！额外地，根据名称查找进程比前两者都快，获取当前进程实例的方法快得不是一个数量级。

这些速度差异源于哪里

我们先看看最慢的方法 GetProcessIds，它的最本质的实现在 ProcessManager 类中：

// ProcessManager
public static int[] GetProcessIds() {
    int[] processIds = new int[256];
    int size;
    for (;;) {
        if (!NativeMethods.EnumProcesses(processIds, processIds.Length * 4, out size))
            throw new Win32Exception();
        if (size == processIds.Length * 4) {
            processIds = new int[processIds.Length * 2];
            continue;
        }
        break;
    }
    int[] ids = new int[size / 4];
    Array.Copy(processIds, ids, ids.Length);
    return ids;
}

先创建一个 256 长度的数组，然后使用本机函数枚举进程列表填充这个数组。如果实际所需的数组大小与传入的数组大小相等，说明数组用完了，有可能进程数比 256 个多。所以，将数组长度扩大为两倍，随后再试一次。直到发现申请的数组长度足够存下进程数为止。

这里用到了本机方法 EnumProcesses 来枚举进程。传入的 size 要乘以 4 是因为传入的是字节数，一个 int 是 4 个字节。

// NativeMethods
[DllImport("psapi.dll", CharSet=System.Runtime.InteropServices.CharSet.Auto, SetLastError=true)]
public static extern bool EnumProcesses(int[] processIds, int size, out int needed);

所以我们可以得知，如果当前计算机中的进程数小于 256 个，那么枚举进程方法仅需执行一次；而如果大于或等于 256 个，则枚举进程的方法需要执行两次或更多次，这是性能很差的一个重要原因。

另外，GetProcesses 方法就要复杂得多，其核心调用的是 ProcessManager.GetProcessInfos 方法。方法很长，但其大体思路是获取当前计算机上的线程列表，然后将线程所在的进程储存到哈希表中（相当于去重），随后返回此哈希表的数组副本。

// ProcessManager
static ProcessInfo[] GetProcessInfos(IntPtr dataPtr, Predicate<int> processIdFilter) {
    // 60 is a reasonable number for processes on a normal machine.
    Hashtable processInfos = new Hashtable(60);
    long totalOffset = 0;
    while(true) {
        IntPtr currentPtr = (IntPtr)((long)dataPtr + totalOffset);
        SystemProcessInformation pi = new SystemProcessInformation();
        Marshal.PtrToStructure(currentPtr, pi);
        // Process ID shouldn't overflow. OS API GetCurrentProcessID returns DWORD.
        int processInfoProcessId = pi.UniqueProcessId.ToInt32();
        if (processIdFilter == null || processIdFilter(processInfoProcessId)) {
            // get information for a process
            ProcessInfo processInfo = new ProcessInfo();
            processInfo.processId = processInfoProcessId;
            processInfo.handleCount = (int)pi.HandleCount;
            processInfo.sessionId = (int)pi.SessionId;
            processInfo.poolPagedBytes = (long)pi.QuotaPagedPoolUsage;;
            processInfo.poolNonpagedBytes = (long)pi.QuotaNonPagedPoolUsage;
            processInfo.virtualBytes = (long)pi.VirtualSize;
            processInfo.virtualBytesPeak = (long)pi.PeakVirtualSize;
            processInfo.workingSetPeak = (long)pi.PeakWorkingSetSize;
            processInfo.workingSet = (long)pi.WorkingSetSize;
            processInfo.pageFileBytesPeak = (long)pi.PeakPagefileUsage;
            processInfo.pageFileBytes = (long)pi.PagefileUsage;
            processInfo.privateBytes = (long)pi.PrivatePageCount;
            processInfo.basePriority = pi.BasePriority;
            if( pi.NamePtr == IntPtr.Zero) {
                if( processInfo.processId == NtProcessManager.SystemProcessID) {
                    processInfo.processName = "System";
                }
                else if( processInfo.processId == NtProcessManager.IdleProcessID) {
                    processInfo.processName = "Idle";
                }
                else {
                    // for normal process without name, using the process ID.
                    processInfo.processName = processInfo.processId.ToString(CultureInfo.InvariantCulture);
                }
            }
            else {
                string processName = GetProcessShortName(Marshal.PtrToStringUni(pi.NamePtr, pi.NameLength/sizeof(char)));
                //
                // On old operating system (NT4 and windows 2000), the process name might be truncated to 15
                // characters. For example, aspnet_admin.exe will show up in performance counter as aspnet_admin.ex.
                // Process class try to return a nicer name. We used to get the main module name for a process and
                // use that as the process name. However normal user doesn't have access to module information,
                // so normal user will see an exception when we try to get a truncated process name.
                //
                if (ProcessManager.IsOSOlderThanXP && (processName.Length == 15)) {
                    if (processName.EndsWith(".", StringComparison.OrdinalIgnoreCase)) {
                        processName = processName.Substring(0, 14);
                    }
                    else if (processName.EndsWith(".e", StringComparison.OrdinalIgnoreCase)) {
                        processName = processName.Substring(0, 13);
                    }
                    else if (processName.EndsWith(".ex", StringComparison.OrdinalIgnoreCase)) {
                        processName = processName.Substring(0, 12);
                    }
                }
                processInfo.processName = processName;
            }
            // get the threads for current process
            processInfos[processInfo.processId] =  processInfo;
            currentPtr = (IntPtr)((long)currentPtr + Marshal.SizeOf(pi));
            int i = 0;
            while( i < pi.NumberOfThreads) {
                SystemThreadInformation ti = new SystemThreadInformation();
                Marshal.PtrToStructure(currentPtr, ti);
                ThreadInfo threadInfo = new ThreadInfo();                    
                threadInfo.processId = (int)ti.UniqueProcess;
                threadInfo.threadId = (int)ti.UniqueThread;
                threadInfo.basePriority = ti.BasePriority;
                threadInfo.currentPriority = ti.Priority;
                threadInfo.startAddress = ti.StartAddress;
                threadInfo.threadState = (ThreadState)ti.ThreadState;
                threadInfo.threadWaitReason = NtProcessManager.GetThreadWaitReason((int)ti.WaitReason);
                processInfo.threadInfoList.Add(threadInfo);
                currentPtr = (IntPtr)((long)currentPtr + Marshal.SizeOf(ti));
                i++;
            }
        }
        if (pi.NextEntryOffset == 0) {
            break;
        }
        totalOffset += pi.NextEntryOffset;
    }
    ProcessInfo[] temp = new ProcessInfo[processInfos.Values.Count];
    processInfos.Values.CopyTo(temp, 0);
    return temp;
}

GetProcessesByName 方法就比较奇怪了，因为其本质上就是调用了 Process.GetProcesses 方法，并在其后额外执行了一些代码。理论上不应该出现耗时更短的情况。事实上，在测试中，我将 GetProcesses 和 GetProcessesByName 方法的执行调换顺序也能得到稳定一致的结果，都是 GetProcessesByName 更快。

public static Process[] GetProcessesByName(string processName, string machineName) {
    if (processName == null) processName = String.Empty;
    Process[] procs = GetProcesses(machineName);
    ArrayList list = new ArrayList();
    for(int i = 0; i < procs.Length; i++) {
        if( String.Equals(processName, procs[i].ProcessName, StringComparison.OrdinalIgnoreCase)) {
            list.Add( procs[i]);
        } else {
            procs[i].Dispose();
        }
    }
    Process[] temp = new Process[list.Count];
    list.CopyTo(temp, 0);
    return temp;
}

至于 GetCurrentProcess 方法能够这么快，很好理解，毕竟是自己进程，有什么拿不到的呢？其内部调用的是本机方法：

[DllImport("kernel32.dll", CharSet=System.Runtime.InteropServices.CharSet.Auto)]
public static extern int GetCurrentProcessId();

另外，有个有意思的现象：