System.Diagnostics.NtProcessManager.GetThreadWaitReason C# (CSharp) Method

        internal static ThreadWaitReason GetThreadWaitReason(int value)
        {
            switch (value)
            {
                case 0:
                case 7: return ThreadWaitReason.Executive;
                case 1:
                case 8: return ThreadWaitReason.FreePage;
                case 2:
                case 9: return ThreadWaitReason.PageIn;
                case 3:
                case 10: return ThreadWaitReason.SystemAllocation;
                case 4:
                case 11: return ThreadWaitReason.ExecutionDelay;
                case 5:
                case 12: return ThreadWaitReason.Suspended;
                case 6:
                case 13: return ThreadWaitReason.UserRequest;
                case 14: return ThreadWaitReason.EventPairHigh; ;
                case 15: return ThreadWaitReason.EventPairLow;
                case 16: return ThreadWaitReason.LpcReceive;
                case 17: return ThreadWaitReason.LpcReply;
                case 18: return ThreadWaitReason.VirtualMemory;
                case 19: return ThreadWaitReason.PageOut;
                default: return ThreadWaitReason.Unknown;
            }
        }

        static ProcessInfo[] GetProcessInfos(IntPtr dataPtr)
        {
            // 60 is a reasonable number for processes on a normal machine.
            Dictionary <int, ProcessInfo> processInfos = new Dictionary <int, ProcessInfo>(60);

            long totalOffset = 0;

            while (true)
            {
                IntPtr currentPtr           = (IntPtr)((long)dataPtr + totalOffset);
                SystemProcessInformation pi = new SystemProcessInformation();

                Marshal.PtrToStructure(currentPtr, pi);

                // get information for a process
                ProcessInfo processInfo = new ProcessInfo();
                // Process ID shouldn't overflow. OS API GetCurrentProcessID returns DWORD.
                processInfo._processId         = pi.UniqueProcessId.ToInt32();
                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)));
                    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);
        }