软件注册是程序开发中常见的一种授权行为,当软件授权通过注册后,软件的部分功能才能可以使用,或者会将软件的使用期限进行延长;
软件需要注册那么就需要考虑用什么内容进行注册,或者是软件提供方想得到什么信息,通常这一块被用一个很笼统的概念“机器码”进行混淆;供方通常在此处做文章,以下是一些示例( 可能不全)
(1)简单粗暴有效的,采用系统生成GUID即可;
(2)含有机器信息的机器码(合法的);比如供方可以根据反馈的机器码,评估出这个软件适合不适合在此机器上使用,或者评估兼容性、用户量等方面的信息; 在软件中只需要将机器的信息比如:CPU、硬盘、内存等信息读取后,加密形成注册码即可;同时,当用户更换电脑后,从软件这面能够精确的识别,更容易实现对软件的授权控制;
(3)含流氓信息的注册码(非法的);会盗取个人的一些资料等;
下面已实现第二种方式进行机器注册码实现:
需求:供方拟获取计算机相关配置,后期进行大数据分析;
实现方面:
第一步、我们需要将电脑的配置信息获取到,直接代码了,此处不废话了
首先我们需要一个电脑信息的实体类,实体的类如下:
public class ComputerInfo
{
/// <summary>
/// 获取本机的MAC;
/// </summary>
public string LocalMac { set; get; }
/// <summary>
/// 获取主板序列号
/// </summary>
/// <returns></returns>
public string BIOSSerialNumber { set; get; }
/// <summary>
/// 获取CPU序列号
/// </summary>
/// <returns></returns>
public string CPUSerialNumber { set; get; }
//获取硬盘序列号
public string HardDiskSerialNumber { set; get; }
//获取网卡地址
public string NetCardMACAddress { set; get; }
/// <summary>
/// 获得CPU编号
/// </summary>
public string CPUID { set; get; }
/// <summary>
/// 获取硬盘序列号
/// </summary>
public string DiskSerialNumber { set; get; }
/// <summary>
/// 获取网卡硬件地址
/// </summary>
public string MacAddress { set; get; }
/// <summary>
/// 获取IP地址
/// </summary>
public string IPAddress { set; get; }
/// <summary>
/// 操作系统的登录用户名
/// </summary>
public string UserName { set; get; }
/// <summary>
/// 获取计算机名
/// </summary>
public string ComputerName { set; get; }
/// <summary>
/// 操作系统类型
/// </summary>
public string SystemType { set; get; }
/// <summary>
/// 物理内存
/// </summary>
public string PhysicalMemory { set; get; }
/// <summary>
/// 显卡PNPDeviceID
/// </summary>
public string VideoPNPID { set; get; }
/// <summary>
/// 声卡PNPDeviceID
/// </summary>
public string SoundPNPID { set; get; }
/// <summary>
/// CPU版本信息
/// </summary>
public string CPUVersion { set; get; }
/// <summary>
/// CPU名称信息
/// </summary>
public string CPUName { set; get; }
/// <summary>
/// CPU制造厂商
/// </summary>
public string CPUManufacturer { set; get; }
/// <summary>
/// 主板制造厂商
/// </summary>
public string BoardManufacturer { set; get; }
/// <summary>
/// 主板编号
/// </summary>
public string BoardID { set; get; }
/// <summary>
/// 主板型号
/// </summary>
public string BoardType { set; get; }
}
第二步,我们需要将电脑信息获取到进行封装,此处建议最好写成单例,用到了上面的电脑配置信息类
public class HardWareTool
{
/// <summary>
/// 静态变量
/// </summary>
private static HardWareTool hardWareTool = new HardWareTool();
public static HardWareTool CreateInstance()
{
return hardWareTool;
}
public ComputerInfo GetComputerInfo()
{
ComputerInfo computerInfo = new ComputerInfo();
computerInfo.BIOSSerialNumber = GetBIOSSerialNumber();
computerInfo.BoardID = GetBoardID();
computerInfo.BoardManufacturer = GetBoardManufacturer();
computerInfo.BoardType = GetBoardType();
computerInfo.ComputerName = GetComputerName();
computerInfo.CPUID = GetCPUID();
computerInfo.CPUManufacturer = GetCPUManufacturer();
computerInfo.CPUName = GetCPUName();
computerInfo.CPUSerialNumber = GetCPUSerialNumber();
computerInfo.CPUVersion = GetCPUVersion();
computerInfo.DiskSerialNumber = GetDiskSerialNumber();
computerInfo.HardDiskSerialNumber = GetHardDiskSerialNumber();
computerInfo.IPAddress = GetIPAddress();
computerInfo.LocalMac = GetLocalMac();
computerInfo.MacAddress = GetMacAddress();
computerInfo.NetCardMACAddress = GetNetCardMACAddress();
computerInfo.PhysicalMemory = GetPhysicalMemory();
computerInfo.SoundPNPID = GetSoundPNPID();
computerInfo.SystemType = GetSystemType();
computerInfo.UserName = GetUserName();
computerInfo.VideoPNPID = GetVideoPNPID();
return computerInfo;
}
public object GetComputerInfoToJson()
{
return JsonConvert.SerializeObject(GetComputerInfo());
}
/// <summary>
/// 获取本机的MAC; //在项目-》添加引用....里面引用System.Management
/// </summary>
public string GetLocalMac()
{
string mac = null;
ManagementObjectSearcher query = new ManagementObjectSearcher("SELECT * FROM Win32_NetworkAdapterConfiguration");
ManagementObjectCollection queryCollection = query.Get();
foreach (ManagementObject mo in queryCollection)
{
if (mo["IPEnabled"].ToString() == "True")
mac = mo["MacAddress"].ToString();
}
return (mac);
}
/// <summary>
/// 获取主板序列号
/// </summary>
/// <returns></returns>
public string GetBIOSSerialNumber()
{
try
{
ManagementObjectSearcher searcher = new ManagementObjectSearcher("Select * From Win32_BIOS");
string sBIOSSerialNumber = "";
foreach (ManagementObject mo in searcher.Get())
{
sBIOSSerialNumber = mo["SerialNumber"].ToString().Trim();
}
return sBIOSSerialNumber;
}
catch
{
return "";
}
}
/// <summary>
/// 获取CPU序列号
/// </summary>
/// <returns></returns>
public string GetCPUSerialNumber()
{
try
{
ManagementObjectSearcher searcher = new ManagementObjectSearcher("Select * From Win32_Processor");
string sCPUSerialNumber = "";
foreach (ManagementObject mo in searcher.Get())
{
sCPUSerialNumber = mo["ProcessorId"].ToString().Trim();
}
return sCPUSerialNumber;
}
catch
{
return "";
}
}
//获取硬盘序列号
public string GetHardDiskSerialNumber()
{
try
{
ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT * FROM Win32_PhysicalMedia");
string sHardDiskSerialNumber = "";
foreach (ManagementObject mo in searcher.Get())
{
sHardDiskSerialNumber = mo["SerialNumber"].ToString().Trim();
break;
}
return sHardDiskSerialNumber;
}
catch
{
return "";
}
}
//获取网卡地址
public string GetNetCardMACAddress()
{
try
{
ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT * FROM Win32_NetworkAdapter WHERE ((MACAddress Is Not NULL) AND (Manufacturer <> 'Microsoft'))");
string NetCardMACAddress = "";
foreach (ManagementObject mo in searcher.Get())
{
NetCardMACAddress = mo["MACAddress"].ToString().Trim();
}
return NetCardMACAddress;
}
catch
{
return "";
}
}
/// <summary>
/// 获得CPU编号
/// </summary>
public string GetCPUID()
{
string cpuid = "";
ManagementClass mc = new ManagementClass("Win32_Processor");
ManagementObjectCollection moc = mc.GetInstances();
foreach (ManagementObject mo in moc)
{
cpuid = mo.Properties["ProcessorId"].Value.ToString();
}
return cpuid;
}
/// <summary>
/// 获取硬盘序列号
/// </summary>
public string GetDiskSerialNumber()
{
//这种模式在插入一个U盘后可能会有不同的结果,如插入我的手机时
String HDid = "";
ManagementClass mc = new ManagementClass("Win32_DiskDrive");
ManagementObjectCollection moc = mc.GetInstances();
foreach (ManagementObject mo in moc)
{
HDid = (string)mo.Properties["Model"].Value;//SerialNumber
break;//这名话解决有多个物理盘时产生的问题,只取第一个物理硬盘
}
return HDid;
}
/// <summary>
/// 获取网卡硬件地址
/// </summary>
public string GetMacAddress()
{
string mac = "";
ManagementClass mc = new ManagementClass("Win32_NetworkAdapterConfiguration");
ManagementObjectCollection moc = mc.GetInstances();
foreach (ManagementObject mo in moc)
{
if ((bool)mo["IPEnabled"] == true)
{
mac = mo["MacAddress"].ToString();
break;
}
}
return mac;
}
/// <summary>
/// 获取IP地址
/// </summary>
public string GetIPAddress()
{
string st = "";
ManagementClass mc = new ManagementClass("Win32_NetworkAdapterConfiguration");
ManagementObjectCollection moc = mc.GetInstances();
foreach (ManagementObject mo in moc)
{
if ((bool)mo["IPEnabled"] == true)
{
//st=mo["IpAddress"].ToString();
System.Array ar;
ar = (System.Array)(mo.Properties["IpAddress"].Value);
st = ar.GetValue(0).ToString();
break;
}
}
return st;
}
/// <summary>
/// 操作系统的登录用户名
/// </summary>
public string GetUserName()
{
return Environment.UserName;
}
/// <summary>
/// 获取计算机名
/// </summary>
public string GetComputerName()
{
return Environment.MachineName;
}
/// <summary>
/// 操作系统类型
/// </summary>
public string GetSystemType()
{
string st = "";
ManagementClass mc = new ManagementClass("Win32_ComputerSystem");
ManagementObjectCollection moc = mc.GetInstances();
foreach (ManagementObject mo in moc)
{
st = mo["SystemType"].ToString();
}
return st;
}
/// <summary>
/// 物理内存
/// </summary>
public string GetPhysicalMemory()
{
string st = "";
ManagementClass mc = new ManagementClass("Win32_ComputerSystem");
ManagementObjectCollection moc = mc.GetInstances();
foreach (ManagementObject mo in moc)
{
st = mo["TotalPhysicalMemory"].ToString();
}
return st;
}
/// <summary>
/// 显卡PNPDeviceID
/// </summary>
public string GetVideoPNPID()
{
string st = "";
ManagementObjectSearcher mos = new ManagementObjectSearcher("Select * from Win32_VideoController");
foreach (ManagementObject mo in mos.Get())
{
st = mo["PNPDeviceID"].ToString();
}
return st;
}
/// <summary>
/// 声卡PNPDeviceID
/// </summary>
public string GetSoundPNPID()
{
string st = "";
ManagementObjectSearcher mos = new ManagementObjectSearcher("Select * from Win32_SoundDevice");
foreach (ManagementObject mo in mos.Get())
{
st = mo["PNPDeviceID"].ToString();
}
return st;
}
/// <summary>
/// CPU版本信息
/// </summary>
public string GetCPUVersion()
{
string st = "";
ManagementObjectSearcher mos = new ManagementObjectSearcher("Select * from Win32_Processor");
foreach (ManagementObject mo in mos.Get())
{
st = mo["Version"].ToString();
}
return st;
}
/// <summary>
/// CPU名称信息
/// </summary>
public string GetCPUName()
{
string st = "";
ManagementObjectSearcher driveID = new ManagementObjectSearcher("Select * from Win32_Processor");
foreach (ManagementObject mo in driveID.Get())
{
st = mo["Name"].ToString();
}
return st;
}
/// <summary>
/// CPU制造厂商
/// </summary>
public string GetCPUManufacturer()
{
string st = "";
ManagementObjectSearcher mos = new ManagementObjectSearcher("Select * from Win32_Processor");
foreach (ManagementObject mo in mos.Get())
{
st = mo["Manufacturer"].ToString();
}
return st;
}
/// <summary>
/// 主板制造厂商
/// </summary>
public string GetBoardManufacturer()
{
SelectQuery query = new SelectQuery("Select * from Win32_BaseBoard");
ManagementObjectSearcher mos = new ManagementObjectSearcher(query);
ManagementObjectCollection.ManagementObjectEnumerator data = mos.Get().GetEnumerator();
data.MoveNext();
ManagementBaseObject board = data.Current;
return board.GetPropertyValue("Manufacturer").ToString();
}
/// <summary>
/// 主板编号
/// </summary>
public string GetBoardID()
{
string st = "";
ManagementObjectSearcher mos = new ManagementObjectSearcher("Select * from Win32_BaseBoard");
foreach (ManagementObject mo in mos.Get())
{
st = mo["SerialNumber"].ToString();
}
return st;
}
/// <summary>
/// 主板型号
/// </summary>
public string GetBoardType()
{
string st = "";
ManagementObjectSearcher mos = new ManagementObjectSearcher("Select * from Win32_BaseBoard");
foreach (ManagementObject mo in mos.Get())
{
st = mo["Product"].ToString();
}
return st;
}
}
第三步:生产机器码的过程,只需根据制定密钥加密即可,代码如下
public class EncryptTool
{
#region 使用 缺省密钥字符串 加密/解密string
private static string ENCRYPTKEY = "1234567899999999";
/// <summary>
/// 使用缺省密钥字符串加密string
/// </summary>
/// <param name="original">明文</param>
/// <returns>密文</returns>
public static string Encrypt(string original)
{
return Encrypt(original, ENCRYPTKEY);
}
/// <summary>
/// 使用缺省密钥字符串解密string
/// </summary>
/// <param name="original">密文</param>
/// <returns>明文</returns>
public static string Decrypt(string original)
{
return Decrypt(original, ENCRYPTKEY, System.Text.Encoding.Default);
}
#endregion
#region 使用 给定密钥字符串 加密/解密string
/// <summary>
/// 使用给定密钥字符串加密string
/// </summary>
/// <param name="original">原始文字</param>
/// <param name="key">密钥</param>
/// <param name="encoding">字符编码方案</param>
/// <returns>密文</returns>
public static string Encrypt(string original, string key)
{
byte[] buff = System.Text.Encoding.Default.GetBytes(original);
byte[] kb = System.Text.Encoding.Default.GetBytes(key);
return Convert.ToBase64String(Encrypt(buff, kb));
}
/// <summary>
/// 使用给定密钥字符串解密string
/// </summary>
/// <param name="original">密文</param>
/// <param name="key">密钥</param>
/// <returns>明文</returns>
public static string Decrypt(string original, string key)
{
return Decrypt(original, key, System.Text.Encoding.Default);
}
/// <summary>
/// 使用给定密钥字符串解密string,返回指定编码方式明文
/// </summary>
/// <param name="encrypted">密文</param>
/// <param name="key">密钥</param>
/// <param name="encoding">字符编码方案</param>
/// <returns>明文</returns>
public static string Decrypt(string encrypted, string key, Encoding encoding)
{
byte[] buff = Convert.FromBase64String(encrypted);
byte[] kb = System.Text.Encoding.Default.GetBytes(key);
return encoding.GetString(Decrypt(buff, kb));
}
#endregion
#region 使用 缺省密钥字符串 加密/解密/byte[]
/// <summary>
/// 使用缺省密钥字符串解密byte[]
/// </summary>
/// <param name="encrypted">密文</param>
/// <param name="key">密钥</param>
/// <returns>明文</returns>
public static byte[] Decrypt(byte[] encrypted)
{
byte[] key = System.Text.Encoding.Default.GetBytes(ENCRYPTKEY);
return Decrypt(encrypted, key);
}
/// <summary>
/// 使用缺省密钥字符串加密
/// </summary>
/// <param name="original">原始数据</param>
/// <param name="key">密钥</param>
/// <returns>密文</returns>
public static byte[] Encrypt(byte[] original)
{
byte[] key = System.Text.Encoding.Default.GetBytes(ENCRYPTKEY);
return Encrypt(original, key);
}
#endregion
#region 使用 给定密钥 加密/解密/byte[]
/// <summary>
/// 生成MD5摘要
/// </summary>
/// <param name="original">数据源</param>
/// <returns>摘要</returns>
public static byte[] MakeMD5(byte[] original)
{
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
byte[] keyhash = hashmd5.ComputeHash(original);
hashmd5 = null;
return keyhash;
}
/// <summary>
/// 使用给定密钥加密
/// </summary>
/// <param name="original">明文</param>
/// <param name="key">密钥</param>
/// <returns>密文</returns>
public static byte[] Encrypt(byte[] original, byte[] key)
{
TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
des.Key = MakeMD5(key);
des.Mode = CipherMode.ECB;
return des.CreateEncryptor().TransformFinalBlock(original, 0, original.Length);
}
/// <summary>
/// 使用给定密钥解密数据
/// </summary>
/// <param name="encrypted">密文</param>
/// <param name="key">密钥</param>
/// <returns>明文</returns>
public static byte[] Decrypt(byte[] encrypted, byte[] key)
{
TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
des.Key = MakeMD5(key);
des.Mode = CipherMode.ECB;
return des.CreateDecryptor().TransformFinalBlock(encrypted, 0, encrypted.Length);
}
#endregion
}
这样一来我们简单的机器码就生成了,注册机只需要将机器码识别出给出注册码即可,软件中只需要将注册码写入系统文件或者注册表即可,操作注册表的代码如下:
public class RegOperatorTool
{
///1.注册表基项静态域
public enum RegDomain
{
/// 对应于 HKEY_CLASSES_ROOT 主键
ClassesRoot = 0,
/// 对应于 HKEY_CURRENT_USER 主键
CurrentUser = 1,
/// 对应于HKEY_LOCAL_MACHINE 主键
LocalMachine = 2,
/// 对应于HKEY_USER 主键
User = 3,
/// 对应于 HEKY_CURRENT_CONFIG 主键
CurrentConfig = 4,
/// 对应于 HKEY_DYN_DATA 主键
DynDa = 5,
/// 对应于 HKEY_PERFORMANCE_DATA 主键
PerformanceData = 6,
}
///2.指定在注册表中存储值时所用的数据类型,或标识注册表中某个值的数据类型
public enum RegValueKind
{
/// 指示一个不受支持的注册表数据类型。例如,不支持Microsoft Win32 API 注册表数据类型REG_RESOURCE_LIST。使用此值指定
Unknown = 0,
/// 指定一个以Null 结尾的字符串。此值与Win32 API 注册表数据类型REG_SZ 等效。
String = 1,
/// 指定一个以NULL 结尾的字符串,该字符串中包含对环境变量(如%PATH%,当值被检索时,就会展开)的未展开的引用。
ExpandString = 2,
/// 此值与Win32 API 注册表数据类型REG_EXPAND_SZ 等效。
Binary = 3,
/// 指定任意格式的二进制数据。此值与Win32 API 注册表数据类型REG_BINARY 等效。
DWord = 4,
/// 指定一个32 位二进制数。此值与Win32 API 注册表数据类型REG_DWORD 等效。
/// 指定一个以NULL 结尾的字符串数组,以两个空字符结束。此值与Win32 API 注册表数据类型REG_MULTI_SZ 等效。
MultiString = 5,
/// 指定一个64 位二进制数。此值与Win32 API 注册表数据类型REG_QWORD 等效。
QWord = 6,
}
///3.注册表操作类
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属性)
/// 虚方法,子类可进行重写
/// .如果RegeditKey为空、null,则返回false
/// .如果SubKey为空、null或者SubKey指定的注册表项不存在,返回false
/// </summary>
/// <returns>返回键值是否存在,存在返回true,否则返回false</returns>
public virtual bool IsRegeditKeyExist()
{
///返回结果
bool result = false;
///判断是否设置键值属性
if (_regeditkey == string.Empty || _regeditkey == null)
{
return false;
}
///判断注册表项是否存在
if (IsSubKeyExist())
{
///打开注册表项
RegistryKey key = OpenSubKey();
///键值集合
string[] regeditKeyNames;
///获取键值集合
regeditKeyNames = key.GetValueNames();
///遍历键值集合,如果存在键值,则退出遍历
foreach (string regeditKey in regeditKeyNames)
{
if (string.Compare(regeditKey, _regeditkey, true) == 0)
{
result = true;
break;
}
}
///关闭对注册表项的更改
key.Close();
}
return result;
}
/// <summary>
/// 判断键值是否存在(请先设置SubKey属性)
/// 虚方法,子类可进行重写
/// 如果SubKey为空、null或者SubKey指定的注册表项不存在,返回false
/// </summary>
/// <param name="name">键值名称</param>
/// <returns>返回键值是否存在,存在返回true,否则返回false</returns>
public virtual bool IsRegeditKeyExist(string name)
{
///返回结果
bool result = false;
///判断是否设置键值属性
if (name == string.Empty || name == null)
{
return false;
}
///判断注册表项是否存在
if (IsSubKeyExist())
{
///打开注册表项
RegistryKey key = OpenSubKey();
///键值集合
string[] regeditKeyNames;
///获取键值集合
regeditKeyNames = key.GetValueNames();
///遍历键值集合,如果存在键值,则退出遍历
foreach (string regeditKey in regeditKeyNames)
{
if (string.Compare(regeditKey, name, true) == 0)
{
result = true;
break;
}
}
///关闭对注册表项的更改
key.Close();
}
return result;
}
/// <summary>
/// 判断键值是否存在
/// 虚方法,子类可进行重写
/// </summary>
/// <param name="name">键值名称</param>
/// <param name="subKey">注册表项名称</param>
/// <returns>返回键值是否存在,存在返回true,否则返回false</returns>
public virtual bool IsRegeditKeyExist(string name, string subKey)
{
///返回结果
bool result = false;
///判断是否设置键值属性
if (name == string.Empty || name == null)
{
return false;
}
///判断注册表项是否存在
if (IsSubKeyExist())
{
///打开注册表项
RegistryKey key = OpenSubKey(subKey);
///键值集合
string[] regeditKeyNames;
///获取键值集合
regeditKeyNames = key.GetValueNames();
///遍历键值集合,如果存在键值,则退出遍历
foreach (string regeditKey in regeditKeyNames)
{
if (string.Compare(regeditKey, name, true) == 0)
{
result = true;
break;
}
}
///关闭对注册表项的更改
key.Close();
}
return result;
}
/// <summary>
/// 判断键值是否存在
/// 虚方法,子类可进行重写
/// </summary>
/// <param name="name">键值名称</param>
/// <param name="subKey">注册表项名称</param>
/// <param name="regDomain">注册表基项域</param>
/// <returns>返回键值是否存在,存在返回true,否则返回false</returns>
public virtual bool IsRegeditKeyExist(string name, string subKey, RegDomain regDomain)
{
///返回结果
bool result = false;
///判断是否设置键值属性
if (name == string.Empty || name == null)
{
return false;
}
///判断注册表项是否存在
if (IsSubKeyExist())
{
///打开注册表项
RegistryKey key = OpenSubKey(subKey, regDomain);
///键值集合
string[] regeditKeyNames;
///获取键值集合
regeditKeyNames = key.GetValueNames();
///遍历键值集合,如果存在键值,则退出遍历
foreach (string regeditKey in regeditKeyNames)
{
if (string.Compare(regeditKey, name, true) == 0)
{
result = true;
break;
}
}
///关闭对注册表项的更改
key.Close();
}
return result;
}
#endregion
#region 设置键值内容
/// <summary>
/// 设置指定的键值内容,不指定内容数据类型(请先设置RegeditKey和SubKey属性)
/// 存在改键值则修改键值内容,不存在键值则先创建键值,再设置键值内容
/// </summary>
/// <param name="content">键值内容</param>
/// <returns>键值内容设置成功,则返回true,否则返回false</returns>
public virtual bool WriteRegeditKey(object content)
{
///返回结果
bool result = false;
///判断是否设置键值属性
if (_regeditkey == string.Empty || _regeditkey == null)
{
return false;
}
///判断注册表项是否存在,如果不存在,则直接创建
if (!IsSubKeyExist(_subkey))
{
CreateSubKey(_subkey);
}
///以可写方式打开注册表项
RegistryKey key = OpenSubKey(true);
///如果注册表项打开失败,则返回false
if (key == null)
{
return false;
}
try
{
key.SetValue(_regeditkey, content);
result = true;
}
catch
{
result = false;
}
finally
{
///关闭对注册表项的更改
key.Close();
}
return result;
}
/// <summary>
/// 设置指定的键值内容,不指定内容数据类型(请先设置SubKey属性)
/// 存在改键值则修改键值内容,不存在键值则先创建键值,再设置键值内容
/// </summary>
/// <param name="name">键值名称</param>
/// <param name="content">键值内容</param>
/// <returns>键值内容设置成功,则返回true,否则返回false</returns>
public virtual bool WriteRegeditKey(string name, object content)
{
///返回结果
bool result = false;
///判断键值是否存在
if (name == string.Empty || name == null)
{
return false;
}
///判断注册表项是否存在,如果不存在,则直接创建
if (!IsSubKeyExist(_subkey))
{
CreateSubKey(_subkey);
}
///以可写方式打开注册表项
RegistryKey key = OpenSubKey(true);
///如果注册表项打开失败,则返回false
if (key == null)
{
return false;
}
try
{
key.SetValue(name, content);
result = true;
}
catch (Exception ex)
{
result = false;
}
finally
{
///关闭对注册表项的更改
key.Close();
}
return result;
}
/// <summary>
/// 设置指定的键值内容,指定内容数据类型(请先设置SubKey属性)
/// 存在改键值则修改键值内容,不存在键值则先创建键值,再设置键值内容
/// </summary>
/// <param name="name">键值名称</param>
/// <param name="content">键值内容</param>
/// <returns>键值内容设置成功,则返回true,否则返回false</returns>
public virtual bool WriteRegeditKey(string name, object content, RegValueKind regValueKind)
{
///返回结果
bool result = false;
///判断键值是否存在
if (name == string.Empty || name == null)
{
return false;
}
///判断注册表项是否存在,如果不存在,则直接创建
if (!IsSubKeyExist(_subkey))
{
CreateSubKey(_subkey);
}
///以可写方式打开注册表项
RegistryKey key = OpenSubKey(true);
///如果注册表项打开失败,则返回false
if (key == null)
{
return false;
}
try
{
key.SetValue(name, content, GetRegValueKind(regValueKind));
result = true;
}
catch
{
result = false;
}
finally
{
///关闭对注册表项的更改
key.Close();
}
return result;
}
#endregion
#region 读取键值内容
/// <summary>
/// 读取键值内容(请先设置RegeditKey和SubKey属性)
/// .如果RegeditKey为空、null或者RegeditKey指示的键值不存在,返回null
/// .如果SubKey为空、null或者SubKey指示的注册表项不存在,返回null
/// .反之,则返回键值内容
/// </summary>
/// <returns>返回键值内容</returns>
public virtual object ReadRegeditKey()
{
///键值内容结果
object obj = null;
///判断是否设置键值属性
if (_regeditkey == string.Empty || _regeditkey == null)
{
return null;
}
///判断键值是否存在
if (IsRegeditKeyExist(_regeditkey))
{
///打开注册表项
RegistryKey key = OpenSubKey();
if (key != null)
{
obj = key.GetValue(_regeditkey);
}
///关闭对注册表项的更改
key.Close();
}
return obj;
}
/// <summary>
/// 读取键值内容(请先设置SubKey属性)
/// .如果SubKey为空、null或者SubKey指示的注册表项不存在,返回null
/// .反之,则返回键值内容
/// </summary>
/// <param name="name">键值名称</param>
/// <returns>返回键值内容</returns>
public virtual object ReadRegeditKey(string name)
{
///键值内容结果
object obj = null;
///判断是否设置键值属性
if (name == string.Empty || name == null)
{
return null;
}
///判断键值是否存在
if (IsRegeditKeyExist(name))
{
///打开注册表项
RegistryKey key = OpenSubKey();
if (key != null)
{
obj = key.GetValue(name);
}
///关闭对注册表项的更改
key.Close();
}
return obj;
}
/// <summary>
/// 读取键值内容
/// </summary>
/// <param name="name">键值名称</param>
/// <param name="subKey">注册表项名称</param>
/// <returns>返回键值内容</returns>
public virtual object ReadRegeditKey(string name, string subKey)
{
///键值内容结果
object obj = null;
///判断是否设置键值属性
if (name == string.Empty || name == null)
{
return null;
}
///判断键值是否存在
if (IsRegeditKeyExist(name))
{
///打开注册表项
RegistryKey key = OpenSubKey(subKey);
if (key != null)
{
obj = key.GetValue(name);
}
///关闭对注册表项的更改
key.Close();
}
return obj;
}
/// <summary>
/// 读取键值内容
/// </summary>
/// <param name="name">键值名称</param>
/// <param name="subKey">注册表项名称</param>
/// <param name="regDomain">注册表基项域</param>
/// <returns>返回键值内容</returns>
public virtual object ReadRegeditKey(string name, string subKey, RegDomain regDomain)
{
///键值内容结果
object obj = null;
///判断是否设置键值属性
if (name == string.Empty || name == null)
{
return null;
}
///判断键值是否存在
if (IsRegeditKeyExist(name))
{
///打开注册表项
RegistryKey key = OpenSubKey(subKey, regDomain);
if (key != null)
{
obj = key.GetValue(name);
}
///关闭对注册表项的更改
key.Close();
}
return obj;
}
#endregion
#region 删除键值
/// <summary>
/// 删除键值(请先设置RegeditKey和SubKey属性)
/// .如果RegeditKey为空、null或者RegeditKey指示的键值不存在,返回false
/// .如果SubKey为空、null或者SubKey指示的注册表项不存在,返回false
/// </summary>
/// <returns>如果删除成功,返回true,否则返回false</returns>
public virtual bool DeleteRegeditKey()
{
///删除结果
bool result = false;
///判断是否设置键值属性,如果没有设置,则返回false
if (_regeditkey == string.Empty || _regeditkey == null)
{
return false;
}
///判断键值是否存在
if (IsRegeditKeyExist(_regeditkey))
{
///以可写方式打开注册表项
RegistryKey key = OpenSubKey(true);
if (key != null)
{
try
{
///删除键值
key.DeleteValue(_regeditkey);
result = true;
}
catch
{
result = false;
}
finally
{
///关闭对注册表项的更改
key.Close();
}
}
}
return result;
}
/// <summary>
/// 删除键值(请先设置SubKey属性)
/// 如果SubKey为空、null或者SubKey指示的注册表项不存在,返回false
/// </summary>
/// <param name="name">键值名称</param>
/// <returns>如果删除成功,返回true,否则返回false</returns>
public virtual bool DeleteRegeditKey(string name)
{
///删除结果
bool result = false;
///判断键值名称是否为空,如果为空,则返回false
if (name == string.Empty || name == null)
{
return false;
}
///判断键值是否存在
if (IsRegeditKeyExist(name))
{
///以可写方式打开注册表项
RegistryKey key = OpenSubKey(true);
if (key != null)
{
try
{
///删除键值
key.DeleteValue(name);
result = true;
}
catch
{
result = false;
}
finally
{
///关闭对注册表项的更改
key.Close();
}
}
}
return result;
}
/// <summary>
/// 删除键值
/// </summary>
/// <param name="name">键值名称</param>
/// <param name="subKey">注册表项名称</param>
/// <returns>如果删除成功,返回true,否则返回false</returns>
public virtual bool DeleteRegeditKey(string name, string subKey)
{
///删除结果
bool result = false;
///判断键值名称和注册表项名称是否为空,如果为空,则返回false
if (name == string.Empty || name == null || subKey == string.Empty || subKey == null)
{
return false;
}
///判断键值是否存在
if (IsRegeditKeyExist(name))
{
///以可写方式打开注册表项
RegistryKey key = OpenSubKey(subKey, true);
if (key != null)
{
try
{
///删除键值
key.DeleteValue(name);
result = true;
}
catch
{
result = false;
}
finally
{
///关闭对注册表项的更改
key.Close();
}
}
}
return result;
}
/// <summary>
/// 删除键值
/// </summary>
/// <param name="name">键值名称</param>
/// <param name="subKey">注册表项名称</param>
/// <param name="regDomain">注册表基项域</param>
/// <returns>如果删除成功,返回true,否则返回false</returns>
public virtual bool DeleteRegeditKey(string name, string subKey, RegDomain regDomain)
{
///删除结果
bool result = false;
///判断键值名称和注册表项名称是否为空,如果为空,则返回false
if (name == string.Empty || name == null || subKey == string.Empty || subKey == null)
{
return false;
}
///判断键值是否存在
if (IsRegeditKeyExist(name))
{
///以可写方式打开注册表项
RegistryKey key = OpenSubKey(subKey, regDomain, true);
if (key != null)
{
try
{
///删除键值
key.DeleteValue(name);
result = true;
}
catch
{
result = false;
}
finally
{
///关闭对注册表项的更改
key.Close();
}
}
}
return result;
}
#endregion
#endregion
#region 受保护方法
/// <summary>
/// 获取注册表基项域对应顶级节点
/// 例子:如regDomain是ClassesRoot,则返回Registry.ClassesRoot
/// </summary>
/// <param name="regDomain">注册表基项域</param>
/// <returns>注册表基项域对应顶级节点</returns>
protected RegistryKey GetRegDomain(RegDomain regDomain)
{
///创建基于注册表基项的节点
RegistryKey key;
#region 判断注册表基项域
switch (regDomain)
{
case RegDomain.ClassesRoot:
key = Registry.ClassesRoot; break;
case RegDomain.CurrentUser:
key = Registry.CurrentUser; break;
case RegDomain.LocalMachine:
key = Registry.LocalMachine; break;
case RegDomain.User:
key = Registry.Users; break;
case RegDomain.CurrentConfig:
key = Registry.CurrentConfig; break;
case RegDomain.DynDa:
key = Registry.DynData; break;
case RegDomain.PerformanceData:
key = Registry.PerformanceData; break;
default:
key = Registry.LocalMachine; break;
}
#endregion
return key;
}
/// <summary>
/// 获取在注册表中对应的值数据类型
/// 例子:如regValueKind是DWord,则返回RegistryValueKind.DWord
/// </summary>
/// <param name="regValueKind">注册表数据类型</param>
/// <returns>注册表中对应的数据类型</returns>
protected RegistryValueKind GetRegValueKind(RegValueKind regValueKind)
{
RegistryValueKind regValueK;
#region 判断注册表数据类型
switch (regValueKind)
{
case RegValueKind.Unknown:
regValueK = RegistryValueKind.Unknown; break;
case RegValueKind.String:
regValueK = RegistryValueKind.String; break;
case RegValueKind.ExpandString:
regValueK = RegistryValueKind.ExpandString; break;
case RegValueKind.Binary:
regValueK = RegistryValueKind.Binary; break;
case RegValueKind.DWord:
regValueK = RegistryValueKind.DWord; break;
case RegValueKind.MultiString:
regValueK = RegistryValueKind.MultiString; break;
case RegValueKind.QWord:
regValueK = RegistryValueKind.QWord; break;
default:
regValueK = RegistryValueKind.String; break;
}
#endregion
return regValueK;
}
#region 打开注册表项
/// <summary>
/// 打开注册表项节点,以只读方式检索子项
/// 虚方法,子类可进行重写
/// </summary>
/// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在,则返回null,否则返回注册表节点</returns>
protected virtual RegistryKey OpenSubKey()
{
///判断注册表项名称是否为空
if (_subkey == string.Empty || _subkey == null)
{
return null;
}
///创建基于注册表基项的节点
RegistryKey key = GetRegDomain(_domain);
///要打开的注册表项的节点
RegistryKey sKey = null;
///打开注册表项
sKey = key.OpenSubKey(_subkey);
///关闭对注册表项的更改
key.Close();
///返回注册表节点
return sKey;
}
/// <summary>
/// 打开注册表项节点
/// 虚方法,子类可进行重写
/// </summary>
/// <param name="writable">如果需要项的写访问权限,则设置为 true</param>
/// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在,则返回null,否则返回注册表节点</returns>
protected virtual RegistryKey OpenSubKey(bool writable)
{
///判断注册表项名称是否为空
if (_subkey == string.Empty || _subkey == null)
{
return null;
}
///创建基于注册表基项的节点
RegistryKey key = GetRegDomain(_domain);
///要打开的注册表项的节点
RegistryKey sKey = null;
///打开注册表项
sKey = key.OpenSubKey(_subkey, writable);
///关闭对注册表项的更改
key.Close();
///返回注册表节点
return sKey;
}
/// <summary>
/// 打开注册表项节点,以只读方式检索子项
/// 虚方法,子类可进行重写
/// </summary>
/// <param name="subKey">注册表项名称</param>
/// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在,则返回null,否则返回注册表节点</returns>
protected virtual RegistryKey OpenSubKey(string subKey)
{
///判断注册表项名称是否为空
if (subKey == string.Empty || subKey == null)
{
return null;
}
///创建基于注册表基项的节点
RegistryKey key = GetRegDomain(_domain);
///要打开的注册表项的节点
RegistryKey sKey = null;
///打开注册表项
sKey = key.OpenSubKey(subKey);
///关闭对注册表项的更改
key.Close();
///返回注册表节点
return sKey;
}
/// <summary>
/// 打开注册表项节点,以只读方式检索子项
/// 虚方法,子类可进行重写
/// </summary>
/// <param name="subKey">注册表项名称</param>
/// <param name="writable">如果需要项的写访问权限,则设置为 true</param>
/// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在,则返回null,否则返回注册表节点</returns>
protected virtual RegistryKey OpenSubKey(string subKey, bool writable)
{
///判断注册表项名称是否为空
if (subKey == string.Empty || subKey == null)
{
return null;
}
///创建基于注册表基项的节点
RegistryKey key = GetRegDomain(_domain);
///要打开的注册表项的节点
RegistryKey sKey = null;
///打开注册表项
sKey = key.OpenSubKey(subKey, writable);
///关闭对注册表项的更改
key.Close();
///返回注册表节点
return sKey;
}
/// <summary>
/// 打开注册表项节点,以只读方式检索子项
/// 虚方法,子类可进行重写
/// </summary>
/// <param name="subKey">注册表项名称</param>
/// <param name="regDomain">注册表基项域</param>
/// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在,则返回null,否则返回注册表节点</returns>
protected virtual RegistryKey OpenSubKey(string subKey, RegDomain regDomain)
{
///判断注册表项名称是否为空
if (subKey == string.Empty || subKey == null)
{
return null;
}
///创建基于注册表基项的节点
RegistryKey key = GetRegDomain(regDomain);
///要打开的注册表项的节点
RegistryKey sKey = null;
///打开注册表项
sKey = key.OpenSubKey(subKey);
///关闭对注册表项的更改
key.Close();
///返回注册表节点
return sKey;
}
/// <summary>
/// 打开注册表项节点
/// 虚方法,子类可进行重写
/// </summary>
/// <param name="subKey">注册表项名称</param>
/// <param name="regDomain">注册表基项域</param>
/// <param name="writable">如果需要项的写访问权限,则设置为 true</param>
/// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在,则返回null,否则返回注册表节点</returns>
protected virtual RegistryKey OpenSubKey(string subKey, RegDomain regDomain, bool writable)
{
///判断注册表项名称是否为空
if (subKey == string.Empty || subKey == null)
{
return null;
}
///创建基于注册表基项的节点
RegistryKey key = GetRegDomain(regDomain);
///要打开的注册表项的节点
RegistryKey sKey = null;
///打开注册表项
sKey = key.OpenSubKey(subKey, writable);
///关闭对注册表项的更改
key.Close();
///返回注册表节点
return sKey;
}
#endregion
#endregion
}
}
不过注册表操作,存在一定风险,可能会导致电脑蓝屏或宕机,建议将注册码最好写入系统文件,不要采用注册表形式,除非特殊的业务需求
最后贴一张截图吧,实现的效果