c#注册表操作类分享

/// <summary>
/// 注册表基项静态域
///
/// 主要包括：
/// 1.registry.classesroot 对应于hkey_classes_root主键
/// 2.registry.currentuser 对应于hkey_current_user主键
/// 3.registry.localmachine 对应于 hkey_local_machine主键
/// 4.registry.user 对应于 hkey_user主键
/// 5.registry.currentconfig 对应于heky_current_config主键
/// 6.registry.dynda 对应于hkey_dyn_data主键
/// 7.registry.performancedata 对应于hkey_performance_data主键
///
/// 版本:1.0
/// </summary>
public enum regdomain
{
/// <summary>
/// 对应于hkey_classes_root主键
/// </summary>
classesroot = 0,
/// <summary>
/// 对应于hkey_current_user主键
/// </summary>
currentuser = 1,
/// <summary>
/// 对应于 hkey_local_machine主键
/// </summary>
localmachine = 2,
/// <summary>
/// 对应于 hkey_user主键
/// </summary>
user = 3,
/// <summary>
/// 对应于heky_current_config主键
/// </summary>
currentconfig = 4,
/// <summary>
/// 对应于hkey_dyn_data主键
/// </summary>
dynda = 5,
/// <summary>
/// 对应于hkey_performance_data主键
/// </summary>
performancedata = 6,
}

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

