支持硬件监测

Masuit.Tools.Core/AspNetCore/Mime/ContentType.cs

@@ -61,6 +61,7 @@
         public const string Jpeg = "image/jpeg";
         public const string Jpg = "image/jpeg";
         public const string Js = "text/javascript";
+        public const string Json = "application/json";
         public const string Jsf = "text/plain";
         public const string Jspf = "text/plain";
         public const string Kar = "audio/x-midi";

Masuit.Tools.Core/Hardware/CPU_INFO.cs

@@ -0,0 +1,33 @@
+using System.Runtime.InteropServices;
+
+namespace Masuit.Tools.Hardware
+{
+
+    public static partial class SystemInfo
+    {
+        #region 定义CPU的信息结构
+
+        /// <summary>
+        /// 定义CPU的信息结构
+        /// </summary>
+        [StructLayout(LayoutKind.Sequential)]
+        public struct CPU_INFO
+        {
+#pragma warning disable 1591
+            public uint dwOemId;
+            public uint dwPageSize;
+            public uint lpMinimumApplicationAddress;
+            public uint lpMaximumApplicationAddress;
+            public uint dwActiveProcessorMask;
+            public uint dwNumberOfProcessors;
+            public uint dwProcessorType;
+            public uint dwAllocationGranularity;
+            public uint dwProcessorLevel;
+            public uint dwProcessorRevision;
+#pragma warning restore 1591
+        }
+#pragma warning restore 1591
+
+        #endregion
+    }
+}

Masuit.Tools.Core/Hardware/CpuInfo.cs

@@ -0,0 +1,59 @@
+namespace Masuit.Tools.Hardware
+{
+    /// <summary>
+    /// CPU模型
+    /// </summary>
+    public class CpuInfo
+    {
+        /// <summary>
+        /// 设备ID端口
+        /// </summary>
+        public string DeviceID { get; set; }
+
+        /// <summary>
+        /// CPU型号 
+        /// </summary>
+        public string Type { get; set; }
+
+        /// <summary>
+        /// CPU厂商
+        /// </summary>
+        public string Manufacturer { get; set; }
+
+        /// <summary>
+        /// CPU最大睿频
+        /// </summary>
+        public string MaxClockSpeed { get; set; }
+
+        /// <summary>
+        /// CPU的时钟频率
+        /// </summary>
+        public string CurrentClockSpeed { get; set; }
+
+        /// <summary>
+        /// CPU核心数
+        /// </summary>
+        public int NumberOfCores { get; set; }
+
+        /// <summary>
+        /// 逻辑处理器核心数
+        /// </summary>
+        public int NumberOfLogicalProcessors { get; set; }
+
+        /// <summary>
+        /// CPU使用率
+        /// </summary>
+        public double CpuLoad { get; set; }
+
+        /// <summary>
+        /// CPU位宽
+        /// </summary>
+        public string DataWidth { get; set; }
+
+        /// <summary>
+        /// 核心温度
+        /// </summary>
+        public double Temperature { get; set; }
+    }
+#pragma warning restore 1591
+}

Masuit.Tools.Core/Hardware/DiskData.cs

@@ -0,0 +1,9 @@
+namespace Masuit.Tools.Hardware
+{
+    public enum DiskData
+    {
+        ReadAndWrite,
+        Read,
+        Write
+    }
+}

Masuit.Tools.Core/Hardware/MemoryInfo.cs

@@ -0,0 +1,23 @@
+using System.Runtime.InteropServices;
+
+namespace Masuit.Tools.Hardware
+{
+
+    /// <summary>
+    /// 定义内存的信息结构
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential)]
+    public struct MemoryInfo
+    {
+#pragma warning disable 1591
+        public uint dwLength;
+        public uint dwMemoryLoad;
+        public uint dwTotalPhys;
+        public uint dwAvailPhys;
+        public uint dwTotalPageFile;
+        public uint dwAvailPageFile;
+        public uint dwTotalVirtual;
+        public uint dwAvailVirtual;
+#pragma warning restore 1591
+    }
+}

Masuit.Tools.Core/Hardware/NetData.cs

@@ -0,0 +1,9 @@
+namespace Masuit.Tools.Hardware
+{
+    public enum NetData
+    {
+        ReceivedAndSent,
+        Received,
+        Sent
+    }
+}

Masuit.Tools.Core/Hardware/OnLogicalDiskProc.cs

@@ -0,0 +1,4 @@
+namespace Masuit.Tools.Hardware
+{
+    public delegate void OnLogicalDiskProc(string s);
+}

Masuit.Tools.Core/Hardware/RamInfo.cs

@@ -0,0 +1,19 @@
+namespace Masuit.Tools.Hardware
+{
+    /// <summary>
+    /// 内存条模型
+    /// </summary>
+    public class RamInfo
+    {
+#pragma warning disable 1591
+        public double MemoryAvailable { get; set; }
+        public double PhysicalMemory { get; set; }
+        public double TotalPageFile { get; set; }
+        public double AvailablePageFile { get; set; }
+        public double TotalVirtual { get; set; }
+        public double AvailableVirtual { get; set; }
+
+        public double MemoryUsage => (1 - MemoryAvailable / PhysicalMemory) * 100;
+#pragma warning restore 1591
+    }
+}

Masuit.Tools.Core/Hardware/SystemInfo.cs

