下面贴出自己用C#写的注册表操作类，欢迎大家拍砖！
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 }
2018
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
