`
zxlyecf2
  • 浏览: 128983 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

C#注册表读写完整操作类

    博客分类:
  • C#
阅读更多

1.注册表基项静态域

/// <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
    }

 2.指定在注册表中存储值时所用的数据类型,或标识注册表中某个值的数据类型

 /// <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 Win API 注册表数据类型 REG_RESOURCE_LIST。使用此值指定
        /// </summary>
        Unknown = 0,
        /// <summary>
        /// 指定一个以 Null 结尾的字符串。此值与 Win API 注册表数据类型 REG_SZ 等效。
        /// </summary>
        String = 1,
        /// <summary>
        /// 指定一个以 NULL 结尾的字符串,该字符串中包含对环境变量(如 %PATH%,当值被检索时,就会展开)的未展开的引用。
        /// 此值与 Win API 注册表数据类型 REG_EXPAND_SZ 等效。
        /// </summary>
        ExpandString = 2,
        /// <summary>
        /// 指定任意格式的二进制数据。此值与 Win API 注册表数据类型 REG_BINARY 等效。
        /// </summary>
        Binary = 3,
        /// <summary>
        /// 指定一个  位二进制数。此值与 Win API 注册表数据类型 REG_DWORD 等效。
        /// </summary>
        DWord = 4,
        /// <summary>
        /// 指定一个以 NULL 结尾的字符串数组,以两个空字符结束。此值与 WinAPI 注册表数据类型 REG_MULTI_SZ 等效。
        /// </summary>
        MultiString = 5,
        /// <summary>
        /// 指定一个  位二进制数。此值与 Win API 注册表数据类型 REG_QWORD 等效。
        /// </summary>
        QWord = 6
    }

 3.注册表操作类

/// <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()
        {

        }

        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.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 属性)
        /// 虚方法,子类可进行重写
        /// .如果RegeditKey 为空、null,则返回false
        /// .如果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 属性)
        /// .如果RegeditKey 为空、null 或者RegeditKey 指示的键值不存在,返回null
        /// .如果SubKey 为空、null 或者SubKey 指示的注册表项不存在,返回null
        /// .反之,则返回键值内容
        /// </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 属性)
        /// .如果SubKey 为空、null 或者SubKey 指示的注册表项不存在,返回null
        /// .反之,则返回键值内容
        /// </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 属性)
        /// .如果RegeditKey 为空、null 或者RegeditKey 指示的键值不存在,返回false
        /// .如果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
    }

 

3
3
分享到:
评论
1 楼 方学天 2017-06-27  
64位的注册表不能用

相关推荐

    C#演示注册表的读写操作

    C#演示注册表的读写操作,程序中引入了using Microsoft.Win32; 主要是对注册表的操作要用到Registry和RegistryKey两个类,写入注册表:以可写的方式打开SOFTWARE子键,依次创建ChoseColor子键和Color子键。读取...

    注册表操作类C#源码

    C#语言, 可对WINDOWS注册表进行读写修改等操作。

    C#读写注册表的思路及代码

    NET框架在Microsoft.Win32名字空间中提供了两个类来操作注册表:Registry和RegistryKey。这两个类都是密封类不允许被继承。下面我们分别来介绍这两个类。Registry类提供了7个公共的静态域,分别代表7个基本主键...

    C# winform注册表操作

    该程序是将注册表的写入、读取、删除、判断是否存在4个操作统一写到一个类中,并对每一个操作定义了一个返回值作为操作的成功与否的标志符,从能可以让编程人员了解操作的结果。

    文件和注册表操作(C#源码)

    FileProperties:展示文件的详细信息或者文件夹中的文件和文件夹的信息(故包含了如何获取文件信息、如何获取文件夹信息、文件夹中的文件和目录)。...SelfPlacingWindow:有关于读写独立存储器、注册表等相关实现

    超级多的C#辅助类大全

    70. 注册表操作类 71. 科学计数,数学 72. 类型转换 73. 系统操作相关的公共类 74. 缓存 75. 网站安全 76. 网站路径操作类 77. 网络 78. 视频帮助类 79. 视频转换类 80. 计划任务 81. 邮件 82. 邮件2 ...

    c#常用的42个类

    IE浏览器注册表操作 IE设置代理 int转ip Post、Get stmp邮件 string生成图片 s扫描器调用 txt操作 wenjian win7判断管理员身份 加密解密 图像二值化 图片匹配坐标 声音识别 奇虎发布信息 字符串操作2 字符串检查 ...

    C#超经典源码大集

    C#ie实现自动下载示例、C#Socket基本编程、C# WinForm制作异形窗体与控件、C# 编写定时关机程序、C#对注册表的操作、C# 简单文本文件读写、C# 控制远程计算机的服务的方法、C# 木马寄存方式收集、C#实现通过程序自动...

    C#全能速查宝典

    分别介绍了C#语言基础、Windows窗体及常用控件、Windows高级控件、控件公共属性、方法及事件、数据库开发、文件、数据流与注册表、GDI+绘图技术和C#高级编程,共包含562个C#编程中常用的属性、方法、类和各种技术,...

    Visual C# 2010程序设计教程PPT

    Visual C# 2010程序设计...第13章 文件与注册表编程 目录操作 文件管理 读写文件 第14章 语言集成查询-LINQ LINQ实现基础 LINQ概述 LINQ和泛型 LINQ查询步骤 LINQ查询语句 LINQ和数据库操作

    C#读写INI文件的方法

    本文实例讲述了C#读写INI文件的方法。...VC中提供了API函数进行INI文件的读写操作,但是微软推出的C#编程语言中却没有相应的方法,下面是一个C# ini文件读写类,从网上收集的,很全,就是没有对sectio

    Helper Master

    Public class ExcelHelper Excel操作类 Public class FileDEncrypt 文件加解密帮助类 Public class FileDownHelper 文件下载帮助类 Public class FileHelper 文件操作帮助类 Public class FileUpHelper 文件上传...

    Visual.C#.编程精彩百例

    第1篇 Visual C#基础编程实例 实例1 C#经典程序--Hello World 实例2 C#的简单输入输出(I/O) 实例3 C#的复杂输入输出(I/O) 实例4 通信录管理与维护 实例5 文件与目录管理 实例6 用户界面上的“Hello,World...

    Visual C# 2005程序设计自学手册 随书源码第一部分(共三部)

    17.2 读写注册表 379 17.2.1 读取注册表信息 380 17.2.2 向注册表中写入信息 382 17.3 注册表应用 384 17.3.1 将软件使用次数写入注册表 384 17.3.2 通过注册表优化系统 385 17.4 本章小结 386 第18...

    C#开发典型模块大全

    20.2.2 文件的读写操作 513 20.2.3 如何获取两个日期的月份差 515 20.2.4 获取两个日期的相差天数 516 20.2.5 载取字符串中的指定字符 516 20.3 设计过程 517 20.3.1 获取加密字符串的信息 517 20.3.2 ...

    《Visual.C#.编程精彩百例》配套光盘part1

    实例64 有趣的列表框窗体 实例65 数学函数应用 &lt;br&gt;第3篇 Visual C#高级编程实例 实例66 文件夹中的文件列表 实例67 读写文本文件 实例68 读写二进制文件 实例69 显示系统日期与时间(1...

Global site tag (gtag.js) - Google Analytics