C#获取计算机的基本信息:内存，CPU,盘符，等比较详细得CommonHelper类

此处写代码是次要的，主要是为了记录C#托管资源与非托管资源的相关问题的说明

查询计算机得基本信息，可以通过引用using System.Management;的DLL

非托管资源是指：所有的Window内核对象（句柄）都是非托管资源，如对于Stream，数据库连接，GDI+的相关对象，还有Com对象等等，这些资源并不是受到CLR管理；

         托管资源是指：由CLR管理分配和释放的资源，即由CLR里new出来的对象。

其次再来讲，资源的释放方式。

         非托管资源：需要显式释放的，也即需要你写代码释放；

         托管资源：并不需要显式释放，但是如果引用类型本身含有非托管资源，则需要进行现实释放；

此处获取计算机的基本信息，是采用的非托管资源，如果获取的信息很多，每次进行调用，如果不进行释放，否则会占用系统的内存和资源，可能出现意想不到的错误

显式释放的C#实现，由C#语法支持的有：

         1：实现IDisposable接口的Dispose方法；

         2：析构方法（终结器）；

         不由C#语法支持，但是约定支持的显式释放是：

         3：提供显示释放方法，比如常用的Close方法；

详细的可以参照此文档：

C#资源释放及Dispose、Close和析构方法 - 陆敏技 - 博客园