/// <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.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属性）
/// 虚方法，子类可进行重写
/// 1.如果regeditkey为空、null，则返回false
/// 2.如果subkey为空、null或者subkey指定的注册表项不存在，返回false
/// </summary>
/// <returns>返回键值是否存在，存在返回true，否则返回false</returns>
public virtual bool isregeditkeyexist()
{
///返回结果
bool result = false;
///判断是否设置键值属性
if (_regeditkey == string.empty || _regeditkey == null)
{
return false;
}
///判断注册表项是否存在
if (issubkeyexist())
{
///打开注册表项
registrykey key = opensubkey();
///键值集合
string[] regeditkeynames;
///获取键值集合
regeditkeynames = key.getvaluenames();
///遍历键值集合，如果存在键值，则退出遍历
foreach (string regeditkey in regeditkeynames)
{
if (string.compare(regeditkey, _regeditkey, true) == 0)
{
result = true;
break;
}
}
///关闭对注册表项的更改
key.close();
}
return result;
}
/// <summary>
/// 判断键值是否存在（请先设置subkey属性）
/// 虚方法，子类可进行重写
/// 如果subkey为空、null或者subkey指定的注册表项不存在，返回false
/// </summary>
/// <param name="name">键值名称</param>
/// <returns>返回键值是否存在，存在返回true，否则返回false</returns>
public virtual bool isregeditkeyexist(string name)
{
///返回结果
bool result = false;
///判断是否设置键值属性
if (name == string.empty || name == null)
{
return false;
}
///判断注册表项是否存在
if (issubkeyexist())
{
///打开注册表项
registrykey key = opensubkey();
///键值集合
string[] regeditkeynames;
///获取键值集合
regeditkeynames = key.getvaluenames();
///遍历键值集合，如果存在键值，则退出遍历
foreach (string regeditkey in regeditkeynames)
{
if (string.compare(regeditkey, name, true) == 0)
{
result = true;
break;
}
}
///关闭对注册表项的更改
key.close();
}
return result;
}
/// <summary>
/// 判断键值是否存在
/// 虚方法，子类可进行重写
/// </summary>
/// <param name="name">键值名称</param>
/// <param name="subkey">注册表项名称</param>
/// <returns>返回键值是否存在，存在返回true，否则返回false</returns>
public virtual bool isregeditkeyexist(string name, string subkey)
{
///返回结果
bool result = false;
///判断是否设置键值属性
if (name == string.empty || name == null)
{
return false;
}
///判断注册表项是否存在
if (issubkeyexist())
{
///打开注册表项
registrykey key = opensubkey(subkey);
///键值集合
string[] regeditkeynames;
///获取键值集合
regeditkeynames = key.getvaluenames();
///遍历键值集合，如果存在键值，则退出遍历
foreach (string regeditkey in regeditkeynames)
{
if (string.compare(regeditkey, name, true) == 0)
{
result = true;
break;
}
}
///关闭对注册表项的更改
key.close();
}
return result;
}
/// <summary>
/// 判断键值是否存在
/// 虚方法，子类可进行重写
/// </summary>
/// <param name="name">键值名称</param>
/// <param name="subkey">注册表项名称</param>
/// <param name="regdomain">注册表基项域</param>
/// <returns>返回键值是否存在，存在返回true，否则返回false</returns>
public virtual bool isregeditkeyexist(string name, string subkey, regdomain regdomain)
{
///返回结果
bool result = false;
///判断是否设置键值属性
if (name == string.empty || name == null)
{
return false;
}
///判断注册表项是否存在
if (issubkeyexist())
{
///打开注册表项
registrykey key = opensubkey(subkey, regdomain);
///键值集合
string[] regeditkeynames;
///获取键值集合
regeditkeynames = key.getvaluenames();
///遍历键值集合，如果存在键值，则退出遍历
foreach (string regeditkey in regeditkeynames)
{
if (string.compare(regeditkey, name, true) == 0)
{
result = true;
break;
}
}
///关闭对注册表项的更改
key.close();
}
return result;
}
#endregion
#region 设置键值内容
/// <summary>
/// 设置指定的键值内容，不指定内容数据类型（请先设置regeditkey和subkey属性）
/// 存在改键值则修改键值内容，不存在键值则先创建键值，再设置键值内容
/// </summary>
/// <param name="content">键值内容</param>
/// <returns>键值内容设置成功，则返回true，否则返回false</returns>
public virtual bool writeregeditkey(object content)
{
///返回结果
bool result = false;
///判断是否设置键值属性
if (_regeditkey == string.empty || _regeditkey == null)
{
return false;
}
///判断注册表项是否存在，如果不存在，则直接创建
if (!issubkeyexist(_subkey))
{
createsubkey(_subkey);
}
///以可写方式打开注册表项
registrykey key = opensubkey(true);
///如果注册表项打开失败，则返回false
if (key == null)
{
return false;
}
try
{
key.setvalue(_regeditkey, content);
result = true;
}
catch
{
result = false;
}
finally
{
///关闭对注册表项的更改
key.close();
}
return result;
}
/// <summary>
/// 设置指定的键值内容，不指定内容数据类型（请先设置subkey属性）
/// 存在改键值则修改键值内容，不存在键值则先创建键值，再设置键值内容
/// </summary>
/// <param name="name">键值名称</param>
/// <param name="content">键值内容</param>
/// <returns>键值内容设置成功，则返回true，否则返回false</returns>
public virtual bool writeregeditkey(string name, object content)
{
///返回结果
bool result = false;
///判断键值是否存在
if (name == string.empty || name == null)
{
return false;
}
///判断注册表项是否存在，如果不存在，则直接创建
if (!issubkeyexist(_subkey))
{
createsubkey(_subkey);
}
///以可写方式打开注册表项
registrykey key = opensubkey(true);
///如果注册表项打开失败，则返回false
if (key == null)
{
return false;
}
try
{
key.setvalue(name, content);
result = true;
}
catch
{
result = false;
}
finally
{
///关闭对注册表项的更改
key.close();
}
return result;
}
/// <summary>
/// 设置指定的键值内容，指定内容数据类型（请先设置subkey属性）
/// 存在改键值则修改键值内容，不存在键值则先创建键值，再设置键值内容
/// </summary>
/// <param name="name">键值名称</param>
/// <param name="content">键值内容</param>
/// <returns>键值内容设置成功，则返回true，否则返回false</returns>
public virtual bool writeregeditkey(string name, object content, regvaluekind regvaluekind)
{
///返回结果
bool result = false;
///判断键值是否存在
if (name == string.empty || name == null)
{
return false;
}
///判断注册表项是否存在，如果不存在，则直接创建
if (!issubkeyexist(_subkey))
{
createsubkey(_subkey);
}
///以可写方式打开注册表项
registrykey key = opensubkey(true);
///如果注册表项打开失败，则返回false
if (key == null)
{
return false;
}
try
{
key.setvalue(name, content, getregvaluekind(regvaluekind));
result = true;
}
catch
{
result = false;
}
finally
{
///关闭对注册表项的更改
key.close();
}
return result;
}
#endregion
#region 读取键值内容
/// <summary>
/// 读取键值内容（请先设置regeditkey和subkey属性）
/// 1.如果regeditkey为空、null或者regeditkey指示的键值不存在，返回null
/// 2.如果subkey为空、null或者subkey指示的注册表项不存在，返回null
/// 3.反之，则返回键值内容
/// </summary>
/// <returns>返回键值内容</returns>
public virtual object readregeditkey()
{
///键值内容结果
object obj = null;
///判断是否设置键值属性
if (_regeditkey == string.empty || _regeditkey == null)
{
return null;
}
///判断键值是否存在
if (isregeditkeyexist(_regeditkey))
{
///打开注册表项
registrykey key = opensubkey();
if (key != null)
{
obj = key.getvalue(_regeditkey);
}
///关闭对注册表项的更改
key.close();
}
return obj;
}
/// <summary>
/// 读取键值内容（请先设置subkey属性）
/// 1.如果subkey为空、null或者subkey指示的注册表项不存在，返回null
/// 2.反之，则返回键值内容
/// </summary>
/// <param name="name">键值名称</param>
/// <returns>返回键值内容</returns>
public virtual object readregeditkey(string name)
{
///键值内容结果
object obj = null;
///判断是否设置键值属性
if (name == string.empty || name == null)
{
return null;
}
///判断键值是否存在
if (isregeditkeyexist(name))
{
///打开注册表项
registrykey key = opensubkey();
if (key != null)
{
obj = key.getvalue(name);
}
///关闭对注册表项的更改
key.close();
}
return obj;
}
/// <summary>
/// 读取键值内容
/// </summary>
/// <param name="name">键值名称</param>
/// <param name="subkey">注册表项名称</param>
/// <returns>返回键值内容</returns>
public virtual object readregeditkey(string name, string subkey)
{
///键值内容结果
object obj = null;
///判断是否设置键值属性
if (name == string.empty || name == null)
{
return null;
}
///判断键值是否存在
if (isregeditkeyexist(name))
{
///打开注册表项
registrykey key = opensubkey(subkey);
if (key != null)
{
obj = key.getvalue(name);
}
///关闭对注册表项的更改
key.close();
}
return obj;
}
/// <summary>
/// 读取键值内容
/// </summary>
/// <param name="name">键值名称</param>
/// <param name="subkey">注册表项名称</param>
/// <param name="regdomain">注册表基项域</param>
/// <returns>返回键值内容</returns>
public virtual object readregeditkey(string name, string subkey, regdomain regdomain)
{
///键值内容结果
object obj = null;
///判断是否设置键值属性
if (name == string.empty || name == null)
{
return null;
}
///判断键值是否存在
if (isregeditkeyexist(name))
{
///打开注册表项
registrykey key = opensubkey(subkey, regdomain);
if (key != null)
{
obj = key.getvalue(name);
}
///关闭对注册表项的更改
key.close();
}
return obj;
}
#endregion
#region 删除键值
/// <summary>
/// 删除键值（请先设置regeditkey和subkey属性）
/// 1.如果regeditkey为空、null或者regeditkey指示的键值不存在，返回false
/// 2.如果subkey为空、null或者subkey指示的注册表项不存在，返回false
/// </summary>
/// <returns>如果删除成功，返回true，否则返回false</returns>
public virtual bool deleteregeditkey()
{
///删除结果
bool result = false;
///判断是否设置键值属性，如果没有设置，则返回false
if (_regeditkey == string.empty || _regeditkey == null)
{
return false;
}
///判断键值是否存在
if (isregeditkeyexist(_regeditkey))
{
///以可写方式打开注册表项
registrykey key = opensubkey(true);
if (key != null)
{
try
{
///删除键值
key.deletevalue(_regeditkey);
result = true;
}
catch
{
result = false;
}
finally
{
///关闭对注册表项的更改
key.close();
}
}
}
return result;
}
/// <summary>
/// 删除键值（请先设置subkey属性）
/// 如果subkey为空、null或者subkey指示的注册表项不存在，返回false
/// </summary>
/// <param name="name">键值名称</param>
/// <returns>如果删除成功，返回true，否则返回false</returns>
public virtual bool deleteregeditkey(string name)
{
///删除结果
bool result = false;
///判断键值名称是否为空，如果为空，则返回false
if (name == string.empty || name == null)
{
return false;
}
///判断键值是否存在
if (isregeditkeyexist(name))
{
///以可写方式打开注册表项
registrykey key = opensubkey(true);
if (key != null)
{
try
{
///删除键值
key.deletevalue(name);
result = true;
}
catch
{
result = false;
}
finally
{
///关闭对注册表项的更改
key.close();
}
}
}
return result;
}
/// <summary>
/// 删除键值
/// </summary>
/// <param name="name">键值名称</param>
/// <param name="subkey">注册表项名称</param>
/// <returns>如果删除成功，返回true，否则返回false</returns>
public virtual bool deleteregeditkey(string name, string subkey)
{
///删除结果
bool result = false;
///判断键值名称和注册表项名称是否为空，如果为空，则返回false
if (name == string.empty || name == null || subkey == string.empty || subkey == null)
{
return false;
}
///判断键值是否存在
if (isregeditkeyexist(name))
{
///以可写方式打开注册表项
registrykey key = opensubkey(subkey, true);
if (key != null)
{
try
{
///删除键值
key.deletevalue(name);
result = true;
}
catch
{
result = false;
}
finally
{
///关闭对注册表项的更改
key.close();
}
}
}
return result;
}
/// <summary>
/// 删除键值
/// </summary>
/// <param name="name">键值名称</param>
/// <param name="subkey">注册表项名称</param>
/// <param name="regdomain">注册表基项域</param>
/// <returns>如果删除成功，返回true，否则返回false</returns>
public virtual bool deleteregeditkey(string name, string subkey, regdomain regdomain)
{
///删除结果
bool result = false;
///判断键值名称和注册表项名称是否为空，如果为空，则返回false
if (name == string.empty || name == null || subkey == string.empty || subkey == null)
{
return false;
}
///判断键值是否存在
if (isregeditkeyexist(name))
{
///以可写方式打开注册表项
registrykey key = opensubkey(subkey, regdomain, true);
if (key != null)
{
try
{
///删除键值
key.deletevalue(name);
result = true;
}
catch
{
result = false;
}
finally
{
///关闭对注册表项的更改
key.close();
}
}
}
return result;
}
#endregion
#endregion
#region 受保护方法
/// <summary>
/// 获取注册表基项域对应*节点
/// 例子：如regdomain是classesroot，则返回registry.classesroot
/// </summary>
/// <param name="regdomain">注册表基项域</param>
/// <returns>注册表基项域对应*节点</returns>
protected registrykey getregdomain(regdomain regdomain)
{
///创建基于注册表基项的节点
registrykey key;
#region 判断注册表基项域
switch (regdomain)
{
case regdomain.classesroot:
key = registry.classesroot; break;
case regdomain.currentuser:
key = registry.currentuser; break;
case regdomain.localmachine:
key = registry.localmachine; break;
case regdomain.user:
key = registry.users; break;
case regdomain.currentconfig:
key = registry.currentconfig; break;
case regdomain.dynda:
key = registry.dyndata; break;
case regdomain.performancedata:
key = registry.performancedata; break;
default:
key = registry.localmachine; break;
}
#endregion
return key;
}
/// <summary>
/// 获取在注册表中对应的值数据类型
/// 例子：如regvaluekind是dword，则返回registryvaluekind.dword
/// </summary>
/// <param name="regvaluekind">注册表数据类型</param>
/// <returns>注册表中对应的数据类型</returns>
protected registryvaluekind getregvaluekind(regvaluekind regvaluekind)
{
registryvaluekind regvaluek;
#region 判断注册表数据类型
switch (regvaluekind)
{
case regvaluekind.unknown:
regvaluek = registryvaluekind.unknown; break;
case regvaluekind.string:
regvaluek = registryvaluekind.string; break;
case regvaluekind.expandstring:
regvaluek = registryvaluekind.expandstring; break;
case regvaluekind.binary:
regvaluek = registryvaluekind.binary; break;
case regvaluekind.dword:
regvaluek = registryvaluekind.dword; break;
case regvaluekind.multistring:
regvaluek = registryvaluekind.multistring; break;
case regvaluekind.qword:
regvaluek = registryvaluekind.qword; break;
default:
regvaluek = registryvaluekind.string; break;
}
#endregion
return regvaluek;
}
#region 打开注册表项
/// <summary>
/// 打开注册表项节点，以只读方式检索子项
/// 虚方法，子类可进行重写
/// </summary>
/// <returns>如果subkey为空、null或者subkey指示注册表项不存在，则返回null，否则返回注册表节点</returns>
protected virtual registrykey opensubkey()
{
///判断注册表项名称是否为空
if (_subkey == string.empty || _subkey == null)
{
return null;
}
///创建基于注册表基项的节点
registrykey key = getregdomain(_domain);
///要打开的注册表项的节点
registrykey skey = null;
///打开注册表项
skey = key.opensubkey(_subkey);
///关闭对注册表项的更改
key.close();
///返回注册表节点
return skey;
}
/// <summary>
/// 打开注册表项节点
/// 虚方法，子类可进行重写
/// </summary>
/// <param name="writable">如果需要项的写访问权限，则设置为 true</param>
/// <returns>如果subkey为空、null或者subkey指示注册表项不存在，则返回null，否则返回注册表节点</returns>
protected virtual registrykey opensubkey(bool writable)
{
///判断注册表项名称是否为空
if (_subkey == string.empty || _subkey == null)
{
return null;
}
///创建基于注册表基项的节点
registrykey key = getregdomain(_domain);
///要打开的注册表项的节点
registrykey skey = null;
///打开注册表项
skey = key.opensubkey(_subkey, writable);
///关闭对注册表项的更改
key.close();
///返回注册表节点
return skey;
}
/// <summary>
/// 打开注册表项节点，以只读方式检索子项
/// 虚方法，子类可进行重写
/// </summary>
/// <param name="subkey">注册表项名称</param>
/// <returns>如果subkey为空、null或者subkey指示注册表项不存在，则返回null，否则返回注册表节点</returns>
protected virtual registrykey opensubkey(string subkey)
{
///判断注册表项名称是否为空
if (subkey == string.empty || subkey == null)
{
return null;
}
///创建基于注册表基项的节点
registrykey key = getregdomain(_domain);
///要打开的注册表项的节点
registrykey skey = null;
///打开注册表项
skey = key.opensubkey(subkey);
///关闭对注册表项的更改
key.close();
///返回注册表节点
return skey;
}
/// <summary>
/// 打开注册表项节点，以只读方式检索子项
/// 虚方法，子类可进行重写
/// </summary>
/// <param name="subkey">注册表项名称</param>
/// <param name="writable">如果需要项的写访问权限，则设置为 true</param>
/// <returns>如果subkey为空、null或者subkey指示注册表项不存在，则返回null，否则返回注册表节点</returns>
protected virtual registrykey opensubkey(string subkey, bool writable)
{
///判断注册表项名称是否为空
if (subkey == string.empty || subkey == null)
{
return null;
}
///创建基于注册表基项的节点
registrykey key = getregdomain(_domain);
///要打开的注册表项的节点
registrykey skey = null;
///打开注册表项
skey = key.opensubkey(subkey, writable);
///关闭对注册表项的更改
key.close();
///返回注册表节点
return skey;
}
/// <summary>
/// 打开注册表项节点，以只读方式检索子项
/// 虚方法，子类可进行重写
/// </summary>
/// <param name="subkey">注册表项名称</param>
/// <param name="regdomain">注册表基项域</param>
/// <returns>如果subkey为空、null或者subkey指示注册表项不存在，则返回null，否则返回注册表节点</returns>
protected virtual registrykey opensubkey(string subkey, regdomain regdomain)
{
///判断注册表项名称是否为空
if (subkey == string.empty || subkey == null)
{
return null;
}
///创建基于注册表基项的节点
registrykey key = getregdomain(regdomain);
///要打开的注册表项的节点
registrykey skey = null;
///打开注册表项
skey = key.opensubkey(subkey);
///关闭对注册表项的更改
key.close();
///返回注册表节点
return skey;
}
/// <summary>
/// 打开注册表项节点
/// 虚方法，子类可进行重写
/// </summary>
/// <param name="subkey">注册表项名称</param>
/// <param name="regdomain">注册表基项域</param>
/// <param name="writable">如果需要项的写访问权限，则设置为 true</param>
/// <returns>如果subkey为空、null或者subkey指示注册表项不存在，则返回null，否则返回注册表节点</returns>
protected virtual registrykey opensubkey(string subkey, regdomain regdomain, bool writable)
{
///判断注册表项名称是否为空
if (subkey == string.empty || subkey == null)
{
return null;
}
///创建基于注册表基项的节点
registrykey key = getregdomain(regdomain);
///要打开的注册表项的节点
registrykey skey = null;
///打开注册表项
skey = key.opensubkey(subkey, writable);
///关闭对注册表项的更改
key.close();
///返回注册表节点
return skey;
}
#endregion
#endregion
}