详解C#获取特定进程CPU和内存使用率

首先是获取特定进程对象，可以使用Process.GetProcesses()方法来获取系统中运行的所有进程，或者使用Process.GetCurrentProcess()方法来获取当前程序所对应的进程对象。当有了进程对象后，可以通过进程对象名称来创建PerformanceCounter类型对象，通过设定PerformanceCounter构造函数的参数实现获取特定进程的CPU和内存使用情况。 具体实例代码如下： 首先是获取本机中所有进程对象，分别输出某一时刻各 0 Comments

首先是获取特定进程对象，可以使用Process.GetProcesses()方法来获取系统中运行的所有进程，或者使用Process.GetCurrentProcess()方法来获取当前程序所对应的进程对象。当有了进程对象后，可以通过进程对象名称来创建PerformanceCounter类型对象，通过设定PerformanceCounter构造函数的参数实现获取特定进程的CPU和内存使用情况。

具体实例代码如下：

首先是获取本机中所有进程对象，分别输出某一时刻各个进程的内存使用情况：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Diagnostics;

using System.Threading;

namespace CSharpPerformance

{//该程序可以实时监控所有进程或者指定进程的工作集、私有工作集

class Program

{

static void Main(string[] args)

{

//新建一个Stopwatch变量用来统计程序运行时间

Stopwatch watch = Stopwatch.StartNew();

//获取本机运行的所有进程ID和进程名,并输出哥进程所使用的工作集和私有工作集

foreach (Process ps in Process.GetProcesses())

{

PerformanceCounter pf1 = new PerformanceCounter("Process", "Working Set - Private", ps.ProcessName);

PerformanceCounter pf2 = new PerformanceCounter("Process", "Working Set", ps.ProcessName);

Console.WriteLine("{0}:{1} {2:N}KB", ps.ProcessName, "工作集(进程类)", ps.WorkingSet64 / 1024);

Console.WriteLine("{0}:{1} {2:N}KB", ps.ProcessName, "工作集 ", pf2.NextValue() / 1024);

//私有工作集

Console.WriteLine("{0}:{1} {2:N}KB", ps.ProcessName, "私有工作集 ", pf1.NextValue() / 1024);

}

watch.Stop();

Console.WriteLine(watch.Elapsed);

Console.ReadLine();

}

}

}

其中，工作集ps.WorkingSet64是静态的，pf2.NextValue()是动态变化的，工作集包含进程运行时其独占的内存和与其他进程共享的内存的和，而私有工作集是只包含进程独占的内存。

下面一组代码可以动态显示本程序所对应的进程的CPU和内存使用率的变化：

首先是SystemInfo.cs类：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Threading;

using System.IO;

using System.Text;

using System.Management;

using System.Runtime.InteropServices;

namespace CSharpPerformance

{

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

}

}

然后是执行代码：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Diagnostics;

using System.Threading;

namespace CSharpPerformance

{//该程序可以实时监控程序本身对应进程的工作集、私有工作集和CPU使用率

class Program

{

static void Main(string[] args)

{

//获取当前进程对象

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("\r系统CPU使用率：{0}%", totalcpu.NextValue());

//Thread.Sleep(interval);

//第二章方法获取系统CPU和内存使用情况

Console.Write("\r系统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();

}

}

}

以上程序可以正常运行，没隔1S刷新一次，实现动态显示本程序对应进程的CPU和内存使用情况。

原文链接：http://www.cnblogs.com/maowang1991/p/3285983.html

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。

本文链接：https://my.lmcjl.com/post/9041.html

展开阅读全文

相关文章

4 评论

留下您的评论.