using System;using System.Collections.Generic;using System.Text;using Microsoft.Win32;namespace Register{    public class RegisterHelper    {        ///  <summary>        ///  注册表基项静态域        ///        ///  主要包括：        ///1.Registry.ClassesRoot  对应于 HKEY_CLASSES_ROOT 主键        ///2.Registry.CurrentUser  对应于 HKEY_CURRENT_USER 主键        ///3.Registry.LocalMachine  对应于HKEY_LOCAL_MACHINE 主键        ///4.Registry.User  对应于HKEY_USER 主键        ///5.Registry.CurrentConfig  对应于 HEKY_CURRENT_CONFIG 主键        ///6.Registry.DynDa  对应于 HKEY_DYN_DATA 主键        ///7.Registry.PerformanceData  对应于 HKEY_PERFORMANCE_DATA 主键        ///        ///  版本:1.0         ///  </summary>         public enum RegDomain        {            ///  <summary>            ///  对应于 HKEY_CLASSES_ROOT 主键            ///  </summary>             ClassesRoot = 0,            ///  <summary>            ///  对应于 HKEY_CURRENT_USER 主键            ///  </summary>             CurrentUser = 1,            ///  <summary>            ///  对应于HKEY_LOCAL_MACHINE 主键            ///  </summary>             LocalMachine = 2,            ///  <summary>            ///  对应于HKEY_USER 主键            ///  </summary>             User = 3,            ///  <summary>            ///  对应于 HEKY_CURRENT_CONFIG 主键            ///  </summary>             CurrentConfig = 4,            ///  <summary>            ///  对应于 HKEY_DYN_DATA 主键            ///  </summary>             DynDa = 5,            ///  <summary>            ///  对应于 HKEY_PERFORMANCE_DATA 主键            ///  </summary>             PerformanceData = http://www.mamicode.com/6,"software\\";            ///默认注册表基项域            _domain = RegDomain.LocalMachine;        }        ///  <summary>        ///  构造函数        ///  </summary>        ///  <param name="subKey">注册表项名称</param>        ///  <param name="regDomain">注册表基项域</param>         public RegisterHelper(string subKey, RegDomain regDomain)        {            ///设置注册表项名称            _subkey = subKey;            ///设置注册表基项域            _domain = regDomain;        }        #endregion        #region  公有方法        #region  创建注册表项        ///  <summary>        ///  创建注册表项，默认创建在注册表基项HKEY_LOCAL_MACHINE 下面（请壬柚?SubKey 属性）        ///  虚方法，子类可进行重写        ///  </summary>         public virtual void CreateSubKey()        {            ///判断注册表项名称是否为空，如果为空，返回 false            if (_subkey == string.Empty || _subkey == null)            {                return;            }            ///创建基于注册表基项的节点            RegistryKey key = GetRegDomain(_domain);            ///要创建的注册表项的节点            RegistryKey sKey;            if (!IsSubKeyExist())            {                sKey = key.CreateSubKey(_subkey);            }            //sKey.Close();             ///关闭对注册表项的更改            key.Close();        }        ///  <summary>        ///  创建注册表项，默认创建在注册表基项HKEY_LOCAL_MACHINE 下面        ///  虚方法，子类可进行重写        ///  例子：如 subkey 是 software\\higame\\，则将创建 HKEY_LOCAL_MACHINE\\software\\higame\\注册表项        ///  </summary>         ///  <param name="subKey">注册表项名称</param>         public virtual void CreateSubKey(string subKey)        {            ///判断注册表项名称是否为空，如果为空，返回 false            if (subKey == string.Empty || subKey == null)            {                return;            }            ///创建基于注册表基项的节点            RegistryKey key = GetRegDomain(_domain);            ///要创建的注册表项的节点            RegistryKey sKey;            if (!IsSubKeyExist(subKey))            {                sKey = key.CreateSubKey(subKey);            }            //sKey.Close();             ///关闭对注册表项的更改            key.Close();        }        ///  <summary>        ///  创建注册表项，默认创建在注册表基项HKEY_LOCAL_MACHINE 下面        ///  虚方法，子类可进行重写        ///  </summary>        ///  <param name="regDomain">注册表基项域</param>         public virtual void CreateSubKey(RegDomain regDomain)        {            ///判断注册表项名称是否为空，如果为空，返回 false            if (_subkey == string.Empty || _subkey == null)            {                return;            }            ///创建基于注册表基项的节点            RegistryKey key = GetRegDomain(regDomain);            ///要创建的注册表项的节点            RegistryKey sKey;            if (!IsSubKeyExist(regDomain))            {                sKey = key.CreateSubKey(_subkey);            }            //sKey.Close();             ///关闭对注册表项的更改            key.Close();        }        ///  <summary>        ///  创建注册表项（请先设置 SubKey 属性）        ///  虚方法，子类可进行重写        ///  例子：如 regDomain 是 HKEY_LOCAL_MACHINE，subkey 是 software\\higame\\，则将创建 HKEY_LOCAL_MACHINE\\software\\higame\\注册表项        ///  </summary>        ///  <param name="subKey">注册表项名称</param>        ///  <param name="regDomain">注册表基项域</param>         public virtual void CreateSubKey(string subKey, RegDomain regDomain)        {            ///判断注册表项名称是否为空，如果为空，返回 false            if (subKey == string.Empty || subKey == null)            {                return;            }            ///创建基于注册表基项的节点            RegistryKey key = GetRegDomain(regDomain);            ///要创建的注册表项的节点            RegistryKey sKey;            if (!IsSubKeyExist(subKey, regDomain))            {                sKey = key.CreateSubKey(subKey);            }            //sKey.Close();             ///关闭对注册表项的更改            key.Close();        }        #endregion        #region  判断注册表项是否存在        ///  <summary>        ///  判断注册表项是否存在，默认是在注册表基项 HKEY_LOCAL_MACHINE 下判断（请先设置 SubKey 属性）        ///  虚方法，子类可进行重写        ///  例子：如果设置了 Domain 和 SubKey 属性，则判断 Domain\\SubKey，否则默认判断 HKEY_LOCAL_MACHINE\\software\\         ///  </summary>        ///  <returns>返回注册表项是否存在，存在返回 true，否则返回 false</returns>         public virtual bool IsSubKeyExist()        {            ///判断注册表项名称是否为空，如果为空，返回 false            if (_subkey == string.Empty || _subkey == null)            {                return false;            }            ///检索注册表子项            ///如果 sKey 为 null,说明没有该注册表项不存在，否则存在            RegistryKey sKey = OpenSubKey(_subkey, _domain);            if (sKey == null)            {                return false;            }            return true;        }        ///  <summary>        ///  判断注册表项是否存在，默认是在注册表基项 HKEY_LOCAL_MACHINE 下判断        ///  虚方法，子类可进行重写        ///  例子：如 subkey 是 software\\higame\\，则将判断 HKEY_LOCAL_MACHINE\\software\\higame\\注册表项是否存在        ///  </summary>        ///  <param name="subKey">注册表项名称</param>        ///  <returns>返回注册表项是否存在，存在返回 true，否则返回 false</returns>         public virtual bool IsSubKeyExist(string subKey)        {            ///判断注册表项名称是否为空，如果为空，返回 false            if (subKey == string.Empty || subKey == null)            {                return false;            }            ///检索注册表子项            ///如果 sKey 为 null,说明没有该注册表项不存在，否则存在            RegistryKey sKey = OpenSubKey(subKey);            if (sKey == null)            {                return false;            }            return true;        }        ///  <summary>        ///  判断注册表项是否存在        ///  虚方法，子类可进行重写        ///  例子：如 regDomain 是 HKEY_CLASSES_ROOT，则将判断 HKEY_CLASSES_ROOT\\SubKey 注册表项是否存在        ///  </summary>        ///  <param name="regDomain">注册表基项域</param>        ///  <returns>返回注册表项是否存在，存在返回 true，否则返回 false</returns>         public virtual bool IsSubKeyExist(RegDomain regDomain)        {            ///判断注册表项名称是否为空，如果为空，返回 false            if (_subkey == string.Empty || _subkey == null)            {                return false;            }            ///检索注册表子项            ///如果 sKey 为 null,说明没有该注册表项不存在，否则存在            RegistryKey sKey = OpenSubKey(_subkey, regDomain);            if (sKey == null)            {                return false;            }            return true;        }        ///  <summary>        ///  判断注册表项是否存在（请先设置 SubKey 属性）        ///  虚方法，子类可进行重写        ///  例子：如 regDomain 是 HKEY_CLASSES_ROOT，subkey 是 software\\higame\\，则将判断 HKEY_CLASSES_ROOT\\software\\higame\\注册表项是否存在        ///  </summary>        ///  <param name="subKey">注册表项名称</param>        ///  <param name="regDomain">注册表基项域</param>        ///  <returns>返回注册表项是否存在，存在返回 true，否则返回 false</returns>         public virtual bool IsSubKeyExist(string subKey, RegDomain regDomain)        {            ///判断注册表项名称是否为空，如果为空，返回 false            if (subKey == string.Empty || subKey == null)            {                return false;            }            ///检索注册表子项            ///如果 sKey 为 null,说明没有该注册表项不存在，否则存在            RegistryKey sKey = OpenSubKey(subKey, regDomain);            if (sKey == null)            {                return false;            }            return true;        }        #endregion        #region  删除注册表项        ///  <summary>        ///  删除注册表项（请先设置 SubKey 属性）        ///  虚方法，子类可进行重写        ///  </summary>        ///  <returns>如果删除成功，则返回 true，否则为 false</returns>         public virtual bool DeleteSubKey()        {            ///返回删除是否成功            bool result = false;            ///判断注册表项名称是否为空，如果为空，返回 false            if (_subkey == string.Empty || _subkey == null)            {                return false;            }            ///创建基于注册表基项的节点            RegistryKey key = GetRegDomain(_domain);            if (IsSubKeyExist())            {                try                {                    ///删除注册表项                     key.DeleteSubKey(_subkey);                    result = true;                }                catch                {                    result = false;                }            }            ///关闭对注册表项的更改            key.Close();            return result;        }        ///  <summary>        ///  删除注册表项（请先设置 SubKey 属性）        ///  虚方法，子类可进行重写        ///  </summary>        ///  <param name="subKey">注册表项名称</param>        ///  <returns>如果删除成功，则返回 true，否则为 false</returns>         public virtual bool DeleteSubKey(string subKey)        {            ///返回删除是否成功            bool result = false;            ///判断注册表项名称是否为空，如果为空，返回 false            if (subKey == string.Empty || subKey == null)            {                return false;            }            ///创建基于注册表基项的节点            RegistryKey key = GetRegDomain(_domain);            if (IsSubKeyExist())            {                try                {                    ///删除注册表项                    key.DeleteSubKey(subKey);                    result = true;                }                catch                {                    result = false;                }            }            ///关闭对注册表项的更改            key.Close();            return result;        }        ///  <summary>        ///  删除注册表项        ///  虚方法，子类可进行重写        ///  </summary>        ///  <param name="subKey">注册表项名称</param>        ///  <param name="regDomain">注册表基项域</param>        ///  <returns>如果删除成功，则返回 true，否则为 false</returns>         public virtual bool DeleteSubKey(string subKey, RegDomain regDomain)        {            ///返回删除是否成功            bool result = false;            ///判断注册表项名称是否为空，如果为空，返回 false            if (subKey == string.Empty || subKey == null)            {                return false;            }            ///创建基于注册表基项的节点            RegistryKey key = GetRegDomain(regDomain);            if (IsSubKeyExist(subKey, regDomain))            {                try                {                    ///删除注册表项                    key.DeleteSubKey(subKey);                    result = true;                }                catch                {                    result = false;                }            }            ///关闭对注册表项的更改            key.Close();            return result;        }        #endregion        #region  判断键值是否存在        ///  <summary>        ///  判断键值是否存在（请先设置 SubKey 和 RegeditKey 属性）        ///  虚方法，子类可进行重写        ///1.如果 RegeditKey 为空、null，则返回 false         ///2.如果 SubKey 为空、 null 或者 SubKey 指定的注册表项不存在，返回 false         ///  </summary>        ///  <returns>返回键值是否存在，存在返回 true，否则返回 false</returns>         public virtual bool IsRegeditKeyExist()        {            ///返回结果            bool result = false;            ///判断是否设置键值属性            if (_regeditkey == string.Empty || _regeditkey == null)            {                return false;            }            ///判断注册表项是否存在            if (IsSubKeyExist())            {                ///打开注册表项                RegistryKey key = OpenSubKey();                ///键值集合                string[] regeditKeyNames;                ///获取键值集合                regeditKeyNames = key.GetValueNames();                ///遍历键值集合，如果存在键值，则退出遍历                foreach (string regeditKey in regeditKeyNames)                {                    if (string.Compare(regeditKey, _regeditkey, true) == 0)                    {                        result = true;                        break;                    }                }                ///关闭对注册表项的更改                key.Close();            }            return result;        }        ///  <summary>        ///  判断键值是否存在（请先设置 SubKey 属性）        ///  虚方法，子类可进行重写        ///  如果 SubKey 为空、null 或者 SubKey 指定的注册表项不存在，返回 false         ///  </summary>        ///  <param name="name">键值名称</param>        ///  <returns>返回键值是否存在，存在返回 true，否则返回 false</returns>         public virtual bool IsRegeditKeyExist(string name)        {            ///返回结果            bool result = false;            ///判断是否设置键值属性            if (name == string.Empty || name == null)            {                return false;            }            ///判断注册表项是否存在            if (IsSubKeyExist())            {                ///打开注册表项                RegistryKey key = OpenSubKey();                ///键值集合                string[] regeditKeyNames;                ///获取键值集合                regeditKeyNames = key.GetValueNames();                ///遍历键值集合，如果存在键值，则退出遍历                foreach (string regeditKey in regeditKeyNames)                {                    if (string.Compare(regeditKey, name, true) == 0)                    {                        result = true;                        break;                    }                }                ///关闭对注册表项的更改                key.Close();            }            return result;        }        ///  <summary>        ///  判断键值是否存在        ///  虚方法，子类可进行重写        ///  </summary>        ///  <param name="name">键值名称</param>        ///  <param name="subKey">注册表项名称</param>        ///  <returns>返回键值是否存在，存在返回 true，否则返回 false</returns>         public virtual bool IsRegeditKeyExist(string name, string      subKey)        {            ///返回结果            bool result = false;            ///判断是否设置键值属性            if (name == string.Empty || name == null)            {                return false;            }            ///判断注册表项是否存在            if (IsSubKeyExist())            {                ///打开注册表项                RegistryKey key = OpenSubKey(subKey);                ///键值集合                string[] regeditKeyNames;                ///获取键值集合                regeditKeyNames = key.GetValueNames();                ///遍历键值集合，如果存在键值，则退出遍历                foreach (string regeditKey in regeditKeyNames)                {                    if (string.Compare(regeditKey, name, true) == 0)                    {                        result = true;                        break;                    }                }                ///关闭对注册表项的更改                key.Close();            }            return result;        }        ///  <summary>        ///  判断键值是否存在        ///  虚方法，子类可进行重写        ///  </summary>        ///  <param name="name">键值名称</param>        ///  <param name="subKey">注册表项名称</param>        ///  <param name="regDomain">注册表基项域</param>        ///  <returns>返回键值是否存在，存在返回 true，否则返回 false</returns>         public virtual bool IsRegeditKeyExist(string name, string      subKey, RegDomain regDomain)        {            ///返回结果            bool result = false;            ///判断是否设置键值属性            if (name == string.Empty || name == null)            {                return false;            }            ///判断注册表项是否存在            if (IsSubKeyExist())            {                ///打开注册表项                RegistryKey key = OpenSubKey(subKey, regDomain);                ///键值集合                string[] regeditKeyNames;                ///获取键值集合                regeditKeyNames = key.GetValueNames();                ///遍历键值集合，如果存在键值，则退出遍历                foreach (string regeditKey in regeditKeyNames)                {                    if (string.Compare(regeditKey, name, true) == 0)                    {                        result = true;                        break;                    }                }                ///关闭对注册表项的更改                key.Close();            }            return result;        }        #endregion        #region  设置键值内容        ///  <summary>        ///  设置指定的键值内容，不指定内容数据类型（请先设置 RegeditKey 和 SubKey 属性）        ///  存在改键值则修改键值内容，不存在键值则先创建键值，再设置键值内容        ///  </summary>        ///  <param name="content">键值内容</param>        ///  <returns>键值内容设置成功，则返回 true，否则返回 false</returns>         public virtual bool WriteRegeditKey(object content)        {            ///返回结果            bool result = false;            ///判断是否设置键值属性            if (_regeditkey == string.Empty || _regeditkey == null)            {                return false;            }            ///判断注册表项是否存在，如果不存在，则直接创建            if (!IsSubKeyExist(_subkey))            {                CreateSubKey(_subkey);            }            ///以可写方式打开注册表项            RegistryKey key = OpenSubKey(true);            ///如果注册表项打开失败，则返回 false            if (key == null)            {                return false;            }            try            {                key.SetValue(_regeditkey, content);                result = true;            }            catch            {                result = false;            }            finally            {                ///关闭对注册表项的更改                key.Close();            }            return result;        }///  <summary>        ///  设置指定的键值内容，不指定内容数据类型（请先设置 SubKey 属性）        ///  存在改键值则修改键值内容，不存在键值则先创建键值，再设置键值内容        ///  </summary>        ///  <param name="name">键值名称</param>        ///  <param name="content">键值内容</param>        ///  <returns>键值内容设置成功，则返回 true，否则返回 false</returns>         public virtual bool WriteRegeditKey(string name, object content)        {            ///返回结果            bool result = false;            ///判断键值是否存在            if (name == string.Empty || name == null)            {                return false;            }            ///判断注册表项是否存在，如果不存在，则直接创建            if (!IsSubKeyExist(_subkey))            {                CreateSubKey(_subkey);            }            ///以可写方式打开注册表项            RegistryKey key = OpenSubKey(true);            ///如果注册表项打开失败，则返回 false            if (key == null)            {                return false;            }            try            {                key.SetValue(name, content);                result = true;            }            catch (Exception ex)            {                result = false;            }            finally            {                ///关闭对注册表项的更改                key.Close();            }            return result;        }        ///  <summary>        ///  设置指定的键值内容，指定内容数据类型（请先设置 SubKey 属性）        ///  存在改键值则修改键值内容，不存在键值则先创建键值，再设置键值内容        ///  </summary>        ///  <param name="name">键值名称</param>        ///  <param name="content">键值内容</param>        ///  <returns>键值内容设置成功，则返回 true，否则返回 false</returns>         public virtual bool WriteRegeditKey(string name, object content, RegValueKind regValueKind)        {            ///返回结果            bool result = false;            ///判断键值是否存在            if (name == string.Empty || name == null)            {                return false;            }            ///判断注册表项是否存在，如果不存在，则直接创建            if (!IsSubKeyExist(_subkey))            {                CreateSubKey(_subkey);            }            ///以可写方式打开注册表项            RegistryKey key = OpenSubKey(true);            ///如果注册表项打开失败，则返回 false            if (key == null)            {                return false;            }            try            {                key.SetValue(name, content, GetRegValueKind(regValueKind));                result = true;            }            catch            {                result = false;            }            finally            {                ///关闭对注册表项的更改                key.Close();            }            return result;        }        #endregion        #region  读取键值内容        ///  <summary>        ///  读取键值内容（请先设置 RegeditKey 和 SubKey 属性）        ///1.如果 RegeditKey 为空、 null 或者 RegeditKey 指示的键值不存在，返回 null         ///2.如果 SubKey 为空、 null 或者 SubKey 指示的注册表项不存在，返回 null         ///3.反之，则返回键值内容        ///  </summary>        ///  <returns>返回键值内容</returns>         public virtual object ReadRegeditKey()        {            ///键值内容结果            object obj = null;            ///判断是否设置键值属性            if (_regeditkey == string.Empty || _regeditkey == null)            {                return null;            }            ///判断键值是否存在            if (IsRegeditKeyExist(_regeditkey))            {                ///打开注册表项                RegistryKey key = OpenSubKey();                if (key != null)                {                    obj = key.GetValue(_regeditkey);                }                ///关闭对注册表项的更改                key.Close();            }            return obj;        }        ///  <summary>        ///  读取键值内容（请先设置 SubKey 属性）        ///1.如果 SubKey 为空、 null 或者 SubKey 指示的注册表项不存在，返回 null         ///2.反之，则返回键值内容        ///  </summary>        ///  <param name="name">键值名称</param>        ///  <returns>返回键值内容</returns>         public virtual object ReadRegeditKey(string name)        {            ///键值内容结果            object obj = null;            ///判断是否设置键值属性            if (name == string.Empty || name == null)            {                return null;            }            ///判断键值是否存在            if (IsRegeditKeyExist(name))            {                ///打开注册表项                RegistryKey key = OpenSubKey();                if (key != null)                {                    obj = key.GetValue(name);                }                ///关闭对注册表项的更改                key.Close();            }            return obj;        }        ///  <summary>        ///  读取键值内容        ///  </summary>        ///  <param name="name">键值名称</param>        ///  <param name="subKey">注册表项名称</param>        ///  <returns>返回键值内容</returns>         public virtual object ReadRegeditKey(string name, string subKey)        {            ///键值内容结果            object obj = null;            ///判断是否设置键值属性            if (name == string.Empty || name == null)            {                return null;            }            ///判断键值是否存在            if (IsRegeditKeyExist(name))            {                ///打开注册表项                RegistryKey key = OpenSubKey(subKey);                if (key != null)                {                    obj = key.GetValue(name);                }                ///关闭对注册表项的更改                 key.Close();            }            return obj;        }        ///  <summary>        ///  读取键值内容        ///  </summary>        ///  <param name="name">键值名称</param>        ///  <param name="subKey">注册表项名称</param>        ///  <param name="regDomain">注册表基项域</param>        ///  <returns>返回键值内容</returns>         public virtual object ReadRegeditKey(string name, string subKey, RegDomain regDomain)        {            ///键值内容结果            object obj = null;            ///判断是否设置键值属性            if (name == string.Empty || name == null)            {                return null;            }            ///判断键值是否存在            if (IsRegeditKeyExist(name))            {                ///打开注册表项                RegistryKey key = OpenSubKey(subKey, regDomain);                if (key != null)                {                    obj = key.GetValue(name);                }                ///关闭对注册表项的更改                key.Close();            }            return obj;        }        #endregion        #region  删除键值        ///  <summary>        ///  删除键值（请先设置 RegeditKey 和 SubKey 属性）        ///1.如果 RegeditKey 为空、 null 或者 RegeditKey 指示的键值不存在，返回 false         ///2.如果 SubKey 为空、 null 或者 SubKey 指示的注册表项不存在，返回 false         ///  </summary>        ///  <returns>如果删除成功，返回 true，否则返回 false</returns>         public virtual bool DeleteRegeditKey()        {            ///删除结果            bool result = false;            ///判断是否设置键值属性，如果没有设置，则返回 false            if (_regeditkey == string.Empty || _regeditkey == null)            {                return false;            }            ///判断键值是否存在            if (IsRegeditKeyExist(_regeditkey))            {                ///以可写方式打开注册表项                RegistryKey key = OpenSubKey(true);                if (key != null)                {                    try                    {                        ///删除键值                        key.DeleteValue(_regeditkey);                        result = true;                    }                    catch                    {                        result = false;                    }                    finally                    {                        ///关闭对注册表项的更改                        key.Close();                    }                }            }            return result;        }        ///  <summary>        ///  删除键值（请先设置 SubKey 属性）        ///  如果 SubKey 为空、null 或者 SubKey 指示的注册表项不存在，返回 false         ///  </summary>        ///  <param name="name">键值名称</param>        ///  <returns>如果删除成功，返回 true，否则返回 false</returns>         public virtual bool DeleteRegeditKey(string name)        {            ///删除结果            bool result = false;            ///判断键值名称是否为空，如果为空，则返回 false            if (name == string.Empty || name == null)            {                return false;            }            ///判断键值是否存在            if (IsRegeditKeyExist(name))            {                ///以可写方式打开注册表项                RegistryKey key = OpenSubKey(true);                if (key != null)                {                    try                    {                        ///删除键值                        key.DeleteValue(name);                        result = true;                    }                    catch                    {                        result = false;                    }                    finally                    {                        ///关闭对注册表项的更改                        key.Close();                    }                }            }            return result;        }        ///  <summary>        ///  删除键值        ///  </summary>        ///  <param name="name">键值名称</param>        ///  <param name="subKey">注册表项名称</param>        ///  <returns>如果删除成功，返回 true，否则返回 false</returns>         public virtual bool DeleteRegeditKey(string name, string subKey)        {            ///删除结果            bool result = false;            ///判断键值名称和注册表项名称是否为空，如果为空，则返回 false            if (name == string.Empty || name == null || subKey == string.Empty || subKey == null)            {                return false;            }            ///判断键值是否存在            if (IsRegeditKeyExist(name))            {                ///以可写方式打开注册表项                RegistryKey key = OpenSubKey(subKey, true);                if (key != null)                {                    try                    {                        ///删除键值                        key.DeleteValue(name);                        result = true;                    }                    catch                    {                        result = false;                    }                    finally                    {                        ///关闭对注册表项的更改                        key.Close();                    }                }            }            return result;        }        ///  <summary>        ///  删除键值        ///  </summary>        ///  <param name="name">键值名称</param>        ///  <param name="subKey">注册表项名称</param>        ///  <param name="regDomain">注册表基项域</param>        ///  <returns>如果删除成功，返回 true，否则返回 false</returns>         public virtual bool DeleteRegeditKey(string name, string subKey, RegDomain regDomain)        {            ///删除结果            bool result = false;            ///判断键值名称和注册表项名称是否为空，如果为空，则返回 false            if (name == string.Empty || name == null || subKey == string.Empty || subKey == null)            {                return false;            }            ///判断键值是否存在            if (IsRegeditKeyExist(name))            {                ///以可写方式打开注册表项                RegistryKey key = OpenSubKey(subKey, regDomain, true);                if (key != null)                {                    try                    {                        ///删除键值                        key.DeleteValue(name);                        result = true;                    }                    catch                    {                        result = false;                    }                    finally                    {                        ///关闭对注册表项的更改                        key.Close();                    }                }            }            return result;        }        #endregion        #endregion        #region  受保护方法        ///  <summary>        ///  获取注册表基项域对应顶级节点        ///  例子：如 regDomain 是 ClassesRoot，则返回 Registry.ClassesRoot         ///  </summary>        ///  <param name="regDomain">注册表基项域</param>        ///  <returns>注册表基项域对应顶级节点</returns>         protected RegistryKey GetRegDomain(RegDomain regDomain)        {            ///创建基于注册表基项的节点            RegistryKey key;            #region  判断注册表基项域            switch (regDomain)            {                case RegDomain.ClassesRoot:                    key = Registry.ClassesRoot;                    break;                case RegDomain.CurrentUser:                    key = Registry.CurrentUser;                    break;                case RegDomain.LocalMachine:                    key = Registry.LocalMachine;                    break;                case RegDomain.User:                    key = Registry.Users;                    break;                case RegDomain.CurrentConfig:                    key = Registry.CurrentConfig;                    break;                case RegDomain.DynDa:                    key = Registry.DynData;                    break;                case RegDomain.PerformanceData:                    key = Registry.PerformanceData;                    break;                default:                    key = Registry.LocalMachine;                    break;            }            #endregion            return key;        }        ///  <summary>        ///  获取在注册表中对应的值数据类型        ///  例子：如 regValueKind 是 DWord，则返回 RegistryValueKind.DWord         ///  </summary>        ///  <param name="regValueKind">注册表数据类型</param>        ///  <returns>注册表中对应的数据类型</returns>         protected RegistryValueKind GetRegValueKind(RegValueKind regValueKind)        {            RegistryValueKind regValueK;            #region  判断注册表数据类型            switch (regValueKind)            {                case RegValueKind.Unknown:                    regValueK = RegistryValueKind.Unknown;                    break;                case RegValueKind.String:                    regValueK = RegistryValueKind.String;                    break;                case RegValueKind.ExpandString:                    regValueK = RegistryValueKind.ExpandString;                    break;                case RegValueKind.Binary:                    regValueK = RegistryValueKind.Binary;                    break;                case RegValueKind.DWord:                    regValueK = RegistryValueKind.DWord;                    break;                case RegValueKind.MultiString:                    regValueK = RegistryValueKind.MultiString;                    break;                case RegValueKind.QWord:                    regValueK = RegistryValueKind.QWord;                    break;                default:                    regValueK = RegistryValueKind.String;                    break;            }            #endregion            return regValueK;        }        #region  打开注册表项        ///  <summary>        ///  打开注册表项节点，以只读方式检索子项        ///  虚方法，子类可进行重写        ///  </summary>        ///  <returns>如果 SubKey 为空、 null 或者 SubKey 指示注册表项不存在，则返回 null，否则返回注册表节点</returns>         protected virtual RegistryKey OpenSubKey()        {            ///判断注册表项名称是否为空            if (_subkey == string.Empty || _subkey == null)            {                return null;            }            ///创建基于注册表基项的节点            RegistryKey key = GetRegDomain(_domain);            ///要打开的注册表项的节点            RegistryKey sKey = null;            ///打开注册表项            sKey = key.OpenSubKey(_subkey);            ///关闭对注册表项的更改            key.Close();            ///返回注册表节点            return sKey;        }        ///  <summary>        ///  打开注册表项节点        ///  虚方法，子类可进行重写        ///  </summary>        ///  <param name="writable">如果需要项的写访问权限，则设置为true</param>        ///  <returns>如果 SubKey 为空、 null 或者 SubKey 指示注册表项不存在，则返回 null，否则返回注册表节点</returns>         protected virtual RegistryKey OpenSubKey(bool writable)        {            ///判断注册表项名称是否为空            if (_subkey == string.Empty || _subkey == null)            {                return null;            }            ///创建基于注册表基项的节点             RegistryKey key = GetRegDomain(_domain);            ///要打开的注册表项的节点            RegistryKey sKey = null;            ///打开注册表项            sKey = key.OpenSubKey(_subkey, writable);            ///关闭对注册表项的更改            key.Close();            ///返回注册表节点            return sKey;        }        ///  <summary>        ///  打开注册表项节点，以只读方式检索子项        ///  虚方法，子类可进行重写        ///  </summary>        ///  <param name="subKey">注册表项名称</param>        ///  <returns>如果 SubKey 为空、 null 或者 SubKey 指示注册表项不存在，则返回 null，否则返回注册表节点</returns>         protected virtual RegistryKey OpenSubKey(string subKey)        {            ///判断注册表项名称是否为空            if (subKey == string.Empty || subKey == null)            {                return null;            }            ///创建基于注册表基项的节点            RegistryKey key = GetRegDomain(_domain);            ///要打开的注册表项的节点            RegistryKey sKey = null;            ///打开注册表项            sKey = key.OpenSubKey(subKey);            ///关闭对注册表项的更改            key.Close();            ///返回注册表节点            return sKey;        }        ///  <summary>        ///  打开注册表项节点，以只读方式检索子项        ///  虚方法，子类可进行重写        ///  </summary>         ///  <param name="subKey">注册表项名称</param>        ///  <param name="writable">如果需要项的写访问权限，则设置为true</param>        ///  <returns>如果 SubKey 为空、 null 或者 SubKey 指示注册表项不存在，则返回 null，否则返回注册表节点</returns>         protected virtual RegistryKey OpenSubKey(string subKey, bool writable)        {            ///判断注册表项名称是否为空            if (subKey == string.Empty || subKey == null)            {                return null;            }            ///创建基于注册表基项的节点            RegistryKey key = GetRegDomain(_domain);            ///要打开的注册表项的节点            RegistryKey sKey = null;            ///打开注册表项            sKey = key.OpenSubKey(subKey, writable);            ///关闭对注册表项的更改            key.Close();            ///返回注册表节点            return sKey;        }        ///  <summary>        ///  打开注册表项节点，以只读方式检索子项        ///  虚方法，子类可进行重写        ///  </summary>        ///  <param name="subKey">注册表项名称</param>        ///  <param name="regDomain">注册表基项域</param>        ///  <returns>如果 SubKey 为空、 null 或者 SubKey 指示注册表项不存在，则返回 null，否则返回注册表节点</returns>         protected virtual RegistryKey OpenSubKey(string subKey, RegDomain regDomain)        {            ///判断注册表项名称是否为空            if (subKey == string.Empty || subKey == null)            {                return null;            }            ///创建基于注册表基项的节点            RegistryKey key = GetRegDomain(regDomain);            ///要打开的注册表项的节点            RegistryKey sKey = null;            ///打开注册表项            sKey = key.OpenSubKey(subKey);            ///关闭对注册表项的更改            key.Close();            ///返回注册表节点            return sKey;        }        ///  <summary>        ///  打开注册表项节点        ///  虚方法，子类可进行重写        ///  </summary>        ///  <param name="subKey">注册表项名称</param>        ///  <param name="regDomain">注册表基项域</param>        ///  <param name="writable">如果需要项的写访问权限，则设置为true</param>        ///  <returns>如果 SubKey 为空、 null 或者 SubKey 指示注册表项不存在，则返回 null，否则返回注册表节点</returns>         protected virtual RegistryKey OpenSubKey(string subKey, RegDomain regDomain, bool writable)        {            ///判断注册表项名称是否为空            if (subKey == string.Empty || subKey == null)            {                return null;            }            ///创建基于注册表基项的节点            RegistryKey key = GetRegDomain(regDomain);            ///要打开的注册表项的节点            RegistryKey sKey = null;            ///打开注册表项            sKey = key.OpenSubKey(subKey, writable);            ///关闭对注册表项的更改            key.Close();            ///返回注册表节点            return sKey;        }        #endregion        #endregion    }}