信息发布软件,b2b软件,广告发布软件

 找回密码
 立即注册
搜索

VB.NET中如何得到计算机硬件信息和实例教程

查看数: 97938 | 评论数: 1 | 收藏 0
关灯 | 提示:支持键盘翻页<-左 右->
    组图打开中,请稍候......
发布时间: 2017-2-26 17:21

正文摘要:

本文汇集了在.net中得到计算机硬件信息的一些功能。  得到显示器分辨率  Dim X As Short = System.<a href="http://dev.21tx.com/os/windows/" target="_blank">Windows</a>.Forms.Screen.Prima ...

回复

信息发布软件 发表于 2017-2-26 17:23:02
  1. 在项目开发过程中,经常会需要读取所在计算机的硬件信息,包括CPU的序列号,主板的序列号,硬盘的序列号,MAC地址,IP地址,用户名,系统类型,计算机名称,操作系统类型,物理内存大小,BIOS内容等。
  2. 开发环境:VS2005   .NET2.0
  3. 项目工程文件:Computer.zip  
  4. /*****************************************************************/
  5. /* 作者:虞晓杰
  6. * Emial:fishyxj@sina.com
  7. * 2011.9.26
  8. * 功能:用于获取计算机的各种信息,包括CPU的ID,MAC地址,硬盘ID,
  9. * IP地址登录用户名,计算机名称,系统类型,物理内存,主板的ID,
  10. * BIOS的ID
  11. *
  12. * 缺陷:当计算机存在虚拟网卡时,无法区分虚拟网卡与真实网卡,因此
  13. * 读取MAC地址时,会存在不稳定的情况。需要自行处理虚拟网卡MAC的情
  14. * 况
  15. /*****************************************************************/
  16. using System;
  17. using System.Collections.Generic;
  18. using System.Text;
  19. using System.Management;
  20. using System.Collections;
  21. using System.Net.NetworkInformation;
  22. using Microsoft.Win32;
  23. namespace XFish.Utils
  24. {
  25.     /// <summary>
  26.     /// 计算机信息类
  27.     /// </summary>
  28.     public class Computer
  29.     {
  30.         #region 类内部变量
  31.         private string _CpuID;
  32.         private string _MacAddress;
  33.         private ArrayList _MacAddList;
  34.         private string _DiskID;
  35.         private string _IpAddress;
  36.         private string _LoginUserName;
  37.         private string _ComputerName;
  38.         private string _SystemType;
  39.         private string _TotalPhysicalMemory; //单位:M   
  40.         private string _BaseboardID;
  41.         private string _BiosID;
  42.         private static Computer _instance;
  43.         #endregion
  44.         #region 类属性
  45.         /// <summary>
  46.         /// 获取计算机信息全局实例
  47.         /// </summary>
  48.         /// <returns>Computer实例</returns>
  49.         public static Computer Instance()
  50.         {
  51.             if (_instance == null)
  52.                 _instance = new Computer();
  53.             return _instance;
  54.         }
  55.         /// <summary>
  56.         /// 获取CPU的ID
  57.         /// </summary>
  58.         public string CpuID
  59.         {
  60.             get { return _CpuID; }
  61.         }
  62.         /// <summary>
  63.         /// 获取MAC地址
  64.         /// </summary>
  65.         public string MacAddress
  66.         {
  67.             get { return _MacAddress; }
  68.         }
  69.         /// <summary>
  70.         /// 获取计算机中的MAC地址列表,当存在多个网卡时(包括虚拟网卡)
  71.         /// </summary>
  72.         public ArrayList MacAddList
  73.         {
  74.             get { return _MacAddList; }
  75.         }
  76.         /// <summary>
  77.         /// 获取硬盘ID
  78.         /// </summary>
  79.         public string DiskID
  80.         {
  81.             get { return _DiskID; }
  82.         }
  83.         /// <summary>
  84.         /// 获取IP地址(活跃的网卡)
  85.         /// </summary>
  86.         public string IpAddress
  87.         {
  88.             get { return _IpAddress; }
  89.         }
  90.         /// <summary>
  91.         /// 系统登录用户名
  92.         /// </summary>
  93.         public string LoginUserName
  94.         {
  95.             get { return _LoginUserName; }
  96.         }
  97.         /// <summary>
  98.         /// 计算机名称
  99.         /// </summary>
  100.         public string ComputerName
  101.         {
  102.             get { return _ComputerName; }
  103.         }
  104.         /// <summary>
  105.         /// 操作系统类型
  106.         /// </summary>
  107.         public string SystemType
  108.         {
  109.             get { return _SystemType; }
  110.         }
  111.         /// <summary>
  112.         /// 总的物理内存
  113.         /// </summary>
  114.         public string TotalPhysicalMemory
  115.         {
  116.             get { return _TotalPhysicalMemory; }
  117.         }
  118.         /// <summary>
  119.         /// 主板ID
  120.         /// </summary>
  121.         public string BaseboardID
  122.         {
  123.             get { return _BaseboardID; }
  124.         }
  125.         /// <summary>
  126.         /// BIOS的ID
  127.         /// </summary>
  128.         public string BiosID
  129.         {
  130.             get { return _BiosID; }
  131.         }
  132.         #endregion
  133.         #region 类初始化
  134.         public Computer()
  135.         {
  136.             _CpuID = GetCpuID();
  137.             _MacAddress = GetMacAddress();
  138.             _MacAddList = GetMacAddList();
  139.             _DiskID = GetDiskID();
  140.             _IpAddress = GetIPAddress();
  141.             _LoginUserName = GetUserName();
  142.             _SystemType = GetSystemType();
  143.             _TotalPhysicalMemory = GetTotalPhysicalMemory();
  144.             _ComputerName = GetComputerName();
  145.             _BaseboardID = GetBaseBoardID();
  146.             _BiosID = GetBiosID();
  147.         }
  148.         #endregion
  149.         #region 类方法
  150.         /// <summary>
  151.         /// 获取BIOS序列号
  152.         /// </summary>
  153.         /// <returns></returns>
  154.         private string GetBiosID()
  155.         {
  156.            
  157.             try
  158.             {
  159.                 //方法一
  160.                 //SelectQuery Query = new SelectQuery("SELECT * FROM Win32_BaseBoard");
  161.                 //ManagementObjectSearcher driveID = new ManagementObjectSearcher(Query);
  162.                 //ManagementObjectCollection.ManagementObjectEnumerator data = driveID.Get().GetEnumerator();
  163.                 //data.MoveNext();
  164.                 //ManagementBaseObject board = data.Current;
  165.                 //return board.GetPropertyValue("SerialNumber").ToString();

  166.                 //方法二
  167.                 System.Management.ManagementObjectSearcher cmicWmi = new ManagementObjectSearcher("SELECT   *   FROM   Win32_BIOS");
  168.                 string biosid = string.Empty;
  169.                 ManagementObjectCollection moc = cmicWmi.Get();
  170.                 foreach (ManagementObject cmicWmiObj in moc)
  171.                 {
  172.                     biosid = cmicWmiObj["SerialNumber"].ToString();
  173.                 }
  174.                 return biosid;
  175.                 //System.Management.ManagementObjectSearcher cmicWmi = new ManagementObjectSearcher("SELECT   *   FROM   Win32_BIOS");
  176.                 //string biosid = string.Empty;
  177.                 //ManagementObjectCollection moc = cmicWmi.Get();
  178.                 //foreach (ManagementObject cmicWmiObj in moc)
  179.                 //{
  180.                 //    biosid += GetAllInfo(cmicWmiObj);
  181.                 //}
  182.                 //return biosid;
  183.             }
  184.             catch(Exception ex)
  185.             {
  186.                 //throw new Exception("unknow:"+ex.Message);
  187.                 return "unknow";
  188.             }
  189.             finally
  190.             {
  191.             }
  192.         }
  193.         /// <summary>
  194.         /// 获取CPU序列号
  195.         /// </summary>
  196.         /// <returns></returns>
  197.         private string GetCpuID()
  198.         {
  199.             try
  200.             {
  201.                 //获取CPU序列号代码   
  202.                 string cpuInfo = "";//cpu序列号   
  203.                 ManagementClass mc = new ManagementClass("Win32_Processor");
  204.                 ManagementObjectCollection moc = mc.GetInstances();
  205.                 foreach (ManagementObject mo in moc)
  206.                 {
  207.                     cpuInfo = mo.Properties["ProcessorId"].Value.ToString();
  208.                 }
  209.                 moc = null;
  210.                 mc = null;
  211.                 return cpuInfo;
  212.                 //string cpuInfo = "";//cpu序列号   
  213.                 //ManagementClass mc = new ManagementClass("Win32_Processor");
  214.                 //ManagementObjectCollection moc = mc.GetInstances();
  215.                 //foreach (ManagementObject mo in moc)
  216.                 //{
  217.                 //    cpuInfo += GetAllInfo(mo);
  218.                 //}
  219.                 //moc = null;
  220.                 //mc = null;
  221.                 //return cpuInfo;
  222.             }
  223.             catch (Exception ex)
  224.             {
  225.                 return "unknow";
  226.             }
  227.             finally
  228.             {
  229.             }
  230.         }
  231.         /// <summary>
  232.         /// 获取MAC地址列表
  233.         /// </summary>
  234.         /// <returns></returns>
  235.         private ArrayList GetMacAddList()
  236.         {
  237.             try
  238.             {
  239.                 ArrayList maclist = new ArrayList();
  240.                 ArrayList warelessMacList = new ArrayList();
  241.                 NetworkInterface[] fNetworkInterfaces = NetworkInterface.GetAllNetworkInterfaces();
  242.                 foreach (NetworkInterface adapter in fNetworkInterfaces)
  243.                 {
  244.                     string fRegistryKey = "SYSTEM\\CurrentControlSet\\Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}\\" + adapter.Id + "\\Connection";
  245.                     RegistryKey rk = Registry.LocalMachine.OpenSubKey(fRegistryKey, false);
  246.                     if (rk != null)
  247.                     {
  248.                         // 区分 PnpInstanceID   
  249.                         // 如果前面有 PCI 就是本机的真实网卡   
  250.                         // MediaSubType 为 01 则是常见网卡,02为无线网卡。   
  251.                         string fPnpInstanceID = rk.GetValue("PnpInstanceID", "").ToString();
  252.                         int fMediaSubType = Convert.ToInt32(rk.GetValue("MediaSubType", 0));
  253.                         if (fPnpInstanceID.Length > 3 &&
  254.                         fPnpInstanceID.Substring(0, 3) == "PCI")
  255.                         {
  256.                             string mac = adapter.GetPhysicalAddress().ToString();
  257.                             mac = GetMacStr(mac);
  258.                             maclist.Add(mac);
  259.                         }
  260.                         else if (fMediaSubType == 1)
  261.                             continue;
  262.                         else if (fMediaSubType == 2)
  263.                         {
  264.                             string mac = adapter.GetPhysicalAddress().ToString();
  265.                             mac = GetMacStr(mac);
  266.                             warelessMacList.Add(mac);
  267.                         }
  268.                     }
  269.                 }
  270.                 maclist.AddRange(warelessMacList);
  271.                 return maclist;
  272.             }
  273.             catch
  274.             {
  275.                 try
  276.                 {
  277.                     ArrayList maclist = new ArrayList();
  278.                     ManagementClass mc = new ManagementClass("Win32_NetworkAdapterConfiguration");
  279.                     ManagementObjectCollection moc = mc.GetInstances();
  280.                     foreach (ManagementObject mo in moc)
  281.                     {
  282.                         if (mo["MacAddress"] != null)
  283.                         {
  284.                             string mac = mo["MacAddress"].ToString();
  285.                             maclist.Add(mac);
  286.                         }
  287.                     }
  288.                     moc = null;
  289.                     mc = null;
  290.                     return maclist;
  291.                 }
  292.                 catch
  293.                 {
  294.                     return null;
  295.                 }
  296.             }
  297.         }
  298.         /// <summary>
  299.         /// 获取MAC地址
  300.         /// </summary>
  301.         /// <returns></returns>
  302.         private string GetMacAddress()
  303.         {
  304.             try
  305.             {
  306.                 string warelessMac = string.Empty;
  307.                 string mac = string.Empty;
  308.                 NetworkInterface[] fNetworkInterfaces = NetworkInterface.GetAllNetworkInterfaces();
  309.                 foreach (NetworkInterface adapter in fNetworkInterfaces)
  310.                 {
  311.                     string fRegistryKey = "SYSTEM\\CurrentControlSet\\Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}\\" + adapter.Id + "\\Connection";
  312.                     RegistryKey rk = Registry.LocalMachine.OpenSubKey(fRegistryKey, false);
  313.                     if (rk != null)
  314.                     {
  315.                         // 区分 PnpInstanceID   
  316.                         // 如果前面有 PCI 就是本机的真实网卡   
  317.                         // MediaSubType 为 01 则是常见网卡,02为无线网卡。   
  318.                         string fPnpInstanceID = rk.GetValue("PnpInstanceID", "").ToString();
  319.                         int fMediaSubType = Convert.ToInt32(rk.GetValue("MediaSubType", 0));
  320.                         if (fPnpInstanceID.Length > 3 &&
  321.                         fPnpInstanceID.Substring(0, 3) == "PCI")
  322.                         {
  323.                             mac = adapter.GetPhysicalAddress().ToString();
  324.                             break;
  325.                         }
  326.                         else if (fMediaSubType == 1)
  327.                             continue;
  328.                         else if (fMediaSubType == 2)
  329.                             warelessMac = adapter.GetPhysicalAddress().ToString();
  330.                     }
  331.                 }
  332.                 if (!mac.Equals(string.Empty))
  333.                     return GetMacStr(mac);
  334.                 else if (!warelessMac.Equals(string.Empty))
  335.                     return GetMacStr(warelessMac);
  336.                 else
  337.                     return "unknow";
  338.             }
  339.             catch (Exception ex)
  340.             {
  341.                 return "unknow";
  342.             }
  343.             finally
  344.             {
  345.             }
  346.         }
  347.         /// <summary>
  348.         /// 获取MAC地址
  349.         /// </summary>
  350.         /// <param name="mac"></param>
  351.         /// <returns></returns>
  352.         private string GetMacStr(string mac)
  353.         {
  354.             string newmac = string.Empty;
  355.             newmac = mac.Substring(0, 2);
  356.             mac = mac.Substring(2, mac.Length - 2);
  357.             while (!mac.Equals(string.Empty))
  358.             {
  359.                 newmac += ":";
  360.                 newmac += mac.Substring(0, 2);
  361.                 mac = mac.Substring(2, mac.Length - 2);
  362.             }
  363.             return newmac;
  364.         }
  365.         /// <summary>
  366.         /// 获取IP地址
  367.         /// </summary>
  368.         /// <returns></returns>
  369.         private string GetIPAddress()
  370.         {
  371.             try
  372.             {
  373.                 //获取IP地址   
  374.                 string st = "";
  375.                 ManagementClass mc = new ManagementClass("Win32_NetworkAdapterConfiguration");
  376.                 ManagementObjectCollection moc = mc.GetInstances();
  377.                 foreach (ManagementObject mo in moc)
  378.                 {
  379.                     if ((bool)mo["IPEnabled"] == true)
  380.                     {
  381.                         //st=mo["IpAddress"].ToString();   
  382.                         System.Array ar;
  383.                         ar = (System.Array)(mo.Properties["IpAddress"].Value);
  384.                         st = ar.GetValue(0).ToString();
  385.                         break;
  386.                     }
  387.                 }
  388.                 moc = null;
  389.                 mc = null;
  390.                 return st;
  391.             }
  392.             catch (Exception ex)
  393.             {
  394.                 return "unknow";
  395.             }
  396.         }
  397.         /// <summary>
  398.         /// 获取硬盘的序列号
  399.         /// </summary>
  400.         /// <returns></returns>
  401.         private string GetDiskID()
  402.         {
  403.             try
  404.             {
  405.                 //方法一
  406.                 //ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT * FROM Win32_PhysicalMedia");
  407.                 //String strHardDiskID = null;
  408.                 //foreach (ManagementObject mo in searcher.Get())
  409.                 //{
  410.                 //    strHardDiskID = mo["SerialNumber"].ToString().Trim();
  411.                 //    break;
  412.                 //}
  413.                 //return strHardDiskID;
  414.                 //方法二
  415.                 //System.Management.ManagementObjectSearcher cmicWmi = new ManagementObjectSearcher("SELECT   *   FROM   Win32_DiskDrive");
  416.                 //string diskid = string.Empty;
  417.                 //foreach (ManagementObject cmicWmiObj in cmicWmi.Get())
  418.                 //{
  419.                 //    diskid = cmicWmiObj["signature"].ToString();
  420.                 //}
  421.                 //return diskid;
  422.                

  423.                 //方法三   
  424.                 //String HDid = "";
  425.                 //ManagementClass mc = new ManagementClass("Win32_DiskDrive");
  426.                 //ManagementObjectCollection moc = mc.GetInstances();
  427.                 //foreach (ManagementObject mo in moc)
  428.                 //{
  429.                 //    HDid = (string)mo.Properties["model"].Value;
  430.                 //}
  431.                 //moc = null;
  432.                 //mc = null;
  433.                 //return HDid;
  434.                 //方法四
  435.                 System.Management.ManagementObjectSearcher cmicWmi = new ManagementObjectSearcher("SELECT   *   FROM   Win32_DiskDrive");
  436.                 string tmp = string.Empty;
  437.                 foreach (ManagementObject cmicWmiObj in cmicWmi.Get())
  438.                 {
  439.                     bool isSyspan = false;
  440.                     System.Management.PropertyDataCollection pdc = cmicWmiObj.Properties;
  441.                     string info = string.Empty;
  442.                     foreach (PropertyData pd in pdc)
  443.                     {
  444.                         if (pd.Name.Equals("Name"))
  445.                         {
  446.                             if (pd.Value.Equals("\\\\.\\PHYSICALDRIVE0"))
  447.                             {
  448.                                 isSyspan = true;
  449.                             }
  450.                         }
  451.                         if (isSyspan)
  452.                         {
  453.                             if (pd.Name.Equals("PNPDeviceID"))
  454.                             {
  455.                                 tmp += pd.Value;
  456.                             }
  457.                             else if (pd.Name.Equals("Signature"))
  458.                             {
  459.                                 tmp += pd.Value;
  460.                                 break;
  461.                             }
  462.                         }
  463.                     }
  464.                 }
  465.                 return tmp;
  466.                
  467.             }
  468.             catch (Exception ex)
  469.             {
  470.                 return "unknow";
  471.             }
  472.             finally
  473.             {
  474.             }
  475.         }
  476.         /// <summary>   
  477.         /// 操作系统的登录用户名   
  478.         /// </summary>   
  479.         /// <returns></returns>   
  480.         private string GetUserName()
  481.         {
  482.             try
  483.             {
  484.                 string st = "";
  485.                 ManagementClass mc = new ManagementClass("Win32_ComputerSystem");
  486.                 ManagementObjectCollection moc = mc.GetInstances();
  487.                 foreach (ManagementObject mo in moc)
  488.                 {
  489.                     st = mo["UserName"].ToString();
  490.                 }
  491.                 moc = null;
  492.                 mc = null;
  493.                 return st;
  494.             }
  495.             catch (Exception ex)
  496.             {
  497.                 return "unknow";
  498.             }
  499.             finally
  500.             {
  501.             }
  502.         }
  503.         /// <summary>   
  504.         /// 获取计算机操作系统类型  
  505.         /// </summary>   
  506.         /// <returns></returns>   
  507.         private string GetSystemType()
  508.         {
  509.             try
  510.             {
  511.                 string st = "";
  512.                 ManagementClass mc = new ManagementClass("Win32_ComputerSystem");
  513.                 ManagementObjectCollection moc = mc.GetInstances();
  514.                 foreach (ManagementObject mo in moc)
  515.                 {
  516.                     st = mo["SystemType"].ToString();
  517.                 }
  518.                 moc = null;
  519.                 mc = null;
  520.                 return st;
  521.             }
  522.             catch (Exception ex)
  523.             {
  524.                 return "unknow";
  525.             }
  526.             finally
  527.             {
  528.             }
  529.         }
  530.         /// <summary>   
  531.         /// 获取计算机物理内存   
  532.         /// </summary>   
  533.         /// <returns></returns>   
  534.         private string GetTotalPhysicalMemory()
  535.         {
  536.             try
  537.             {
  538.                 string st = "";
  539.                 ManagementClass mc = new ManagementClass("Win32_ComputerSystem");
  540.                 ManagementObjectCollection moc = mc.GetInstances();
  541.                 foreach (ManagementObject mo in moc)
  542.                 {
  543.                     st = mo["TotalPhysicalMemory"].ToString();
  544.                 }
  545.                 moc = null;
  546.                 mc = null;
  547.                 return st;
  548.             }
  549.             catch (Exception ex)
  550.             {
  551.                 return "unknow";
  552.             }
  553.             finally
  554.             {
  555.             }
  556.         }
  557.         /// <summary>
  558.         /// 获取主板的ID
  559.         /// </summary>
  560.         /// <returns></returns>
  561.         private string GetBaseBoardID()
  562.         {
  563.             try
  564.             {
  565.                 //string strbNumber = string.Empty;
  566.                 //ManagementObjectSearcher mos = new ManagementObjectSearcher("select * from Win32_baseboard");
  567.                 //foreach (ManagementObject mo in mos.Get())
  568.                 //{
  569.                 //    strbNumber = mo["SerialNumber"].ToString();
  570.                 //    break;
  571.                 //}
  572.                 //return strbNumber;
  573.                 ManagementClass mc = new ManagementClass("WIN32_BaseBoard");
  574.                 ManagementObjectCollection moc = mc.GetInstances();
  575.                 string SerialNumber = "";
  576.                 foreach (ManagementObject mo in moc)
  577.                 {
  578.                     SerialNumber = mo["SerialNumber"].ToString();
  579.                     break;
  580.                 }
  581.                 return SerialNumber;
  582.                 //ManagementClass mc = new ManagementClass("WIN32_BaseBoard");
  583.                 //ManagementObjectCollection moc = mc.GetInstances();
  584.                 //string SerialNumber = "";
  585.                 //foreach (ManagementObject mo in moc)
  586.                 //{
  587.                 //    SerialNumber = GetAllInfo(mo);
  588.                 //}
  589.                 //return SerialNumber;
  590.             }
  591.             catch (Exception ex)
  592.             {
  593.                 return "unknow";
  594.             }
  595.             finally
  596.             {
  597.             }
  598.         }
  599.         /// <summary>
  600.         /// 获取计算机名称
  601.         /// </summary>
  602.         /// <returns></returns>
  603.         private string GetComputerName()
  604.         {
  605.             try
  606.             {
  607.                 return System.Environment.GetEnvironmentVariable("ComputerName");
  608.             }
  609.             catch(Exception ex)
  610.             {
  611.                 return "unknow";
  612.             }
  613.             finally
  614.             {
  615.             }
  616.         }
  617.         #endregion
  618.     }
  619. }
复制代码

QQ|( 京ICP备09078825号 )

本网站信息发布软件,是可以发布论坛,发送信息到各大博客,各大b2b软件自动发布,好不夸张的说:只要手工能发在电脑打开IE能发的网站,用这个宣传软件就可以仿制动作,进行推送发到您想发送的B2B网站或是信息发布平台上,不管是后台,还是前台,都可以进行最方便的广告发布,这个广告发布软件,可以按月购买,还可以试用软件,对网站的验证码也可以完全自动对信息发布,让客户自动找上门,使企业轻松实现b2b发布,这个信息发布软件,均是本站原创正版开发,拥有正版的血统,想要新功能,欢迎提意见给我,一好的分类信息群发软件在手,舍我其谁。QQ896757558

GMT+8, 2024-5-19 22:11 , Processed in 0.270197 second(s), 42 queries .

宣传软件--信息发布软件--b2b软件广告发布软件

快速回复 返回顶部 返回列表