Created
October 13, 2012 11:51
-
-
Save oec2003/3884309 to your computer and use it in GitHub Desktop.
注册表帮助类
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
using System; | |
using System.Collections.Generic; | |
using System.Linq; | |
using System.Text; | |
using Microsoft.Win32; | |
using System.IO; | |
using System.Diagnostics; | |
using System.Runtime.InteropServices; | |
namespace FW.CommonFunction | |
{ | |
/// <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 RegHelper | |
{ | |
#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 RegHelper() | |
{ | |
///默认注册表项名称 | |
_subkey = "software\\"; | |
///默认注册表基项域 | |
_domain = RegDomain.LocalMachine; | |
} | |
/// <summary> | |
/// 构造函数 | |
/// </summary> | |
/// <param name="subKey">注册表项名称</param> | |
/// <param name="regDomain">注册表基项域</param> | |
public RegHelper(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 (Exception ex) | |
{ | |
result = false; | |
} | |
finally | |
{ | |
///关闭对注册表项的更改 | |
key.Close(); | |
} | |
return result; | |
} | |
/// <summary> | |
/// 设置指定的键值内容,指定内容数据类型(请先设置SubKey属性) | |
/// 存在改键值则修改键值内容,不存在键值则先创建键值,再设置键值内容 | |
/// </summary> | |
/// <param name="name">键值名称</param> | |
/// <param name="content">键值内容</param> | |
/// <returns>键值内容设置成功,则返回true,否则返回false</returns> | |
public virtual bool WriteRegeditKey(string name, object content, RegValueKind regValueKind) | |
{ | |
///返回结果 | |
bool result = false; | |
///判断键值是否存在 | |
if (name == string.Empty || name == null) | |
{ | |
return false; | |
} | |
///判断注册表项是否存在,如果不存在,则直接创建 | |
if (!IsSubKeyExist(_subkey)) | |
{ | |
CreateSubKey(_subkey); | |
} | |
///以可写方式打开注册表项 | |
RegistryKey key = OpenSubKey(true); | |
///如果注册表项打开失败,则返回false | |
if (key == null) | |
{ | |
return false; | |
} | |
try | |
{ | |
key.SetValue(name, content, GetRegValueKind(regValueKind)); | |
result = true; | |
} | |
catch | |
{ | |
result = false; | |
} | |
finally | |
{ | |
///关闭对注册表项的更改 | |
key.Close(); | |
} | |
return result; | |
} | |
#endregion | |
#region 读取键值内容 | |
/// <summary> | |
/// 读取键值内容(请先设置RegeditKey和SubKey属性) | |
/// 1.如果RegeditKey为空、null或者RegeditKey指示的键值不存在,返回null | |
/// 2.如果SubKey为空、null或者SubKey指示的注册表项不存在,返回null | |
/// 3.反之,则返回键值内容 | |
/// </summary> | |
/// <returns>返回键值内容</returns> | |
public virtual object ReadRegeditKey() | |
{ | |
///键值内容结果 | |
object obj = null; | |
///判断是否设置键值属性 | |
if (_regeditkey == string.Empty || _regeditkey == null) | |
{ | |
return null; | |
} | |
///判断键值是否存在 | |
if (IsRegeditKeyExist(_regeditkey)) | |
{ | |
///打开注册表项 | |
RegistryKey key = OpenSubKey(); | |
if (key != null) | |
{ | |
obj = key.GetValue(_regeditkey); | |
} | |
///关闭对注册表项的更改 | |
key.Close(); | |
} | |
return obj; | |
} | |
/// <summary> | |
/// 读取键值内容(请先设置SubKey属性) | |
/// 1.如果SubKey为空、null或者SubKey指示的注册表项不存在,返回null | |
/// 2.反之,则返回键值内容 | |
/// </summary> | |
/// <param name="name">键值名称</param> | |
/// <returns>返回键值内容</returns> | |
public virtual object ReadRegeditKey(string name) | |
{ | |
///键值内容结果 | |
object obj = null; | |
///判断是否设置键值属性 | |
if (name == string.Empty || name == null) | |
{ | |
return null; | |
} | |
///判断键值是否存在 | |
if (IsRegeditKeyExist(name)) | |
{ | |
///打开注册表项 | |
RegistryKey key = OpenSubKey(); | |
if (key != null) | |
{ | |
obj = key.GetValue(name); | |
} | |
///关闭对注册表项的更改 | |
key.Close(); | |
} | |
return obj; | |
} | |
/// <summary> | |
/// 读取键值内容 | |
/// </summary> | |
/// <param name="name">键值名称</param> | |
/// <param name="subKey">注册表项名称</param> | |
/// <returns>返回键值内容</returns> | |
public virtual object ReadRegeditKey(string name, string subKey) | |
{ | |
///键值内容结果 | |
object obj = null; | |
///判断是否设置键值属性 | |
if (name == string.Empty || name == null) | |
{ | |
return null; | |
} | |
///判断键值是否存在 | |
if (IsRegeditKeyExist(name)) | |
{ | |
///打开注册表项 | |
RegistryKey key = OpenSubKey(subKey); | |
if (key != null) | |
{ | |
obj = key.GetValue(name); | |
} | |
///关闭对注册表项的更改 | |
key.Close(); | |
} | |
return obj; | |
} | |
/// <summary> | |
/// 读取键值内容 | |
/// </summary> | |
/// <param name="name">键值名称</param> | |
/// <param name="subKey">注册表项名称</param> | |
/// <param name="regDomain">注册表基项域</param> | |
/// <returns>返回键值内容</returns> | |
public virtual object ReadRegeditKey(string name, string subKey, RegDomain regDomain) | |
{ | |
///键值内容结果 | |
object obj = null; | |
///判断是否设置键值属性 | |
if (name == string.Empty || name == null) | |
{ | |
return null; | |
} | |
///判断键值是否存在 | |
if (IsRegeditKeyExist(name)) | |
{ | |
///打开注册表项 | |
RegistryKey key = OpenSubKey(subKey, regDomain); | |
if (key != null) | |
{ | |
obj = key.GetValue(name); | |
} | |
///关闭对注册表项的更改 | |
key.Close(); | |
} | |
return obj; | |
} | |
#endregion | |
#region 删除键值 | |
/// <summary> | |
/// 删除键值(请先设置RegeditKey和SubKey属性) | |
/// 1.如果RegeditKey为空、null或者RegeditKey指示的键值不存在,返回false | |
/// 2.如果SubKey为空、null或者SubKey指示的注册表项不存在,返回false | |
/// </summary> | |
/// <returns>如果删除成功,返回true,否则返回false</returns> | |
public virtual bool DeleteRegeditKey() | |
{ | |
///删除结果 | |
bool result = false; | |
///判断是否设置键值属性,如果没有设置,则返回false | |
if (_regeditkey == string.Empty || _regeditkey == null) | |
{ | |
return false; | |
} | |
///判断键值是否存在 | |
if (IsRegeditKeyExist(_regeditkey)) | |
{ | |
///以可写方式打开注册表项 | |
RegistryKey key = OpenSubKey(true); | |
if (key != null) | |
{ | |
try | |
{ | |
///删除键值 | |
key.DeleteValue(_regeditkey); | |
result = true; | |
} | |
catch | |
{ | |
result = false; | |
} | |
finally | |
{ | |
///关闭对注册表项的更改 | |
key.Close(); | |
} | |
} | |
} | |
return result; | |
} | |
/// <summary> | |
/// 删除键值(请先设置SubKey属性) | |
/// 如果SubKey为空、null或者SubKey指示的注册表项不存在,返回false | |
/// </summary> | |
/// <param name="name">键值名称</param> | |
/// <returns>如果删除成功,返回true,否则返回false</returns> | |
public virtual bool DeleteRegeditKey(string name) | |
{ | |
///删除结果 | |
bool result = false; | |
///判断键值名称是否为空,如果为空,则返回false | |
if (name == string.Empty || name == null) | |
{ | |
return false; | |
} | |
///判断键值是否存在 | |
if (IsRegeditKeyExist(name)) | |
{ | |
///以可写方式打开注册表项 | |
RegistryKey key = OpenSubKey(true); | |
if (key != null) | |
{ | |
try | |
{ | |
///删除键值 | |
key.DeleteValue(name); | |
result = true; | |
} | |
catch | |
{ | |
result = false; | |
} | |
finally | |
{ | |
///关闭对注册表项的更改 | |
key.Close(); | |
} | |
} | |
} | |
return result; | |
} | |
/// <summary> | |
/// 删除键值 | |
/// </summary> | |
/// <param name="name">键值名称</param> | |
/// <param name="subKey">注册表项名称</param> | |
/// <returns>如果删除成功,返回true,否则返回false</returns> | |
public virtual bool DeleteRegeditKey(string name, string subKey) | |
{ | |
///删除结果 | |
bool result = false; | |
///判断键值名称和注册表项名称是否为空,如果为空,则返回false | |
if (name == string.Empty || name == null || subKey == string.Empty || subKey == null) | |
{ | |
return false; | |
} | |
///判断键值是否存在 | |
if (IsRegeditKeyExist(name)) | |
{ | |
///以可写方式打开注册表项 | |
RegistryKey key = OpenSubKey(subKey, true); | |
if (key != null) | |
{ | |
try | |
{ | |
///删除键值 | |
key.DeleteValue(name); | |
result = true; | |
} | |
catch | |
{ | |
result = false; | |
} | |
finally | |
{ | |
///关闭对注册表项的更改 | |
key.Close(); | |
} | |
} | |
} | |
return result; | |
} | |
/// <summary> | |
/// 删除键值 | |
/// </summary> | |
/// <param name="name">键值名称</param> | |
/// <param name="subKey">注册表项名称</param> | |
/// <param name="regDomain">注册表基项域</param> | |
/// <returns>如果删除成功,返回true,否则返回false</returns> | |
public virtual bool DeleteRegeditKey(string name, string subKey, RegDomain regDomain) | |
{ | |
///删除结果 | |
bool result = false; | |
///判断键值名称和注册表项名称是否为空,如果为空,则返回false | |
if (name == string.Empty || name == null || subKey == string.Empty || subKey == null) | |
{ | |
return false; | |
} | |
///判断键值是否存在 | |
if (IsRegeditKeyExist(name)) | |
{ | |
///以可写方式打开注册表项 | |
RegistryKey key = OpenSubKey(subKey, regDomain, true); | |
if (key != null) | |
{ | |
try | |
{ | |
///删除键值 | |
key.DeleteValue(name); | |
result = true; | |
} | |
catch | |
{ | |
result = false; | |
} | |
finally | |
{ | |
///关闭对注册表项的更改 | |
key.Close(); | |
} | |
} | |
} | |
return result; | |
} | |
#endregion | |
#endregion | |
#region 受保护方法 | |
/// <summary> | |
/// 获取注册表基项域对应顶级节点 | |
/// 例子:如regDomain是ClassesRoot,则返回Registry.ClassesRoot | |
/// </summary> | |
/// <param name="regDomain">注册表基项域</param> | |
/// <returns>注册表基项域对应顶级节点</returns> | |
protected RegistryKey GetRegDomain(RegDomain regDomain) | |
{ | |
///创建基于注册表基项的节点 | |
RegistryKey key; | |
#region 判断注册表基项域 | |
switch (regDomain) | |
{ | |
case RegDomain.ClassesRoot: | |
key = Registry.ClassesRoot; break; | |
case RegDomain.CurrentUser: | |
key = Registry.CurrentUser; break; | |
case RegDomain.LocalMachine: | |
key = Registry.LocalMachine; break; | |
case RegDomain.User: | |
key = Registry.Users; break; | |
case RegDomain.CurrentConfig: | |
key = Registry.CurrentConfig; break; | |
case RegDomain.DynDa: | |
key = Registry.DynData; break; | |
case RegDomain.PerformanceData: | |
key = Registry.PerformanceData; break; | |
default: | |
key = Registry.LocalMachine; break; | |
} | |
#endregion | |
return key; | |
} | |
/// <summary> | |
/// 获取在注册表中对应的值数据类型 | |
/// 例子:如regValueKind是DWord,则返回RegistryValueKind.DWord | |
/// </summary> | |
/// <param name="regValueKind">注册表数据类型</param> | |
/// <returns>注册表中对应的数据类型</returns> | |
protected RegistryValueKind GetRegValueKind(RegValueKind regValueKind) | |
{ | |
RegistryValueKind regValueK; | |
#region 判断注册表数据类型 | |
switch (regValueKind) | |
{ | |
case RegValueKind.Unknown: | |
regValueK = RegistryValueKind.Unknown; break; | |
case RegValueKind.String: | |
regValueK = RegistryValueKind.String; break; | |
case RegValueKind.ExpandString: | |
regValueK = RegistryValueKind.ExpandString; break; | |
case RegValueKind.Binary: | |
regValueK = RegistryValueKind.Binary; break; | |
case RegValueKind.DWord: | |
regValueK = RegistryValueKind.DWord; break; | |
case RegValueKind.MultiString: | |
regValueK = RegistryValueKind.MultiString; break; | |
case RegValueKind.QWord: | |
regValueK = RegistryValueKind.QWord; break; | |
default: | |
regValueK = RegistryValueKind.String; break; | |
} | |
#endregion | |
return regValueK; | |
} | |
#region 打开注册表项 | |
/// <summary> | |
/// 打开注册表项节点,以只读方式检索子项 | |
/// 虚方法,子类可进行重写 | |
/// </summary> | |
/// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在,则返回null,否则返回注册表节点</returns> | |
protected virtual RegistryKey OpenSubKey() | |
{ | |
///判断注册表项名称是否为空 | |
if (_subkey == string.Empty || _subkey == null) | |
{ | |
return null; | |
} | |
///创建基于注册表基项的节点 | |
RegistryKey key = GetRegDomain(_domain); | |
///要打开的注册表项的节点 | |
RegistryKey sKey = null; | |
///打开注册表项 | |
sKey = key.OpenSubKey(_subkey); | |
///关闭对注册表项的更改 | |
key.Close(); | |
///返回注册表节点 | |
return sKey; | |
} | |
/// <summary> | |
/// 打开注册表项节点 | |
/// 虚方法,子类可进行重写 | |
/// </summary> | |
/// <param name="writable">如果需要项的写访问权限,则设置为 true</param> | |
/// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在,则返回null,否则返回注册表节点</returns> | |
protected virtual RegistryKey OpenSubKey(bool writable) | |
{ | |
///判断注册表项名称是否为空 | |
if (_subkey == string.Empty || _subkey == null) | |
{ | |
return null; | |
} | |
///创建基于注册表基项的节点 | |
RegistryKey key = GetRegDomain(_domain); | |
///要打开的注册表项的节点 | |
RegistryKey sKey = null; | |
///打开注册表项 | |
sKey = key.OpenSubKey(_subkey, writable); | |
///关闭对注册表项的更改 | |
key.Close(); | |
///返回注册表节点 | |
return sKey; | |
} | |
/// <summary> | |
/// 打开注册表项节点,以只读方式检索子项 | |
/// 虚方法,子类可进行重写 | |
/// </summary> | |
/// <param name="subKey">注册表项名称</param> | |
/// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在,则返回null,否则返回注册表节点</returns> | |
protected virtual RegistryKey OpenSubKey(string subKey) | |
{ | |
///判断注册表项名称是否为空 | |
if (subKey == string.Empty || subKey == null) | |
{ | |
return null; | |
} | |
///创建基于注册表基项的节点 | |
RegistryKey key = GetRegDomain(_domain); | |
///要打开的注册表项的节点 | |
RegistryKey sKey = null; | |
///打开注册表项 | |
sKey = key.OpenSubKey(subKey); | |
///关闭对注册表项的更改 | |
key.Close(); | |
///返回注册表节点 | |
return sKey; | |
} | |
/// <summary> | |
/// 打开注册表项节点,以只读方式检索子项 | |
/// 虚方法,子类可进行重写 | |
/// </summary> | |
/// <param name="subKey">注册表项名称</param> | |
/// <param name="writable">如果需要项的写访问权限,则设置为 true</param> | |
/// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在,则返回null,否则返回注册表节点</returns> | |
protected virtual RegistryKey OpenSubKey(string subKey, bool writable) | |
{ | |
///判断注册表项名称是否为空 | |
if (subKey == string.Empty || subKey == null) | |
{ | |
return null; | |
} | |
///创建基于注册表基项的节点 | |
RegistryKey key = GetRegDomain(_domain); | |
///要打开的注册表项的节点 | |
RegistryKey sKey = null; | |
///打开注册表项 | |
sKey = key.OpenSubKey(subKey, writable); | |
///关闭对注册表项的更改 | |
key.Close(); | |
///返回注册表节点 | |
return sKey; | |
} | |
/// <summary> | |
/// 打开注册表项节点,以只读方式检索子项 | |
/// 虚方法,子类可进行重写 | |
/// </summary> | |
/// <param name="subKey">注册表项名称</param> | |
/// <param name="regDomain">注册表基项域</param> | |
/// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在,则返回null,否则返回注册表节点</returns> | |
protected virtual RegistryKey OpenSubKey(string subKey, RegDomain regDomain) | |
{ | |
///判断注册表项名称是否为空 | |
if (subKey == string.Empty || subKey == null) | |
{ | |
return null; | |
} | |
///创建基于注册表基项的节点 | |
RegistryKey key = GetRegDomain(regDomain); | |
///要打开的注册表项的节点 | |
RegistryKey sKey = null; | |
///打开注册表项 | |
sKey = key.OpenSubKey(subKey); | |
///关闭对注册表项的更改 | |
key.Close(); | |
///返回注册表节点 | |
return sKey; | |
} | |
/// <summary> | |
/// 打开注册表项节点 | |
/// 虚方法,子类可进行重写 | |
/// </summary> | |
/// <param name="subKey">注册表项名称</param> | |
/// <param name="regDomain">注册表基项域</param> | |
/// <param name="writable">如果需要项的写访问权限,则设置为 true</param> | |
/// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在,则返回null,否则返回注册表节点</returns> | |
protected virtual RegistryKey OpenSubKey(string subKey, RegDomain regDomain, bool writable) | |
{ | |
///判断注册表项名称是否为空 | |
if (subKey == string.Empty || subKey == null) | |
{ | |
return null; | |
} | |
///创建基于注册表基项的节点 | |
RegistryKey key = GetRegDomain(regDomain); | |
///要打开的注册表项的节点 | |
RegistryKey sKey = null; | |
///打开注册表项 | |
sKey = key.OpenSubKey(subKey, writable); | |
///关闭对注册表项的更改 | |
key.Close(); | |
///返回注册表节点 | |
return sKey; | |
} | |
#endregion | |
#endregion | |
#region 导入导出Reg | |
[DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Ansi)] | |
static extern int MessageBox(IntPtr hwnd, string text, string caption, uint type); | |
/// <summary> | |
/// 从注册表导出到文件,在导出的过程是异步的,不受操作进程管理 | |
/// </summary> | |
/// <param name="SavingFilePath">从注册表导出的文件,如果是已存在的,会提示覆盖; | |
/// 如果不存在由参数指定名字的文件,将自动创建一个。导出的文件的扩展名应当是.REG的</param> | |
/// <param name="regPath">指定注册表的某一键被导出,如果指定null值,将导出整个注册表</param> | |
/// <returns>成功返回0,用户中断返回1</returns> | |
public static int ExportReg(string SavingFilePath, string regPath) | |
{ | |
//如果文件存在,MSG提示是否覆盖,不覆盖,中断操作 | |
//如果注册表路径为空,导出全部 | |
if (File.Exists(SavingFilePath)) | |
if (MessageBox(IntPtr.Zero, | |
string.Format("存在名为:{0}的文件,是否覆盖 ?", | |
SavingFilePath), | |
string.Format("进程:{0} pid: {1}", | |
Process.GetCurrentProcess().ProcessName, | |
Process.GetCurrentProcess().Id), | |
0x00000004 | |
| 0x00200000 | 0x00000020 | 0x00000100) == 7) | |
{ | |
return 1; //说明,在应用的地方,用对话框,再操作,再调用一次 | |
} | |
Process.Start( | |
"regedit", | |
string.Format(" /E {0} {1} ", SavingFilePath, regPath)); | |
//Console.WriteLine(10);//异步的,非同步执行 | |
// Feng.Regedit.RegExportImport.ExportReg(@"c:\789.reg",@"HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run"); | |
// Feng.Regedit. RegExportImport.ExportReg(@"c:\789.reg",null); | |
return 0; | |
} | |
/// <summary> | |
/// 从文件导入的注册表 | |
/// </summary> | |
/// <param name="SavedFilePath">指定在磁盘上存在的文件,如果指定的文件不存在,将抛出异常</param> | |
/// <param name="regPath">指定注册表的键(包含在SavedFilePath文件中保存的关键字),如果该参数设置为null将导入整个 SavedFilePath文件 | |
/// 中保存的所有关于注册表的关键字</param> | |
/// <returns>成功返回0</returns> | |
public static int ImportReg(string SavedFilePath, string regPath) | |
{ | |
if (!File.Exists(SavedFilePath)) | |
throw new ArgumentException("参数 SavedFilePath 指定无效路径"); | |
Process.Start( | |
"regedit", | |
string.Format(" /C {0} {1}", | |
SavedFilePath, | |
regPath));//线程外的 | |
return 0; | |
} | |
#endregion | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment