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, RegDomainregDomain)
  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(RegDomainregDomain)
 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 boolIsSubKeyExist(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, RegDomainregDomain)
 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, RegDomainregDomain)
 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, RegDomainregDomain)
 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, RegDomainregDomain)
 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         /// <paramname="name">键值名称</param>
1011         /// <paramname="subKey">注册表项名称</param>
1012         /// <paramname="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         /// <paramname="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         /// <paramname="regValueKind">注册表数据类型</param>
1097         /// <returns>注册表中对应的数据类型</returns>
1098         protected RegistryValueKind GetRegValueKind(RegValueKindregValueKind)
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         /// <paramname="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         /// <paramname="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         /// <paramname="subKey">注册表项名称</param>
1212         /// <paramname="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         /// <paramname="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         /// <paramname="subKey">注册表项名称</param>
1268         /// <param name="regDomain">注册表基项域</param>
1269         /// <paramname="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     }