自己封装的注册表操作类

 

1. using System;
2. using System.Collections.Generic;
3. using System.Text;
4. using Microsoft.Win32;
6. namespace WWBClassLib.PC
7. {
8.     public class RegEdit
9.     {
10.         /// <summary>
11.         /// 
12.         /// </summary>
13.         /// <param name="RegUrl">节点路径（全路径 HKEY_LOCAL_MACHINE/SOFTWARE ） 用 "/" 分隔</param>
14.         /// <param name="name">项目名称</param>
15.         /// <returns></returns>
16.         public static string GetRegistData(string RegUrl,string name)
17.         {
18.             string registData;
19.             char[] sp = {'/'};
20.             string[] nodes = RegUrl.Split(sp);
21.             RegistryKey root = null;
23.             switch (nodes[0].ToUpper())
24.             {
25.                 case "HKEY_CLASSES_ROOT":
26.                     root = Registry.ClassesRoot;
27.                     break;
28.                 case "HKEY_CURRENT_USER":
29.                     root = Registry.CurrentUser;
30.                     break;
31.                 case "HKEY_LOCAL_MACHINE":
32.                     root = Registry.LocalMachine;
33.                     break;
34.                 case "HKEY_USERS":
35.                     root = Registry.Users;
36.                     break;
37.                 case "HKEY_CURRENT_CONFIG":
38.                     root = Registry.CurrentConfig;
39.                     break;
40.                 
42.             }
44.             if (root == null)
45.             {
46.                 return "error root";
47.             }
49.             RegistryKey node = root;
51.             for (int i = 1; i < nodes.Length; i++)
52.             {
53.                
54.                 node = node.OpenSubKey(nodes[i], true);
55.                 if (node == null)
56.                 {
57.                     return nodes[i] + "节点不存在";
58.                 }
59.                 
60.             }
61.             
62.             registData = node.GetValue(name).ToString();
63.             return registData;
64.         }
66.         /// <summary>
67.         /// 写入注册表值
68.         /// </summary>
69.         /// <param name="RegUrl">路径(全路径，不存在的节点自动创建)</param>
70.         /// <param name="name">名称</param>
71.         /// <param name="value">值</param>
72.         /// <returns></returns>
73.         public static string WTRegedit(string RegUrl, string name, object value)
74.         {
76.            
77.             char[] sp = { '/' };
78.             string[] nodes = RegUrl.Split(sp);
79.             RegistryKey root = null;
81.             switch (nodes[0].ToUpper())
82.             {
83.                 case "HKEY_CLASSES_ROOT":
84.                     root = Registry.ClassesRoot;
85.                     break;
86.                 case "HKEY_CURRENT_USER":
87.                     root = Registry.CurrentUser;
88.                     break;
89.                 case "HKEY_LOCAL_MACHINE":
90.                     root = Registry.LocalMachine;
91.                     break;
92.                 case "HKEY_USERS":
93.                     root = Registry.Users;
94.                     break;
95.                 case "HKEY_CURRENT_CONFIG":
96.                     root = Registry.CurrentConfig;
97.                     break;
100.             }
102.             if (root == null)
103.             {
104.                 return "error root";
105.             }
107.             RegistryKey node = root;
109.             for (int i = 1; i < nodes.Length; i++)
110.             {
111.                 if(!IsRegeditExit(node,nodes[i]))
112.                 {
113.                     node = node.CreateSubKey(nodes[i]);
114.                     continue;
115.                 }
116.                 node = node.OpenSubKey(nodes[i], true);
117.                 
119.             }
121.             node.SetValue(name, value);
122.             return "";
123.         }
125.         private static bool IsRegeditExit(RegistryKey node ,string name)
126.         {
127.             string [] subkeyNames = node.GetSubKeyNames();
128.             foreach (string keyName in subkeyNames)
129.             {
130.                 if (keyName == name)
131.                 {
132.                      
133.                      return true;
134.                 }
135.             }
136.             return false;
137.         }
139.         /// <summary>
140.         /// 删除注册表节点
141.         /// </summary>
142.         /// <param name="RegUrl">路径（全路径）</param>
143.         /// <param name="name">键值（节点值）</param>
144.          /// <returns></returns>
145.         public static string DeleteRegist(string RegUrl, string name)
146.         {
147.             char[] sp = { '/' };
148.             string[] nodes = RegUrl.Split(sp);
149.             RegistryKey root = null;
151.             switch (nodes[0].ToUpper())
152.             {
153.                 case "HKEY_CLASSES_ROOT":
154.                     root = Registry.ClassesRoot;
155.                     break;
156.                 case "HKEY_CURRENT_USER":
157.                     root = Registry.CurrentUser;
158.                     break;
159.                 case "HKEY_LOCAL_MACHINE":
160.                     root = Registry.LocalMachine;
161.                     break;
162.                 case "HKEY_USERS":
163.                     root = Registry.Users;
164.                     break;
165.                 case "HKEY_CURRENT_CONFIG":
166.                     root = Registry.CurrentConfig;
167.                     break;
170.             }
172.             if (root == null)
173.             {
174.                 return "error root";
175.             }
177.             RegistryKey node = root;
179.             for (int i = 1; i < nodes.Length; i++)
180.             {
182.                 node = node.OpenSubKey(nodes[i], true);
183.                 if (node == null)
184.                 {
185.                     return nodes[i] + "节点不存在";
186.                 }
188.             }
190.             if (!IsRegeditExit(node, name))
191.             {
192.                 return name + "键值不存在";
193.             }
194.             else
195.             {
196.                 node.DeleteSubKeyTree(name);
197.             }
198.             return "";
200.             
201.         } 
203.     }
204. }