C# 注册表操作类（完整版）winform

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 }

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

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     }