c#注冊表操作類分享

2020-01-24 02:45:20

字體：大中小

來源：轉載

供稿：網友

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