using System.Management; 

1. /// 获取本机用户名、MAC地址、内网IP地址、公网IP地址、硬盘ID、CPU序列号、系统名称、物理内存。  
2. /// </summary>  
3. public class GetSystemInfo  
4. {  
5.     /// <summary>  
6.     /// 操作系统的登录用户名  
7.     /// </summary>  
8.     /// <returns>系统的登录用户名</returns>  
9.     public static string GetUserName()  
10.     {  
11.         try  
12.         {  
13.             string strUserName = string.Empty;  
14.             ManagementClass mc = new ManagementClass("Win32_ComputerSystem");  
15.             ManagementObjectCollection moc = mc.GetInstances();  
16.             foreach (ManagementObject mo in moc)  
17.             {  
18.                 strUserName = mo["UserName"].ToString();  
19.             }  
20.             moc = null;  
21.             mc = null;  
22.             return strUserName;  
23.         }  
24.         catch  
25.         {  
26.             return "unknown";  
27.         }  
28.     }  
29.     /// <summary>  
30.     /// 获取本机MAC地址  
31.     /// </summary>  
32.     /// <returns>本机MAC地址</returns>  
33.     public static string GetMacAddress()  
34.     {  
35.         try  
36.         {  
37.             string strMac = string.Empty;  
38.             ManagementClass mc = new ManagementClass("Win32_NetworkAdapterConfiguration");  
39.             ManagementObjectCollection moc = mc.GetInstances();  
40.             foreach (ManagementObject mo in moc)  
41.             {  
42.                 if ((bool)mo["IPEnabled"] == true)  
43.                 {  
44.                     strMac = mo["MacAddress"].ToString();  
45.                 }  
46.             }  
47.             moc = null;  
48.             mc = null;  
49.             return strMac;  
50.         }  
51.         catch  
52.         {  
53.             return "unknown";  
54.         }  
55.     }  
56.     /// <summary>  
57.     /// 获取本机的物理地址  
58.     /// </summary>  
59.     /// <returns></returns>  
60.     public static string getMacAddr_Local()  
61.     {  
62.         string madAddr = null;  
63.         try  
64.         {  
65.             ManagementClass mc = new ManagementClass("Win32_NetworkAdapterConfiguration");  
66.             ManagementObjectCollection moc2 = mc.GetInstances();  
67.             foreach (ManagementObject mo in moc2)  
68.             {  
69.                 if (Convert.ToBoolean(mo["IPEnabled"]) == true)  
70.                 {  
71.                     madAddr = mo["MacAddress"].ToString();  
72.                     madAddr = madAddr.Replace(':', '-');  
73.                 }  
74.                 mo.Dispose();  
75.             }  
76.             if (madAddr == null)  
77.             {  
78.                 return "unknown";  
79.             }  
80.             else  
81.             {  
82.                 return madAddr;  
83.             }  
84.         }  
85.         catch (Exception)  
86.         {  
87.             return "unknown";  
88.         }  
89.     }  
90.     /// <summary>  
91.     /// 获取客户端内网IPv6地址  
92.     /// </summary>  
93.     /// <returns>客户端内网IPv6地址</returns>  
94.     public static string GetClientLocalIPv6Address()  
95.     {  
96.         string strLocalIP = string.Empty;  
97.         try  
98.         {  
99.             IPHostEntry ipHost = Dns.GetHostEntry(Dns.GetHostName());  
100.             IPAddress ipAddress = ipHost.AddressList[0];  
101.             strLocalIP = ipAddress.ToString();  
102.             return strLocalIP;  
103.         }  
104.         catch  
105.         {  
106.             return "unknown";  
107.         }  
108.     }  
109.     /// <summary>  
110.     /// 获取客户端内网IPv4地址  
111.     /// </summary>  
112.     /// <returns>客户端内网IPv4地址</returns>  
113.     public static string GetClientLocalIPv4Address()  
114.     {  
115.         string strLocalIP = string.Empty;  
116.         try  
117.         {  
118.             IPHostEntry ipHost = Dns.Resolve(Dns.GetHostName());  
119.             IPAddress ipAddress = ipHost.AddressList[0];  
120.             strLocalIP = ipAddress.ToString();  
121.             return strLocalIP;  
122.         }  
123.         catch  
124.         {  
125.             return "unknown";  
126.         }  
127.     }  
128.     /// <summary>  
129.     /// 获取客户端内网IPv4地址集合  
130.     /// </summary>  
131.     /// <returns>返回客户端内网IPv4地址集合</returns>  
132.     public static List<string> GetClientLocalIPv4AddressList()  
133.     {  
134.         List<string> ipAddressList = new List<string>();  
135.         try  
136.         {  
137.             IPHostEntry ipHost = Dns.Resolve(Dns.GetHostName());  
138.             foreach (IPAddress ipAddress in ipHost.AddressList)  
139.             {  
140.                 if (!ipAddressList.Contains(ipAddress.ToString()))  
141.                 {  
142.                     ipAddressList.Add(ipAddress.ToString());  
143.                 }  
144.             }  
145.         }  
146.         catch  
147.         {  
148.   
149.         }  
150.         return ipAddressList;  
151.     }  
152.   
153.     /// <summary>  
154.     /// 获取客户端外网IP地址  
155.     /// </summary>  
156.     /// <returns>客户端外网IP地址</returns>  
157.     public static string GetClientInternetIPAddress()  
158.     {  
159.         string strInternetIPAddress = string.Empty;  
160.         try  
161.         {  
162.             using (WebClient webClient = new WebClient())  
163.             {  
164.                 strInternetIPAddress = webClient.DownloadString("http://www.coridc.com/ip");  
165.                 Regex r = new Regex("[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}");  
166.                 Match mth = r.Match(strInternetIPAddress);  
167.                 if (!mth.Success)  
168.                 {  
169.                     strInternetIPAddress = GetClientInternetIPAddress2();  
170.                     mth = r.Match(strInternetIPAddress);  
171.                     if (!mth.Success)  
172.                     {  
173.                         strInternetIPAddress = "unknown";  
174.                     }  
175.                 }  
176.                 return strInternetIPAddress;  
177.             }  
178.         }  
179.         catch  
180.         {  
181.             return "unknown";  
182.         }  
183.     }  
184.     /// <summary>  
185.     /// 获取本机公网IP地址  
186.     /// </summary>  
187.     /// <returns>本机公网IP地址</returns>  
188.     private static string GetClientInternetIPAddress2()  
189.     {  
190.         string tempip = "";  
191.         try  
192.         {  
193.             //http://iframe.ip138.com/ic.asp 返回的是：您的IP是：[220.231.17.99] 来自：北京市 光环新网  
194.             WebRequest wr = WebRequest.Create("http://iframe.ip138.com/ic.asp");  
195.             Stream s = wr.GetResponse().GetResponseStream();  
196.             StreamReader sr = new StreamReader(s, Encoding.Default);  
197.             string all = sr.ReadToEnd(); //读取网站的数据  
198.   
199.             int start = all.IndexOf("[") + 1;  
200.             int end = all.IndexOf("]", start);  
201.             tempip = all.Substring(start, end - start);  
202.             sr.Close();  
203.             s.Close();  
204.             return tempip;  
205.         }  
206.         catch  
207.         {  
208.             return "unknown";  
209.         }  
210.     }  
211.     /// <summary>  
212.     /// 获取硬盘序号  
213.     /// </summary>  
214.     /// <returns>硬盘序号</returns>  
215.     public static string GetDiskID()  
216.     {  
217.         try  
218.         {  
219.             string strDiskID = string.Empty;  
220.             ManagementClass mc = new ManagementClass("Win32_DiskDrive");  
221.             ManagementObjectCollection moc = mc.GetInstances();  
222.             foreach (ManagementObject mo in moc)  
223.             {  
224.                 strDiskID = mo.Properties["Model"].Value.ToString();  
225.             }  
226.             moc = null;  
227.             mc = null;  
228.             return strDiskID;  
229.         }  
230.         catch  
231.         {  
232.             return "unknown";  
233.         }  
234.     }  
235.     /// <summary>  
236.     /// 获取CpuID  
237.     /// </summary>  
238.     /// <returns>CpuID</returns>  
239.     public static string GetCpuID()  
240.     {  
241.         try  
242.         {  
243.             string strCpuID = string.Empty;  
244.             ManagementClass mc = new ManagementClass("Win32_Processor");  
245.             ManagementObjectCollection moc = mc.GetInstances();  
246.             foreach (ManagementObject mo in moc)  
247.             {  
248.                 strCpuID = mo.Properties["ProcessorId"].Value.ToString();  
249.             }  
250.             moc = null;  
251.             mc = null;  
252.             return strCpuID;  
253.         }  
254.         catch  
255.         {  
256.             return "unknown";  
257.         }  
258.     }  
259.     /// <summary>  
260.     /// 获取操作系统类型  
261.     /// </summary>  
262.     /// <returns>操作系统类型</returns>  
263.     public static string GetSystemType()  
264.     {  
265.         try  
266.         {  
267.             string strSystemType = string.Empty;  
268.             ManagementClass mc = new ManagementClass("Win32_ComputerSystem");  
269.             ManagementObjectCollection moc = mc.GetInstances();  
270.             foreach (ManagementObject mo in moc)  
271.             {  
272.                 strSystemType = mo["SystemType"].ToString();  
273.             }  
274.             moc = null;  
275.             mc = null;  
276.             return strSystemType;  
277.         }  
278.         catch  
279.         {  
280.             return "unknown";  
281.         }  
282.     }  
283.     /// <summary>  
284.     /// 获取操作系统名称  
285.     /// </summary>  
286.     /// <returns>操作系统名称</returns>  
287.     public static string GetSystemName()  
288.     {  
289.         try  
290.         {  
291.             string strSystemName = string.Empty;  
292.             ManagementObjectSearcher mos = new ManagementObjectSearcher("root\\CIMV2", "SELECT PartComponent FROM Win32_SystemOperatingSystem");  
293.             foreach (ManagementObject mo in mos.Get())  
294.             {  
295.                 strSystemName = mo["PartComponent"].ToString();  
296.             }  
297.             mos = new ManagementObjectSearcher("root\\CIMV2", "SELECT Caption FROM Win32_OperatingSystem");  
298.             foreach (ManagementObject mo in mos.Get())  
299.             {  
300.                 strSystemName = mo["Caption"].ToString();  
301.             }  
302.             return strSystemName;  
303.         }  
304.         catch  
305.         {  
306.             return "unknown";  
307.         }  
308.     }  
309.     /// <summary>  
310.     /// 获取物理内存信息  
311.     /// </summary>  
312.     /// <returns>物理内存信息</returns>  
313.     public static string GetTotalPhysicalMemory()  
314.     {  
315.         try  
316.         {  
317.             string strTotalPhysicalMemory = string.Empty;  
318.             ManagementClass mc = new ManagementClass("Win32_ComputerSystem");  
319.             ManagementObjectCollection moc = mc.GetInstances();  
320.             foreach (ManagementObject mo in moc)  
321.             {  
322.                 strTotalPhysicalMemory = mo["TotalPhysicalMemory"].ToString();  
323.             }  
324.             moc = null;  
325.             mc = null;  
326.             return strTotalPhysicalMemory;  
327.         }  
328.         catch  
329.         {  
330.             return "unknown";  
331.         }  
332.     }  
333.   
334.     /// <summary>  
335.     /// 获取主板id  
336.     /// </summary>  
337.     /// <returns></returns>  
338.     public static string GetMotherBoardID()  
339.     {  
340.         try  
341.         {  
342.             ManagementClass mc = new ManagementClass("Win32_BaseBoard");  
343.             ManagementObjectCollection moc = mc.GetInstances();  
344.             string strID = null;  
345.             foreach (ManagementObject mo in moc)  
346.             {  
347.                 strID = mo.Properties["SerialNumber"].Value.ToString();  
348.                 break;  
349.             }  
350.             return strID;  
351.         }  
352.         catch  
353.         {  
354.             return "unknown";  
355.         }  
356.     }  
357.   
358.     /// <summary>  
359.     /// 获取公用桌面路径    
     
360. 
     
361. 1. public static string GetAllUsersDesktopFolderPath()  
     2. {  
     3.     RegistryKey folders;  
     4.     folders = OpenRegistryPath(Registry.LocalMachine, @"/software/microsoft/windows/currentversion/explorer/shell folders");  
     5.     string desktopPath = folders.GetValue("Common Desktop").ToString();  
     6.     return desktopPath;  
     7. }  
     8. /// <summary>  
     9. /// 获取公用启动项路径  
     10. /// </summary>  
     11. public static string GetAllUsersStartupFolderPath()  
     12. {  
     13.     RegistryKey folders;  
     14.     folders = OpenRegistryPath(Registry.LocalMachine, @"/software/microsoft/windows/currentversion/explorer/shell folders");  
     15.     string Startup = folders.GetValue("Common Startup").ToString();  
     16.     return Startup;  
     17. }  
     18. private static RegistryKey OpenRegistryPath(RegistryKey root, string s)  
     19. {  
     20.     s = s.Remove(0, 1) + @"/";  
     21.     while (s.IndexOf(@"/") != -1)  
     22.     {  
     23.         root = root.OpenSubKey(s.Substring(0, s.IndexOf(@"/")));  
     24.         s = s.Remove(0, s.IndexOf(@"/") + 1);  
     25.     }  
     26.     return root;  
     27. } 
         
362. 
     
363. 1. private void Test()  
     2.  {  
     3.      RegistryKey folders;  
     4.      folders = OpenRegistryPath(Registry.LocalMachine, @"/software/microsoft/windows/currentversion/explorer/shell folders");  
     5.      // Windows用户桌面路径  
     6.      string desktopPath = folders.GetValue("Common Desktop").ToString();  
     7.      // Windows用户字体目录路径  
     8.      string fontsPath = folders.GetValue("Fonts").ToString();  
     9.      // Windows用户网络邻居路径  
     10.      string nethoodPath = folders.GetValue("Nethood").ToString();  
     11.      // Windows用户我的文档路径  
     12.      string personalPath = folders.GetValue("Personal").ToString();  
     13.      // Windows用户开始菜单程序路径  
     14.      string programsPath = folders.GetValue("Programs").ToString();  
     15.      // Windows用户存放用户最近访问文档快捷方式的目录路径  
     16.      string recentPath = folders.GetValue("Recent").ToString();  
     17.      // Windows用户发送到目录路径  
     18.      string sendtoPath = folders.GetValue("Sendto").ToString();  
     19.      // Windows用户开始菜单目录路径  
     20.      string startmenuPath = folders.GetValue("Startmenu").ToString();  
     21.      // Windows用户开始菜单启动项目录路径  
     22.      string startupPath = folders.GetValue("Startup").ToString();  
     23.      // Windows用户收藏夹目录路径  
     24.      string favoritesPath = folders.GetValue("Favorites").ToString();  
     25.      // Windows用户网页历史目录路径  
     26.      string historyPath = folders.GetValue("History").ToString();  
     27.      // Windows用户Cookies目录路径  
     28.      string cookiesPath = folders.GetValue("Cookies").ToString();  
     29.      // Windows用户Cache目录路径  
     30.      string cachePath = folders.GetValue("Cache").ToString();  
     31.      // Windows用户应用程式数据目录路径  
     32.      string appdataPath = folders.GetValue("Appdata").ToString();  
     33.      // Windows用户打印目录路径  
     34.      string printhoodPath = folders.GetValue("Printhood").ToString();  
     35.  }</span>