@@ -0,0 +1,858 @@
+using Masuit.Tools.Logging;
+using Microsoft.Win32;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Management;
+using System.Net;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading;
+
+namespace Masuit.Tools.Hardware
+{
+    /// <summary>
+    /// 硬件信息，部分功能需要C++支持
+    /// </summary>
+    public static partial class SystemInfo
+    {
+        #region 字段
+
+        private const int GwHwndfirst = 0;
+        private const int GwHwndnext = 2;
+        private const int GwlStyle = -16;
+        private const int WsVisible = 268435456;
+        private const int WsBorder = 8388608;
+        private static readonly PerformanceCounter PcCpuLoad; //CPU计数器 
+
+        private static readonly PerformanceCounter MemoryCounter = new PerformanceCounter();
+        private static readonly PerformanceCounter CpuCounter = new PerformanceCounter();
+        private static readonly PerformanceCounter DiskReadCounter = new PerformanceCounter();
+        private static readonly PerformanceCounter DiskWriteCounter = new PerformanceCounter();
+
+        private static readonly string[] InstanceNames;
+        private static readonly PerformanceCounter[] NetRecvCounters;
+        private static readonly PerformanceCounter[] NetSentCounters;
+
+        #endregion
+
+        #region 构造函数 
+
+        /// <summary>
+        /// 静态构造函数
+        /// </summary>
+        static SystemInfo()
+        {
+            //初始化CPU计数器 
+            PcCpuLoad = new PerformanceCounter("Processor", "% Processor Time", "_Total");
+            PcCpuLoad.MachineName = ".";
+            PcCpuLoad.NextValue();
+
+            //CPU个数 
+            ProcessorCount = Environment.ProcessorCount;
+
+            //获得物理内存 
+            try
+            {
+                ManagementClass mc = new ManagementClass("Win32_ComputerSystem");
+                ManagementObjectCollection moc = mc.GetInstances();
+                foreach (ManagementBaseObject mo in moc)
+                {
+                    if (mo["TotalPhysicalMemory"] != null)
+                    {
+                        PhysicalMemory = long.Parse(mo["TotalPhysicalMemory"].ToString());
+                    }
+                }
+
+                PerformanceCounterCategory cat = new PerformanceCounterCategory("Network Interface");
+                InstanceNames = cat.GetInstanceNames();
+                NetRecvCounters = new PerformanceCounter[InstanceNames.Length];
+                for (int i = 0; i < InstanceNames.Length; i++) NetRecvCounters[i] = new PerformanceCounter();
+
+                NetSentCounters = new PerformanceCounter[InstanceNames.Length];
+                for (int i = 0; i < InstanceNames.Length; i++) NetSentCounters[i] = new PerformanceCounter();
+
+                CompactFormat = false;
+            }
+            catch (Exception e)
+            {
+                LogManager.Error(e);
+            }
+        }
+
+        #endregion
+
+        public static bool CompactFormat { get; set; }
+
+        #region CPU核心 
+
+        /// <summary>
+        /// 获取CPU核心数 
+        /// </summary>
+        public static int ProcessorCount { get; }
+
+        #endregion
+
+        #region CPU占用率 
+
+        /// <summary>
+        /// 获取CPU占用率 %
+        /// </summary>
+        public static float CpuLoad => PcCpuLoad.NextValue();
+
+        #endregion
+
+        #region 可用内存 
+
+        /// <summary>
+        /// 获取可用内存
+        /// </summary>
+        public static long MemoryAvailable
+        {
+            get
+            {
+                try
+                {
+                    long availablebytes = 0;
+                    ManagementClass mos = new ManagementClass("Win32_OperatingSystem");
+                    foreach (var o in mos.GetInstances())
+                    {
+                        var mo = (ManagementObject)o;
+                        if (mo["FreePhysicalMemory"] != null) availablebytes = 1024 * long.Parse(mo["FreePhysicalMemory"].ToString());
+                    }
+
+                    return availablebytes;
+                }
+                catch (Exception)
+                {
+                    return 0;
+                }
+            }
+        }
+
+        #endregion
+
+        #region 物理内存 
+
+        /// <summary>
+        /// 获取物理内存
+        /// </summary>
+        public static long PhysicalMemory { get; }
+
+        #endregion
+
+        #region 查找所有应用程序标题 
+
+        /// <summary>
+        /// 查找所有应用程序标题 
+        /// </summary>
+        /// <param name="handle">应用程序标题范型</param>
+        /// <returns>所有应用程序集合</returns>
+        public static ArrayList FindAllApps(int handle)
+        {
+            ArrayList apps = new ArrayList();
+
+            int hwCurr = GetWindow(handle, GwHwndfirst);
+
+            while (hwCurr > 0)
+            {
+                int IsTask = WsVisible | WsBorder;
+                int lngStyle = GetWindowLongA(hwCurr, GwlStyle);
+                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, GwHwndnext);
+            }
+
+            return apps;
+        }
+
+        #endregion
+
+        #region 获取CPU的数量
+
+        /// <summary>
+        /// 获取CPU的数量
+        /// </summary>
+        /// <returns>CPU的数量</returns>
+        public static int GetCpuCount()
+        {
+            try
+            {
+                ManagementClass m = new ManagementClass("Win32_Processor");
+                ManagementObjectCollection mn = m.GetInstances();
+                return mn.Count;
+            }
+            catch (Exception)
+            {
+                return 0;
+            }
+        }
+
+        #endregion
+
+        #region 获取CPU信息
+
+        /// <summary>
+        /// 获取CPU信息
+        /// </summary>
+        /// <returns>CPU信息</returns>
+        public static List<CpuInfo> GetCpuInfo()
+        {
+            try
+            {
+                List<CpuInfo> list = new List<CpuInfo>();
+                ManagementObjectSearcher mySearcher = new ManagementObjectSearcher("SELECT * FROM Win32_Processor");
+                foreach (var o in mySearcher.Get())
+                {
+                    var myObject = (ManagementObject)o;
+                    list.Add(new CpuInfo
+                    {
+                        CpuLoad = CpuLoad,
+                        NumberOfLogicalProcessors = ProcessorCount,
+                        CurrentClockSpeed = myObject.Properties["CurrentClockSpeed"].Value.ToString(),
+                        Manufacturer = myObject.Properties["Manufacturer"].Value.ToString(),
+                        MaxClockSpeed = myObject.Properties["MaxClockSpeed"].Value.ToString(),
+                        Type = myObject.Properties["Name"].Value.ToString(),
+                        DataWidth = myObject.Properties["DataWidth"].Value.ToString(),
+                        DeviceID = myObject.Properties["DeviceID"].Value.ToString(),
+                        NumberOfCores = Convert.ToInt32(myObject.Properties["NumberOfCores"].Value),
+                        Temperature = GetCPUTemperature()
+                    });
+                }
+
+                return list;
+            }
+            catch (Exception)
+            {
+                return new List<CpuInfo>();
+            }
+        }
+
+        #endregion
+
+        #region 获取内存信息
+
+        /// <summary>
+        /// 获取内存信息
+        /// </summary>
+        /// <returns>内存信息</returns>
+        public static RamInfo GetRamInfo() => new RamInfo
+        {
+            MemoryAvailable = GetFreePhysicalMemory(),
+            PhysicalMemory = GetTotalPhysicalMemory(),
+            TotalPageFile = GetTotalVirtualMemory(),
+            AvailablePageFile = GetTotalVirtualMemory() - GetUsedVirtualMemory(),
+            AvailableVirtual = 1 - GetUsageVirtualMemory(),
+            TotalVirtual = 1 - GetUsedPhysicalMemory()
+        };
+
+        #endregion
+
+        #region 获取CPU温度
+
+        /// <summary>
+        /// 获取CPU温度
+        /// </summary>
+        /// <returns>CPU温度</returns>
+        public static double GetCPUTemperature()
+        {
+            try
+            {
+                string str = "";
+                ManagementObjectSearcher vManagementObjectSearcher = new ManagementObjectSearcher(@"root\WMI", @"select * from MSAcpi_ThermalZoneTemperature");
+                foreach (ManagementObject managementObject in vManagementObjectSearcher.Get())
+                {
+                    str += managementObject.Properties["CurrentTemperature"].Value.ToString();
+                }
+
+                //这就是CPU的温度了
+                double temp = (double.Parse(str) - 2732) / 10;
+                return Math.Round(temp, 2);
+            }
+            catch (Exception)
+            {
+                return 0;
+            }
+        }
+
+        #endregion
+
+        #region WMI接口获取CPU使用率
+
+        /// <summary>
+        /// WMI接口获取CPU使用率
+        /// </summary>
+        /// <returns></returns>
+        public static string GetProcessorData()
+        {
+            double d = GetCounterValue(CpuCounter, "Processor", "% Processor Time", "_Total");
+            return CompactFormat ? (int)d + "%" : d.ToString("F") + "%";
+        }
+
+        #endregion
+
+        #region 获取虚拟内存使用率详情
+
+        /// <summary>
+        /// 获取虚拟内存使用率详情
+        /// </summary>
+        /// <returns></returns>
+        public static string GetMemoryVData()
+        {
+            double d = GetCounterValue(MemoryCounter, "Memory", "% Committed Bytes In Use", null);
+            var str = d.ToString("F") + "% (";
+
+            d = GetCounterValue(MemoryCounter, "Memory", "Committed Bytes", null);
+            str += FormatBytes(d) + " / ";
+
+            d = GetCounterValue(MemoryCounter, "Memory", "Commit Limit", null);
+            return str + FormatBytes(d) + ") ";
+        }
+
+        /// <summary>
+        /// 获取虚拟内存使用率
+        /// </summary>
+        /// <returns></returns>
+        public static double GetUsageVirtualMemory()
+        {
+            return GetCounterValue(MemoryCounter, "Memory", "% Committed Bytes In Use", null);
+        }
+
+        /// <summary>
+        /// 获取虚拟内存已用大小
+        /// </summary>
+        /// <returns></returns>
+        public static double GetUsedVirtualMemory()
+        {
+            return GetCounterValue(MemoryCounter, "Memory", "Committed Bytes", null);
+        }
+
+        /// <summary>
+        /// 获取虚拟内存总大小
+        /// </summary>
+        /// <returns></returns>
+        public static double GetTotalVirtualMemory()
+        {
+            return GetCounterValue(MemoryCounter, "Memory", "Commit Limit", null);
+        }
+
+        #endregion
+
+        #region 获取物理内存使用率详情
+
+        /// <summary>
+        /// 获取物理内存使用率详情描述
+        /// </summary>
+        /// <returns></returns>
+        public static string GetMemoryPData()
+        {
+            string s = QueryComputerSystem("totalphysicalmemory");
+            double totalphysicalmemory = Convert.ToDouble(s);
+
+            double d = GetCounterValue(MemoryCounter, "Memory", "Available Bytes", null);
+            d = totalphysicalmemory - d;
+
+            s = CompactFormat ? "%" : "% (" + FormatBytes(d) + " / " + FormatBytes(totalphysicalmemory) + ")";
+            d /= totalphysicalmemory;
+            d *= 100;
+            return CompactFormat ? (int)d + s : d.ToString("F") + s;
+        }
+
+        /// <summary>
+        /// 获取物理内存总数，单位B
+        /// </summary>
+        /// <returns></returns>
+        public static double GetTotalPhysicalMemory()
+        {
+            string s = QueryComputerSystem("totalphysicalmemory");
+            return Convert.ToDouble(s);
+        }
+
+        /// <summary>
+        /// 获取空闲的物理内存数，单位B
+        /// </summary>
+        /// <returns></returns>
+        public static double GetFreePhysicalMemory()
+        {
+            return GetCounterValue(MemoryCounter, "Memory", "Available Bytes", null);
+        }
+
+        /// <summary>
+        /// 获取已经使用了的物理内存数，单位B
+        /// </summary>
+        /// <returns></returns>
+        public static double GetUsedPhysicalMemory()
+        {
+            return GetTotalPhysicalMemory() - GetFreePhysicalMemory();
+        }
+
+        #endregion
+
+        #region 获取硬盘的读写速率
+
+        /// <summary>
+        /// 获取硬盘的读写速率
+        /// </summary>
+        /// <param name="dd">读或写</param>
+        /// <returns></returns>
+        public static double GetDiskData(DiskData dd) => dd == DiskData.Read ? GetCounterValue(DiskReadCounter, "PhysicalDisk", "Disk Read Bytes/sec", "_Total") : dd == DiskData.Write ? GetCounterValue(DiskWriteCounter, "PhysicalDisk", "Disk Write Bytes/sec", "_Total") : dd == DiskData.ReadAndWrite ? GetCounterValue(DiskReadCounter, "PhysicalDisk", "Disk Read Bytes/sec", "_Total") + GetCounterValue(DiskWriteCounter, "PhysicalDisk", "Disk Write Bytes/sec", "_Total") : 0;
+
+        #endregion
+
+        #region 获取网络的传输速率
+
+        /// <summary>
+        /// 获取网络的传输速率
+        /// </summary>
+        /// <param name="nd">上传或下载</param>
+        /// <returns></returns>
+        public static double GetNetData(NetData nd)
+        {
+            if (InstanceNames.Length == 0) return 0;
+
+            double d = 0;
+            for (int i = 0; i < InstanceNames.Length; i++) d += nd == NetData.Received ? GetCounterValue(NetRecvCounters[i], "Network Interface", "Bytes Received/sec", InstanceNames[i]) : nd == NetData.Sent ? GetCounterValue(NetSentCounters[i], "Network Interface", "Bytes Sent/sec", InstanceNames[i]) : nd == NetData.ReceivedAndSent ? GetCounterValue(NetRecvCounters[i], "Network Interface", "Bytes Received/sec", InstanceNames[i]) + GetCounterValue(NetSentCounters[i], "Network Interface", "Bytes Sent/sec", InstanceNames[i]) : 0;
+
+            return d;
+        }
+
+        #endregion
+
+        /// <summary>
+        /// 获取网卡硬件地址
+        /// </summary>
+        /// <returns></returns>
+        public static IList<string> GetMacAddress()
+        {
+            //获取网卡硬件地址       
+            try
+            {
+                IList<string> list = new List<string>();
+                ManagementClass mc = new ManagementClass("Win32_NetworkAdapterConfiguration");
+                using (mc)
+                {
+                    ManagementObjectCollection moc = mc.GetInstances();
+                    using (moc)
+                    {
+                        foreach (ManagementObject mo in moc)
+                        {
+                            if ((bool)mo["IPEnabled"])
+                            {
+                                list.Add(mo["MacAddress"].ToString());
+                            }
+                        }
+                    }
+                }
+
+                return list;
+            }
+            catch (Exception)
+            {
+                return new List<string>();
+            }
+        }
+
+        /// <summary>
+        /// 获取IP地址 
+        /// </summary>
+        /// <returns></returns>
+        public static IList<string> GetIPAddress()
+        {
+            //获取IP地址        
+            try
+            {
+                IList<string> list = new List<string>();
+                ManagementClass mc = new ManagementClass("Win32_NetworkAdapterConfiguration");
+                using (mc)
+                {
+                    ManagementObjectCollection moc = mc.GetInstances();
+                    using (moc)
+                    {
+                        foreach (ManagementObject mo in moc)
+                        {
+                            if ((bool)mo["IPEnabled"])
+                            {
+                                var ar = (Array)(mo.Properties["IpAddress"].Value);
+                                var st = ar.GetValue(0).ToString();
+                                list.Add(st);
+                            }
+                        }
+
+                        return list;
+                    }
+                }
+            }
+            catch (Exception)
+            {
+                return new List<string>()
+                {
+                    "未能获取到操作系统版本，可能是当前程序无管理员权限，如果是web应用程序，请将应用程序池的高级设置中的进程模型下的标识设置为：LocalSystem；如果是普通桌面应用程序，请提升管理员权限后再操作。"
+                };
+            }
+        }
+
+        /// <summary>  
+        /// 获取当前使用的IP  
+        /// </summary>  
+        /// <returns></returns>  
+        public static string GetLocalUsedIP()
+        {
+            string result = RunApp("route", "print", true);
+            Match m = Regex.Match(result, @"0.0.0.0\s+0.0.0.0\s+(\d+.\d+.\d+.\d+)\s+(\d+.\d+.\d+.\d+)");
+            if (m.Success)
+            {
+                return m.Groups[2].Value;
+            }
+
+            try
+            {
+                System.Net.Sockets.TcpClient c = new System.Net.Sockets.TcpClient();
+                c.Connect("www.baidu.com", 80);
+                string ip = ((IPEndPoint)c.Client.LocalEndPoint).Address.ToString();
+                c.Close();
+                return ip;
+            }
+            catch (Exception)
+            {
+                return "未能获取到操作系统版本，可能是当前程序无管理员权限，如果是web应用程序，请将应用程序池的高级设置中的进程模型下的标识设置为：LocalSystem；如果是普通桌面应用程序，请提升管理员权限后再操作。";
+            }
+        }
+
+        /// <summary>  
+        /// 运行一个控制台程序并返回其输出参数。  
+        /// </summary>  
+        /// <param name="filename">程序名</param>  
+        /// <param name="arguments">输入参数</param>
+        /// <param name="recordLog">是否记录日志</param>
+        /// <returns></returns>  
+        public static string RunApp(string filename, string arguments, bool recordLog)
+        {
+            try
+            {
+                if (recordLog)
+                {
+                    Trace.WriteLine(filename + " " + arguments);
+                }
+
+                Process proc = new Process
+                {
+                    StartInfo =
+                    {
+                        FileName = filename,
+                        CreateNoWindow = true,
+                        Arguments = arguments,
+                        RedirectStandardOutput = true,
+                        UseShellExecute = false
+                    }
+                };
+                proc.Start();
+
+                using (System.IO.StreamReader sr = new System.IO.StreamReader(proc.StandardOutput.BaseStream, Encoding.Default))
+                {
+                    Thread.Sleep(100); //貌似调用系统的nslookup还未返回数据或者数据未编码完成，程序就已经跳过直接执行  
+                    //txt = sr.ReadToEnd()了，导致返回的数据为空，故睡眠令硬件反应  
+                    if (!proc.HasExited) //在无参数调用nslookup后，可以继续输入命令继续操作，如果进程未停止就直接执行  
+                    {
+                        //txt = sr.ReadToEnd()程序就在等待输入，而且又无法输入，直接掐住无法继续运行  
+                        proc.Kill();
+                    }
+
+                    string txt = sr.ReadToEnd();
+                    sr.Close();
+                    if (recordLog)
+                        Trace.WriteLine(txt);
+                    return txt;
+                }
+            }
+            catch (Exception ex)
+            {
+                Trace.WriteLine(ex);
+                return ex.Message;
+            }
+        }
+
+        /// <summary>
+        /// 获取操作系统版本
+        /// </summary>
+        /// <returns></returns>
+        public static string GetOsVersion()
+        {
+            try
+            {
+                return Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Windows NT\CurrentVersion")?.GetValue("ProductName").ToString();
+            }
+            catch (Exception)
+            {
+                return "未能获取到操作系统版本，可能是当前程序无管理员权限，如果是web应用程序，请将应用程序池的高级设置中的进程模型下的标识设置为：LocalSystem；如果是普通桌面应用程序，请提升管理员权限后再操作。";
+            }
+        }
+
+        #region 将速度值格式化成字节单位
+
+        /// <summary>
+        /// 将速度值格式化成字节单位
+        /// </summary>
+        /// <param name="bytes"></param>
+        /// <returns></returns>
+        public static string FormatBytes(this double bytes)
+        {
+            int unit = 0;
+            while (bytes > 1024)
+            {
+                bytes /= 1024;
+                ++unit;
+            }
+
+            string s = CompactFormat ? ((int)bytes).ToString() : bytes.ToString("F") + " ";
+            return s + (Unit)unit;
+        }
+
+        #endregion
+
+        #region 查询计算机系统信息
+
+        /// <summary>
+        /// 获取计算机开机时间
+        /// </summary>
+        /// <returns>datetime</returns>
+        public static DateTime BootTime()
+        {
+            var query = new SelectQuery("SELECT LastBootUpTime FROM Win32_OperatingSystem WHERE Primary='true'");
+            var searcher = new ManagementObjectSearcher(query);
+
+            foreach (ManagementObject mo in searcher.Get())
+            {
+                return ManagementDateTimeConverter.ToDateTime(mo.Properties["LastBootUpTime"].Value.ToString());
+            }
+
+            return DateTime.Now - TimeSpan.FromMilliseconds(Environment.TickCount & Int32.MaxValue);
+        }
+
+        /// <summary>
+        /// 查询计算机系统信息
+        /// </summary>
+        /// <param name="type">类型名</param>
+        /// <returns></returns>
+        public static string QueryComputerSystem(string type)
+        {
+            try
+            {
+                string str = null;
+                ManagementObjectSearcher objCS = new ManagementObjectSearcher("SELECT * FROM Win32_ComputerSystem");
+                foreach (ManagementObject objMgmt in objCS.Get()) str = objMgmt[type].ToString();
+                return str;
+            }
+            catch (Exception)
+            {
+                return "未能获取到操作系统版本，可能是当前程序无管理员权限，如果是web应用程序，请将应用程序池的高级设置中的进程模型下的标识设置为：LocalSystem；如果是普通桌面应用程序，请提升管理员权限后再操作。";
+            }
+        }
+
+        #endregion
+
+        #region 获取环境变量
+
+        /// <summary>
+        /// 获取环境变量
+        /// </summary>
+        /// <param name="type">环境变量名</param>
+        /// <returns></returns>
+        public static string QueryEnvironment(string type) => Environment.ExpandEnvironmentVariables(type);
+
+        #endregion
+
+        #region 获取磁盘空间
+
+        /// <summary>
+        /// 获取磁盘可用空间
+        /// </summary>
+        /// <returns></returns>
+        public static Dictionary<string, string> DiskFree()
+        {
+            try
+            {
+                Dictionary<string, string> dic = new Dictionary<string, string>();
+                ManagementObjectSearcher objCS = new ManagementObjectSearcher("SELECT * FROM Win32_LogicalDisk");
+                foreach (ManagementObject objMgmt in objCS.Get())
+                {
+                    var device = objMgmt["DeviceID"];
+                    if (null != device)
+                    {
+                        var space = objMgmt["FreeSpace"];
+                        if (null != space)
+                        {
+                            dic.Add(device.ToString(), FormatBytes(double.Parse(space.ToString())));
+                        }
+                    }
+                }
+
+                return dic;
+            }
+            catch (Exception)
+            {
+                return new Dictionary<string, string>()
+                {
+                    { "null", "未能获取到操作系统版本，可能是当前程序无管理员权限，如果是web应用程序，请将应用程序池的高级设置中的进程模型下的标识设置为：LocalSystem；如果是普通桌面应用程序，请提升管理员权限后再操作。" }
+                };
+            }
+        }
+
+        /// <summary>
+        /// 获取磁盘总空间
+        /// </summary>
+        /// <returns></returns>
+        public static Dictionary<string, string> DiskTotalSpace()
+        {
+            try
+            {
+                Dictionary<string, string> dic = new Dictionary<string, string>();
+                ManagementObjectSearcher objCS = new ManagementObjectSearcher("SELECT * FROM Win32_LogicalDisk");
+                foreach (ManagementObject objMgmt in objCS.Get())
+                {
+                    var device = objMgmt["DeviceID"];
+                    if (null != device)
+                    {
+                        var space = objMgmt["Size"];
+                        if (null != space)
+                        {
+                            dic.Add(device.ToString(), FormatBytes(double.Parse(space.ToString())));
+                        }
+                    }
+                }
+
+                return dic;
+            }
+            catch (Exception)
+            {
+                return new Dictionary<string, string>();
+            }
+        }
+
+
+        /// <summary>
+        /// 获取磁盘已用空间
+        /// </summary>
+        /// <returns></returns>
+        public static Dictionary<string, string> DiskUsedSpace()
+        {
+            try
+            {
+                Dictionary<string, string> dic = new Dictionary<string, string>();
+                ManagementObjectSearcher objCS = new ManagementObjectSearcher("SELECT * FROM Win32_LogicalDisk");
+                foreach (ManagementObject objMgmt in objCS.Get())
+                {
+                    var device = objMgmt["DeviceID"];
+                    if (null != device)
+                    {
+                        var free = objMgmt["FreeSpace"];
+                        var total = objMgmt["Size"];
+                        if (null != total)
+                        {
+                            dic.Add(device.ToString(), FormatBytes(double.Parse(total.ToString()) - free.ToString().ToDouble()));
+                        }
+                    }
+                }
+
+                return dic;
+            }
+            catch (Exception)
+            {
+                return new Dictionary<string, string>()
+                {
+                    { "null", "未能获取到操作系统版本，可能是当前程序无管理员权限，如果是web应用程序，请将应用程序池的高级设置中的进程模型下的标识设置为：LocalSystem；如果是普通桌面应用程序，请提升管理员权限后再操作。" }
+                };
+            }
+        }
+
+        /// <summary>
+        /// 获取磁盘使用率
+        /// </summary>
+        /// <returns></returns>
+        public static Dictionary<string, double> DiskUsage()
+        {
+            try
+            {
+                Dictionary<string, double> dic = new Dictionary<string, double>();
+                ManagementObjectSearcher objCS = new ManagementObjectSearcher("SELECT * FROM Win32_LogicalDisk");
+                foreach (ManagementObject objMgmt in objCS.Get())
+                {
+                    var device = objMgmt["DeviceID"];
+                    if (null != device)
+                    {
+                        var free = objMgmt["FreeSpace"];
+                        var total = objMgmt["Size"];
+                        if (null != total && total.ToString().ToDouble() > 0)
+                        {
+                            dic.Add(device.ToString(), 1 - free.ToString().ToDouble() / total.ToString().ToDouble());
+                        }
+                    }
+                }
+
+                return dic;
+            }
+            catch (Exception)
+            {
+                return new Dictionary<string, double>()
+                {
+                    { "未能获取到操作系统版本，可能是当前程序无管理员权限，如果是web应用程序，请将应用程序池的高级设置中的进程模型下的标识设置为：LocalSystem；如果是普通桌面应用程序，请提升管理员权限后再操作。", 0 }
+                };
+            }
+        }
+
+        #endregion
+
+        private static double GetCounterValue(PerformanceCounter pc, string categoryName, string counterName, string instanceName)
+        {
+            pc.CategoryName = categoryName;
+            pc.CounterName = counterName;
+            pc.InstanceName = instanceName;
+            return pc.NextValue();
+        }
+
+        #region Win32API声明 
+
+#pragma warning disable 1591
+        [DllImport("kernel32")]
+        public static extern void GetWindowsDirectory(StringBuilder winDir, int count);
+
+        [DllImport("kernel32")]
+        public static extern void GetSystemDirectory(StringBuilder sysDir, int count);
+
+        [DllImport("kernel32")]
+        public static extern void GetSystemInfo(ref CPU_INFO cpuinfo);
+
+        [DllImport("kernel32")]
+        public static extern void GlobalMemoryStatus(ref MemoryInfo meminfo);
+
+        [DllImport("kernel32")]
+        public static extern void GetSystemTime(ref SystemtimeInfo stinfo);
+
+        [DllImport("IpHlpApi.dll")]
+        public static extern uint GetIfTable(byte[] pIfTable, ref uint pdwSize, bool bOrder);
+
+        [DllImport("User32")]
+        public static extern int GetWindow(int hWnd, int wCmd);
+
+        [DllImport("User32")]
+        public static extern int GetWindowLongA(int hWnd, int wIndx);
+
+        [DllImport("user32.dll")]
+        public static extern bool GetWindowText(int hWnd, StringBuilder title, int maxBufSize);
+
+        [DllImport("user32", CharSet = CharSet.Auto)]
+        public static extern int GetWindowTextLength(IntPtr hWnd);
+#pragma warning restore 1591
+
+        #endregion
+    }
+}