public class ComputerInfo
        {
            public string ComputerName { get; set; }
            public string RemovableDeviceID { get; set; }
            public string SystemNameInfo { get; set; }
            public string SystemTypeInfo { get; set; }
            public string CupInfo { get; set; }
            public string SystemMemorySizeOfGB { get; set; }
            public string MemoryAvailable { get; set; }
        }
        public static ComputerInfo GetComputerInfo()
        {
            ComputerInfo computerInfo = new ComputerInfo();
            computerInfo.ComputerName = GetComputerName();
            computerInfo.RemovableDeviceID = GetRemovableDeviceID();
            computerInfo.SystemNameInfo = GetSystemName();
            computerInfo.SystemTypeInfo = GetSystemType();
            computerInfo.CupInfo = GetCPUInfo();
            computerInfo.SystemMemorySizeOfGB = GetSystemMemorySizeOfGB();
            computerInfo.MemoryAvailable = GetMemoryAvailable();
            return computerInfo;
        }
        /// <summary> 
        /// 操作系统的登录用户名 
        /// </summary> 
        /// <returns></returns> 
        public static string GetUserName()
        {
            try
            {
                string st = "";
                ManagementClass mc = new ManagementClass("Win32_ComputerSystem");
                ManagementObjectCollection moc = mc.GetInstances();
                foreach (ManagementObject mo in moc)
                {
                    st = mo["UserName"].ToString();
                }
                mc = null;
                moc.Dispose();
                return st;
            }
            catch
            {
                return "unknow";
            }
        }

        /// <summary> 
        /// PC类型 
        /// </summary> 
        /// <returns></returns> 
        public static string GetSystemType()
        {
            try
            {
                string st = "";
                ManagementClass mc = new ManagementClass("Win32_ComputerSystem");
                ManagementObjectCollection moc = mc.GetInstances();
                foreach (ManagementObject mo in moc)
                {
                    st = mo["SystemType"].ToString();
                }
                mc = null;
                moc.Dispose();
                return st;
            }
            catch
            {
                return "unknow";
            }
        }

        /// <summary> 
        /// 物理内存 
        /// </summary> 
        /// <returns></returns> 
        public static string GetTotalPhysicalMemory()
        {
            try
            {
                string st = "";
                ManagementClass mc = new ManagementClass("Win32_ComputerSystem");
                ManagementObjectCollection moc = mc.GetInstances();
                foreach (ManagementObject mo in moc)
                {
                    st = mo["TotalPhysicalMemory"].ToString();
                }
                mc = null;
                moc.Dispose();
                return st;
            }
            catch
            {
                return "unknow";
            }
        }

        /// <summary> 
        ///  获取计算机名称
        /// </summary> 
        /// <returns></returns> 
        public static string GetComputerName()
        {
            try
            {
                return System.Environment.GetEnvironmentVariable("ComputerName");
            }
            catch
            {
                return "unknow";
            }
        }

        /// <summary>
        /// 取得设备硬盘的卷标号
        /// </summary>
        /// <returns></returns>
        public static string GetDiskVolumeSerialNumber()
        {
            try
            {
                ManagementClass mc = new ManagementClass("Win32_NetworkAdapterConfiguration");
                ManagementObject mo = new ManagementObject("win32_logicaldisk.deviceid=\"c:\"");
                mo.Get();
                mc = null;
                mo.Dispose();
                return mo.GetPropertyValue("VolumeSerialNumber").ToString();
            }
            catch (Exception)
            {
                return "unknow";
            }
        }


        /// <summary>
        /// 获取电脑盘符下的各个的使用情况
        /// </summary>
        /// <returns></returns>
        public static string GetRemovableDeviceID()
        {
            try
            {

                List<DeviceInfo> deviceList = new List<DeviceInfo>();
                ManagementObjectSearcher query = new ManagementObjectSearcher("SELECT  *  From  Win32_LogicalDisk ");
                ManagementObjectCollection queryCollection = query.Get();
                foreach (ManagementObject mo in queryCollection)
                {
                    DeviceInfo deviceInfo = new DeviceInfo();
                    string[] deviceIDFreeSpace = GetHardDiskFreeSpace(mo["DeviceID"].ToString());
                    deviceInfo.DeviceId = mo["DeviceID"].ToString();
                    deviceInfo.TotalSize = deviceIDFreeSpace[0];
                    deviceInfo.FreeSpaceSize = deviceIDFreeSpace[1];
                    deviceList.Add(deviceInfo);
                }
                query = null;
                queryCollection.Dispose();
                return JsonConvert.SerializeObject(deviceList);
            }
            catch (Exception)
            {
                return "unknow";
            }
        }

        /// <summary>
        /// 获取磁盘得大小
        /// </summary>
        /// <param name="str_HardDiskName"></param>
        /// <returns></returns>
        private static string[] GetHardDiskFreeSpace(string str_HardDiskName)
        {
            try
            {
                string[] hardDisk = new string[2];
                long numTotalSize = 0L;
                long numAvailableFreeSpace = 0L;
                string strTotalSize = "";
                string strAvailableFreeSpace = "";
                str_HardDiskName = str_HardDiskName + @"\";
                foreach (DriveInfo info in DriveInfo.GetDrives())
                {
                    if (info.Name.ToUpper() == str_HardDiskName.ToUpper())
                    {
                        numTotalSize = info.TotalSize;
                        numAvailableFreeSpace = info.AvailableFreeSpace;
                        strTotalSize = FileHelper.GetFileSizeStr(numTotalSize);
                        strAvailableFreeSpace = FileHelper.GetFileSizeStr(numAvailableFreeSpace);
                    }
                }
                hardDisk[0] = strTotalSize;
                hardDisk[1] = strAvailableFreeSpace;
                return hardDisk;
            }
            catch (Exception)
            {
                return null;
            }
        }


        /// <summary>
        /// 获取到系统名称
        /// </summary>
        /// <returns>返回当前电脑系统的名称</returns>
        public static string GetSystemName()
        {
            try
            {
                string str = null;
                ManagementClass mc = new ManagementClass("Win32_OperatingSystem");
                ManagementObjectCollection mo = mc.GetInstances();
                foreach (ManagementObject m in mo)
                {
                    str = m["Name"].ToString();
                    break;
                }
                mc = null;
                mo.Dispose();
                return str;
            }
            catch (Exception)
            {
                return "unknow";
            }
        }

        /// <summary>
        /// 获取到GPU的名称
        /// </summary>
        /// <returns>返回当前电脑的GPU名称</returns>
        public static string GetGPUName()
        {
            string str = null;
            ManagementClass manage = new ManagementClass("Win32_VideoController");
            ManagementObjectCollection manageCollection = manage.GetInstances();
            foreach (ManagementObject m in manageCollection)
            {
                str = m["VideoProcessor"].ToString().Replace("Family", "");
                break;
            }
            manage = null;
            manageCollection.Dispose();
            return str;
        }
        /// <summary>
        /// 获取到CPU的名称
        /// </summary>
        /// <returns>返回当前电脑CPU的名称</returns>
        public static string GetCPUInfo()
        {
            string str = null;
            ManagementClass mcCPU = new ManagementClass("Win32_Processor");
            ManagementObjectCollection mocCPU = mcCPU.GetInstances();
            foreach (ManagementObject m in mocCPU)
            {
                str = m["Name"].ToString();
                break;
            }
            mcCPU = null;
            mocCPU.Dispose();
            return str;
        }
        /// <summary>
        /// 获取到系统的内存(GB)
        /// </summary>
        /// <returns>返回当前电脑内存的大小</returns>
        public static string GetSystemMemorySizeOfGB()
        {
            float size = 0;
            ManagementObjectSearcher searcher = new ManagementObjectSearcher();   //用于查询一些如系统信息的管理对象
            searcher.Query = new SelectQuery("Win32_PhysicalMemory", "", new string[] { "Capacity" });//设置查询条件
            ManagementObjectCollection collection = searcher.Get();   //获取内存容量 
            ManagementObjectCollection.ManagementObjectEnumerator em = collection.GetEnumerator();
            long capacity = 0;
            while (em.MoveNext())
            {
                ManagementBaseObject baseObj = em.Current;
                if (baseObj.Properties["Capacity"].Value != null)
                {
                    capacity += long.Parse(baseObj.Properties["Capacity"].Value.ToString());
                }
            }
            size = (capacity / 1024 / 1024 / 1024);
            em.Dispose();
            return size.ToString() + "G";
        }

        /// <summary>
        /// 获取可用内存
        /// </summary>
        public static string GetMemoryAvailable()
        {
            try
            {
                float size = 0;
                long availablebytes = 0;
                ManagementClass mos = new ManagementClass("Win32_OperatingSystem");
                foreach (ManagementObject mo in mos.GetInstances())
                {
                    if (mo["FreePhysicalMemory"] != null)
                    {
                        availablebytes = 1024 * long.Parse(mo["FreePhysicalMemory"].ToString());
                    }
                }
                mos.Dispose();
                size = (availablebytes / 1024 / 1024 / 1024);
                return size.ToString() + "G";
            }
            catch (Exception)
            {
                return "unknow";
            }
        }
        public class DeviceInfo
        {
            public string DeviceId { get; set; }
            public string TotalSize { get; set; }
            public string FreeSpaceSize { get; set; }
        }

需要看demo的可以自行下载