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

  1. view plaincopy to clipboardprint?  
  2. using System;      
  3. using System.Runtime.InteropServices;      
  4. using System.Management;      
  5.     
  6. namespace Hardware      
  7. {      
  8.     /// <summary>      
  9.     /// HardwareInfo 的摘要说明。      
  10.     /// </summary>      
  11.     public class HardwareInfo      
  12.     {      
  13.         //取机器名       
  14.         public string GetHostName()      
  15.         {      
  16.             return System.Net.Dns.GetHostName();      
  17.         }      
  18.         //取CPU编号      
  19.         public String GetCpuID()      
  20.         {      
  21.             try      
  22.             {      
  23.                 ManagementClass mc = new ManagementClass("Win32_Processor");      
  24.                 ManagementObjectCollection moc = mc.GetInstances();      
  25.     
  26.                 String strCpuID = null;      
  27.                 foreach (ManagementObject mo in moc)      
  28.                 {      
  29.                     strCpuID = mo.Properties["ProcessorId"].Value.ToString();      
  30.                     break;      
  31.                 }      
  32.                 return strCpuID;      
  33.             }      
  34.             catch      
  35.             {      
  36.                 return "";      
  37.             }      
  38.     
  39.         }//end method      
  40.     
  41.         //取第一块硬盘编号      
  42.         public String GetHardDiskID()      
  43.         {      
  44.             try      
  45.             {      
  46.                 ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT * FROM Win32_PhysicalMedia");      
  47.                 String strHardDiskID = null;      
  48.                 foreach (ManagementObject mo in searcher.Get())      
  49.                 {      
  50.                     strHardDiskID = mo["SerialNumber"].ToString().Trim();      
  51.                     break;      
  52.                 }      
  53.                 return strHardDiskID;      
  54.             }      
  55.             catch      
  56.             {      
  57.                 return "";      
  58.             }      
  59.         }//end       
  60.     
  61.         public enum NCBCONST      
  62.         {      
  63.             NCBNAMSZ = 16,      /* absolute length of a net name         */      
  64.             MAX_LANA = 254,      /* lana's in range 0 to MAX_LANA inclusive   */      
  65.             NCBENUM = 0x37,      /* NCB ENUMERATE LANA NUMBERS            */      
  66.             NRC_GOODRET = 0x00,      /* good return                              */      
  67.             NCBRESET = 0x32,      /* NCB RESET                        */      
  68.             NCBASTAT = 0x33,      /* NCB ADAPTER STATUS                  */      
  69.             NUM_NAMEBUF = 30,      /* Number of NAME's BUFFER               */      
  70.         }      
  71.     
  72.         [StructLayout(LayoutKind.Sequential)]      
  73.         public struct ADAPTER_STATUS      
  74.         {      
  75.             [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]      
  76.             public byte[] adapter_address;      
  77.             public byte rev_major;      
  78.             public byte reserved0;      
  79.             public byte adapter_type;      
  80.             public byte rev_minor;      
  81.             public ushort duration;      
  82.             public ushort frmr_recv;      
  83.             public ushort frmr_xmit;      
  84.             public ushort iframe_recv_err;      
  85.             public ushort xmit_aborts;      
  86.             public uint xmit_success;      
  87.             public uint recv_success;      
  88.             public ushort iframe_xmit_err;      
  89.             public ushort recv_buff_unavail;      
  90.             public ushort t1_timeouts;      
  91.             public ushort ti_timeouts;      
  92.             public uint reserved1;      
  93.             public ushort free_ncbs;      
  94.             public ushort max_cfg_ncbs;      
  95.             public ushort max_ncbs;      
  96.             public ushort xmit_buf_unavail;      
  97.             public ushort max_dgram_size;      
  98.             public ushort pending_sess;      
  99.             public ushort max_cfg_sess;      
  100.             public ushort max_sess;      
  101.             public ushort max_sess_pkt_size;      
  102.             public ushort name_count;      
  103.         }      
  104.     
  105.         [StructLayout(LayoutKind.Sequential)]      
  106.         public struct NAME_BUFFER      
  107.         {      
  108.             [MarshalAs(UnmanagedType.ByValArray, SizeConst = (int)NCBCONST.NCBNAMSZ)]      
  109.             public byte[] name;      
  110.             public byte name_num;      
  111.             public byte name_flags;      
  112.         }      
  113.     
  114.         [StructLayout(LayoutKind.Sequential)]      
  115.         public struct NCB      
  116.         {      
  117.             public byte ncb_command;      
  118.             public byte ncb_retcode;      
  119.             public byte ncb_lsn;      
  120.             public byte ncb_num;      
  121.             public IntPtr ncb_buffer;      
  122.             public ushort ncb_length;      
  123.             [MarshalAs(UnmanagedType.ByValArray, SizeConst = (int)NCBCONST.NCBNAMSZ)]      
  124.             public byte[] ncb_callname;      
  125.             [MarshalAs(UnmanagedType.ByValArray, SizeConst = (int)NCBCONST.NCBNAMSZ)]      
  126.             public byte[] ncb_name;      
  127.             public byte ncb_rto;      
  128.             public byte ncb_sto;      
  129.             public IntPtr ncb_post;      
  130.             public byte ncb_lana_num;      
  131.             public byte ncb_cmd_cplt;      
  132.             [MarshalAs(UnmanagedType.ByValArray, SizeConst = 10)]      
  133.             public byte[] ncb_reserve;      
  134.             public IntPtr ncb_event;      
  135.         }      
  136.     
  137.         [StructLayout(LayoutKind.Sequential)]      
  138.         public struct LANA_ENUM      
  139.         {      
  140.             public byte length;      
  141.             [MarshalAs(UnmanagedType.ByValArray, SizeConst = (int)NCBCONST.MAX_LANA)]      
  142.             public byte[] lana;      
  143.         }      
  144.     
  145.         [StructLayout(LayoutKind.Auto)]      
  146.         public struct ASTAT      
  147.         {      
  148.             public ADAPTER_STATUS adapt;      
  149.             [MarshalAs(UnmanagedType.ByValArray, SizeConst = (int)NCBCONST.NUM_NAMEBUF)]      
  150.             public NAME_BUFFER[] NameBuff;      
  151.         }      
  152.         public class Win32API      
  153.         {      
  154.             [DllImport("NETAPI32.DLL")]      
  155.             public static extern char Netbios(ref NCB ncb);      
  156.         }      
  157.     
  158.         public string GetMacAddress()      
  159.         {      
  160.             string addr = "";      
  161.             try      
  162.             {      
  163.                 int cb;      
  164.                 ASTAT adapter;      
  165.                 NCB Ncb = new NCB();      
  166.                 char uRetCode;      
  167.                 LANA_ENUM lenum;      
  168.     
  169.                 Ncb.ncb_command = (byte)NCBCONST.NCBENUM;      
  170.                 cb = Marshal.SizeOf(typeof(LANA_ENUM));      
  171.                 Ncb.ncb_buffer = Marshal.AllocHGlobal(cb);      
  172.                 Ncb.ncb_length = (ushort)cb;      
  173.                 uRetCode = Win32API.Netbios(ref Ncb);      
  174.                 lenum = (LANA_ENUM)Marshal.PtrToStructure(Ncb.ncb_buffer, typeof(LANA_ENUM));      
  175.                 Marshal.FreeHGlobal(Ncb.ncb_buffer);      
  176.                 if (uRetCode != (short)NCBCONST.NRC_GOODRET)      
  177.                     return "";      
  178.     
  179.                 for (int i = 0; i < lenum.length; i++)      
  180.                 {      
  181.                     Ncb.ncb_command = (byte)NCBCONST.NCBRESET;      
  182.                     Ncb.ncb_lana_num = lenum.lana[i];      
  183.                     uRetCode = Win32API.Netbios(ref Ncb);      
  184.                     if (uRetCode != (short)NCBCONST.NRC_GOODRET)      
  185.                         return "";      
  186.     
  187.                     Ncb.ncb_command = (byte)NCBCONST.NCBASTAT;      
  188.                     Ncb.ncb_lana_num = lenum.lana[i];      
  189.                     Ncb.ncb_callname[0] = (byte)'*';      
  190.                     cb = Marshal.SizeOf(typeof(ADAPTER_STATUS)) + Marshal.SizeOf(typeof(NAME_BUFFER)) * (int)NCBCONST.NUM_NAMEBUF;      
  191.                     Ncb.ncb_buffer = Marshal.AllocHGlobal(cb);      
  192.                     Ncb.ncb_length = (ushort)cb;      
  193.                     uRetCode = Win32API.Netbios(ref Ncb);      
  194.                     adapter.adapt = (ADAPTER_STATUS)Marshal.PtrToStructure(Ncb.ncb_buffer, typeof(ADAPTER_STATUS));      
  195.                     Marshal.FreeHGlobal(Ncb.ncb_buffer);      
  196.     
  197.                     if (uRetCode == (short)NCBCONST.NRC_GOODRET)      
  198.                     {      
  199.                         if (i > 0)      
  200.                             addr += ":";      
  201.                         addr = string.Format("{0,2:X}{1,2:X}{2,2:X}{3,2:X}{4,2:X}{5,2:X}",      
  202.                          adapter.adapt.adapter_address[0],      
  203.                          adapter.adapt.adapter_address[1],      
  204.                          adapter.adapt.adapter_address[2],      
  205.                          adapter.adapt.adapter_address[3],      
  206.                          adapter.adapt.adapter_address[4],      
  207.                          adapter.adapt.adapter_address[5]);      
  208.                     }      
  209.                 }      
  210.             }      
  211.             catch      
  212.             { }      
  213.             return addr.Replace(' ''0');      
  214.         }      
  215.     }      
  216. }     
  217. using System;   
  218. using System.Runtime.InteropServices;   
  219. using System.Management;   
  220.  
  221. namespace Hardware   
  222. {   
  223.     /// <summary>   
  224.     /// HardwareInfo 的摘要说明。   
  225.     /// </summary>   
  226.     public class HardwareInfo   
  227.     {   
  228.         //取机器名    
  229.         public string GetHostName()   
  230.         {   
  231.             return System.Net.Dns.GetHostName();   
  232.         }   
  233.         //取CPU编号   
  234.         public String GetCpuID()   
  235.         {   
  236.             try   
  237.             {   
  238.                 ManagementClass mc = new ManagementClass("Win32_Processor");   
  239.                 ManagementObjectCollection moc = mc.GetInstances();   
  240.  
  241.                 String strCpuID = null;   
  242.                 foreach (ManagementObject mo in moc)   
  243.                 {   
  244.                     strCpuID = mo.Properties["ProcessorId"].Value.ToString();   
  245.                     break;   
  246.                 }   
  247.                 return strCpuID;   
  248.             }   
  249.             catch   
  250.             {   
  251.                 return "";   
  252.             }   
  253.  
  254.         }//end method   
  255.  
  256.         //取第一块硬盘编号   
  257.         public String GetHardDiskID()   
  258.         {   
  259.             try   
  260.             {   
  261.                 ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT * FROM Win32_PhysicalMedia");   
  262.                 String strHardDiskID = null;   
  263.                 foreach (ManagementObject mo in searcher.Get())   
  264.                 {   
  265.                     strHardDiskID = mo["SerialNumber"].ToString().Trim();   
  266.                     break;   
  267.                 }   
  268.                 return strHardDiskID;   
  269.             }   
  270.             catch   
  271.             {   
  272.                 return "";   
  273.             }   
  274.         }//end    
  275.  
  276.         public enum NCBCONST   
  277.         {   
  278.             NCBNAMSZ = 16,      /* absolute length of a net name         */   
  279.             MAX_LANA = 254,      /* lana's in range 0 to MAX_LANA inclusive   */   
  280.             NCBENUM = 0x37,      /* NCB ENUMERATE LANA NUMBERS            */   
  281.             NRC_GOODRET = 0x00,      /* good return                              */   
  282.             NCBRESET = 0x32,      /* NCB RESET                        */   
  283.             NCBASTAT = 0x33,      /* NCB ADAPTER STATUS                  */   
  284.             NUM_NAMEBUF = 30,      /* Number of NAME's BUFFER               */   
  285.         }   
  286.  
  287.         [StructLayout(LayoutKind.Sequential)]   
  288.         public struct ADAPTER_STATUS   
  289.         {   
  290.             [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]   
  291.             public byte[] adapter_address;   
  292.             public byte rev_major;   
  293.             public byte reserved0;   
  294.             public byte adapter_type;   
  295.             public byte rev_minor;   
  296.             public ushort duration;   
  297.             public ushort frmr_recv;   
  298.             public ushort frmr_xmit;   
  299.             public ushort iframe_recv_err;   
  300.             public ushort xmit_aborts;   
  301.             public uint xmit_success;   
  302.             public uint recv_success;   
  303.             public ushort iframe_xmit_err;   
  304.             public ushort recv_buff_unavail;   
  305.             public ushort t1_timeouts;   
  306.             public ushort ti_timeouts;   
  307.             public uint reserved1;   
  308.             public ushort free_ncbs;   
  309.             public ushort max_cfg_ncbs;   
  310.             public ushort max_ncbs;   
  311.             public ushort xmit_buf_unavail;   
  312.             public ushort max_dgram_size;   
  313.             public ushort pending_sess;   
  314.             public ushort max_cfg_sess;   
  315.             public ushort max_sess;   
  316.             public ushort max_sess_pkt_size;   
  317.             public ushort name_count;   
  318.         }   
  319.  
  320.         [StructLayout(LayoutKind.Sequential)]   
  321.         public struct NAME_BUFFER   
  322.         {   
  323.             [MarshalAs(UnmanagedType.ByValArray, SizeConst = (int)NCBCONST.NCBNAMSZ)]   
  324.             public byte[] name;   
  325.             public byte name_num;   
  326.             public byte name_flags;   
  327.         }   
  328.  
  329.         [StructLayout(LayoutKind.Sequential)]   
  330.         public struct NCB   
  331.         {   
  332.             public byte ncb_command;   
  333.             public byte ncb_retcode;   
  334.             public byte ncb_lsn;   
  335.             public byte ncb_num;   
  336.             public IntPtr ncb_buffer;   
  337.             public ushort ncb_length;   
  338.             [MarshalAs(UnmanagedType.ByValArray, SizeConst = (int)NCBCONST.NCBNAMSZ)]   
  339.             public byte[] ncb_callname;   
  340.             [MarshalAs(UnmanagedType.ByValArray, SizeConst = (int)NCBCONST.NCBNAMSZ)]   
  341.             public byte[] ncb_name;   
  342.             public byte ncb_rto;   
  343.             public byte ncb_sto;   
  344.             public IntPtr ncb_post;   
  345.             public byte ncb_lana_num;   
  346.             public byte ncb_cmd_cplt;   
  347.             [MarshalAs(UnmanagedType.ByValArray, SizeConst = 10)]   
  348.             public byte[] ncb_reserve;   
  349.             public IntPtr ncb_event;   
  350.         }   
  351.  
  352.         [StructLayout(LayoutKind.Sequential)]   
  353.         public struct LANA_ENUM   
  354.         {   
  355.             public byte length;   
  356.             [MarshalAs(UnmanagedType.ByValArray, SizeConst = (int)NCBCONST.MAX_LANA)]   
  357.             public byte[] lana;   
  358.         }   
  359.  
  360.         [StructLayout(LayoutKind.Auto)]   
  361.         public struct ASTAT   
  362.         {   
  363.             public ADAPTER_STATUS adapt;   
  364.             [MarshalAs(UnmanagedType.ByValArray, SizeConst = (int)NCBCONST.NUM_NAMEBUF)]   
  365.             public NAME_BUFFER[] NameBuff;   
  366.         }   
  367.         public class Win32API   
  368.         {   
  369.             [DllImport("NETAPI32.DLL")]   
  370.             public static extern char Netbios(ref NCB ncb);   
  371.         }   
  372.  
  373.         public string GetMacAddress()   
  374.         {   
  375.             string addr = "";   
  376.             try   
  377.             {   
  378.                 int cb;   
  379.                 ASTAT adapter;   
  380.                 NCB Ncb = new NCB();   
  381.                 char uRetCode;   
  382.                 LANA_ENUM lenum;   
  383.  
  384.                 Ncb.ncb_command = (byte)NCBCONST.NCBENUM;   
  385.                 cb = Marshal.SizeOf(typeof(LANA_ENUM));   
  386.                 Ncb.ncb_buffer = Marshal.AllocHGlobal(cb);   
  387.                 Ncb.ncb_length = (ushort)cb;   
  388.                 uRetCode = Win32API.Netbios(ref Ncb);   
  389.                 lenum = (LANA_ENUM)Marshal.PtrToStructure(Ncb.ncb_buffer, typeof(LANA_ENUM));   
  390.                 Marshal.FreeHGlobal(Ncb.ncb_buffer);   
  391.                 if (uRetCode != (short)NCBCONST.NRC_GOODRET)   
  392.                     return "";   
  393.  
  394.                 for (int i = 0; i < lenum.length; i++)   
  395.                 {   
  396.                     Ncb.ncb_command = (byte)NCBCONST.NCBRESET;   
  397.                     Ncb.ncb_lana_num = lenum.lana[i];   
  398.                     uRetCode = Win32API.Netbios(ref Ncb);   
  399.                     if (uRetCode != (short)NCBCONST.NRC_GOODRET)   
  400.                         return "";   
  401.  
  402.                     Ncb.ncb_command = (byte)NCBCONST.NCBASTAT;   
  403.                     Ncb.ncb_lana_num = lenum.lana[i];   
  404.                     Ncb.ncb_callname[0] = (byte)'*';   
  405.                     cb = Marshal.SizeOf(typeof(ADAPTER_STATUS)) + Marshal.SizeOf(typeof(NAME_BUFFER)) * (int)NCBCONST.NUM_NAMEBUF;   
  406.                     Ncb.ncb_buffer = Marshal.AllocHGlobal(cb);   
  407.                     Ncb.ncb_length = (ushort)cb;   
  408.                     uRetCode = Win32API.Netbios(ref Ncb);   
  409.                     adapter.adapt = (ADAPTER_STATUS)Marshal.PtrToStructure(Ncb.ncb_buffer, typeof(ADAPTER_STATUS));   
  410.                     Marshal.FreeHGlobal(Ncb.ncb_buffer);   
  411.  
  412.                     if (uRetCode == (short)NCBCONST.NRC_GOODRET)   
  413.                     {   
  414.                         if (i > 0)   
  415.                             addr += ":";   
  416.                         addr = string.Format("{0,2:X}{1,2:X}{2,2:X}{3,2:X}{4,2:X}{5,2:X}",   
  417.                          adapter.adapt.adapter_address[0],   
  418.                          adapter.adapt.adapter_address[1],   
  419.                          adapter.adapt.adapter_address[2],   
  420.                          adapter.adapt.adapter_address[3],   
  421.                          adapter.adapt.adapter_address[4],   
  422.                          adapter.adapt.adapter_address[5]);   
  423.                     }   
  424.                 }   
  425.             }   
  426.             catch   
  427.             { }   
  428.             return addr.Replace(' ''0');   
  429.         }   
  430.     }   
  431. }   
  432.    
  433.  

使用方法举例:

  1. view plaincopy to clipboardprint?  
  2. //获取硬盘序列号      
  3. Hardware.HardwareInfo hardwareInfo = new Hardware.HardwareInfo();      
  4. string hardDiskID = hardwareInfo.GetHardDiskID();      
  5. System.Console.WriteLine(hardDiskID);      
  6.     
  7. //获取CPU序列号      
  8. string cpuID = hardwareInfo.GetCpuID();      
  9. System.Console.WriteLine(cpuID);      
  10. //获取硬盘序列号Hardware.HardwareInfo hardwareInfo = new Hardware.HardwareInfo();string hardDiskID = hardwareInfo.GetHardDiskID();System.Console.WriteLine(hardDiskID);//获取CPU序列号string cpuID = hardwareInfo.GetCpuID();System.Console.WriteLine(cpuID);