进程监视类ProceWatcher

/*========================================================
* Author:myhuang
* Date:2007-02-26
* Note:获取进程主要属性值
========================================================*/
using System;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;
using System.Management;

namespace ProceWatcher
{
/// <summary>
/// 进程类
/// </summary>
public class MyProcess
{
/// <summary>
/// 进程ID
/// </summary>
public int ProceID;
/// <summary>
/// 进程名称
/// </summary>
public string ProceName;
/// <summary>
/// 执行路径
/// </summary>
public string ExecPath;
/// <summary>
/// 创建者
/// </summary>
public string Creator;
/// <summary>
/// 创建时间
/// </summary>
public string CreateTime;
/// <summary>
/// 线程数
/// </summary>
public int ThreadsCount;
/// <summary>
/// CPU占用率
/// </summary>
public double CpuPercent;
/// <summary>
/// 上次CPU时间
/// </summary>
public long OldCpuTime;
/// <summary>
/// 物理内存(KB)
/// </summary>
public long MemoryKB;
/// <summary>
/// 虚拟内存(KB)
/// </summary>
public long VirtualKB;
/// <summary>
/// 父进程名
/// </summary>
public string ParentProce;
/// <summary>
/// 公司信息
/// </summary>
public string CompanyName;
/// <summary>
/// 是否是目标进程
/// </summary>
public bool Target;
/// <summary>
/// 是否活动
/// </summary>
public bool Active;
}

#region 委 托
public delegate void DlgProceNew(MyProcess pProce);
public delegate void DlgProceClosed(MyProcess pProce);
public delegate void DlgProceRefresh(MyProcess pProce,double pCpuPercent);
public delegate void DlgDetailList(MyProcess pProce);
#endregion

/// <summary>
/// 该类提供获取进程信息的功能
/// </summary>
public class ProcessInfo
{
#region 私有成员
/// <summary>
/// 字典类，用于保存各进程信息
/// </summary>
private Dictionary<int, MyProcess> mDict;
/// <summary>
/// 当前总CPU时间
/// </summary>
private double mCurrentTotalCpuTime;
/// <summary>
/// CPU空闲比率
/// </summary>
private double mIdleCpuPercent;
/// <summary>
/// 当前进程
/// </summary>
private Process[] mCurrentAll;
/// <summary>
/// 性能计数器，用于获取CPU空闲百分比
/// </summary>
private static PerformanceCounter mIdle = new PerformanceCounter("Process", "% Processor Time", "Idle");
/// <summary>
/// 性能计数器，用于获取CPU总利用率
/// </summary>
private static PerformanceCounter mTotal = new PerformanceCounter("Process", "% Processor Time", "_Total");
private object mLock = new object();
#endregion

#region 事 件
/// <summary>
/// 当出现新进程时触发该事件
/// </summary>
public event DlgProceNew HandleProceNew;
/// <summary>
/// 当进程关闭时触发该事件
/// </summary>
public event DlgProceClosed HandleProceClosed;
/// <summary>
/// 当进程信息更新时触发该事件
/// </summary>
public event DlgProceRefresh HandleProceRefresh;
/// <summary>
/// 当获取进程详细信息时触发该事件
/// </summary>
public event DlgDetailList HandleDetailList;
#endregion

/// <summary>
/// 构造器
/// </summary>
public ProcessInfo()
{
}

/// <summary>
/// 提供刷新进程列表的功能
/// </summary>
/// <param name="pReLoadAll">是否强制完全重新加载</param>
public void RefreshProceList(bool pReLoadAll)
{
//当前进程列表
this.mCurrentAll = Process.GetProcesses();

#region 初始化或重新加载
if (this.mDict ==null || pReLoadAll)
{
//初始化字典类
this.mDict = new Dictionary<int, MyProcess>();
//获取基本信息
this.FillBaseInfo(this.mCurrentAll);
//获取需要更新的信息
this.FillNeedRefreshInfo(this.mCurrentAll);
return;
}
#endregion

#region 进程关闭处理
//使用lock避免多线程造成mDict不一致(?)
lock (this.mLock)
{
//foreach枚举时不能删除原集合元素，记录相应的key，循环完成之后再删除
List<int> list = new List<int>();
foreach (KeyValuePair<int, MyProcess> kvp in this.mDict)
{
if (this.ProceClosedInDict(kvp.Key))
{
list.Add(kvp.Key);
}
}
MyProcess mp = null;
foreach (int id in list)
{
if (this.mDict.ContainsKey(id))
{
mp = this.mDict[id];
this.mDict.Remove(id);
//触发进程关闭事件
if (this.HandleProceClosed != null)
{
this.HandleProceClosed(mp);
}
}
}
}
#endregion

#region 进程信息刷新(包括新增)
for (int i = 0; i < this.mCurrentAll.Length; i++)
{
//新增进程
if (!this.mDict.ContainsKey(this.mCurrentAll[i].Id))
{
this.FillBaseInfo(this.mCurrentAll[i]);
}
}
this.FillNeedRefreshInfo(this.mCurrentAll);
#endregion
}

/// <summary>
/// 提供刷新进程其它详细信息的功能
/// </summary>
/// <param name="pID">进程ID</param>
public void RefreshDetailList(int pID)
{
this.FillDetailUseWmi(pID);
}

/// <summary>
/// 获取指定进程集合中各进程的基本信息
/// </summary>
/// <param name="pCurrentAll"></param>
private void FillBaseInfo(params Process[] pCurrentAll)
{
MyProcess mp = null;
for (int i = 0; i < pCurrentAll.Length; i++)
{
//判断在循环中途，是否有某一进程退出
if (this.ProceClosedInCurrentList(pCurrentAll[i]))
{
return;
}

mp = new MyProcess();
mp.ProceID = pCurrentAll[i].Id;
mp.ProceName = pCurrentAll[i].ProcessName;
try
{
//对于空闲进程idle等，无法获取其主模块文件名
mp.ExecPath = pCurrentAll[i].MainModule.FileName.ToLower();//
mp.CreateTime = pCurrentAll[i].StartTime.ToString();
mp.CompanyName = pCurrentAll[i].MainModule.FileVersionInfo.CompanyName;
}
catch
{
}

//根据执行文件路径，判断进程是否为目标进程
if (mp.ExecPath!=null && ConfigMgr.ValueExists(mp.ExecPath))
{
mp.Target = true;
}

//初始化“上一次CPU时间”为0
mp.OldCpuTime = 0;
this.mDict.Add(mp.ProceID, mp);

//触发新进程事件
if (this.HandleProceNew != null)
{
this.HandleProceNew(mp);
}
}
mp = null;
}

/// <summary>
/// 获取指定进程集合中各进程需要刷新的信息
/// </summary>
/// <param name="pCurrentAll"></param>
private void FillNeedRefreshInfo(params Process[] pCurrentAll)
{
for (int i = 0; i < pCurrentAll.Length; i++)
{
//判断在循环中途，是否有某一进程退出，及字典中是否已移除该项(?)
if (this.ProceClosedInCurrentList(pCurrentAll[i]) || !this.mDict.ContainsKey(pCurrentAll[i].Id))
{
return;
}

this.mDict[pCurrentAll[i].Id].MemoryKB = pCurrentAll[i].WorkingSet64 / 1024;
this.mDict[pCurrentAll[i].Id].VirtualKB = pCurrentAll[i].VirtualMemorySize64 / 1024;
this.mDict[pCurrentAll[i].Id].ThreadsCount = pCurrentAll[i].Threads.Count;
}

//以下计算CPU利用率，不放在同一for循环中是为了避免循环时间间隔造成CPU利用率的误差
this.mCurrentTotalCpuTime = this.CalCurrentTotalCpuTime();
for (int i = 0; i < pCurrentAll.Length; i++)
{
//空闲进程idle
if (pCurrentAll[i].Id == 0)
{
this.mDict[pCurrentAll[i].Id].CpuPercent = this.mIdleCpuPercent;
}
else
{
try
{
//无法保证进程不会中途退出，此时无法获取其CUP时间
long ms = (long)pCurrentAll[i].TotalProcessorTime.TotalMilliseconds;
double d = (ms - this.mDict[pCurrentAll[i].Id].OldCpuTime) * 1.0 / this.mCurrentTotalCpuTime;
this.mDict[pCurrentAll[i].Id].CpuPercent = d;
this.mDict[pCurrentAll[i].Id].OldCpuTime = ms;
}
catch
{
}
}

//调用刷新事件
if (this.HandleProceRefresh != null)
{
this.HandleProceRefresh(this.mDict[pCurrentAll[i].Id], 100 - this.mIdleCpuPercent);
}
}
}

/// <summary>
/// 使用Wmi获取指定进程的创建者等信息
/// </summary>
/// <param name="pID">进程ID</param>
private void FillDetailUseWmi(int pID)
{
ManagementObjectSearcher searcher = new ManagementObjectSearcher("Select * From Win32_Process Where ProcessID=" + pID);
ManagementObjectCollection moc = searcher.Get();

ManagementOperationObserver observer = new ManagementOperationObserver();
HandleObjectReady hor = new HandleObjectReady();
//监测异步方法是否已成功返回
observer.ObjectReady += new ObjectReadyEventHandler(hor.Done);

foreach (ManagementObject mo in moc)
{
//异步调用该对象的GetOwner方法，获取进程创建者
mo.InvokeMethod(observer, "GetOwner", null);
//等待异步调用返回
while (!hor.Complete)
{
System.Threading.Thread.Sleep(500);
}

string user = "";
//判断获取用户名的操作是否成功
if (hor.Obj["returnValue"].ToString() == "0")
{
user = hor.Obj.Properties["User"].Value.ToString();
}
//判断字典中是否已移除该项
if (!this.mDict.ContainsKey(pID))
{
return;
}
if (mo["ParentProcessID"] != null && this.mDict.ContainsKey(Convert.ToInt32(mo["ParentProcessID"])))
{
//根据父进程ID获取父进程名称
this.mDict[pID].ParentProce = this.mDict[Convert.ToInt32(mo["ParentProcessID"])].ProceName;
}
this.mDict[pID].Creator = user;

//触发刷新进程详细信息事件
if (this.HandleDetailList != null)
{
this.HandleDetailList(this.mDict[pID]);
}
}

//释放资源
searcher.Dispose();
searcher = null;
moc.Dispose();
moc = null;
observer = null;
hor = null;
}

/// <summary>
/// 计算当前总CPU时间
/// </summary>
/// <returns></returns>
private double CalCurrentTotalCpuTime()
{
double d = 0;
//获取性能计数器值
double idlePercent = mIdle.NextValue();
double totalPercent = mTotal.NextValue();
//避免除0异常
if (totalPercent == 0)
{
this.mIdleCpuPercent = 0;
}
else
{
//可能遇到多核或超线程CPU，CPU空闲进程比率不能直接使用计数器的值
this.mIdleCpuPercent = idlePercent * 100 / totalPercent;
}

//以下获取上一次计算至当前总的非空闲CPU时间
foreach (Process p in this.mCurrentAll)
{
//对空闲进程及中途退出的进程不做处理
if (p.Id == 0 || p.HasExited)
{
continue;
}

if (this.mDict ==null || !this.mDict.ContainsKey(p.Id))
{
d += p.TotalProcessorTime.TotalMilliseconds;
}
else
{
d += p.TotalProcessorTime.TotalMilliseconds - this.mDict[p.Id].OldCpuTime;
}
}

//当前非空闲CPU时间/当前非空闲时间所占比率=当前总CPU时间
//return d / (totalPercent - idlePercent);
return d / (100 - mIdleCpuPercent);
}

/// <summary>
/// 判断字典中所存的某个进程是否已退出
/// </summary>
/// <param name="pID"></param>
/// <returns></returns>
private bool ProceClosedInDict(int pID)
{
for (int i = 0; i < this.mCurrentAll.Length; i++)
{
if (!this.ProceClosedInCurrentList(this.mCurrentAll[i]) && this.mCurrentAll[i].Id == pID)
{
return false;
}
}
return true;
}

/// <summary>
/// 判断当前进程列表中的进程是否已中途退出
/// </summary>
/// <param name="pProce"></param>
/// <returns></returns>
private bool ProceClosedInCurrentList(Process pProce)
{
if (pProce.Id == 0)
{
return false;
}
else
{
return pProce.HasExited;
}
}
}

/// <summary>
/// 该类用于监测Wmi异步调用方法是否已经返回
/// </summary>
public class HandleObjectReady
{
private bool complete = false;
private ManagementBaseObject obj;

public void Done(object sender, ObjectReadyEventArgs e)
{
complete = true;
obj = e.NewObject;
}

public bool Complete
{
get
{
return complete;
}
}

public ManagementBaseObject Obj
{
get
{
return obj;
}
}
}

}