【进程资源】监视进程资源

做一个web仪表盘 监控quartz任务的资源消耗情况，先把实现做了。

public class SystemInfo
      {
          private int m_ProcessorCount = 0;   //CPU个数
          private PerformanceCounter pcCpuLoad;   //CPU计数器
          private long m_PhysicalMemory = 0;   //物理内存
  
          private const int GW_HWNDFIRST = 0;
          private const int GW_HWNDNEXT = 2;
          private const int GWL_STYLE = (-16);
          private const int WS_VISIBLE = 268435456;
          private const int WS_BORDER = 8388608;
  
          #region AIP声明
          [DllImport("IpHlpApi.dll")]
          extern static public uint GetIfTable(byte[] pIfTable, ref uint pdwSize, bool bOrder);
  
          [DllImport("User32")]
          private extern static int GetWindow(int hWnd, int wCmd);
  
          [DllImport("User32")]
          private extern static int GetWindowLongA(int hWnd, int wIndx);
  
          [DllImport("user32.dll")]
          private static extern bool GetWindowText(int hWnd, StringBuilder title, int maxBufSize);
  
          [DllImport("user32", CharSet = CharSet.Auto)]
          private extern static int GetWindowTextLength(IntPtr hWnd);
          #endregion
  
          #region 构造函数
          /// <summary>
          /// 构造函数，初始化计数器等
          /// </summary>
          public SystemInfo()
          {
              //初始化CPU计数器
              pcCpuLoad = new PerformanceCounter("Processor", "% Processor Time", "_Total");
              pcCpuLoad.MachineName = ".";
              pcCpuLoad.NextValue();
  
              //CPU个数
              m_ProcessorCount = Environment.ProcessorCount;
  
              //获得物理内存
              ManagementClass mc = new ManagementClass("Win32_ComputerSystem");
              ManagementObjectCollection moc = mc.GetInstances();
              foreach (ManagementObject mo in moc)
              {
                  if (mo["TotalPhysicalMemory"] != null)
                  {
                      m_PhysicalMemory = long.Parse(mo["TotalPhysicalMemory"].ToString());
                  }
              }
          }
          #endregion
  
          #region CPU个数
          /// <summary>
          /// 获取CPU个数
          /// </summary>
          public int ProcessorCount
          {
              get
              {
                  return m_ProcessorCount;
              }
          }
          #endregion
  
          #region CPU占用率
          /// <summary>
          /// 获取CPU占用率
          /// </summary>
          public float CpuLoad
          {
              get
              {
                  return pcCpuLoad.NextValue();
              }
          }
          #endregion
  
          #region 可用内存
          /// <summary>
          /// 获取可用内存
          /// </summary>
          public long MemoryAvailable
          {
              get
              {
                  long availablebytes = 0;
                  //ManagementObjectSearcher mos = new ManagementObjectSearcher("SELECT * FROM Win32_PerfRawData_PerfOS_Memory");
                  //foreach (ManagementObject mo in mos.Get())
                  //{
                  //    availablebytes = long.Parse(mo["Availablebytes"].ToString());
                  //}
                  ManagementClass mos = new ManagementClass("Win32_OperatingSystem");
                  foreach (ManagementObject mo in mos.GetInstances())
                  {
                      if (mo["FreePhysicalMemory"] != null)
                      {
                          availablebytes = 1024 * long.Parse(mo["FreePhysicalMemory"].ToString());
                      }
                  }
                  return availablebytes;
              }
          }
          #endregion
  
          #region 物理内存
          /// <summary>
          /// 获取物理内存
          /// </summary>
          public long PhysicalMemory
          {
              get
              {
                  return m_PhysicalMemory;
              }
          }
          #endregion
  
          #region 结束指定进程
          /// <summary>
          /// 结束指定进程
          /// </summary>
          /// <param name="pid">进程的 Process ID</param>
          public static void EndProcess(int pid)
          {
              try
              {
                  Process process = Process.GetProcessById(pid);
                  process.Kill();
              }
              catch { }
          }
          #endregion
  
  
          #region 查找所有应用程序标题
          /// <summary>
          /// 查找所有应用程序标题
          /// </summary>
          /// <returns>应用程序标题范型</returns>
          public static List<string> FindAllApps(int Handle)
          {
              List<string> Apps = new List<string>();
  
              int hwCurr;
              hwCurr = GetWindow(Handle, GW_HWNDFIRST);
  
              while (hwCurr > 0)
              {
                  int IsTask = (WS_VISIBLE | WS_BORDER);
                  int lngStyle = GetWindowLongA(hwCurr, GWL_STYLE);
                  bool TaskWindow = ((lngStyle & IsTask) == IsTask);
                  if (TaskWindow)
                  {
                      int length = GetWindowTextLength(new IntPtr(hwCurr));
                      StringBuilder sb = new StringBuilder(2 * length + 1);
                      GetWindowText(hwCurr, sb, sb.Capacity);
                      string strTitle = sb.ToString();
                      if (!string.IsNullOrEmpty(strTitle))
                      {
                          Apps.Add(strTitle);
                      }
                  }
                  hwCurr = GetWindow(hwCurr, GW_HWNDNEXT);
              }
  
              return Apps;
          }
          #endregion     
      }

     private void button2_Click(object sender, EventArgs e)
        {

          
             //获取当前进程对象
              Process cur = Process.GetCurrentProcess();
  
              PerformanceCounter curpcp = new PerformanceCounter("Process", "Working Set - Private", cur.ProcessName);
              PerformanceCounter curpc = new PerformanceCounter("Process", "Working Set", cur.ProcessName);
              PerformanceCounter curtime = new PerformanceCounter("Process", "% Processor Time", cur.ProcessName);
  
              //上次记录CPU的时间
              TimeSpan prevCpuTime = TimeSpan.Zero;
              //Sleep的时间间隔
              int interval = 1000;
  
              PerformanceCounter totalcpu = new PerformanceCounter("Processor", "% Processor Time", "_Total");
  
              SystemInfo sys = new SystemInfo();
              const int KB_DIV = 1024;
              const int MB_DIV = 1024 * 1024;
              const int GB_DIV = 1024 * 1024 * 1024;
              while (true)
              {
                  //第一种方法计算CPU使用率
                  //当前时间
                  TimeSpan curCpuTime = cur.TotalProcessorTime;
                  //计算
                  double value = (curCpuTime - prevCpuTime).TotalMilliseconds / interval / Environment.ProcessorCount * 100;
                  prevCpuTime = curCpuTime;
  
                  Console.WriteLine("{0}:{1}  {2:N}KB CPU使用率：{3}", cur.ProcessName, "工作集(进程类)", cur.WorkingSet64 / 1024,value);//这个工作集只是在一开始初始化，后期不变
                  Console.WriteLine("{0}:{1}  {2:N}KB CPU使用率：{3}", cur.ProcessName, "工作集        ", curpc.NextValue() / 1024,value);//这个工作集是动态更新的
                  //第二种计算CPU使用率的方法
                  Console.WriteLine("{0}:{1}  {2:N}KB CPU使用率：{3}%", cur.ProcessName, "私有工作集    ", curpcp.NextValue() / 1024,curtime.NextValue()/Environment.ProcessorCount);
                  //Thread.Sleep(interval);
  
                  //第一种方法获取系统CPU使用情况
                  Console.Write("
系统CPU使用率：{0}%", totalcpu.NextValue());
                  //Thread.Sleep(interval);
  
                  //第二章方法获取系统CPU和内存使用情况
                  Console.Write("
系统CPU使用率：{0}%，系统内存使用大小：{1}MB({2}GB)", sys.CpuLoad, (sys.PhysicalMemory - sys.MemoryAvailable) / MB_DIV, (sys.PhysicalMemory - sys.MemoryAvailable) / (double)GB_DIV);
                  Thread.Sleep(interval);
              }
  
              Console.ReadLine();
         
        }