logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

使用C#获取CPU及硬盘序列号的源代码

 *我爱阳光* 2010-09-24
 

首先需添加对System.Management的引用。

  1. using System;
  2. using System.Runtime.InteropServices;
  3. using System.Management;
  5. namespace Hardware
  6. {
  7.     /// <summary>
  8.     /// HardwareInfo 的摘要说明。
  9.     /// </summary>
  10.     public class HardwareInfo
  11.     {
  12.         //取机器名 
  13.         public string GetHostName()
  14.         {
  15.             return System.Net.Dns.GetHostName();
  16.         }
  17.         //取CPU编号
  18.         public String GetCpuID()
  19.         {
  20.             try
  21.             {
  22.                 ManagementClass mc = new ManagementClass("Win32_Processor");
  23.                 ManagementObjectCollection moc = mc.GetInstances();
  25.                 String strCpuID = null;
  26.                 foreach (ManagementObject mo in moc)
  27.                 {
  28.                     strCpuID = mo.Properties["ProcessorId"].Value.ToString();
  29.                     break;
  30.                 }
  31.                 return strCpuID;
  32.             }
  33.             catch
  34.             {
  35.                 return "";
  36.             }
  38.         }//end method
  40.         //取第一块硬盘编号
  41.         public String GetHardDiskID()
  42.         {
  43.             try
  44.             {
  45.                 ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT * FROM Win32_PhysicalMedia");
  46.                 String strHardDiskID = null;
  47.                 foreach (ManagementObject mo in searcher.Get())
  48.                 {
  49.                     strHardDiskID = mo["SerialNumber"].ToString().Trim();
  50.                     break;
  51.                 }
  52.                 return strHardDiskID;
  53.             }
  54.             catch
  55.             {
  56.                 return "";
  57.             }
  58.         }//end 
  60.         public enum NCBCONST
  61.         {
  62.             NCBNAMSZ = 16,      /* absolute length of a net name         */
  63.             MAX_LANA = 254,      /* lana's in range 0 to MAX_LANA inclusive   */
  64.             NCBENUM = 0x37,      /* NCB ENUMERATE LANA NUMBERS            */
  65.             NRC_GOODRET = 0x00,      /* good return                              */
  66.             NCBRESET = 0x32,      /* NCB RESET                        */
  67.             NCBASTAT = 0x33,      /* NCB ADAPTER STATUS                  */
  68.             NUM_NAMEBUF = 30,      /* Number of NAME's BUFFER               */
  69.         }
  71.         [StructLayout(LayoutKind.Sequential)]
  72.         public struct ADAPTER_STATUS
  73.         {
  74.             [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]
  75.             public byte[] adapter_address;
  76.             public byte rev_major;
  77.             public byte reserved0;
  78.             public byte adapter_type;
  79.             public byte rev_minor;
  80.             public ushort duration;
  81.             public ushort frmr_recv;
  82.             public ushort frmr_xmit;
  83.             public ushort iframe_recv_err;
  84.             public ushort xmit_aborts;
  85.             public uint xmit_success;
  86.             public uint recv_success;
  87.             public ushort iframe_xmit_err;
  88.             public ushort recv_buff_unavail;
  89.             public ushort t1_timeouts;
  90.             public ushort ti_timeouts;
  91.             public uint reserved1;
  92.             public ushort free_ncbs;
  93.             public ushort max_cfg_ncbs;
  94.             public ushort max_ncbs;
  95.             public ushort xmit_buf_unavail;
  96.             public ushort max_dgram_size;
  97.             public ushort pending_sess;
  98.             public ushort max_cfg_sess;
  99.             public ushort max_sess;
  100.             public ushort max_sess_pkt_size;
  101.             public ushort name_count;
  102.         }
  104.         [StructLayout(LayoutKind.Sequential)]
  105.         public struct NAME_BUFFER
  106.         {
  107.             [MarshalAs(UnmanagedType.ByValArray, SizeConst = (int)NCBCONST.NCBNAMSZ)]
  108.             public byte[] name;
  109.             public byte name_num;
  110.             public byte name_flags;
  111.         }
  113.         [StructLayout(LayoutKind.Sequential)]
  114.         public struct NCB
  115.         {
  116.             public byte ncb_command;
  117.             public byte ncb_retcode;
  118.             public byte ncb_lsn;
  119.             public byte ncb_num;
  120.             public IntPtr ncb_buffer;
  121.             public ushort ncb_length;
  122.             [MarshalAs(UnmanagedType.ByValArray, SizeConst = (int)NCBCONST.NCBNAMSZ)]
  123.             public byte[] ncb_callname;
  124.             [MarshalAs(UnmanagedType.ByValArray, SizeConst = (int)NCBCONST.NCBNAMSZ)]
  125.             public byte[] ncb_name;
  126.             public byte ncb_rto;
  127.             public byte ncb_sto;
  128.             public IntPtr ncb_post;
  129.             public byte ncb_lana_num;
  130.             public byte ncb_cmd_cplt;
  131.             [MarshalAs(UnmanagedType.ByValArray, SizeConst = 10)]
  132.             public byte[] ncb_reserve;
  133.             public IntPtr ncb_event;
  134.         }
  136.         [StructLayout(LayoutKind.Sequential)]
  137.         public struct LANA_ENUM
  138.         {
  139.             public byte length;
  140.             [MarshalAs(UnmanagedType.ByValArray, SizeConst = (int)NCBCONST.MAX_LANA)]
  141.             public byte[] lana;
  142.         }
  144.         [StructLayout(LayoutKind.Auto)]
  145.         public struct ASTAT
  146.         {
  147.             public ADAPTER_STATUS adapt;
  148.             [MarshalAs(UnmanagedType.ByValArray, SizeConst = (int)NCBCONST.NUM_NAMEBUF)]
  149.             public NAME_BUFFER[] NameBuff;
  150.         }
  151.         public class Win32API
  152.         {
  153.             [DllImport("NETAPI32.DLL")]
  154.             public static extern char Netbios(ref NCB ncb);
  155.         }
  157.         public string GetMacAddress()
  158.         {
  159.             string addr = "";
  160.             try
  161.             {
  162.                 int cb;
  163.                 ASTAT adapter;
  164.                 NCB Ncb = new NCB();
  165.                 char uRetCode;
  166.                 LANA_ENUM lenum;
  168.                 Ncb.ncb_command = (byte)NCBCONST.NCBENUM;
  169.                 cb = Marshal.SizeOf(typeof(LANA_ENUM));
  170.                 Ncb.ncb_buffer = Marshal.AllocHGlobal(cb);
  171.                 Ncb.ncb_length = (ushort)cb;
  172.                 uRetCode = Win32API.Netbios(ref Ncb);
  173.                 lenum = (LANA_ENUM)Marshal.PtrToStructure(Ncb.ncb_buffer, typeof(LANA_ENUM));
  174.                 Marshal.FreeHGlobal(Ncb.ncb_buffer);
  175.                 if (uRetCode != (short)NCBCONST.NRC_GOODRET)
  176.                     return "";
  178.                 for (int i = 0; i < lenum.length; i++)
  179.                 {
  180.                     Ncb.ncb_command = (byte)NCBCONST.NCBRESET;
  181.                     Ncb.ncb_lana_num = lenum.lana[i];
  182.                     uRetCode = Win32API.Netbios(ref Ncb);
  183.                     if (uRetCode != (short)NCBCONST.NRC_GOODRET)
  184.                         return "";
  186.                     Ncb.ncb_command = (byte)NCBCONST.NCBASTAT;
  187.                     Ncb.ncb_lana_num = lenum.lana[i];
  188.                     Ncb.ncb_callname[0] = (byte)'*';
  189.                     cb = Marshal.SizeOf(typeof(ADAPTER_STATUS)) + Marshal.SizeOf(typeof(NAME_BUFFER)) * (int)NCBCONST.NUM_NAMEBUF;
  190.                     Ncb.ncb_buffer = Marshal.AllocHGlobal(cb);
  191.                     Ncb.ncb_length = (ushort)cb;
  192.                     uRetCode = Win32API.Netbios(ref Ncb);
  193.                     adapter.adapt = (ADAPTER_STATUS)Marshal.PtrToStructure(Ncb.ncb_buffer, typeof(ADAPTER_STATUS));
  194.                     Marshal.FreeHGlobal(Ncb.ncb_buffer);
  196.                     if (uRetCode == (short)NCBCONST.NRC_GOODRET)
  197.                     {
  198.                         if (i > 0)
  199.                             addr += ":";
  200.                         addr = string.Format("{0,2:X}{1,2:X}{2,2:X}{3,2:X}{4,2:X}{5,2:X}",
  201.                          adapter.adapt.adapter_address[0],
  202.                          adapter.adapt.adapter_address[1],
  203.                          adapter.adapt.adapter_address[2],
  204.                          adapter.adapt.adapter_address[3],
  205.                          adapter.adapt.adapter_address[4],
  206.                          adapter.adapt.adapter_address[5]);
  207.                     }
  208.                 }
  209.             }
  210.             catch
  211.             { }
  212.             return addr.Replace(' ', '0');
  213.         }
  214.     }
  215. }

使用方法举例：

  1. //获取硬盘序列号
  2. Hardware.HardwareInfo hardwareInfo = new Hardware.HardwareInfo();
  3. string hardDiskID = hardwareInfo.GetHardDiskID();
  4. System.Console.WriteLine(hardDiskID);
  6. //获取CPU序列号
  7. string cpuID = hardwareInfo.GetCpuID();

    本站是提供个人知识管理的网络存储空间，所有内容均由用户发布，不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息，谨防诈骗。如发现有害或侵权内容，请点击一键举报。
    转藏 分享 献花（0）

    来自： *我爱阳光* > 《我的图书馆》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多