Masuit.Tools.Core/Hardware/SystemtimeInfo.cs

@@ -0,0 +1,22 @@
+using System.Runtime.InteropServices;
+
+namespace Masuit.Tools.Hardware
+{
+    /// <summary>
+    /// 定义系统时间的信息结构
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential)]
+    public struct SystemtimeInfo
+    {
+#pragma warning disable 1591
+        public ushort wYear;
+        public ushort wMonth;
+        public ushort wDayOfWeek;
+        public ushort wDay;
+        public ushort wHour;
+        public ushort wMinute;
+        public ushort wSecond;
+        public ushort wMilliseconds;
+#pragma warning restore 1591
+    }
+}

Masuit.Tools.Core/Hardware/Unit.cs

@@ -0,0 +1,15 @@
+namespace Masuit.Tools.Hardware
+{
+
+    /// <summary>
+    /// 字节单位枚举
+    /// </summary>
+    enum Unit
+    {
+        B,
+        KB,
+        MB,
+        GB,
+        EB
+    }
+}

Masuit.Tools.Core/Masuit.Tools.Core.csproj

@@ -36,6 +36,13 @@ github：https://github.com/ldqk/Masuit.Tools</Description>
     <PackageReference Include="Microsoft.AspNetCore.All" Version="2.1.5" />
     <PackageReference Include="SharpCompress" Version="0.22.0" />
     <PackageReference Include="System.Drawing.Common" Version="4.5.1" />
