c#获取机器硬件信息

简介: using System;  using System.Management;  namespace Soyee.
  1. using System;  
  2. using System.Management;  
  3. namespace Soyee.Comm  
  4. {  
  5.     /// <summary>  
  6.     /// Computer Information  
  7.     /// </summary>  
  8.     public class Computer  
  9.     {  
  10.         public string CpuID;  
  11.         public string MacAddress;  
  12.         public string DiskID;  
  13.         public string IpAddress;  
  14.         public string LoginUserName;  
  15.         public string ComputerName;  
  16.         public string SystemType;  
  17.         public string TotalPhysicalMemory; //单位:M  
  18.         private static Computer _instance;  
  19.         public static Computer Instance()  
  20.         {  
  21.             if (_instance == null)  
  22.                 _instance = new Computer();  
  23.             return _instance;  
  24.         }  
  25.         protected  Computer()  
  26.         {  
  27.             CpuID=GetCpuID();  
  28.             MacAddress=GetMacAddress();  
  29.             DiskID=GetDiskID();  
  30.             IpAddress=GetIPAddress();  
  31.             LoginUserName=GetUserName();  
  32.             SystemType=GetSystemType();  
  33.             TotalPhysicalMemory=GetTotalPhysicalMemory();  
  34.             ComputerName=GetComputerName();  
  35.         }  
  36.         string  GetCpuID()  
  37.         {  
  38.             try  
  39.             {  
  40.                 //获取CPU序列号代码  
  41.                 string cpuInfo = "";//cpu序列号  
  42.                 ManagementClass mc = new ManagementClass("Win32_Processor");  
  43.                 ManagementObjectCollection moc = mc.GetInstances();  
  44.                 foreach(ManagementObject mo in moc)  
  45.                 {  
  46.                     cpuInfo = mo.Properties["ProcessorId"].Value.ToString();  
  47.                 }  
  48.                 moc=null;  
  49.                 mc=null;  
  50.                 return cpuInfo;  
  51.             }  
  52.             catch  
  53.             {  
  54.                 return "unknow";  
  55.             }  
  56.             finally  
  57.             {  
  58.             }  
  59.               
  60.         }  
  61.         string  GetMacAddress()  
  62.         {  
  63.             try  
  64.             {  
  65.                 //获取网卡硬件地址  
  66.                 string mac="";  
  67.                 ManagementClass mc = new ManagementClass("Win32_NetworkAdapterConfiguration");  
  68.                 ManagementObjectCollection moc = mc.GetInstances();  
  69.                 foreach(ManagementObject mo in moc)  
  70.                 {  
  71.                     if((bool)mo["IPEnabled"] == true)  
  72.                     {  
  73.                         mac=mo["MacAddress"].ToString();  
  74.                         break;  
  75.                     }  
  76.                 }  
  77.                 moc=null;  
  78.                 mc=null;  
  79.                 return mac;  
  80.             }  
  81.             catch  
  82.             {  
  83.                 return "unknow";  
  84.             }  
  85.             finally  
  86.             {  
  87.             }  
  88.               
  89.         }  
  90.         string  GetIPAddress()  
  91.         {  
  92.             try  
  93.             {  
  94.                 //获取IP地址  
  95.                 string st="";  
  96.                 ManagementClass mc = new ManagementClass("Win32_NetworkAdapterConfiguration");  
  97.                 ManagementObjectCollection moc = mc.GetInstances();  
  98.                 foreach(ManagementObject mo in moc)  
  99.                 {  
  100.                     if((bool)mo["IPEnabled"] == true)  
  101.                     {  
  102.                         //st=mo["IpAddress"].ToString();  
  103.                         System.Array ar;  
  104.                         ar=(System.Array)(mo.Properties["IpAddress"].Value);  
  105.                         st=ar.GetValue(0).ToString();  
  106.                         break;  
  107.                     }  
  108.                 }  
  109.                 moc=null;  
  110.                 mc=null;  
  111.                 return st;  
  112.             }  
  113.             catch  
  114.             {  
  115.                 return "unknow";  
  116.             }  
  117.             finally  
  118.             {  
  119.             }  
  120.               
  121.         }  
  122.            
  123.         string  GetDiskID()  
  124.         {  
  125.             try  
  126.             {  
  127.                 //获取硬盘ID  
  128.                 String HDid="";  
  129.                 ManagementClass mc = new ManagementClass("Win32_DiskDrive");  
  130.                 ManagementObjectCollection moc = mc.GetInstances();  
  131.                 foreach(ManagementObject mo in moc)  
  132.                 {  
  133.                     HDid = (string)mo.Properties["Model"].Value;  
  134.                 }  
  135.                 moc=null;  
  136.                 mc=null;  
  137.                 return HDid;  
  138.             }  
  139.             catch  
  140.             {  
  141.                 return "unknow";  
  142.             }  
  143.             finally  
  144.             {  
  145.             }  
  146.                   
  147.         }  
  148.   
  149.         /// <summary>  
  150.         /// 操作系统的登录用户名  
  151.         /// </summary>  
  152.         /// <returns></returns>  
  153.         string  GetUserName()  
  154.         {  
  155.             try  
  156.             {  
  157.                 string st="";  
  158.                 ManagementClass mc = new ManagementClass("Win32_ComputerSystem");  
  159.                 ManagementObjectCollection moc = mc.GetInstances();  
  160.                 foreach(ManagementObject mo in moc)  
  161.                 {  
  162.                       
  163.                     st=mo["UserName"].ToString();  
  164.                       
  165.                 }  
  166.                 moc=null;  
  167.                 mc=null;  
  168.                 return st;  
  169.             }  
  170.             catch  
  171.             {  
  172.                 return "unknow";  
  173.             }  
  174.             finally  
  175.             {  
  176.             }  
  177.               
  178.         }  
  179.   
  180.   
  181.         /// <summary>  
  182.         /// PC类型  
  183.         /// </summary>  
  184.         /// <returns></returns>  
  185.         string  GetSystemType()  
  186.         {  
  187.             try  
  188.             {  
  189.                 string st="";  
  190.                 ManagementClass mc = new ManagementClass("Win32_ComputerSystem");  
  191.                 ManagementObjectCollection moc = mc.GetInstances();  
  192.                 foreach(ManagementObject mo in moc)  
  193.                 {  
  194.                       
  195.                     st=mo["SystemType"].ToString();  
  196.                       
  197.                 }  
  198.                 moc=null;  
  199.                 mc=null;  
  200.                 return st;  
  201.             }  
  202.             catch  
  203.             {  
  204.                 return "unknow";  
  205.             }  
  206.             finally  
  207.             {  
  208.             }  
  209.               
  210.         }  
  211.   
  212.         /// <summary>  
  213.         /// 物理内存  
  214.         /// </summary>  
  215.         /// <returns></returns>  
  216.         string  GetTotalPhysicalMemory()  
  217.         {  
  218.             try  
  219.             {  
  220.                   
  221.                 string st="";  
  222.                 ManagementClass mc = new ManagementClass("Win32_ComputerSystem");  
  223.                 ManagementObjectCollection moc = mc.GetInstances();  
  224.                 foreach(ManagementObject mo in moc)  
  225.                 {  
  226.                       
  227.                     st=mo["TotalPhysicalMemory"].ToString();  
  228.                       
  229.                 }  
  230.                 moc=null;  
  231.                 mc=null;  
  232.                 return st;  
  233.             }  
  234.             catch  
  235.             {  
  236.                 return "unknow";  
  237.             }  
  238.             finally  
  239.             {  
  240.             }  
  241.         }  
  242.         /// <summary>  
  243.         ///   
  244.         /// </summary>  
  245.         /// <returns></returns>  
  246.         string  GetComputerName()  
  247.         {  
  248.             try  
  249.             {                 
  250.                 return System.Environment.GetEnvironmentVariable("ComputerName");  
  251.             }  
  252.             catch  
  253.             {  
  254.                 return "unknow";  
  255.             }  
  256.             finally  
  257.             {  
  258.             }  
  259.         }  
  260.   
  261.   
  262.     }  
  263. }
