c# 操作注册表

最新推荐文章于 2024-05-16 16:02:03 发布
最新推荐文章于 2024-05-16 16:02:03 发布
阅读量363 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/az44yao/article/details/103289511
版权 
using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Win32;
using System.Diagnostics;
namespace TestUpdater
{
    /*
    RegeditKey  键值属性
SubKey 目录
Domain 大目录

 CreateSubKey 创建注册表项（请先设置SubKey属性）
GetSubName  获得子项(目录)
GetSubValueName  获得子键(键值对的键)
IsSubKeyExist  判断注册表项是否存在（请先设置SubKey属性）
DeleteSubKey  删除注册表项
IsRegeditKeyExist 判断键值是否存在

WriteRegeditKey   设置指定的键值内容，指定内容数据类型（请先设置SubKey属性）

ReadRegeditKey  读取键值内容（请先设置RegeditKey和SubKey属性）

DeleteRegeditKey  删除键值

GetRegDomain  获取注册表基项域对应顶级节点

GetRegValueKind 获取在注册表中对应的值数据类型

OpenSubKey  打开注册表项节点，以只读方式检索子项

IsSameSubKey

GetNumber
     */
    /// <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>
        HKEY_CLASSES_ROOT = 0,
        /// <summary>
        /// 对应于HKEY_CURRENT_USER主键
        /// </summary>
        HKEY_CURRENT_USER = 1,
        /// <summary>
        /// 对应于 HKEY_LOCAL_MACHINE主键
        /// </summary>
        HKEY_LOCAL_MACHINE = 2,
        /// <summary>
        /// 对应于 HKEY_USER主键
        /// </summary>
        HKEY_USER = 3,
        /// <summary>
        /// 对应于HEKY_CURRENT_CONFIG主键
        /// </summary>
        HEKY_CURRENT_CONFIG = 4,
        /// <summary>
        /// 对应于HKEY_DYN_DATA主键
        /// </summary>
        HKEY_DYN_DATA = 5,
        /// <summary>
        /// 对应于HKEY_PERFORMANCE_DATA主键
        /// </summary>
        HKEY_PERFORMANCE_DATA = 6,
    }
    //2.指定在注册表中存储值时所用的数据类型，或标识注册表中某个值的数据类型
    /// <summary>
    /// 指定在注册表中存储值时所用的数据类型，或标识注册表中某个值的数据类型
    /// 
    /// 主要包括：
    /// 1.RegistryValueKind.Unknown
    /// 2.RegistryValueKind.String
    /// 3.RegistryValueKind.ExpandString
    /// 4.RegistryValueKind.Binary
    /// 5.RegistryValueKind.DWord
    /// 6.RegistryValueKind.MultiString
    /// 7.RegistryValueKind.QWord
    /// 
    /// 版本:1.0
    /// </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,
    }
    public struct RegisterItem
    {
        public RegDomain Domain;
        public string Subkey;
        public string ValueKey;
        public string RealValue;//实际值
        public string ExpectedValue;//期望值
        public RegValueKind ValueKind;
        public string InnerCode;
        public string ExcelVer;
        public RegisterItem(RegDomain _domain, string _subKey, string _valueKey
        , string _realValue, string _expectedValue, RegValueKind _kind, string _innerCode)
        {
            Domain = _domain;
            Subkey = _subKey;
            ValueKey = _valueKey;
            RealValue = _realValue;
            ExpectedValue = _expectedValue;
            ValueKind = _kind;
            InnerCode = _innerCode;
            ExcelVer = string.Empty;
        }
        public RegisterItem Copy()
        {
            RegisterItem item = new RegisterItem();
            item.Domain = Domain;
            item.Subkey = Subkey;
            item.ValueKey = ValueKey;
            item.RealValue = RealValue;
            item.ExpectedValue = ExpectedValue;
            item.ValueKind = ValueKind;
            item.InnerCode = InnerCode;
            return item;
        }
    }
    // 3.注册表操作类
    /// <summary>
    /// 注册表操作类
    /// 
    /// 主要包括以下操作：
    /// 1.创建注册表项
    /// 2.读取注册表项
    /// 3.判断注册表项是否存在
    /// 4.删除注册表项
    /// 5.创建注册表键值
    /// 6.读取注册表键值
    /// 7.判断注册表键值是否存在
    /// 8.删除注册表键值
    /// 
    /// 版本:1.0
    /// </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.HKEY_CURRENT_USER;
        }
        /// <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
        public virtual string[] GetSubName(string subKey)
        {
            RegistryKey key = GetRegDomain(_domain);
            if (string.IsNullOrEmpty(subKey))
            {
                return key.GetSubKeyNames();
            }
            RegistryKey sKey = key.OpenSubKey(subKey);
            if (sKey == null)
            {
                return null;
            }
            return sKey.GetSubKeyNames();
        }
        /// <summary>
        /// 获得子键的名字
        /// </summary>
        /// <param name="subKey"></param>
        /// <returns></returns>
        public virtual string[] GetSubValueName(string subKey)
        {
            ///判断注册表项名称是否为空，如果为空，返回false
            if (subKey == string.Empty || subKey == null)
            {
                return null;
            }
            ///检索注册表子项
            ///如果sKey为null,说明没有该注册表项不存在，否则存在
            RegistryKey sKey = OpenSubKey(subKey);
            if (sKey == null)
            {
                return null;
            }
            return sKey.GetValueNames();
        }
        #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 result;
            }
            ///创建基于注册表基项的节点
            RegistryKey key = GetRegDomain(_domain);
            //if (IsSubKeyExist())
            //{
            try
            {
                if (key.OpenSubKey(subKey) == null)
                {
                    result = true;
                }
                else
                {
                    key.DeleteSubKeyTree(subKey);
                    if (key.OpenSubKey(subKey) == null)
                    {
                        result = true;
                    }
                }
            }
            catch (Exception ex)
            {
                LogManager.LogInstance.WriteLog(ex.Message);
                LogManager.LogInstance.WriteLog(ex.StackTrace);
                result = false;
            }
            //}
            ///关闭对注册表项的更改
            key.Close();
            Debug.WriteLine(result);
            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 (Exception ex)
                {
                    LogManager.LogInstance.WriteLog(ex.Message);
                    LogManager.LogInstance.WriteLog(ex.StackTrace);
                    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)
            {
                name = "";
            }
            ///判断注册表项是否存在
            //if (IsSubKeyExist())
            //{
            ///打开注册表项
            RegistryKey key = OpenSubKey();
            ///键值集合
            string[] regeditKeyNames;
            ///获取键值集合
            regeditKeyNames = key.GetValueNames();
            ///遍历键值集合，如果存在键值，则退出遍历
            foreach (string regeditKey in regeditKeyNames)
            {
                if (regeditKey.StartsWith(name))
                {
                    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)
            {
                name = "";
            }
            ///判断注册表项是否存在，如果不存在，则直接创建
            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)
            {
                name = "";
            }
            ///判断键值是否存在
            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 (Exception ex)
                    {
                        LogManager.LogInstance.WriteLog(ex.Message);
                        LogManager.LogInstance.WriteLog(ex.StackTrace);
                        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
                    {
                        ///删除键值
                        ///
                        //Log.WriteLine(_subkey + "\\" + name);
                        key.DeleteValue(name);
                        result = true;
                    }
                    catch (Exception ex)
                    {
                        LogManager.LogInstance.WriteLog(ex.Message);
                        LogManager.LogInstance.WriteLog(ex.StackTrace);
                        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 (Exception ex)
                    {
                        LogManager.LogInstance.WriteLog(ex.Message);
                        LogManager.LogInstance.WriteLog(ex.StackTrace);
                        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 (Exception ex)
                    {
                        LogManager.LogInstance.WriteLog(ex.Message);
                        LogManager.LogInstance.WriteLog(ex.StackTrace);
                        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.HKEY_CLASSES_ROOT:
                    key = Registry.ClassesRoot; break;
                case RegDomain.HKEY_CURRENT_USER:
                    key = Registry.CurrentUser; break;
                case RegDomain.HKEY_LOCAL_MACHINE:
                    key = Registry.LocalMachine; break;
                case RegDomain.HKEY_USER:
                    key = Registry.Users; break;
                case RegDomain.HEKY_CURRENT_CONFIG:
                    key = Registry.CurrentConfig; break;
                case RegDomain.HKEY_DYN_DATA:
                    key = Registry.DynData; break;
                case RegDomain.HKEY_PERFORMANCE_DATA:
                    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
        public virtual bool IsSameSubKey(string name, string strvalue)
        {
            bool result = false;
            ///判断注册表项名称是否为空，如果为空，返回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 (regeditKey.StartsWith(name))
                    {
                        object value = ReadRegeditKey(regeditKey);
                        if (value.ToString().Contains(strvalue))
                        {
                            result = true;
                            break;
                        }
                    }
                }
                ///关闭对注册表项的更改
                key.Close();
            }
            return result;
        }
        public virtual int GetNumber(string name)
        {
            int result = 0;
            ///判断注册表项名称是否为空，如果为空，返回false
            if (name == string.Empty || name == null)
            {
                return 0;
            }
            if (IsSubKeyExist())
            {
                ///打开注册表项
                RegistryKey key = OpenSubKey();
                ///键值集合
                string[] regeditKeyNames;
                ///获取键值集合
                regeditKeyNames = key.GetValueNames();
                ///遍历键值集合，如果存在键值，则退出遍历
                foreach (string regeditKey in regeditKeyNames)
                {
                    if (regeditKey.StartsWith(name))
                    {
                        result++;
                    }
                }
                ///关闭对注册表项的更改
                key.Close();
            }
            return result;
        }
    }
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;

namespace TestUpdater
{
    /// <summary>
    /// 日志管理
    /// </summary>
    public class LogManager
    {
        private string _logDir; // 日志文件存放目录

        private static LogManager m_LogInstance; // 静态单例对象
        // 静态构造函数
        static LogManager()
        {
            m_LogInstance = new LogManager();
        }
        // 私有构造函数（必备函数，不允许外部对该类进行实例化）
        private LogManager()
        {
            _logDir = Environment.CurrentDirectory + "\\Log";
            this.DelOldFile();
        }
        /// <summary>
        /// 属性获取单例对象
        /// </summary>
        public static LogManager LogInstance
        {
            get { return m_LogInstance; }
        }

        /// <summary>
        /// 写入一条日志记录
        /// </summary>
        /// <param name="pLog">日志记录内容</param>
        public void WriteLog(string pLog)
        {
            lock (this._logDir) //排它锁：防止主程序中出现多线程同时访问同一个文件出错
            {
                // 根据时间创建一个日志文件
                var vDT = DateTime.Now;
                string vLogFile = string.Format("{0}\\Log{1}{2}{3}.log", _logDir, vDT.Year, vDT.Month, vDT.Day);
                // 创建文件流，用于写入
                using (FileStream fs = new FileStream(vLogFile, FileMode.Append))
                {
                    StreamWriter sw = new StreamWriter(fs);
                    sw.WriteLine("{0}  >>  {1}", vDT.ToString("yyyy-MM-dd HH:mm:ss"), pLog);
                    sw.Flush();
                    sw.Close();
                    fs.Close();
                }
            }
        }

        // 删除过期文件
        private void DelOldFile()
        {
            // 遍历指定文件夹下所有子文件，将一定期限前的日志文件删除。
            if (!Directory.Exists(this._logDir))
            {
                // 如果文件夹目录不存在
                Directory.CreateDirectory(this._logDir);
                return;
            }

            var vFiles = (new DirectoryInfo(this._logDir)).GetFiles();
            for (int i = vFiles.Length - 1; i >= 0; i--)
            {
                // 指定条件，然后删除
                if (vFiles[i].Name.Contains("Log"))
                {
                    if ((DateTime.Now - vFiles[i].LastWriteTime).Days > 7)
                    {
                        vFiles[i].Delete();
                    }
                }
            }
        }

    } // end class
}

 

az44yao
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C#：注册表操作
zcc9618的博客
10-13 747
参考资料： https://blog.csdn.net/yal179/article/details/40402435 https://www.cnblogs.com/boby-/p/4724255.html   ****************************************************************** 界面：   代码： using...
【C#_注册表操作】
hy_ccp的博客
02-21 1129
注册表在软件开发中可以存储一些关键信息，这样就不会轻易被删除的，作用比较多,比如可以用它来做授权相关事宜等.
C# 系统应用之注册表使用详解
杨秀璋的专栏
05-11 9126
本文主要讲述C#如何使用注册表的信息，包括注册表的基本结构及使用方法。一方面讲述了注册表相关的基础知识,另一方面通过代码结合图片格式讲述简单运用注册表。创建注册表键、删除键、获取值、设置值等方法，并通过自己最近的研究讲述一些自己的体会。最后希望文章对大家有所帮助。
【C#】——注册表技术（三）
刘梦娇
06-30 439
创建和修改注册表信息1.创建注册表信息通过 RegistryKey 类的 CreateSubKey 方法和 SetValue 方法可以创建注册表信息（1）CreateSubKey 方法主要用于创建一个新子项或打开一个现有子项以进行写访问。public RegistryKey CreateSubKey（string subkey）subkey：要创建或打开的子项的名称或路径。返回值：Registry...
了解计算机注册表-通过C#代码实现注册表的操作
最新发布
weixin_41712594的博客
05-16 681
注册表是一种在Windows操作系统中用于存储配置信息和系统设置的关键组成部分。它是一个层次结构的数据库，包含了操作系统、硬件、用户和应用程序的配置信息。
C#操作注册表（通俗易懂、详尽）
mengxiangde的博客
11-18 7790
要访问注册表，可以使用Microsoft.Win32命名空间中的两个类Registry 和RegistryKey。RegistryKey实例表示一个注册表项，这个类的方法可以浏览子键、创建新键、读取或修改键中的值。换言之，该类可以完成对注册表项进行的所有操作(除了设置键的安全级别之外)。RegistryKey类可以用于完成对注册表的所有操作。Registry是不能实例化的一个类。它的作用只是提供表...
C#实现简单的木马程序（学习木马制作流程）
美奇软件开发工作室
09-19 4098
要实现木马服务的程序，需要实现以下几个功能： 后台的运行（隐藏技术） 控制码的接收与注册表的修改 一、先建立一个Windows窗体应用程序，为了方便隐藏，项目名称可使用与系统相近的名称（如svchost.exe等）。 1.将窗体属性"ShowInTaskbar"设为false,让它运行时不会在任务栏中显示。 2.将窗体属性"Windowstate"设为Mininized，这样窗体就可以隐藏运行了。 二、控制代码的接收，必须在服务程序运行开始时就启动，所以侦听线程必须在程序初始化中启动，所以放在窗体
C＃如何读取注册表中的注册信息
xinsuanwencun的专栏
03-21 1127
引用自：http://www.ltesting.net/html/29/n-17029.html一．初步认识注册表：　　单击"开始/运行"，在"打开"的后面填入"regedit"。就可以看到注册表的数据结构了。如下图。注：Regedit文件是微软公司提供给用户编辑注册表的一个工具。 　　在注册表中称为"主键"，据图可见，"主键"是有层次结构的。主键的下一级主键称为该主键的"子键"。每一个主键可以对拥有多个子键。如图所示，右边的这些值就是所谓的键值了。每一个主键或者子键都可以拥有多个键值。注册表是一个庞大的数
C#操作注册表信息
01-11
在IT领域，C#是一种...在这个压缩包文件`ConsoleClient`中，可能包含了一个使用上述方法实现的控制台应用程序示例，通过运行这个程序，你可以更直观地了解C#操作注册表的实际过程。建议结合源代码学习，以加深理解。
C#操作注册表
05-09
### C#操作注册表知识点详解 #### 一、注册表概述 在Windows操作系统中，注册表（Registry）是一个存储各种系统设置和应用程序设置的核心数据库。它由多个层级组成，每个层级被称为“键”（Key）。注册表对于系统来...
c#操作注册表
03-10
#### 三、使用C#操作注册表 .NET Framework在`Microsoft.Win32`命名空间中提供了两种类来操作注册表：`Registry`和`RegistryKey`。这两种类都是密封类，不能被继承。 1. **Registry类** `Registry`类提供了一...
C#操作注册表的方法详解
09-03
主要介绍了C#操作注册表的方法,结合实例形式较为详细的分析了C#针对注册表的创建、打开、读取、写入、修改、删除等技巧,需要的朋友可以参考下
C# 文件关联方式
chongxing01的专栏
09-03 772
/// <summary> /// 关联文件 /// </summary> /// <param name="_FilePathString">应用程序路径</param> /// <param name="p_FileTypeName">文件类型</param> private static void SaveReg(string _File...
操作注册表
weixin_30521161的博客
10-22 121
操作注册表 Registry.CurrentUser.CreateSubKey("Software\\Microsoft\\MyKey"); RegistryKey rk = Registry.CurrentUser.OpenSubKey("Software\\Microsoft\\MyKey", ...
C#写入注册表打印异常提示无法写入到注册表项
qq_38781075的博客
07-12 1866
报错的异常类： System.UnauthorizedAccessException: // Microsoft.Win32.RegistryKey 只读，因此无法写入；例如，项不是用写访问权限打开的。 或 - Microsoft.Win32.RegistryKey // 对象表示根级别节点，操作系统为 Windows Millennium Edition 或 Windows 98。 因为我打开注册表使用的OpenSubKey函数，这个函数对注册表没有写
C#注册表技术及操作
wenchm的博客
12-09 2521
注册表是一个庞大的数据库系统，它记录了用户安装在计算机上的软件、硬件信息和每一个程序的相互关系。注册表中存放着很多参数，直接控制着整个系统的启动、硬件驱动程序的装载以及应用程序的运行。由于Windows 10系统本身的安全性问题，使用C#操作注册表时，可能会提示无法操作相应的注册表项，这时只需要为提示的注册表项添加everyone用户的读写权限即可。一、注册表基础Windows注册表包含Windows安装、用户喜好以及已安装软件和设备的所有配置信息的核心存储库。1.Registry和类。
C# 操作注册表WindowsRegistry
08-15 132
using System; using System.Collections.Generic; using System.Linq; using System.Text; using Microsoft.Win32; namespace BugsBox.Application.Core { public class WindowsRegistry { ...
windows注册表结构
W.J.H.
07-30 1516
1．HKEY_CLASSES_ROOT     该主键用于管理文件系统，记录的是   Windows   操作系统中所有数据文件的信息，主要记录不同文件的文件名后缀和与之对应的应用程序。当用户双击一个文档时，系统可以通过这些信息启动相应的应用程序。      2．HKEY_CURRENT_USER     该主键用于管理当前用户的配置情况。在这个主键中我们可以查阅计算机中登录的用户信息、密码
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值