完美注册表操作类

1. using System; 
2. using System.Collections.Generic; 
3. using System.Text; 
4. using Microsoft.Win32;//操作注册表的命名空间 
5.  
6. namespace WinXPReg 
7. {  
8. 　 public class RegCtrl 
9.     { 
10.         private static RegistryKey rootkey; 
11.         //构造根键为RootKey的注册表操作类，缺省打开Current_User主键  
12.         public RegCtrl(string RootKey) 
13.         { 
14.             switch (RootKey.ToUpper()) 
15.             { 
16.                 case "CLASSES_ROOT": 
17.                     rootkey = Registry.ClassesRoot; 
18.                     break; 
19.                 case "CURRENT_USER": 
20.                     rootkey = Registry.CurrentUser; 
21.                     break; 
22.                 case "LOCAL_MACHINE": 
23.                     rootkey = Registry.LocalMachine; 
24.                     break; 
25.                 case "USERS": 
26.                     rootkey = Registry.Users; 
27.                     break; 
28.                 case "CURRENT_CONFIG": 
29.                     rootkey = Registry.CurrentConfig; 
30.                     break; 
31.                 case "DYN_DATA": 
32.                     rootkey = Registry.DynData; 
33.                     break; 
34.                 case "PERFORMANCE_DATA": 
35.                     rootkey = Registry.PerformanceData; 
36.                     break; 
37.                 default: 
38.                     rootkey = Registry.CurrentUser; 
39.                     break; 
40.             } 
41.         } 
42.  
43.         // 读取路径为keypath，键名为keyname的注册表键值，缺省返回def  
44.         public string GetRegVal(string keypath, string keyname, string def) 
45.         { 
46.             try 
47.             { 
48.                 RegistryKey key = rootkey.OpenSubKey(keypath); 
49.                 return key.GetValue(keyname, (object)def).ToString(); 
50.             } 
51.             catch 
52.             { 
53.                 return def; 
54.             } 
55.         } 
56.  
57.         /// /// 设置路径为keypath，键名为keyname的注册表键值为keyval /// /// /// ///  
58.         public bool SetRegVal(string keypath, string keyname, string keyval) 
59.         { 
60.             try 
61.             { 
62.                 RegistryKey key = rootkey.OpenSubKey(keypath, true); 
63.                 key.SetValue(keyname, (object)keyval); 
64.                 return true; 
65.             } 
66.             catch 
67.             { 
68.                 return false; 
69.             } 
70.         } 
71.         //创建路径为keypath的键  
72.         public RegistryKey CreateRegKey(string keypath) 
73.         { 
74.             try 
75.             { 
76.                 return rootkey.CreateSubKey(keypath); 
77.             } 
78.             catch 
79.             { 
80.                 return null; 
81.             } 
82.         } 
83.         //删除路径为keypath的子项 
84.         public bool DelRegSubKey(string keypath) 
85.         { 
86.             try { 
87.                 rootkey.DeleteSubKey(keypath); return true;  
88.             } 
89.             catch  
90.             {  
91.                 return false; 
92.             } 
93.         } 
94.  
95.         // 删除路径为keypath的子项及其附属子项  
96.         public bool DelRegSubKeyTree(string keypath) 
97.         { 
98.             try 
99.             { 
100.                 rootkey.DeleteSubKeyTree(keypath); 
101.                 return true; 
102.             } 
103.             catch 
104.             { 
105.                 return false; 
106.             } 
107.         } 
108.         //删除路径为keypath下键名为keyname的键值 
109.         public bool DelRegKeyVal(string keypath, string keyname) 
110.         { 
111.             try 
112.             { 
113.                 RegistryKey key = rootkey.OpenSubKey(keypath, true); 
114.                 key.DeleteValue(keyname); 
115.                 return true; 
116.             } 
117.             catch 
118.             { 
119.                 return false; 
120.             } 
121.         } 
122.     } 
123. }