相关文章
|
1月前
|
C#
24. C# 编程:用户设定敌人初始血值的实现
24. C# 编程:用户设定敌人初始血值的实现
22 0
|
2月前
|
SQL 数据库连接 应用服务中间件
C#WinForm基础编程(三)
C#WinForm基础编程
78 0
|
2月前
C#WinForm基础编程(二)
C#WinForm基础编程
59 0
|
2月前
|
C# 数据安全/隐私保护
C#WinForm基础编程(一)
C#WinForm基础编程
62 0
|
4月前
|
数据采集 前端开发 C#
C#编程艺术:Fizzler库助您高效爬取www.twitter.com音频
Twitter是全球最大的社交媒体平台之一,包含丰富的音频资源。用户可以在Twitter上发布、转发、评论和收听各种音频内容,如音乐、播客、新闻、故事等,直接从Twitter抓取音频数据并非易事,尤其是在考虑到可能的封锁和反爬虫机制。Twitter会对频繁访问的IP地址进行限制或封禁,以防止恶意爬虫的行为。因此,我们需要使用一些技术手段来规避这些障碍,确保稳定而高效的数据访问。
C#编程艺术:Fizzler库助您高效爬取www.twitter.com音频
|
3月前
|
程序员 C#
深入理解 C# 编程:枚举、文件处理、异常处理和数字相加
枚举是一个特殊的“类”,表示一组常量(不可更改/只读变量)。 要创建枚举,请使用 enum 关键字(而不是 class 或 interface),并用逗号分隔枚举项:
38 0
|
5天前
|
存储 安全 网络安全
C#编程的安全性与加密技术
【4月更文挑战第21天】C#在.NET框架支持下,以其面向对象和高级特性成为安全软件开发的利器。本文探讨C#在安全加密领域的应用,包括使用System.Security.Cryptography库实现加密算法,利用SSL/TLS保障网络传输安全,进行身份验证,并强调编写安全代码的重要性。实际案例涵盖在线支付、企业应用和文件加密,展示了C#在应对安全挑战的同时,不断拓展其在该领域的潜力和未来前景。
|
5天前
|
程序员 C#
C#编程中的面向对象编程思想
【4月更文挑战第21天】本文探讨了C#中的面向对象编程,包括类、对象、封装、继承和多态。类是对象的抽象,定义属性和行为;对象是类的实例。封装隐藏内部细节,只暴露必要接口。继承允许类复用和扩展属性与行为,而多态使不同类的对象能通过相同接口调用方法。C#通过访问修饰符实现封装,使用虚方法和抽象方法实现多态。理解并应用这些概念,能提升代码的清晰度和可扩展性,助你成为更好的C#程序员。