alielie
2026-04-23 ef52fd6fd07508883dce4eb002acda59f0169e59
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
using HMI.Simple.Util;
using log4net;
using System;
using System.Diagnostics;
using System.Management;
using System.Timers;
using System.Xml.Linq;
 
namespace WPFProject
{
    public class RunTimeState
    {
        public float cpuRate { get; set; }
        public double remRate { get; set; }
 
        public float totalCpuRate { get; set; }
        public double totalRemRate { get; set; }
    }
 
    public class ResourceListener
    {
        public event EventHandler<RunTimeState> RefreshEvent;
        private Timer timer;
        private System.Threading.CancellationTokenSource _can;
 
        private static ResourceListener instance;
        public static ResourceListener Instance
        {
            get
            {
 
                if (instance == null)
                {
                    instance = new ResourceListener();
                }
                return instance;
            }
        }
        private ILog log = LogManager.GetLogger("ResourceListener");
 
        // CPU占用
        private PerformanceCounter totalCpuCounter;
 
        private PerformanceCounter cpuCounter;
 
        private ResourceListener()
        {
            totalCpuCounter = new PerformanceCounter("Processor", "% Processor Time", "_Total");
            cpuCounter = new PerformanceCounter("Process", "% Processor Time", Process.GetCurrentProcess().ProcessName, true);
        }
 
        public void Start()
        {
            _can = new System.Threading.CancellationTokenSource();
            Refresh();
            timer = new Timer();
            timer.AutoReset = false;
            timer.Interval = 30000;
            timer.Elapsed += Timer_Elapsed;
            timer.Enabled = true;
        }
 
        private void Refresh()
        {
            try
            {
                var _cpuCount = Environment.ProcessorCount;
                ObjectQuery wql = new ObjectQuery("SELECT * FROM Win32_OperatingSystem");
                ManagementObjectSearcher searcher = new ManagementObjectSearcher(wql);
 
                string prcName = Process.GetCurrentProcess().ProcessName;
                var counter_Exec = new PerformanceCounter("Process", "Working Set - Private", prcName);
                ulong dWsp_Exec = (ulong)(counter_Exec.RawValue / 1024);
 
                var totalCpuRate = totalCpuCounter.NextValue();
                var cpuRate = cpuCounter.NextValue() / _cpuCount;
 
                foreach (ManagementObject obj in searcher.Get())
                {
                    ulong totalVisibleMemorySize = (ulong)obj["TotalVisibleMemorySize"];
                    ulong freePhysicalMemory = (ulong)obj["FreePhysicalMemory"];
 
                    ulong usedMemory = totalVisibleMemorySize - freePhysicalMemory;
                    string info = $"\r\n总内存: {totalVisibleMemorySize / 1024} MB\r\n";
 
                    info += $"已使用内存: {usedMemory / 1024} MB\r\n";
                    double usagePercent = usedMemory * 100d / totalVisibleMemorySize;
                    info += $"内存占用率: {usagePercent:F2}%\r\n";
 
                    info += $"应用占用内存: {dWsp_Exec / 1024} MB\r\n";
                    double appPercent = dWsp_Exec * 100d / totalVisibleMemorySize;
                    info += $"应用内存占用率: {appPercent:F2}%";
                    RefreshEvent?.Invoke(this, new RunTimeState
                    {
                        cpuRate = cpuRate,
                        remRate = appPercent,
                        totalCpuRate = totalCpuRate,
                        totalRemRate = usagePercent
                    });
                    log.Info(info);
                    //if (usagePercent > 80)
                    //{
                    //    AlarmUtil.CreateAlarm("App", "内存占用过高,超80%", out _);
                    //}
                }
            }
            catch (Exception ex)
            {
                log.Error("Refresh Resource Error.", ex);
            }
        }
 
        private void Timer_Elapsed(object sender, ElapsedEventArgs e)
        {
            try
            {
                timer.Enabled = false;
                _can.Token.ThrowIfCancellationRequested();
                Refresh();
                timer.Enabled = true;
            }
            catch
            {
 
            }
        }
 
        public void Stop()
        {
            _can?.Cancel();
            _can?.Dispose();
            instance = null;
        }
    }
}