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 publicenum 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 publicenum 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 }
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 publicenum 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 publicclass Register
17 {
18 #region 字段定义
19 ///<summary>
20 /// 注册表项名称
21 ///</summary>
22 privatestring _subkey;
23 ///<summary>
24 /// 注册表基项域
25 ///</summary>
26 private RegDomain _domain;
27 ///<summary>
28 /// 注册表键值
29 ///</summary>
30 privatestring _regeditkey;
31 #endregion
32
33 #region 属性
34 ///<summary>
35 /// 设置注册表项名称
36 ///</summary>
37 publicstring 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 publicstring 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 publicvirtualvoid 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 publicvirtualvoid 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 publicvirtualvoid 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 publicvirtualvoid 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
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 publicclass Register
17 {
18 #region 字段定义
19 ///<summary>
20 /// 注册表项名称
21 ///</summary>
22 privatestring _subkey;
23 ///<summary>
24 /// 注册表基项域
25 ///</summary>
26 private RegDomain _domain;
27 ///<summary>
28 /// 注册表键值
29 ///</summary>
30 privatestring _regeditkey;
31 #endregion
32
33 #region 属性
34 ///<summary>
35 /// 设置注册表项名称
36 ///</summary>
37 publicstring 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 publicstring 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 publicvirtualvoid 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 publicvirtualvoid 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 publicvirtualvoid 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 publicvirtualvoid 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
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 }