+    <PackageReference Include="System.Management" Version="4.5.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Reference Include="System.Diagnostics.PerformanceCounter">
+      <HintPath>C:\Users\Administrator\.nuget\packages\system.diagnostics.performancecounter\4.5.0\ref\netstandard2.0\System.Diagnostics.PerformanceCounter.dll</HintPath>
+    </Reference>
   </ItemGroup>
 
 </Project>

Masuit.Tools.Core/Win32/Windows.cs

@@ -0,0 +1,518 @@
+using Masuit.Tools.Hardware;
+using System;
+using System.Diagnostics;
+using System.Management;
+using System.Net;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading;
+using static System.String;
+
+namespace Masuit.Tools.Win32
+{
+    /// <summary>
+    /// Windows系统的系列方法
+    /// </summary>
+    public static class Windows
+    {
+        /// <summary>
+        /// 跨平台调用C++的方法
+        /// </summary>
+        /// <param name="hwProc">程序句柄</param>
+        /// <returns></returns>
+        [DllImport("psapi.dll")]
+        static extern int EmptyWorkingSet(IntPtr hwProc);
+
+        /// <summary>
+        /// 清理系统内存，返回优化内存后的内存占用率
+        /// </summary>
+        /// <returns>优化内存后的内存占用率</returns>
+        public static double ClearMemory()
+        {
+            ClearMemorySilent();
+            Thread.Sleep(1000);
+            return SystemInfo.GetRamInfo().MemoryUsage;
+        }
+
+        /// <summary>
+        /// 静默清理系统内存
+        /// </summary>
+        public static void ClearMemorySilent()
+        {
+            GC.Collect();
+            GC.WaitForPendingFinalizers();
+            foreach (Process p in Process.GetProcesses())
+            {
+                using (p)
+                {
+                    if ((p.ProcessName.Equals("System")) && (p.ProcessName.Equals("Idle")))
+                    {
+                        //两个系统的关键进程，不整理
+                        continue;
+                    }
+
+                    try
+                    {
+                        EmptyWorkingSet(p.Handle);
+                    }
+                    catch
+                    {
+                        // ignored
+                    }
+                }
+            }
+        }
+
+        /// <summary>  
+        /// 获取当前使用的IP  
+        /// </summary>  
+        /// <returns></returns>  
+        public static string GetLocalUsedIP()
+        {
+            string result = RunApp("route", "print", true);
+            Match m = Regex.Match(result, @"0.0.0.0\s+0.0.0.0\s+(\d+.\d+.\d+.\d+)\s+(\d+.\d+.\d+.\d+)");
+            if (m.Success)
+            {
+                return m.Groups[2].Value;
+            }
+
+            try
+            {
+                string ip;
+                using (System.Net.Sockets.TcpClient c = new System.Net.Sockets.TcpClient())
+                {
+                    c.Connect("www.baidu.com", 80);
+                    ip = ((IPEndPoint)c.Client.LocalEndPoint).Address.ToString();
+                }
+
+                return ip;
+            }
+            catch (Exception)
+            {
+                return null;
+            }
+        }
+
+        /// <summary>  
+        /// 运行一个控制台程序并返回其输出参数。  
+        /// </summary>  
+        /// <param name="filename">程序名</param>  
+        /// <param name="arguments">输入参数</param>
+        /// <param name="recordLog">是否在控制台输出日志</param>
+        /// <returns></returns>  
+        public static string RunApp(string filename, string arguments, bool recordLog)
+        {
+            try
+            {
+                if (recordLog)
+                {
+                    Trace.WriteLine(filename + " " + arguments);
+                }
+
+                Process proc = new Process
+                {
+                    StartInfo =
+                    {
+                        FileName = filename,
+                        CreateNoWindow = true,
+                        Arguments = arguments,
+                        RedirectStandardOutput = true,
+                        UseShellExecute = false
+                    }
+                };
+                proc.Start();
+
+                using (System.IO.StreamReader sr = new System.IO.StreamReader(proc.StandardOutput.BaseStream, Encoding.Default))
+                {
+                    //上面标记的是原文，下面是我自己调试错误后自行修改的  
+                    Thread.Sleep(100); //貌似调用系统的nslookup还未返回数据或者数据未编码完成，程序就已经跳过直接执行  
+                    //txt = sr.ReadToEnd()了，导致返回的数据为空，故睡眠令硬件反应  
+                    if (!proc.HasExited) //在无参数调用nslookup后，可以继续输入命令继续操作，如果进程未停止就直接执行  
+                    {
+                        //txt = sr.ReadToEnd()程序就在等待输入，而且又无法输入，直接掐住无法继续运行  
+                        proc.Kill();
+                    }
+
+                    string txt = sr.ReadToEnd();
+                    if (recordLog)
+                        Trace.WriteLine(txt);
+                    return txt;
+                }
+            }
+            catch (Exception ex)
+            {
+                Trace.WriteLine(ex);
+                return ex.Message;
+            }
+        }
+    }
+
+    /// <summary>
+    /// 服务器信息
+    /// </summary>
+    public class WindowsServer
+    {
+        /// <summary>
+        /// CPUID
+        /// </summary>
+        public string CpuId; //CPU的ID
+
+        /// <summary>
+        /// CPU插槽数
+        /// </summary>
+        public int CpuCount; //CPU的个数
+
+        /// <summary>
+        /// CPU主频
+        /// </summary>
+        public string[] CpuMhz; //CPU频率  单位：hz
+
+        /// <summary>
+        /// mac地址
+        /// </summary>
+        public string MacAddress; //计算机的MAC地址
+
+        /// <summary>
+        /// 硬盘ID
+        /// </summary>
+        public string DiskId; //硬盘的ID
+
+        /// <summary>
+        /// 硬盘大小
+        /// </summary>
+        public string DiskSize; //硬盘大小  单位：bytes
+
+        /// <summary>
+        /// IP地址
+        /// </summary>
+        public string IpAddress; //计算机的IP地址
+
+        /// <summary>
+        /// 系统当前登录用户
+        /// </summary>
+        public string LoginUserName; //操作系统登录用户名
+
+        /// <summary>
+        /// 计算机名
+        /// </summary>
+        public string ComputerName; //计算机名
+
+        /// <summary>
+        /// 操作系统架构
+        /// </summary>
+        public string SystemType; //系统类型
+
+        /// <summary>
+        /// 物理内存，单位MB
+        /// </summary>
+        public string TotalPhysicalMemory; //总共的内存  单位：M 
+
+        private static WindowsServer _instance;
+
+        /// <summary>
+        /// 获取实例
+        /// </summary>
+        public static WindowsServer Instance
+        {
+            get
+            {
+                if (_instance == null) _instance = new WindowsServer();
+                return _instance;
+            }
+        }
+
+        /// <summary>
+        /// 构造函数
+        /// </summary>
+        public WindowsServer()
+        {
+            CpuId = GetCpuID();
+            CpuCount = GetCpuCount();
+            CpuMhz = GetCpuMHZ();
+            MacAddress = GetMacAddress();
+            DiskId = GetDiskID();
+            DiskSize = GetSizeOfDisk();
+            IpAddress = GetIPAddress();
+            LoginUserName = GetUserName();
+            SystemType = GetSystemType();
+            TotalPhysicalMemory = GetTotalPhysicalMemory();
+            ComputerName = GetComputerName();
+        }
+
+        string GetCpuID()
+        {
+            try
+            {
+                //获取CPU序列号代码 
+                string cpuInfo = " "; //cpu序列号 
+                using (var mc = new ManagementClass("Win32_Processor"))
+                {
+                    foreach (ManagementObject mo in mc.GetInstances())
+                    {
+                        using (mo)
+                        {
+                            cpuInfo = mo.Properties["ProcessorId"].Value.ToString();
+                        }
+                    }
+                }
+
+                return cpuInfo;
+            }
+            catch
+            {
+                return "unknow ";
+            }
+        }
+
+        /// <summary>
+        /// 获取CPU个数
+        /// </summary>
+        /// <returns></returns>
+        public static int GetCpuCount()
+        {
+            try
+            {
+                using (var mCpu = new ManagementClass("Win32_Processor"))
+                {
+                    using (ManagementObjectCollection cpus = mCpu.GetInstances())
+                    {
+                        return cpus.Count;
+                    }
+                }
+            }
+            catch
+            {
+                // ignored
+            }
+
+            return -1;
+        }
+
+        /// <summary>
+        /// 获取CPU主频
+        /// </summary>
+        /// <returns></returns>
+        public static string[] GetCpuMHZ()
+        {
+            using (var mc = new ManagementClass("Win32_Processor"))
+            {
+                using (ManagementObjectCollection cpus = mc.GetInstances())
+                {
+                    var mhz = new string[cpus.Count];
+                    int c = 0;
+                    using (var mySearch = new ManagementObjectSearcher("select * from Win32_Processor"))
+                    {
+                        foreach (ManagementObject mo in mySearch.Get())
+                        {
+                            using (mo)
+                            {
+                                mhz[c] = mo.Properties["CurrentClockSpeed"].Value.ToString();
+                                c++;
+                            }
+                        }
+                    }
+
+                    return mhz;
+                }
+            }
+        }
+
+        /// <summary>
+        /// 获取磁盘大小
+        /// </summary>
+        /// <returns></returns>
+        public static string GetSizeOfDisk()
+        {
+            using (var mc = new ManagementClass("Win32_DiskDrive"))
+            {
+                foreach (ManagementObject m in mc.GetInstances())
+                {
+                    using (m)
+                    {
+                        return m.Properties["Size"].Value.ToString();
+                    }
+                }
+            }
+
+            return "-1";
+        }
+
+        string GetMacAddress()
+        {
+            try
+            {
+                //获取网卡硬件地址 
+                string mac = " ";
+                using (var mc = new ManagementClass("Win32_NetworkAdapterConfiguration"))
+                {
+                    foreach (ManagementObject mo in mc.GetInstances())
+                    {
+                        using (mo)
+                        {
+                            if ((bool)mo["IPEnabled"])
+                            {
+                                mac = mo["MacAddress"].ToString();
+                                break;
+                            }
+                        }
+                    }
+                }
+
+                return mac;
+            }
+            catch
+            {
+                return "unknow ";
+            }
+        }
+
+        string GetIPAddress()
+        {
+            try
+            {
+                //获取IP地址 
+                string st = Empty;
+                using (var mc = new ManagementClass("Win32_NetworkAdapterConfiguration"))
+                {
+                    foreach (ManagementObject mo in mc.GetInstances())
+                    {
+                        using (mo)
+                        {
+                            if ((bool)mo["IPEnabled"])
+                            {
+                                //st=mo[ "IpAddress "].ToString(); 
+                                Array ar;
+                                ar = (Array)(mo.Properties["IpAddress"].Value);
+                                st = ar.GetValue(0).ToString();
+                                break;
+                            }
+                        }
+                    }
+                }
+
+                return st;
+            }
+            catch
+            {
+                return "unknow ";
+            }
+        }
+
+        string GetDiskID()
+        {
+            try
+            {
+                //获取硬盘ID 
+                string hdid = Empty;
+                using (var mc = new ManagementClass("Win32_DiskDrive"))
+                {
+                    foreach (ManagementObject mo in mc.GetInstances())
+                    {
+                        using (mo)
+                        {
+                            hdid = (string)mo.Properties["Model"].Value;
+                        }
+                    }
+                }
+
+                return hdid;
+            }
+            catch
+            {
+                return "unknow ";
+            }
+        }
+
+        ///    <summary>  
+        ///   操作系统的登录用户名 
+        ///    </summary>  
+        ///    <returns>  </returns>  
+        string GetUserName()
+        {
+            try
+            {
+                string st = Empty;
+                using (var mc = new ManagementClass("Win32_ComputerSystem"))
+                {
+                    foreach (ManagementObject mo in mc.GetInstances())
+                    {
+                        using (mo)
+                        {
+                            st = mo["UserName"].ToString();
+                        }
+                    }
+                }
+
+                return st;
+            }
+            catch
+            {
+                return "unknow ";
+            }
+        }
+
+        string GetSystemType()
+        {
+            try
+            {
+                string st = Empty;
+                using (var mc = new ManagementClass("Win32_ComputerSystem"))
+                {
+                    foreach (var o in mc.GetInstances())
+                    {
+                        using (o)
+                        {
+                            var mo = (ManagementObject)o;
+                            st = mo["SystemType"].ToString();
+                        }
+                    }
+                }
+
+                return st;
+            }
+            catch
+            {
+                return "unknow ";
+            }
+        }
+
+        string GetTotalPhysicalMemory()
+        {
+            try
+            {
+                string st = Empty;
+                using (var mc = new ManagementClass("Win32_ComputerSystem"))
+                {
+                    using (ManagementObjectCollection moc = mc.GetInstances())
+                    {
+                        foreach (var o in moc)
+                        {
+                            var mo = (ManagementObject)o;
+
+                            st = mo["TotalPhysicalMemory"].ToString();
+                        }
+                    }
+                }
+
+                return st;
+            }
+            catch
+            {
+                return "unknow ";
+            }
+        }
+
+        string GetComputerName()
+        {
+            try
+            {
+                return Environment.GetEnvironmentVariable("ComputerName");
+            }
+            catch
+            {
+                return "unknow ";
+            }
+        }
+    }
+}

Masuit.Tools.Core/Win32/WindowsCommand.cs

@@ -71,11 +71,14 @@ namespace Masuit.Tools.Win32
                         {
                             process.WaitForExit(outtime);
                         }
+
                         output = process.StandardOutput.ReadToEnd(); //读取进程的输出  
                     }
                 }
+
                 return output;
             }
+
             throw new Exception("命令参数无效，必须传入一个控制台能被cmd.exe可执行程序;\n如：ping 127.0.0.1");
         }
     }