C#注册表操作类（完整版）
2013-06-13 12:12
274 查看
下面贴出自己用C#写的注册表操作类，欢迎大家拍砖！
1.注册表基项静态域
2.指定在注册表中存储值时所用的数据类型，或标识注册表中某个值的数据类型
3.注册表操作类
1.注册表基项静态域
1 /// <summary>
2 /// 注册表基项静态域
3 ///
4 /// 主要包括：
5 /// 1.Registry.ClassesRoot 对应于HKEY_CLASSES_ROOT主键
6 /// 2.Registry.CurrentUser 对应于HKEY_CURRENT_USER主键
7 /// 3.Registry.LocalMachine 对应于 HKEY_LOCAL_MACHINE主键
8 /// 4.Registry.User 对应于 HKEY_USER主键
9 /// 5.Registry.CurrentConfig 对应于HEKY_CURRENT_CONFIG主键
10 /// 6.Registry.DynDa 对应于HKEY_DYN_DATA主键
11 /// 7.Registry.PerformanceData 对应于HKEY_PERFORMANCE_DATA主键
12 ///
13 /// 版本:1.0
14 /// </summary>
15 public enum RegDomain
16 {
17 /// <summary>
18 /// 对应于HKEY_CLASSES_ROOT主键
19 /// </summary>
20 ClassesRoot = 0,
21 /// <summary>
22 /// 对应于HKEY_CURRENT_USER主键
23 /// </summary>
24 CurrentUser = 1,
25 /// <summary>
26 /// 对应于 HKEY_LOCAL_MACHINE主键
27 /// </summary>
28 LocalMachine = 2,
29 /// <summary>
30 /// 对应于 HKEY_USER主键
31 /// </summary>
32 User = 3,
33 /// <summary>
34 /// 对应于HEKY_CURRENT_CONFIG主键
35 /// </summary>
36 CurrentConfig = 4,
37 /// <summary>
38 /// 对应于HKEY_DYN_DATA主键
39 /// </summary>
40 DynDa = 5,
41 /// <summary>
42 /// 对应于HKEY_PERFORMANCE_DATA主键
43 /// </summary>
44 PerformanceData = 6,
45 }2.指定在注册表中存储值时所用的数据类型，或标识注册表中某个值的数据类型
1 /// <summary>
2 /// 指定在注册表中存储值时所用的数据类型，或标识注册表中某个值的数据类型
3 ///
4 /// 主要包括：
5 /// 1.RegistryValueKind.Unknown
6 /// 2.RegistryValueKind.String
7 /// 3.RegistryValueKind.ExpandString
8 /// 4.RegistryValueKind.Binary
9 /// 5.RegistryValueKind.DWord
10 /// 6.RegistryValueKind.MultiString
11 /// 7.RegistryValueKind.QWord
12 ///
13 /// 版本:1.0
14 /// </summary>
15 public enum RegValueKind
16 {
17 /// <summary>
18 /// 指示一个不受支持的注册表数据类型。例如，不支持 Microsoft Win32 API 注册表数据类型 REG_RESOURCE_LIST。使用此值指定
19 /// </summary>
20 Unknown = 0,
21 /// <summary>
22 /// 指定一个以 Null 结尾的字符串。此值与 Win32 API 注册表数据类型 REG_SZ 等效。
23 /// </summary>
24 String = 1,
25 /// <summary>
26 /// 指定一个以 NULL 结尾的字符串，该字符串中包含对环境变量（如 %PATH%，当值被检索时，就会展开）的未展开的引用。
27 /// 此值与 Win32 API注册表数据类型 REG_EXPAND_SZ 等效。
28 /// </summary>
29 ExpandString = 2,
30 /// <summary>
31 /// 指定任意格式的二进制数据。此值与 Win32 API 注册表数据类型 REG_BINARY 等效。
32 /// </summary>
33 Binary = 3,
34 /// <summary>
35 /// 指定一个 32 位二进制数。此值与 Win32 API 注册表数据类型 REG_DWORD 等效。
36 /// </summary>
37 DWord = 4,
38 /// <summary>
39 /// 指定一个以 NULL 结尾的字符串数组，以两个空字符结束。此值与 Win32 API 注册表数据类型 REG_MULTI_SZ 等效。
40 /// </summary>
41 MultiString = 5,
42 /// <summary>
43 /// 指定一个 64 位二进制数。此值与 Win32 API 注册表数据类型 REG_QWORD 等效。
44 /// </summary>
45 QWord = 6,
46 }3.注册表操作类
1 /// <summary>
2 /// 注册表操作类
3 ///
4 /// 主要包括以下操作：
5 /// 1.创建注册表项
6 /// 2.读取注册表项
7 /// 3.判断注册表项是否存在
8 /// 4.删除注册表项
9 /// 5.创建注册表键值
10 /// 6.读取注册表键值
11 /// 7.判断注册表键值是否存在
12 /// 8.删除注册表键值
13 ///
14 /// 版本:1.0
15 /// </summary>
16 public class Register
17 {
18 #region 字段定义
19 /// <summary>
20 /// 注册表项名称
21 /// </summary>
22 private string _subkey;
23 /// <summary>
24 /// 注册表基项域
25 /// </summary>
26 private RegDomain _domain;
27 /// <summary>
28 /// 注册表键值
29 /// </summary>
30 private string _regeditkey;
31 #endregion
32
33 #region 属性
34 /// <summary>
35 /// 设置注册表项名称
36 /// </summary>
37 public string SubKey
38 {
39 //get { return _subkey; }
40 set { _subkey = value; }
41 }
42
43 /// <summary>
44 /// 注册表基项域
45 /// </summary>
46 public RegDomain Domain
47 {
48 ///get { return _domain; }
49 set { _domain = value; }
50 }
51
52 /// <summary>
53 /// 注册表键值
54 /// </summary>
55 public string RegeditKey
56 {
57 ///get{return _regeditkey;}
58 set { _regeditkey = value; }
59 }
60 #endregion
61
62 #region 构造函数
63 public Register()
64 {
65 ///默认注册表项名称
66 _subkey = "software//";
67 ///默认注册表基项域
68 _domain = RegDomain.LocalMachine;
69 }
70
71 /// <summary>
72 /// 构造函数
73 /// </summary>
74 /// <param name="subKey">注册表项名称</param>
75 /// <param name="regDomain">注册表基项域</param>
76 public Register(string subKey, RegDomain regDomain)
77 {
78 ///设置注册表项名称
79 _subkey = subKey;
80 ///设置注册表基项域
81 _domain = regDomain;
82 }
83 #endregion
84
85 #region 公有方法
86 #region 创建注册表项
87 /// <summary>
88 /// 创建注册表项，默认创建在注册表基项 HKEY_LOCAL_MACHINE下面（请先设置SubKey属性）
89 /// 虚方法，子类可进行重写
90 /// </summary>
91 public virtual void CreateSubKey()
92 {
93 ///判断注册表项名称是否为空，如果为空，返回false
94 if (_subkey == string.Empty || _subkey == null)
95 {
96 return;
97 }
98
99 ///创建基于注册表基项的节点
100 RegistryKey key = GetRegDomain(_domain);
101
102 ///要创建的注册表项的节点
103 RegistryKey sKey;
104 if (!IsSubKeyExist())
105 {
106 sKey = key.CreateSubKey(_subkey);
107 }
108 //sKey.Close();
109 ///关闭对注册表项的更改
110 key.Close();
111 }
112
113 /// <summary>
114 /// 创建注册表项，默认创建在注册表基项 HKEY_LOCAL_MACHINE下面
115 /// 虚方法，子类可进行重写
116 /// 例子：如subkey是software//higame//，则将创建HKEY_LOCAL_MACHINE//software//higame//注册表项
117 /// </summary>
118 /// <param name="subKey">注册表项名称</param>
119 public virtual void CreateSubKey(string subKey)
120 {
121 ///判断注册表项名称是否为空，如果为空，返回false
122 if (subKey == string.Empty || subKey == null)
123 {
124 return;
125 }
126
127 ///创建基于注册表基项的节点
128 RegistryKey key = GetRegDomain(_domain);
129
130 ///要创建的注册表项的节点
131 RegistryKey sKey;
132 if (!IsSubKeyExist(subKey))
133 {
134 sKey = key.CreateSubKey(subKey);
135 }
136 //sKey.Close();
137 ///关闭对注册表项的更改
138 key.Close();
139 }
140
141 /// <summary>
142 /// 创建注册表项，默认创建在注册表基项 HKEY_LOCAL_MACHINE下面
143 /// 虚方法，子类可进行重写
144 /// </summary>
145 /// <param name="regDomain">注册表基项域</param>
146 public virtual void CreateSubKey(RegDomain regDomain)
147 {
148 ///判断注册表项名称是否为空，如果为空，返回false
149 if (_subkey == string.Empty || _subkey == null)
150 {
151 return;
152 }
153
154 ///创建基于注册表基项的节点
155 RegistryKey key = GetRegDomain(regDomain);
156
157 ///要创建的注册表项的节点
158 RegistryKey sKey;
159 if (!IsSubKeyExist(regDomain))
160 {
161 sKey = key.CreateSubKey(_subkey);
162 }
163 //sKey.Close();
164 ///关闭对注册表项的更改
165 key.Close();
166 }
167
168 /// <summary>
169 /// 创建注册表项（请先设置SubKey属性）
170 /// 虚方法，子类可进行重写
171 /// 例子：如regDomain是HKEY_LOCAL_MACHINE，subkey是software//higame//，则将创建HKEY_LOCAL_MACHINE//software//higame//注册表项
172 /// </summary>
173 /// <param name="subKey">注册表项名称</param>
174 /// <param name="regDomain">注册表基项域</param>
175 public virtual void CreateSubKey(string subKey, RegDomain regDomain)
176 {
177 ///判断注册表项名称是否为空，如果为空，返回false
178 if (subKey == string.Empty || subKey == null)
179 {
180 return;
181 }
182
183 ///创建基于注册表基项的节点
184 RegistryKey key = GetRegDomain(regDomain);
185
186 ///要创建的注册表项的节点
187 RegistryKey sKey;
188 if (!IsSubKeyExist(subKey, regDomain))
189 {
190 sKey = key.CreateSubKey(subKey);
191 }
192 //sKey.Close();
193 ///关闭对注册表项的更改
194 key.Close();
195 }
196 #endregion
197
198 #region 判断注册表项是否存在
199 /// <summary>
200 /// 判断注册表项是否存在，默认是在注册表基项HKEY_LOCAL_MACHINE下判断（请先设置SubKey属性）
201 /// 虚方法，子类可进行重写
202 /// 例子：如果设置了Domain和SubKey属性，则判断Domain//SubKey，否则默认判断HKEY_LOCAL_MACHINE//software//
203 /// </summary>
204 /// <returns>返回注册表项是否存在，存在返回true，否则返回false</returns>
205 public virtual bool IsSubKeyExist()
206 {
207 ///判断注册表项名称是否为空，如果为空，返回false
208 if (_subkey == string.Empty || _subkey == null)
209 {
210 return false;
211 }
212
213 ///检索注册表子项
214 ///如果sKey为null,说明没有该注册表项不存在，否则存在
215 RegistryKey sKey = OpenSubKey(_subkey, _domain);
216 if (sKey == null)
217 {
218 return false;
219 }
220 return true;
221 }
222
223 /// <summary>
224 /// 判断注册表项是否存在，默认是在注册表基项HKEY_LOCAL_MACHINE下判断
225 /// 虚方法，子类可进行重写
226 /// 例子：如subkey是software//higame//，则将判断HKEY_LOCAL_MACHINE//software//higame//注册表项是否存在
227 /// </summary>
228 /// <param name="subKey">注册表项名称</param>
229 /// <returns>返回注册表项是否存在，存在返回true，否则返回false</returns>
230 public virtual bool IsSubKeyExist(string subKey)
231 {
232 ///判断注册表项名称是否为空，如果为空，返回false
233 if (subKey == string.Empty || subKey == null)
234 {
235 return false;
236 }
237
238 ///检索注册表子项
239 ///如果sKey为null,说明没有该注册表项不存在，否则存在
240 RegistryKey sKey = OpenSubKey(subKey);
241 if (sKey == null)
242 {
243 return false;
244 }
245 return true;
246 }
247
248 /// <summary>
249 /// 判断注册表项是否存在
250 /// 虚方法，子类可进行重写
251 /// 例子：如regDomain是HKEY_CLASSES_ROOT，则将判断HKEY_CLASSES_ROOT//SubKey注册表项是否存在
252 /// </summary>
253 /// <param name="regDomain">注册表基项域</param>
254 /// <returns>返回注册表项是否存在，存在返回true，否则返回false</returns>
255 public virtual bool IsSubKeyExist(RegDomain regDomain)
256 {
257 ///判断注册表项名称是否为空，如果为空，返回false
258 if (_subkey == string.Empty || _subkey == null)
259 {
260 return false;
261 }
262
263 ///检索注册表子项
264 ///如果sKey为null,说明没有该注册表项不存在，否则存在
265 RegistryKey sKey = OpenSubKey(_subkey, regDomain);
266 if (sKey == null)
267 {
268 return false;
269 }
270 return true;
271 }
272
273 /// <summary>
274 /// 判断注册表项是否存在（请先设置SubKey属性）
275 /// 虚方法，子类可进行重写
276 /// 例子：如regDomain是HKEY_CLASSES_ROOT，subkey是software//higame//，则将判断HKEY_CLASSES_ROOT//software//higame//注册表项是否存在
277 /// </summary>
278 /// <param name="subKey">注册表项名称</param>
279 /// <param name="regDomain">注册表基项域</param>
280 /// <returns>返回注册表项是否存在，存在返回true，否则返回false</returns>
281 public virtual bool IsSubKeyExist(string subKey, RegDomain regDomain)
282 {
283 ///判断注册表项名称是否为空，如果为空，返回false
284 if (subKey == string.Empty || subKey == null)
285 {
286 return false;
287 }
288
289 ///检索注册表子项
290 ///如果sKey为null,说明没有该注册表项不存在，否则存在
291 RegistryKey sKey = OpenSubKey(subKey, regDomain);
292 if (sKey == null)
293 {
294 return false;
295 }
296 return true;
297 }
298 #endregion
299
300 #region 删除注册表项
301 /// <summary>
302 /// 删除注册表项（请先设置SubKey属性）
303 /// 虚方法，子类可进行重写
304 /// </summary>
305 /// <returns>如果删除成功，则返回true，否则为false</returns>
306 public virtual bool DeleteSubKey()
307 {
308 ///返回删除是否成功
309 bool result = false;
310
311 ///判断注册表项名称是否为空，如果为空，返回false
312 if (_subkey == string.Empty || _subkey == null)
313 {
314 return false;
315 }
316
317 ///创建基于注册表基项的节点
318 RegistryKey key = GetRegDomain(_domain);
319
320 if (IsSubKeyExist())
321 {
322 try
323 {
324 ///删除注册表项
325 key.DeleteSubKey(_subkey);
326 result = true;
327 }
328 catch
329 {
330 result = false;
331 }
332 }
333 ///关闭对注册表项的更改
334 key.Close();
335 return result;
336 }
337
338 /// <summary>
339 /// 删除注册表项（请先设置SubKey属性）
340 /// 虚方法，子类可进行重写
341 /// </summary>
342 /// <param name="subKey">注册表项名称</param>
343 /// <returns>如果删除成功，则返回true，否则为false</returns>
344 public virtual bool DeleteSubKey(string subKey)
345 {
346 ///返回删除是否成功
347 bool result = false;
348
349 ///判断注册表项名称是否为空，如果为空，返回false
350 if (subKey == string.Empty || subKey == null)
351 {
352 return false;
353 }
354
355 ///创建基于注册表基项的节点
356 RegistryKey key = GetRegDomain(_domain);
357
358 if (IsSubKeyExist())
359 {
360 try
361 {
362 ///删除注册表项
363 key.DeleteSubKey(subKey);
364 result = true;
365 }
366 catch
367 {
368 result = false;
369 }
370 }
371 ///关闭对注册表项的更改
372 key.Close();
373 return result;
374 }
375
376 /// <summary>
377 /// 删除注册表项
378 /// 虚方法，子类可进行重写
379 /// </summary>
380 /// <param name="subKey">注册表项名称</param>
381 /// <param name="regDomain">注册表基项域</param>
382 /// <returns>如果删除成功，则返回true，否则为false</returns>
383 public virtual bool DeleteSubKey(string subKey, RegDomain regDomain)
384 {
385 ///返回删除是否成功
386 bool result = false;
387
388 ///判断注册表项名称是否为空，如果为空，返回false
389 if (subKey == string.Empty || subKey == null)
390 {
391 return false;
392 }
393
394 ///创建基于注册表基项的节点
395 RegistryKey key = GetRegDomain(regDomain);
396
397 if (IsSubKeyExist(subKey, regDomain))
398 {
399 try
400 {
401 ///删除注册表项
402 key.DeleteSubKey(subKey);
403 result = true;
404 }
405 catch
406 {
407 result = false;
408 }
409 }
410 ///关闭对注册表项的更改
411 key.Close();
412 return result;
413 }
414 #endregion
415
416 #region 判断键值是否存在
417 /// <summary>
418 /// 判断键值是否存在（请先设置SubKey和RegeditKey属性）
419 /// 虚方法，子类可进行重写
420 /// 1.如果RegeditKey为空、null，则返回false
421 /// 2.如果SubKey为空、null或者SubKey指定的注册表项不存在，返回false
422 /// </summary>
423 /// <returns>返回键值是否存在，存在返回true，否则返回false</returns>
424 public virtual bool IsRegeditKeyExist()
425 {
426 ///返回结果
427 bool result = false;
428
429 ///判断是否设置键值属性
430 if (_regeditkey == string.Empty || _regeditkey == null)
431 {
432 return false;
433 }
434
435 ///判断注册表项是否存在
436 if (IsSubKeyExist())
437 {
438 ///打开注册表项
439 RegistryKey key = OpenSubKey();
440 ///键值集合
441 string[] regeditKeyNames;
442 ///获取键值集合
443 regeditKeyNames = key.GetValueNames();
444 ///遍历键值集合，如果存在键值，则退出遍历
445 foreach (string regeditKey in regeditKeyNames)
446 {
447 if (string.Compare(regeditKey, _regeditkey, true) == 0)
448 {
449 result = true;
450 break;
451 }
452 }
453 ///关闭对注册表项的更改
454 key.Close();
455 }
456 return result;
457 }
458
459 /// <summary>
460 /// 判断键值是否存在（请先设置SubKey属性）
461 /// 虚方法，子类可进行重写
462 /// 如果SubKey为空、null或者SubKey指定的注册表项不存在，返回false
463 /// </summary>
464 /// <param name="name">键值名称</param>
465 /// <returns>返回键值是否存在，存在返回true，否则返回false</returns>
466 public virtual bool IsRegeditKeyExist(string name)
467 {
468 ///返回结果
469 bool result = false;
470
471 ///判断是否设置键值属性
472 if (name == string.Empty || name == null)
473 {
474 return false;
475 }
476
477 ///判断注册表项是否存在
478 if (IsSubKeyExist())
479 {
480 ///打开注册表项
481 RegistryKey key = OpenSubKey();
482 ///键值集合
483 string[] regeditKeyNames;
484 ///获取键值集合
485 regeditKeyNames = key.GetValueNames();
486 ///遍历键值集合，如果存在键值，则退出遍历
487 foreach (string regeditKey in regeditKeyNames)
488 {
489 if (string.Compare(regeditKey, name, true) == 0)
490 {
491 result = true;
492 break;
493 }
494 }
495 ///关闭对注册表项的更改
496 key.Close();
497 }
498 return result;
499 }
500
501 /// <summary>
502 /// 判断键值是否存在
503 /// 虚方法，子类可进行重写
504 /// </summary>
505 /// <param name="name">键值名称</param>
506 /// <param name="subKey">注册表项名称</param>
507 /// <returns>返回键值是否存在，存在返回true，否则返回false</returns>
508 public virtual bool IsRegeditKeyExist(string name, string subKey)
509 {
510 ///返回结果
511 bool result = false;
512
513 ///判断是否设置键值属性
514 if (name == string.Empty || name == null)
515 {
516 return false;
517 }
518
519 ///判断注册表项是否存在
520 if (IsSubKeyExist())
521 {
522 ///打开注册表项
523 RegistryKey key = OpenSubKey(subKey);
524 ///键值集合
525 string[] regeditKeyNames;
526 ///获取键值集合
527 regeditKeyNames = key.GetValueNames();
528 ///遍历键值集合，如果存在键值，则退出遍历
529 foreach (string regeditKey in regeditKeyNames)
530 {
531 if (string.Compare(regeditKey, name, true) == 0)
532 {
533 result = true;
534 break;
535 }
536 }
537 ///关闭对注册表项的更改
538 key.Close();
539 }
540 return result;
541 }
542
543 /// <summary>
544 /// 判断键值是否存在
545 /// 虚方法，子类可进行重写
546 /// </summary>
547 /// <param name="name">键值名称</param>
548 /// <param name="subKey">注册表项名称</param>
549 /// <param name="regDomain">注册表基项域</param>
550 /// <returns>返回键值是否存在，存在返回true，否则返回false</returns>
551 public virtual bool IsRegeditKeyExist(string name, string subKey, RegDomain regDomain)
552 {
553 ///返回结果
554 bool result = false;
555
556 ///判断是否设置键值属性
557 if (name == string.Empty || name == null)
558 {
559 return false;
560 }
561
562 ///判断注册表项是否存在
563 if (IsSubKeyExist())
564 {
565 ///打开注册表项
566 RegistryKey key = OpenSubKey(subKey, regDomain);
567 ///键值集合
568 string[] regeditKeyNames;
569 ///获取键值集合
570 regeditKeyNames = key.GetValueNames();
571 ///遍历键值集合，如果存在键值，则退出遍历
572 foreach (string regeditKey in regeditKeyNames)
573 {
574 if (string.Compare(regeditKey, name, true) == 0)
575 {
576 result = true;
577 break;
578 }
579 }
580 ///关闭对注册表项的更改
581 key.Close();
582 }
583 return result;
584 }
585 #endregion
586
587 #region 设置键值内容
588 /// <summary>
589 /// 设置指定的键值内容，不指定内容数据类型（请先设置RegeditKey和SubKey属性）
590 /// 存在改键值则修改键值内容，不存在键值则先创建键值，再设置键值内容
591 /// </summary>
592 /// <param name="content">键值内容</param>
593 /// <returns>键值内容设置成功，则返回true，否则返回false</returns>
594 public virtual bool WriteRegeditKey(object content)
595 {
596 ///返回结果
597 bool result = false;
598
599 ///判断是否设置键值属性
600 if (_regeditkey == string.Empty || _regeditkey == null)
601 {
602 return false;
603 }
604
605 ///判断注册表项是否存在，如果不存在，则直接创建
606 if (!IsSubKeyExist(_subkey))
607 {
608 CreateSubKey(_subkey);
609 }
610
611 ///以可写方式打开注册表项
612 RegistryKey key = OpenSubKey(true);
613
614 ///如果注册表项打开失败，则返回false
615 if (key == null)
616 {
617 return false;
618 }
619
620 try
621 {
622 key.SetValue(_regeditkey, content);
623 result = true;
624 }
625 catch
626 {
627 result = false;
628 }
629 finally
630 {
631 ///关闭对注册表项的更改
632 key.Close();
633 }
634 return result;
635 }
636
637 /// <summary>
638 /// 设置指定的键值内容，不指定内容数据类型（请先设置SubKey属性）
639 /// 存在改键值则修改键值内容，不存在键值则先创建键值，再设置键值内容
640 /// </summary>
641 /// <param name="name">键值名称</param>
642 /// <param name="content">键值内容</param>
643 /// <returns>键值内容设置成功，则返回true，否则返回false</returns>
644 public virtual bool WriteRegeditKey(string name, object content)
645 {
646 ///返回结果
647 bool result = false;
648
649 ///判断键值是否存在
650 if (name == string.Empty || name == null)
651 {
652 return false;
653 }
654
655 ///判断注册表项是否存在，如果不存在，则直接创建
656 if (!IsSubKeyExist(_subkey))
657 {
658 CreateSubKey(_subkey);
659 }
660
661 ///以可写方式打开注册表项
662 RegistryKey key = OpenSubKey(true);
663
664 ///如果注册表项打开失败，则返回false
665 if (key == null)
666 {
667 return false;
668 }
669
670 try
671 {
672 key.SetValue(name, content);
673 result = true;
674 }
675 catch (Exception ex)
676 {
677 result = false;
678 }
679 finally
680 {
681 ///关闭对注册表项的更改
682 key.Close();
683 }
684 return result;
685 }
686
687 /// <summary>
688 /// 设置指定的键值内容，指定内容数据类型（请先设置SubKey属性）
689 /// 存在改键值则修改键值内容，不存在键值则先创建键值，再设置键值内容
690 /// </summary>
691 /// <param name="name">键值名称</param>
692 /// <param name="content">键值内容</param>
693 /// <returns>键值内容设置成功，则返回true，否则返回false</returns>
694 public virtual bool WriteRegeditKey(string name, object content, RegValueKind regValueKind)
695 {
696 ///返回结果
697 bool result = false;
698
699 ///判断键值是否存在
700 if (name == string.Empty || name == null)
701 {
702 return false;
703 }
704
705 ///判断注册表项是否存在，如果不存在，则直接创建
706 if (!IsSubKeyExist(_subkey))
707 {
708 CreateSubKey(_subkey);
709 }
710
711 ///以可写方式打开注册表项
712 RegistryKey key = OpenSubKey(true);
713
714 ///如果注册表项打开失败，则返回false
715 if (key == null)
716 {
717 return false;
718 }
719
720 try
721 {
722 key.SetValue(name, content, GetRegValueKind(regValueKind));
723 result = true;
724 }
725 catch
726 {
727 result = false;
728 }
729 finally
730 {
731 ///关闭对注册表项的更改
732 key.Close();
733 }
734 return result;
735 }
736 #endregion
737
738 #region 读取键值内容
739 /// <summary>
740 /// 读取键值内容（请先设置RegeditKey和SubKey属性）
741 /// 1.如果RegeditKey为空、null或者RegeditKey指示的键值不存在，返回null
742 /// 2.如果SubKey为空、null或者SubKey指示的注册表项不存在，返回null
743 /// 3.反之，则返回键值内容
744 /// </summary>
745 /// <returns>返回键值内容</returns>
746 public virtual object ReadRegeditKey()
747 {
748 ///键值内容结果
749 object obj = null;
750
751 ///判断是否设置键值属性
752 if (_regeditkey == string.Empty || _regeditkey == null)
753 {
754 return null;
755 }
756
757 ///判断键值是否存在
758 if (IsRegeditKeyExist(_regeditkey))
759 {
760 ///打开注册表项
761 RegistryKey key = OpenSubKey();
762 if (key != null)
763 {
764 obj = key.GetValue(_regeditkey);
765 }
766 ///关闭对注册表项的更改
767 key.Close();
768 }
769 return obj;
770 }
771
772 /// <summary>
773 /// 读取键值内容（请先设置SubKey属性）
774 /// 1.如果SubKey为空、null或者SubKey指示的注册表项不存在，返回null
775 /// 2.反之，则返回键值内容
776 /// </summary>
777 /// <param name="name">键值名称</param>
778 /// <returns>返回键值内容</returns>
779 public virtual object ReadRegeditKey(string name)
780 {
781 ///键值内容结果
782 object obj = null;
783
784 ///判断是否设置键值属性
785 if (name == string.Empty || name == null)
786 {
787 return null;
788 }
789
790 ///判断键值是否存在
791 if (IsRegeditKeyExist(name))
792 {
793 ///打开注册表项
794 RegistryKey key = OpenSubKey();
795 if (key != null)
796 {
797 obj = key.GetValue(name);
798 }
799 ///关闭对注册表项的更改
800 key.Close();
801 }
802 return obj;
803 }
804
805 /// <summary>
806 /// 读取键值内容
807 /// </summary>
808 /// <param name="name">键值名称</param>
809 /// <param name="subKey">注册表项名称</param>
810 /// <returns>返回键值内容</returns>
811 public virtual object ReadRegeditKey(string name, string subKey)
812 {
813 ///键值内容结果
814 object obj = null;
815
816 ///判断是否设置键值属性
817 if (name == string.Empty || name == null)
818 {
819 return null;
820 }
821
822 ///判断键值是否存在
823 if (IsRegeditKeyExist(name))
824 {
825 ///打开注册表项
826 RegistryKey key = OpenSubKey(subKey);
827 if (key != null)
828 {
829 obj = key.GetValue(name);
830 }
831 ///关闭对注册表项的更改
832 key.Close();
833 }
834 return obj;
835 }
836
837 /// <summary>
838 /// 读取键值内容
839 /// </summary>
840 /// <param name="name">键值名称</param>
841 /// <param name="subKey">注册表项名称</param>
842 /// <param name="regDomain">注册表基项域</param>
843 /// <returns>返回键值内容</returns>
844 public virtual object ReadRegeditKey(string name, string subKey, RegDomain regDomain)
845 {
846 ///键值内容结果
847 object obj = null;
848
849 ///判断是否设置键值属性
850 if (name == string.Empty || name == null)
851 {
852 return null;
853 }
854
855 ///判断键值是否存在
856 if (IsRegeditKeyExist(name))
857 {
858 ///打开注册表项
859 RegistryKey key = OpenSubKey(subKey, regDomain);
860 if (key != null)
861 {
862 obj = key.GetValue(name);
863 }
864 ///关闭对注册表项的更改
865 key.Close();
866 }
867 return obj;
868 }
869 #endregion
870
871 #region 删除键值
872 /// <summary>
873 /// 删除键值（请先设置RegeditKey和SubKey属性）
874 /// 1.如果RegeditKey为空、null或者RegeditKey指示的键值不存在，返回false
875 /// 2.如果SubKey为空、null或者SubKey指示的注册表项不存在，返回false
876 /// </summary>
877 /// <returns>如果删除成功，返回true，否则返回false</returns>
878 public virtual bool DeleteRegeditKey()
879 {
880 ///删除结果
881 bool result = false;
882
883 ///判断是否设置键值属性，如果没有设置，则返回false
884 if (_regeditkey == string.Empty || _regeditkey == null)
885 {
886 return false;
887 }
888
889 ///判断键值是否存在
890 if (IsRegeditKeyExist(_regeditkey))
891 {
892 ///以可写方式打开注册表项
893 RegistryKey key = OpenSubKey(true);
894 if (key != null)
895 {
896 try
897 {
898 ///删除键值
899 key.DeleteValue(_regeditkey);
900 result = true;
901 }
902 catch
903 {
904 result = false;
905 }
906 finally
907 {
908 ///关闭对注册表项的更改
909 key.Close();
910 }
911 }
912 }
913
914 return result;
915 }
916
917 /// <summary>
918 /// 删除键值（请先设置SubKey属性）
919 /// 如果SubKey为空、null或者SubKey指示的注册表项不存在，返回false
920 /// </summary>
921 /// <param name="name">键值名称</param>
922 /// <returns>如果删除成功，返回true，否则返回false</returns>
923 public virtual bool DeleteRegeditKey(string name)
924 {
925 ///删除结果
926 bool result = false;
927
928 ///判断键值名称是否为空，如果为空，则返回false
929 if (name == string.Empty || name == null)
930 {
931 return false;
932 }
933
934 ///判断键值是否存在
935 if (IsRegeditKeyExist(name))
936 {
937 ///以可写方式打开注册表项
938 RegistryKey key = OpenSubKey(true);
939 if (key != null)
940 {
941 try
942 {
943 ///删除键值
944 key.DeleteValue(name);
945 result = true;
946 }
947 catch
948 {
949 result = false;
950 }
951 finally
952 {
953 ///关闭对注册表项的更改
954 key.Close();
955 }
956 }
957 }
958
959 return result;
960 }
961
962 /// <summary>
963 /// 删除键值
964 /// </summary>
965 /// <param name="name">键值名称</param>
966 /// <param name="subKey">注册表项名称</param>
967 /// <returns>如果删除成功，返回true，否则返回false</returns>
968 public virtual bool DeleteRegeditKey(string name, string subKey)
969 {
970 ///删除结果
971 bool result = false;
972
973 ///判断键值名称和注册表项名称是否为空，如果为空，则返回false
974 if (name == string.Empty || name == null || subKey == string.Empty || subKey == null)
975 {
976 return false;
977 }
978
979 ///判断键值是否存在
980 if (IsRegeditKeyExist(name))
981 {
982 ///以可写方式打开注册表项
983 RegistryKey key = OpenSubKey(subKey, true);
984 if (key != null)
985 {
986 try
987 {
988 ///删除键值
989 key.DeleteValue(name);
990 result = true;
991 }
992 catch
993 {
994 result = false;
995 }
996 finally
997 {
998 ///关闭对注册表项的更改
999 key.Close();
1000 }
1001 }
1002 }
1003
1004 return result;
1005 }
1006
1007 /// <summary>
1008 /// 删除键值
1009 /// </summary>
1010 /// <param name="name">键值名称</param>
1011 /// <param name="subKey">注册表项名称</param>
1012 /// <param name="regDomain">注册表基项域</param>
1013 /// <returns>如果删除成功，返回true，否则返回false</returns>
1014 public virtual bool DeleteRegeditKey(string name, string subKey, RegDomain regDomain)
1015 {
1016 ///删除结果
1017 bool result = false;
1018
1019 ///判断键值名称和注册表项名称是否为空，如果为空，则返回false
1020 if (name == string.Empty || name == null || subKey == string.Empty || subKey == null)
1021 {
1022 return false;
1023 }
1024
1025 ///判断键值是否存在
1026 if (IsRegeditKeyExist(name))
1027 {
1028 ///以可写方式打开注册表项
1029 RegistryKey key = OpenSubKey(subKey, regDomain, true);
1030 if (key != null)
1031 {
1032 try
1033 {
1034 ///删除键值
1035 key.DeleteValue(name);
1036 result = true;
1037 }
1038 catch
1039 {
1040 result = false;
1041 }
1042 finally
1043 {
1044 ///关闭对注册表项的更改
1045 key.Close();
1046 }
1047 }
1048 }
1049
1050 return result;
1051 }
1052 #endregion
1053 #endregion
1054
1055 #region 受保护方法
1056 /// <summary>
1057 /// 获取注册表基项域对应顶级节点
1058 /// 例子：如regDomain是ClassesRoot，则返回Registry.ClassesRoot
1059 /// </summary>
1060 /// <param name="regDomain">注册表基项域</param>
1061 /// <returns>注册表基项域对应顶级节点</returns>
1062 protected RegistryKey GetRegDomain(RegDomain regDomain)
1063 {
1064 ///创建基于注册表基项的节点
1065 RegistryKey key;
1066
1067 #region 判断注册表基项域
1068 switch (regDomain)
1069 {
1070 case RegDomain.ClassesRoot:
1071 key = Registry.ClassesRoot; break;
1072 case RegDomain.CurrentUser:
1073 key = Registry.CurrentUser; break;
1074 case RegDomain.LocalMachine:
1075 key = Registry.LocalMachine; break;
1076 case RegDomain.User:
1077 key = Registry.Users; break;
1078 case RegDomain.CurrentConfig:
1079 key = Registry.CurrentConfig; break;
1080 case RegDomain.DynDa:
1081 key = Registry.DynData; break;
1082 case RegDomain.PerformanceData:
1083 key = Registry.PerformanceData; break;
1084 default:
1085 key = Registry.LocalMachine; break;
1086 }
1087 #endregion
1088
1089 return key;
1090 }
1091
1092 /// <summary>
1093 /// 获取在注册表中对应的值数据类型
1094 /// 例子：如regValueKind是DWord，则返回RegistryValueKind.DWord
1095 /// </summary>
1096 /// <param name="regValueKind">注册表数据类型</param>
1097 /// <returns>注册表中对应的数据类型</returns>
1098 protected RegistryValueKind GetRegValueKind(RegValueKind regValueKind)
1099 {
1100 RegistryValueKind regValueK;
1101
1102 #region 判断注册表数据类型
1103 switch (regValueKind)
1104 {
1105 case RegValueKind.Unknown:
1106 regValueK = RegistryValueKind.Unknown; break;
1107 case RegValueKind.String:
1108 regValueK = RegistryValueKind.String; break;
1109 case RegValueKind.ExpandString:
1110 regValueK = RegistryValueKind.ExpandString; break;
1111 case RegValueKind.Binary:
1112 regValueK = RegistryValueKind.Binary; break;
1113 case RegValueKind.DWord:
1114 regValueK = RegistryValueKind.DWord; break;
1115 case RegValueKind.MultiString:
1116 regValueK = RegistryValueKind.MultiString; break;
1117 case RegValueKind.QWord:
1118 regValueK = RegistryValueKind.QWord; break;
1119 default:
1120 regValueK = RegistryValueKind.String; break;
1121 }
1122 #endregion
1123 return regValueK;
1124 }
1125
1126 #region 打开注册表项
1127 /// <summary>
1128 /// 打开注册表项节点，以只读方式检索子项
1129 /// 虚方法，子类可进行重写
1130 /// </summary>
1131 /// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在，则返回null，否则返回注册表节点</returns>
1132 protected virtual RegistryKey OpenSubKey()
1133 {
1134 ///判断注册表项名称是否为空
1135 if (_subkey == string.Empty || _subkey == null)
1136 {
1137 return null;
1138 }
1139
1140 ///创建基于注册表基项的节点
1141 RegistryKey key = GetRegDomain(_domain);
1142
1143 ///要打开的注册表项的节点
1144 RegistryKey sKey = null;
1145 ///打开注册表项
1146 sKey = key.OpenSubKey(_subkey);
1147 ///关闭对注册表项的更改
1148 key.Close();
1149 ///返回注册表节点
1150 return sKey;
1151 }
1152
1153 /// <summary>
1154 /// 打开注册表项节点
1155 /// 虚方法，子类可进行重写
1156 /// </summary>
1157 /// <param name="writable">如果需要项的写访问权限，则设置为 true</param>
1158 /// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在，则返回null，否则返回注册表节点</returns>
1159 protected virtual RegistryKey OpenSubKey(bool writable)
1160 {
1161 ///判断注册表项名称是否为空
1162 if (_subkey == string.Empty || _subkey == null)
1163 {
1164 return null;
1165 }
1166
1167 ///创建基于注册表基项的节点
1168 RegistryKey key = GetRegDomain(_domain);
1169
1170 ///要打开的注册表项的节点
1171 RegistryKey sKey = null;
1172 ///打开注册表项
1173 sKey = key.OpenSubKey(_subkey, writable);
1174 ///关闭对注册表项的更改
1175 key.Close();
1176 ///返回注册表节点
1177 return sKey;
1178 }
1179
1180 /// <summary>
1181 /// 打开注册表项节点，以只读方式检索子项
1182 /// 虚方法，子类可进行重写
1183 /// </summary>
1184 /// <param name="subKey">注册表项名称</param>
1185 /// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在，则返回null，否则返回注册表节点</returns>
1186 protected virtual RegistryKey OpenSubKey(string subKey)
1187 {
1188 ///判断注册表项名称是否为空
1189 if (subKey == string.Empty || subKey == null)
1190 {
1191 return null;
1192 }
1193
1194 ///创建基于注册表基项的节点
1195 RegistryKey key = GetRegDomain(_domain);
1196
1197 ///要打开的注册表项的节点
1198 RegistryKey sKey = null;
1199 ///打开注册表项
1200 sKey = key.OpenSubKey(subKey);
1201 ///关闭对注册表项的更改
1202 key.Close();
1203 ///返回注册表节点
1204 return sKey;
1205 }
1206
1207 /// <summary>
1208 /// 打开注册表项节点，以只读方式检索子项
1209 /// 虚方法，子类可进行重写
1210 /// </summary>
1211 /// <param name="subKey">注册表项名称</param>
1212 /// <param name="writable">如果需要项的写访问权限，则设置为 true</param>
1213 /// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在，则返回null，否则返回注册表节点</returns>
1214 protected virtual RegistryKey OpenSubKey(string subKey, bool writable)
1215 {
1216 ///判断注册表项名称是否为空
1217 if (subKey == string.Empty || subKey == null)
1218 {
1219 return null;
1220 }
1221
1222 ///创建基于注册表基项的节点
1223 RegistryKey key = GetRegDomain(_domain);
1224
1225 ///要打开的注册表项的节点
1226 RegistryKey sKey = null;
1227 ///打开注册表项
1228 sKey = key.OpenSubKey(subKey, writable);
1229 ///关闭对注册表项的更改
1230 key.Close();
1231 ///返回注册表节点
1232 return sKey;
1233 }
1234
1235 /// <summary>
1236 /// 打开注册表项节点，以只读方式检索子项
1237 /// 虚方法，子类可进行重写
1238 /// </summary>
1239 /// <param name="subKey">注册表项名称</param>
1240 /// <param name="regDomain">注册表基项域</param>
1241 /// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在，则返回null，否则返回注册表节点</returns>
1242 protected virtual RegistryKey OpenSubKey(string subKey, RegDomain regDomain)
1243 {
1244 ///判断注册表项名称是否为空
1245 if (subKey == string.Empty || subKey == null)
1246 {
1247 return null;
1248 }
1249
1250 ///创建基于注册表基项的节点
1251 RegistryKey key = GetRegDomain(regDomain);
1252
1253 ///要打开的注册表项的节点
1254 RegistryKey sKey = null;
1255 ///打开注册表项
1256 sKey = key.OpenSubKey(subKey);
1257 ///关闭对注册表项的更改
1258 key.Close();
1259 ///返回注册表节点
1260 return sKey;
1261 }
1262
1263 /// <summary>
1264 /// 打开注册表项节点
1265 /// 虚方法，子类可进行重写
1266 /// </summary>
1267 /// <param name="subKey">注册表项名称</param>
1268 /// <param name="regDomain">注册表基项域</param>
1269 /// <param name="writable">如果需要项的写访问权限，则设置为 true</param>
1270 /// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在，则返回null，否则返回注册表节点</returns>
1271 protected virtual RegistryKey OpenSubKey(string subKey, RegDomain regDomain, bool writable)
1272 {
1273 ///判断注册表项名称是否为空
1274 if (subKey == string.Empty || subKey == null)
1275 {
1276 return null;
1277 }
1278
1279 ///创建基于注册表基项的节点
1280 RegistryKey key = GetRegDomain(regDomain);
1281
1282 ///要打开的注册表项的节点
1283 RegistryKey sKey = null;
1284 ///打开注册表项
1285 sKey = key.OpenSubKey(subKey, writable);
1286 ///关闭对注册表项的更改
1287 key.Close();
1288 ///返回注册表节点
1289 return sKey;
1290 }
1291 #endregion
1292 #endregion
1293 }
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- C#注册表操作类（完整版）
- c++编写xml操作类（完整版）（更新）
- C#注册表操作类--完整优化版
- 【原创】C#注册表操作类（完整版）
- C#注册表操作类（完整版）
- c#注册表操作类
- 注册表操作类 完整版 费了好大劲找全了
- C# 注册表操作类（完整版）winform
- c#注册表操作类
- c#注册表操作类分享
- C#注册表操作类
- C#注册表操作类 实用操作函数
- C#注册表操作类
- C# 注册表操作类（完整版）winform
- c++编写xml操作类（完整版）
- C# 注册表操作类（完整版）
- hadoop hdfs java api 文件操作类
- XML Helper XML操作类
- Memcache 操作类
- 一个memcache的常用操作类