C#注冊表讀寫完整操作類

1.注冊表基項靜態域

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

 2.指定在注冊表中存儲值時所用的數據類型，或標識注冊表中某個值的數據類型

/// <summary>
   /// 指定在注冊表中存儲值時所用的數據類型，或標識注冊表中某個值的數據類型
   ///1.RegistryValueKind.Unknown
   ///2.RegistryValueKind.String
   ///3.RegistryValueKind.ExpandString
   ///4.RegistryValueKind.Binary
   ///5.RegistryValueKind.DWord
   ///6.RegistryValueKind.MultiString
   ///7.RegistryValueKind.QWord
   /// </summary>
   public enum RegValueKind
   {
       /// <summary>
       /// 指示一個不受支持的注冊表數據類型。例如，不支持 Microsoft Win API 注冊表數據類型 REG_RESOURCE_LIST。使用此值指定
       /// </summary>
       Unknown = 0,
       /// <summary>
       /// 指定一個以 Null 結尾的字符串。此值與 Win API 注冊表數據類型 REG_SZ 等效。
       /// </summary>
       String = 1,
       /// <summary>
       /// 指定一個以 NULL 結尾的字符串，該字符串中包含對環境變量（如 %PATH%，當值被檢索時，就會展開）的未展開的引用。
       /// 此值與 Win API 注冊表數據類型 REG_EXPAND_SZ 等效。
       /// </summary>
       ExpandString = 2,
       /// <summary>
       /// 指定任意格式的二進制數據。此值與 Win API 注冊表數據類型 REG_BINARY 等效。
       /// </summary>
       Binary = 3,
       /// <summary>
       /// 指定一個  位二進制數。此值與 Win API 注冊表數據類型 REG_DWORD 等效。
       /// </summary>
       DWord = 4,
       /// <summary>
       /// 指定一個以 NULL 結尾的字符串數組，以兩個空字符結束。此值與 WinAPI 注冊表數據類型 REG_MULTI_SZ 等效。
       /// </summary>
       MultiString = 5,
       /// <summary>
       /// 指定一個  位二進制數。此值與 Win API 注冊表數據類型 REG_QWORD 等效。
       /// </summary>
       QWord = 6
   }

 3.注冊表操作類

/// <summary>
    /// 注冊表操作類
    ///1.創建注冊表項
    ///2.讀取注冊表項
    ///3.判斷注冊表項是否存在
    ///4.刪除注冊表項
    ///5.創建注冊表鍵值
    ///6.讀取注冊表鍵值
    ///7.判斷注冊表鍵值是否存在
    ///8.刪除注冊表鍵值
    /// </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()
        {

        }

        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
    }