C# 注册表操作类

using System;
using Microsoft.Win32;
using System.Collections.Generic;
using System.Text;
namespace Common
{
    /// <summary>
    /// 注册表操作类
    ///
    /// 主要包括以下操作：
    /// 1.创建注册表项
    /// 2.读取注册表项
    /// 3.判断注册表项是否存在
    /// 4.删除注册表项
    /// 5.创建注册表键值
    /// 6.读取注册表键值
    /// 7.判断注册表键值是否存在
    /// 8.删除注册表键值
    ///
    /// </summary>
    public class Register
    {
        #region 字段定义
        /// <summary>
        /// 注册表项名称
        /// </summary>
        private string _subkey;
        /// <summary>
        /// 注册表基项域
        /// </summary>
        private RegDomain _domain;
        /// <summary>
        /// 注册表键值
        /// </summary>
        private string _regeditkey;
        #endregion

        #region 属性
        /// <summary>
        /// 设置注册表项名称
        /// </summary>
        public string SubKey
        {
            //get { return _subkey; }
            set { _subkey = value; }
        }

        /// <summary>
        /// 注册表基项域
        /// </summary>
        public RegDomain Domain
        {
            ///get { return _domain; }
            set { _domain = value; }
        }

        /// <summary>
        /// 注册表键值
        /// </summary>
        public string RegeditKey
        {
            ///get{return _regeditkey;}
            set { _regeditkey = value; }
        }
        #endregion

        #region 构造函数
        public Register( )
        {
            ///默认注册表项名称
            _subkey = "software\\";
            ///默认注册表基项域
            _domain = RegDomain.LocalMachine;
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="subKey">注册表项名称</param>
        /// <param name="regDomain">注册表基项域</param>
        public Register( 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.DeleteSubKeyTree( _subkey);
                    //key.DeleteSubKey( _subkey );
                    result = true;
                }
                catch(Exception ex)
                {
                    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="content">默认键值内容</param>
        /// <returns>键值内容设置成功，则返回true，否则返回false</returns>
        public virtual bool WriteRegeditSetValue( object content )
        {
            ///返回结果
            bool result = false;

            ///判断注册表项是否存在，如果不存在，则直接创建
            if ( !IsSubKeyExist( _subkey ) )
            {
                CreateSubKey( _subkey );
            }

            ///以可写方式打开注册表项
            RegistryKey key = OpenSubKey( true );

            ///如果注册表项打开失败，则返回false
            if ( key == null )
            {
                return false;
            }

            try
            {
                key.SetValue( null , 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
    }

    /// <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主键
    ///
    /// </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=6 ,
    }

    /// <summary>
    /// 指定在注册表中存储值时所用的数据类型，或标识注册表中某个值的数据类型
    ///
    /// 主要包括：
    /// 1.RegistryValueKind.Unknown
    /// 2.RegistryValueKind.String
    /// 3.RegistryValueKind.ExpandString
    /// 4.RegistryValueKind.Binary
    /// 5.RegistryValueKind.DWord
    /// 6.RegistryValueKind.MultiString
    /// 7.RegistryValueKind.QWord
    ///
    /// </summary>
    public enum RegValueKind
    {
        /// <summary>
        /// 指示一个不受支持的注册表数据类型。例如，不支持 Microsoft Win32 API 注册表数据类型 REG_RESOURCE_LIST。使用此值指定
        /// </summary>
        Unknown=0 ,
        /// <summary>
        /// 指定一个以 Null 结尾的字符串。此值与 Win32 API 注册表数据类型 REG_SZ 等效。
        /// </summary>
        String=1 ,
        /// <summary>
        /// 指定一个以 NULL 结尾的字符串，该字符串中包含对环境变量（如 %PATH%，当值被检索时，就会展开）的未展开的引用。
        /// 此值与 Win32 API注册表数据类型 REG_EXPAND_SZ 等效。
        /// </summary>
        ExpandString=2 ,
        /// <summary>
        /// 指定任意格式的二进制数据。此值与 Win32 API 注册表数据类型 REG_BINARY 等效。
        /// </summary>
        Binary=3 ,
        /// <summary>
        /// 指定一个 32 位二进制数。此值与 Win32 API 注册表数据类型 REG_DWORD 等效。
        /// </summary>
        DWord=4 ,
        /// <summary>
        /// 指定一个以 NULL 结尾的字符串数组，以两个空字符结束。此值与 Win32 API 注册表数据类型 REG_MULTI_SZ 等效。
        /// </summary>
        MultiString=5 ,
        /// <summary>
        /// 指定一个 64 位二进制数。此值与 Win32 API 注册表数据类型 REG_QWORD 等效。
        /// </summary>
        QWord=6 ,
    }
}