/// <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);
}
/// <summary>
/// 打开注册表项节点，以只读方式检索子项
/// 虚方法，子类可进行重写
/// </summary>
/// <param name="subKey">注册表项名称</param>
/// <param name="regDomain">注册表基项域</param>
/// <returns>如果 SubKey 为空、 null 或者 SubKey 指示注册表项不存在，则返回 null，否则返回注册表节点</returns>
protected virtual RegistryKey OpenSubKey(string subKey, RegDomain regDomain)
{
try
{
//判断注册表项名称是否为空
if (string.IsNullOrEmpty(subKey))
{
return(null);
}
//创建基于注册表基项的节点
RegistryKey key = GetRegDomain(regDomain);
//要打开的注册表项的节点
RegistryKey sKey = null;
//打开注册表项
sKey = key.OpenSubKey(subKey, RegistryKeyPermissionCheck.ReadWriteSubTree, RegistryRights.FullControl);
//关闭对注册表项的更改
key.Close();
//返回注册表节点
return(sKey);
}
catch (Exception e)
{
Log.Debug(e);
}
return(null);
}
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>
/// 读取键值内容
/// </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);
}
/// <summary>
/// 设置本节点的位置
/// </summary>
/// <param name="subKey">节点路径</param>
/// <param name="regDomain">所处的域</param>
public void SetNode(string subKey, RegDomain regDomain)
{
///设置注册表项名称
_subkey = subKey;
///设置注册表基项域
_domain = regDomain;
}
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;
}
/// <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)
{
try
{
//判断注册表项名称是否为空
if (string.IsNullOrEmpty(subKey))
{
return(null);
}
//创建基于注册表基项的节点
RegistryKey key = GetRegDomain(regDomain);
//要打开的注册表项的节点
RegistryKey sKey = null;
//打开注册表项
sKey = key.OpenSubKey(subKey, writable);
//关闭对注册表项的更改
key.Close();
//返回注册表节点
return(sKey);
}
catch (Exception e)
{
Log.Debug(e);
}
return(null);
}
/// <summary>
/// 删除注册表子项中某项目的值
/// </summary>
/// <param name="regDomain">注册表分类节点</param>
/// <param name="subKey">要创建或打开的子项的名称或路径</param>
/// <param name="strItemName">项目名称</param>
public void DeleteRigistryItemValue(RegDomain regDomain, string subKey, string strItemName)
{
RegistryKey registrySubKey = this.GetRegistrySubKey(regDomain, subKey, true);
registrySubKey.DeleteValue(strItemName);
registrySubKey.Close();
}
/// <summary>
/// 删除注册表的指定子项
/// </summary>
/// <param name="regDomain">注册表分类节点</param>
/// <param name="subKey">要创建或打开的子项的名称或路径</param>
public void DeleteRegistrySubKey(RegDomain regDomain, string subKey)
{
RegistryKey regDomainKey = this.GetRegDomainKey(regDomain);
regDomainKey.DeleteSubKey(subKey);
regDomainKey.Close();
}
/// <summary>
/// 根据枚举类型转换为对应的注册表键对象
/// </summary>
/// <param name="regDomain"></param>
/// <returns></returns>
public RegistryKey GetRegDomainKey(RegDomain regDomain)
{
RegistryKey result;
switch (regDomain)
{
case RegDomain.RegDomain_Root:
result = Registry.ClassesRoot;
break;
case RegDomain.RegDomain_CurrentUser:
result = Registry.CurrentUser;
break;
case RegDomain.RegDomain_LocalMachine:
result = Registry.LocalMachine;
break;
case RegDomain.RegDomain_Users:
result = Registry.Users;
break;
case RegDomain.RegDomain_Config:
result = Registry.CurrentConfig;
break;
case RegDomain.RegDomain_PerformanceData:
result = Registry.PerformanceData;
break;
default:
result = null;
break;
}
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);
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="subKey">注册表项名称</param>
/// <param name="regDomain">注册表基项域</param>
public RegisterEx(string subKey, RegDomain regDomain)
{
///设置注册表项名称Software\\ZLSoft或者Software\\\ZLSoft替换为Software\ZLSoft
_regPath = (subKey + @"\").Replace(@"\\", @"\").Replace(@"\\", @"\");
///设置注册表基项域
_regDomain = regDomain;
}
/// <summary>
/// 设置注册表子项中某项目的值
/// </summary>
/// <param name="regDomain">注册表分类节点</param>
/// <param name="subKey">要创建或打开的子项的名称或路径</param>
/// <param name="strItemName">项目名称</param>
/// <param name="value">项目值内容</param>
public void SetRigistryItemValue(RegDomain regDomain, string subKey, string strItemName, object value)
{
RegistryKey registryKey = this.GetRegistrySubKey(regDomain, subKey, true);
if (null == registryKey)
{
registryKey = this.CreateRegistrySubKey(regDomain, subKey);
}
registryKey.SetValue(strItemName, value);
registryKey.Close();
}
protected virtual RegistryKey OpenSubKey(string subKey, RegDomain regDomain, bool writable)
{
if (subKey == string.Empty || subKey == null)
{
return(null);
}
RegistryKey regDomain2 = this.GetRegDomain(regDomain);
RegistryKey result = regDomain2.OpenSubKey(subKey, writable);
regDomain2.Close();
return(result);
}
/// <summary>
/// 移除开机启动项
/// </summary>
/// <param name="name">名称</param>
/// <param name="isLocalMachine">注册表位置</param>
/// <returns></returns>
public static bool RemoveAutoStart(string name, bool isLocalMachine = false)
{
RegDomain domain = RegDomain.CurrentUser;
if (isLocalMachine)
{
domain = RegDomain.LocalMachine;
}
Register run = new Register(@"Software\Microsoft\Windows\CurrentVersion\Run", domain);
return(run.DeleteRegeditKey(name));
}
/// <summary>
/// 获取注册表子项中某个项目的值
/// </summary>
/// <param name="regDomain">注册表分类节点</param>
/// <param name="subKey">要创建或打开的子项的名称或路径</param>
/// <param name="strItemName">项目名称</param>
/// <returns></returns>
public object GetRigistryItemValue(RegDomain regDomain, string subKey, string strItemName)
{
RegistryKey registrySubKey = this.GetRegistrySubKey(regDomain, subKey, false);
object result;
if (null == registrySubKey)
{
result = null;
}
else
{
result = registrySubKey.GetValue(strItemName);
}
return result;
}
public virtual void CreateSubKey(string subKey, RegDomain regDomain)
{
if (subKey == string.Empty || subKey == null)
{
return;
}
RegistryKey regDomain2 = this.GetRegDomain(regDomain);
if (!this.IsSubKeyExist(subKey, regDomain))
{
regDomain2.CreateSubKey(subKey);
}
regDomain2.Close();
}
/// <summary>
/// 判断注册表子项的值是否包含某项目
/// </summary>
/// <param name="regDomain">注册表分类节点</param>
/// <param name="subKey">要创建或打开的子项的名称或路径</param>
/// <param name="strItemName">项目名称</param>
/// <returns></returns>
public bool IsRigistryItemExist(RegDomain regDomain, string subKey, string strItemName)
{
RegistryKey registrySubKey = this.GetRegistrySubKey(regDomain, subKey, false);
string[] valueNames = registrySubKey.GetValueNames();
bool result = false;
for (int i = 0; i < valueNames.Length; i++)
{
if (valueNames[i] == strItemName)
{
result = true;
break;
}
}
return result;
}
/// <summary>
/// 判断注册表项是否存在
/// 例子：如regDomain是HKEY_CLASSES_ROOT，
/// subkey是software\\CNKI\\，
/// 则将判断HKEY_CLASSES_ROOT\\software\\CNKI\\注册表项是否存在
/// </summary>
/// <param name="subKey">注册表项名称（例：software\\CNKI\\）</param>
/// <param name="regDomain">注册表基项域</param>
/// <returns>返回注册表项是否存在，存在返回true，否则返回false</returns>
/// <remarks>
/// 2014-02-27 add by yzq
/// </remarks>
public bool IsSubKeyExist(string subKey, RegDomain regDomain)
{
//判断注册表项名称是否为空，如果为空，返回false
if (string.IsNullOrEmpty(subKey))
{
return(false);
}
//检索注册表子项
//如果sKey为null,说明没有该注册表项不存在，否则存在
RegistryKey sKey = OpenSubKey(subKey, regDomain, false);
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);
}
public virtual object ReadRegeditKey(string name, string subKey, RegDomain regDomain)
{
object result = null;
if (name == string.Empty || name == null)
{
return(null);
}
if (this.IsRegeditKeyExist(name))
{
RegistryKey registryKey = this.OpenSubKey(subKey, regDomain);
if (registryKey != null)
{
result = registryKey.GetValue(name);
}
registryKey.Close();
}
return(result);
}
public virtual bool WriteRegeditKey(string name, string subkey, RegDomain domain, object content, RegValueKind regValueKind)
{
//返回结果
bool result = false;
//判断注册表项是否存在，如果不存在，则直接创建
if (!IsSubKeyExist(subkey, domain))
{
CreateSubKey(subkey, domain);
}
if (string.IsNullOrEmpty(name))
{
return(true);
}
//以可写方式打开注册表项
RegistryKey key = OpenSubKey(subkey, domain, true);
//如果注册表项打开失败，则返回 false
if (key == null)
{
return(false);
}
try
{
key.SetValue(name, content, GetRegValueKind(regValueKind));
result = true;
}
catch (Exception e)
{
Log.Debug(e);
result = false;
}
finally
{
//关闭对注册表项的更改
key.Close();
}
return(result);
}
/// <summary>
/// 设置指定的键值内容，指定内容数据类型（请先设置SubKey属性）
/// 存在改键值则修改键值内容，不存在键值则先创建键值，再设置键值内容
/// </summary>
/// <param name="subKey">注册表项名称（例：software\\CNKI\\）</param>
/// <param name="regDomain">注册表基项域</param>
/// <param name="name">键值名称</param>
/// <param name="content">键值内容</param>
/// <param name="errMsg">错误信息</param>
/// <returns>键值内容设置成功，则返回true，否则返回false</returns>
/// <remarks>
/// 2014-02-27 add by yzq
/// </remarks>
public bool WriteRegeditKey(string subKey, RegDomain regDomain, string name, object content, out string errMsg)
{
//返回结果
bool result = false;
errMsg = string.Empty;
//判断键值是否存在
//if (string.IsNullOrEmpty(name))
//{
// errMsg = "未找到指定的键值名称";
// return false;
//}
//判断注册表项是否存在，如果不存在，则直接创建
if (!IsSubKeyExist(subKey, regDomain))
{
CreateSubKey(subKey, regDomain);
}
//以可写方式打开注册表项
RegistryKey key = OpenSubKey(subKey, regDomain, true);
//如果注册表项打开失败，则返回false
if (key == null)
{
return(false);
}
try
{
key.SetValue(name, content);
result = true;
}
catch (Exception ex)
{
errMsg = "设置键值内容失败，错误信息：" + ex.Message;
result = false;
}
finally
{
//关闭对注册表项的更改
key.Close();
}
return(result);
}
/// <summary>
/// 检查是否有指定的开机启动项
/// </summary>
/// <returns></returns>
public static bool CheckAutoStart(string name, string runPath, bool isLocalMachine = false)
{
RegDomain domain = RegDomain.CurrentUser;
if (isLocalMachine)
{
domain = RegDomain.LocalMachine;
}
Register run = new Register(@"Software\Microsoft\Windows\CurrentVersion\Run", domain);
object value = run.ReadRegeditKey(name);
if (value == null)
{
return(false);
}
if (value.ToString() != runPath)
{
return(false);
}
return(true);
}
/// <summary>
/// 打开注册表项节点，以只读方式检索子项
/// 虚方法，子类可进行重写
/// </summary>
/// <param name="subKey">注册表项名称</param>
/// <param name="regDomain">注册表基项域</param>
/// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在，则返回null，否则返回注册表节点</returns>
public static 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>
/// 创建注册表项（请先设置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 (string.IsNullOrEmpty(subKey))
{
return;
}
//创建基于注册表基项的节点
RegistryKey key = GetRegDomain(regDomain);
//要创建的注册表项的节点
//RegistryKey sKey;
if (!IsSubKeyExist(subKey, regDomain))
{
key.CreateSubKey(subKey);
}
//sKey.Close();
//关闭对注册表项的更改
key.Close();
}
/// <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);
}
/// <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>
/// 删除键值
/// </summary>
/// <param name="name">键值名称</param>
/// <param name="subKey">注册表项名称</param>
/// <param name="regDomain">注册表基项域</param>
/// <param name="errMsg">错误信息</param>
/// <returns>如果删除成功，返回true，否则返回false</returns>
/// <remarks>
/// 2014-02-27 add by yzq
/// </remarks>
public bool DeleteRegeditKey(string name, string subKey, RegDomain regDomain, out string errMsg)
{
//删除结果
bool result = false;
errMsg = string.Empty;
//判断键值名称和注册表项名称是否为空，如果为空，则返回false
if (string.IsNullOrEmpty(name) || string.IsNullOrEmpty(subKey))
{
errMsg = "未找到指定键值名称";
return(false);
}
//判断键值是否存在
if (IsRegeditKeyExist(name, subKey, regDomain))
{
//以可写方式打开注册表项
RegistryKey key = OpenSubKey(subKey, regDomain, true);
if (key != null)
{
try
{
//删除键值
key.DeleteValue(name);
result = true;
}
catch (Exception ex)
{
errMsg = "删除键值失败,错误原因:" + ex.Message;
result = false;
}
finally
{
//关闭对注册表项的更改
key.Close();
}
}
}
return(result);
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="subKey">注册表项名称</param>
/// <param name="regDomain">注册表基项域</param>
public DMEWin_Register(string subKey, RegDomain regDomain)
{
///设置注册表项名称
_subkey = subKey;
///设置注册表基项域
_domain = regDomain;
}
public DMEWin_Register()
{
///默认注册表项名称
_subkey = "software\\";
///默认注册表基项域
_domain = RegDomain.LocalMachine;
}
/// <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;
}
/// <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;
}
public RegistryBase()
{
///默认注册表项名称
_subkey = "software\\";
///默认注册表基项域
_domain = RegDomain.LocalMachine;
}
/// <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();
}
/// <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;
}
/// <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;
}
/// <summary>
/// 检索与指定名称关联的值。如果注册表中不存在名称/值对，则返回 null。
/// </summary>
/// <param name="name">要检索的值的名称。</param>
/// <param name="subkey">子项的名称或路径。</param>
/// <param name="regDomain">注册表基项</param>
/// <returns>与 name 关联的值；如果未找到 name，则为 null。</returns>
public static object GetValue(string name, string subkey, RegDomain regDomain)
{
object value = null;
var sub = GetSubKey(subkey, false, regDomain);
if (sub != null)
{
value = sub.GetValue(name);
sub.Close();
}
return value;
}
/// <summary>
/// 使用指定的注册表数据类型设置注册表项中的名称/值对的值。
/// </summary>
/// <param name="name">要存储的值的名称。</param>
/// <param name="value">要存储的数据。</param>
/// <param name="subkey">子项的名称或路径。</param>
/// <param name="regDomain">注册表基项</param>
/// <param name="regValueKind">在存储数据时使用的注册表数据类型。</param>
public static void SetValue(string name, object value, string subkey, RegDomain regDomain, RegValueKind regValueKind)
{
var sub = GetSubKey(subkey, true, regDomain);
if (sub != null)
{
sub.SetValue(name, value, GetRegValueKind(regValueKind));
sub.Close();
}
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="subKey">注册表项名称</param>
/// <param name="regDomain">注册表基项域</param>
public RegisterUtil(string subKey, RegDomain regDomain)
{
///设置注册表项名称
_subkey = subKey;
///设置注册表基项域
_domain = regDomain;
}
/// <summary>
/// 检索指定的子项。
/// </summary>
/// <param name="subkey">要打开的子项的名称或路径。</param>
/// <param name="writable">如果需要项的写访问权限，则设置为 true。</param>
/// <param name="regDomain">注册表基项</param>
/// <returns>请求的子项；如果操作失败，则为 null。</returns>
private static RegistryKey GetSubKey(string subkey, bool writable, RegDomain regDomain)
{
var rootReg = GetRegDomain(regDomain);
return rootReg.OpenSubKey(subkey, writable);
}
/// <summary>
/// 获取注册表基项域对应顶级节点
/// </summary>
/// <param name="regDomain">注册表基项域</param>
/// <returns>注册表基项域对应顶级节点</returns>
static RegistryKey GetRegDomain(RegDomain regDomain)
{
switch (regDomain)
{
case RegDomain.ClassesRoot:
return Registry.ClassesRoot;
case RegDomain.CurrentUser:
return Registry.CurrentUser;
case RegDomain.LocalMachine:
return Registry.LocalMachine;
case RegDomain.User:
return Registry.Users;
case RegDomain.CurrentConfig:
return Registry.CurrentConfig;
case RegDomain.DynDa:
return Registry.PerformanceData;
case RegDomain.PerformanceData:
return Registry.PerformanceData;
default:
return Registry.LocalMachine;
}
}
/// <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;
}
/// <summary>
/// 创建新子项。字符串 subkey 不区分大小写。
/// </summary>
/// <param name="subkey">子项的名称或路径</param>
/// <param name="regDomain">注册表基项</param>
/// <exception cref="System.ArgumentNullException">subkey 为 null。</exception>
/// <remarks>
/// 例如:
/// subkey="Software\XCISoft",regDomain="RegDomain.LocalMachine"
/// 将创建HKEY_LOCAL_MACHINE\Software\XCISoft注册表项
/// </remarks>
public static void CreateSubKey(string subkey, RegDomain regDomain)
{
if (string.IsNullOrEmpty(subkey)) throw new System.ArgumentNullException("subkey");
var rootReg = GetRegDomain(regDomain);
var reg = rootReg.CreateSubKey(subkey);
if (reg != null)
{
reg.Close();
}
rootReg.Close();
}
/// <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;
}
/// <summary>
/// 递归删除子项和任何子级子项。字符串 subkey 不区分大小写。
/// </summary>
/// <param name="subkey">子项的名称或路径</param>
/// <param name="regDomain">注册表基项</param>
/// <exception cref="System.ArgumentNullException">subkey 为 null。</exception>
public static void DeleteSubKeyTree(string subkey, RegDomain regDomain)
{
if (string.IsNullOrEmpty(subkey)) throw new System.ArgumentNullException("subkey");
var rootReg = GetRegDomain(regDomain);
rootReg.DeleteSubKeyTree(subkey);
rootReg.Close();
}
/// <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;
}
/// <summary>
/// 从此项中删除指定值。
/// </summary>
/// <param name="name">要删除的值的名称。</param>
/// <param name="subkey">子项的名称或路径。</param>
/// <param name="regDomain">注册表基项</param>
public static void DeleteValue(string name, string subkey, RegDomain regDomain)
{
var sub = GetSubKey(subkey, true, regDomain);
if (sub != null)
{
sub.DeleteValue(name,false);
sub.Close();
}
}
