1.注册表基项静态域

C#代码  C#注册表读写完整操作类-DESTLIVE
  1. /// <summary>  
  2.     /// 注册表基项静态域  
  3.     ///1.Registry.ClassesRoot 对应于HKEY_CLASSES_ROOT 主键  
  4.     ///2.Registry.CurrentUser 对应于HKEY_CURRENT_USER 主键  
  5.     ///3.Registry.LocalMachine 对应于 HKEY_LOCAL_MACHINE 主键  
  6.     ///4.Registry.User 对应于 HKEY_USER 主键  
  7.     ///5.Registry.CurrentConfig 对应于HEKY_CURRENT_CONFIG 主键  
  8.     ///6.Registry.DynDa 对应于HKEY_DYN_DATA 主键  
  9.     ///7.Registry.PerformanceData 对应于HKEY_PERFORMANCE_DATA 主键  
  10.     /// </summary>  
  11.     public enum RegDomain  
  12.     {  
  13.         /// <summary>  
  14.         /// 对应于HKEY_CLASSES_ROOT 主键  
  15.         /// </summary>  
  16.         ClassesRoot = 0,  
  17.         /// <summary>  
  18.         /// 对应于HKEY_CURRENT_USER 主键  
  19.         /// </summary>  
  20.         CurrentUser = 1,  
  21.         /// <summary>  
  22.         /// 对应于 HKEY_LOCAL_MACHINE 主键  
  23.         /// </summary>  
  24.         LocalMachine = 2,  
  25.         /// <summary>  
  26.         /// 对应于 HKEY_USER 主键  
  27.         /// </summary>  
  28.         User = 3,  
  29.         /// <summary>  
  30.         /// 对应于HEKY_CURRENT_CONFIG 主键  
  31.         /// </summary>  
  32.         CurrentConfig = 4,  
  33.         /// <summary>  
  34.         /// 对应于HKEY_DYN_DATA 主键  
  35.         /// </summary>  
  36.         DynDa = 5,  
  37.         /// <summary>  
  38.         /// 对应于HKEY_PERFORMANCE_DATA 主键  
  39.         /// </summary>  
  40.         PerformanceData = 6  
  41.     }  

 2.指定在注册表中存储值时所用的数据类型,或标识注册表中某个值的数据类型

C#代码  C#注册表读写完整操作类-DESTLIVE
  1. /// <summary>  
  2.    /// 指定在注册表中存储值时所用的数据类型,或标识注册表中某个值的数据类型  
  3.    ///1.RegistryValueKind.Unknown  
  4.    ///2.RegistryValueKind.String  
  5.    ///3.RegistryValueKind.ExpandString  
  6.    ///4.RegistryValueKind.Binary  
  7.    ///5.RegistryValueKind.DWord  
  8.    ///6.RegistryValueKind.MultiString  
  9.    ///7.RegistryValueKind.QWord  
  10.    /// </summary>  
  11.    public enum RegValueKind  
  12.    {  
  13.        /// <summary>  
  14.        /// 指示一个不受支持的注册表数据类型。例如,不支持 Microsoft Win API 注册表数据类型 REG_RESOURCE_LIST。使用此值指定  
  15.        /// </summary>  
  16.        Unknown = 0,  
  17.        /// <summary>  
  18.        /// 指定一个以 Null 结尾的字符串。此值与 Win API 注册表数据类型 REG_SZ 等效。  
  19.        /// </summary>  
  20.        String = 1,  
  21.        /// <summary>  
  22.        /// 指定一个以 NULL 结尾的字符串,该字符串中包含对环境变量(如 %PATH%,当值被检索时,就会展开)的未展开的引用。  
  23.        /// 此值与 Win API 注册表数据类型 REG_EXPAND_SZ 等效。  
  24.        /// </summary>  
  25.        ExpandString = 2,  
  26.        /// <summary>  
  27.        /// 指定任意格式的二进制数据。此值与 Win API 注册表数据类型 REG_BINARY 等效。  
  28.        /// </summary>  
  29.        Binary = 3,  
  30.        /// <summary>  
  31.        /// 指定一个  位二进制数。此值与 Win API 注册表数据类型 REG_DWORD 等效。  
  32.        /// </summary>  
  33.        DWord = 4,  
  34.        /// <summary>  
  35.        /// 指定一个以 NULL 结尾的字符串数组,以两个空字符结束。此值与 WinAPI 注册表数据类型 REG_MULTI_SZ 等效。  
  36.        /// </summary>  
  37.        MultiString = 5,  
  38.        /// <summary>  
  39.        /// 指定一个  位二进制数。此值与 Win API 注册表数据类型 REG_QWORD 等效。  
  40.        /// </summary>  
  41.        QWord = 6  
  42.    }  

 3.注册表操作类

C#代码  C#注册表读写完整操作类-DESTLIVE
  1. /// <summary>  
  2.     /// 注册表操作类  
  3.     ///1.创建注册表项  
  4.     ///2.读取注册表项  
  5.     ///3.判断注册表项是否存在  
  6.     ///4.删除注册表项  
  7.     ///5.创建注册表键值  
  8.     ///6.读取注册表键值  
  9.     ///7.判断注册表键值是否存在  
  10.     ///8.删除注册表键值  
  11.     /// </summary>  
  12.     public class Register  
  13.     {  
  14.         #region 字段定义  
  15.   
  16.         /// <summary>  
  17.         /// 注册表项名称  
  18.         /// </summary>  
  19.         private string _subkey;  
  20.         /// <summary>  
  21.         /// 注册表基项域  
  22.         /// </summary>  
  23.         private RegDomain _domain;  
  24.         /// <summary>  
  25.         /// 注册表键值  
  26.         /// </summary>  
  27.         private string _regeditkey;  
  28.  
  29.         #endregion  
  30.  
  31.         #region 属性  
  32.   
  33.         /// <summary>  
  34.         /// 设置注册表项名称  
  35.         /// </summary>  
  36.         public string SubKey  
  37.         {  
  38.             //get { return _subkey; }  
  39.             set { _subkey = value; }  
  40.         }  
  41.   
  42.         /// <summary>  
  43.         /// 注册表基项域  
  44.         /// </summary>  
  45.         public RegDomain Domain  
  46.         {  
  47.             ///get { return _domain; }  
  48.             set { _domain = value; }  
  49.         }  
  50.   
  51.         /// <summary>  
  52.         /// 注册表键值  
  53.         /// </summary>  
  54.         public string RegeditKey  
  55.         {  
  56.             ///get{return _regeditkey;}  
  57.             set { _regeditkey = value; }  
  58.         }  
  59.  
  60.         #endregion  
  61.  
  62.         #region 构造函数  
  63.   
  64.         public Register()  
  65.         {  
  66.   
  67.         }  
  68.   
  69.         public Register()  
  70.         {  
  71.             ///默认注册表项名称  
  72.             _subkey = "software\\";  
  73.             ///默认注册表基项域  
  74.             _domain = RegDomain.LocalMachine;  
  75.         }  
  76.   
  77.         /// <summary>  
  78.         /// 构造函数  
  79.         /// </summary>  
  80.         /// <param name="subKey">注册表项名称</param>  
  81.         /// <param name="regDomain">注册表基项域</param>  
  82.         public Register(string subKey, RegDomain regDomain)  
  83.         {  
  84.             ///设置注册表项名称  
  85.             _subkey = subKey;  
  86.             ///设置注册表基项域  
  87.             _domain = regDomain;  
  88.         }  
  89.  
  90.         #endregion  
  91.  
  92.         #region 公有方法  
  93.  
  94.         #region 创建注册表项  
  95.   
  96.         /// <summary>  
  97.         /// 创建注册表项,默认创建在注册表基项 HKEY_LOCAL_MACHINE 下面(请先设置SubKey 属性)  
  98.         /// 虚方法,子类可进行重写  
  99.         /// </summary>  
  100.         public virtual void CreateSubKey()  
  101.         {  
  102.             ///判断注册表项名称是否为空,如果为空,返回false  
  103.             if (_subkey == string.Empty || _subkey == null)  
  104.             {  
  105.                 return;  
  106.             }  
  107.   
  108.             ///创建基于注册表基项的节点  
  109.             RegistryKey key = GetRegDomain(_domain);  
  110.   
  111.             ///要创建的注册表项的节点  
  112.             RegistryKey sKey;  
  113.             if (!IsSubKeyExist())  
  114.             {  
  115.                 sKey = key.CreateSubKey(_subkey);  
  116.             }  
  117.             //sKey.Close();  
  118.             ///关闭对注册表项的更改  
  119.             key.Close();  
  120.         }  
  121.   
  122.         /// <summary>  
  123.         /// 创建注册表项,默认创建在注册表基项 HKEY_LOCAL_MACHINE 下面  
  124.         /// 虚方法,子类可进行重写  
  125.         /// 例子:如subkey 是software\\higame\\,则将创建HKEY_LOCAL_MACHINE\\software\\higame\\注册表项  
  126.         /// </summary>  
  127.         /// <param name="subKey">注册表项名称</param>  
  128.         public virtual void CreateSubKey(string subKey)  
  129.         {  
  130.             ///判断注册表项名称是否为空,如果为空,返回false  
  131.             if (subKey == string.Empty || subKey == null)  
  132.             {  
  133.                 return;  
  134.             }  
  135.   
  136.             ///创建基于注册表基项的节点  
  137.             RegistryKey key = GetRegDomain(_domain);  
  138.   
  139.             ///要创建的注册表项的节点  
  140.             RegistryKey sKey;  
  141.             if (!IsSubKeyExist(subKey))  
  142.             {  
  143.                 sKey = key.CreateSubKey(subKey);  
  144.             }  
  145.             //sKey.Close();  
  146.             ///关闭对注册表项的更改  
  147.             key.Close();  
  148.         }  
  149.   
  150.         /// <summary>  
  151.         /// 创建注册表项,默认创建在注册表基项 HKEY_LOCAL_MACHINE 下面  
  152.         /// 虚方法,子类可进行重写  
  153.         /// </summary>  
  154.         /// <param name="regDomain">注册表基项域</param>  
  155.         public virtual void CreateSubKey(RegDomain regDomain)  
  156.         {  
  157.             ///判断注册表项名称是否为空,如果为空,返回false  
  158.             if (_subkey == string.Empty || _subkey == null)  
  159.             {  
  160.                 return;  
  161.             }  
  162.   
  163.             ///创建基于注册表基项的节点  
  164.             RegistryKey key = GetRegDomain(regDomain);  
  165.   
  166.             ///要创建的注册表项的节点  
  167.             RegistryKey sKey;  
  168.             if (!IsSubKeyExist(regDomain))  
  169.             {  
  170.                 sKey = key.CreateSubKey(_subkey);  
  171.             }  
  172.             //sKey.Close();  
  173.             ///关闭对注册表项的更改  
  174.             key.Close();  
  175.         }  
  176.   
  177.         /// <summary>  
  178.         /// 创建注册表项(请先设置SubKey 属性)  
  179.         /// 虚方法,子类可进行重写  
  180.         /// 例子:如regDomain 是HKEY_LOCAL_MACHINE,subkey 是software\\higame\\,则将创建HKEY_LOCAL_MACHINE\\software\\higame\\注册表项  
  181.         /// </summary>  
  182.         /// <param name="subKey">注册表项名称</param>  
  183.         /// <param name="regDomain">注册表基项域</param>  
  184.         public virtual void CreateSubKey(string subKey, RegDomain regDomain)  
  185.         {  
  186.             ///判断注册表项名称是否为空,如果为空,返回false  
  187.             if (subKey == string.Empty || subKey == null)  
  188.             {  
  189.                 return;  
  190.             }  
  191.   
  192.             ///创建基于注册表基项的节点  
  193.             RegistryKey key = GetRegDomain(regDomain);  
  194.   
  195.             ///要创建的注册表项的节点  
  196.             RegistryKey sKey;  
  197.             if (!IsSubKeyExist(subKey, regDomain))  
  198.             {  
  199.                 sKey = key.CreateSubKey(subKey);  
  200.             }  
  201.             //sKey.Close();  
  202.             ///关闭对注册表项的更改  
  203.             key.Close();  
  204.         }  
  205.  
  206.         #endregion  
  207.  
  208.         #region 判断注册表项是否存在  
  209.   
  210.         /// <summary>  
  211.         /// 判断注册表项是否存在,默认是在注册表基项HKEY_LOCAL_MACHINE 下判断(请先设置SubKey 属性)  
  212.         /// 虚方法,子类可进行重写  
  213.         /// 例子:如果设置了Domain 和SubKey 属性,则判断Domain\\SubKey,否则默认判断HKEY_LOCAL_MACHINE\\software\\  
  214.         /// </summary>  
  215.         /// <returns>返回注册表项是否存在,存在返回true,否则返回false</returns>  
  216.         public virtual bool IsSubKeyExist()  
  217.         {  
  218.             ///判断注册表项名称是否为空,如果为空,返回false  
  219.             if (_subkey == string.Empty || _subkey == null)  
  220.             {  
  221.                 return false;  
  222.             }  
  223.   
  224.             ///检索注册表子项  
  225.             ///如果sKey 为null,说明没有该注册表项不存在,否则存在  
  226.             RegistryKey sKey = OpenSubKey(_subkey, _domain);  
  227.             if (sKey == null)  
  228.             {  
  229.                 return false;  
  230.             }  
  231.             return true;  
  232.         }  
  233.   
  234.         /// <summary>  
  235.         /// 判断注册表项是否存在,默认是在注册表基项HKEY_LOCAL_MACHINE 下判断  
  236.         /// 虚方法,子类可进行重写  
  237.         /// 例子:如subkey 是software\\higame\\,则将判断HKEY_LOCAL_MACHINE\\software\\higame\\注册表项是否存在  
  238.         /// </summary>  
  239.         /// <param name="subKey">注册表项名称</param>  
  240.         /// <returns>返回注册表项是否存在,存在返回true,否则返回false</returns>  
  241.         public virtual bool IsSubKeyExist(string subKey)  
  242.         {  
  243.             ///判断注册表项名称是否为空,如果为空,返回false  
  244.             if (subKey == string.Empty || subKey == null)  
  245.             {  
  246.                 return false;  
  247.             }  
  248.   
  249.             ///检索注册表子项  
  250.             ///如果sKey 为null,说明没有该注册表项不存在,否则存在  
  251.             RegistryKey sKey = OpenSubKey(subKey);  
  252.             if (sKey == null)  
  253.             {  
  254.                 return false;  
  255.             }  
  256.             return true;  
  257.         }  
  258.   
  259.         /// <summary>  
  260.         /// 判断注册表项是否存在  
  261.         /// 虚方法,子类可进行重写  
  262.         /// 例子:如regDomain 是HKEY_CLASSES_ROOT,则将判断HKEY_CLASSES_ROOT\\SubKey 注册表项是否存在  
  263.         /// </summary>  
  264.         /// <param name="regDomain">注册表基项域</param>  
  265.         /// <returns>返回注册表项是否存在,存在返回true,否则返回false</returns>  
  266.         public virtual bool IsSubKeyExist(RegDomain regDomain)  
  267.         {  
  268.             ///判断注册表项名称是否为空,如果为空,返回false  
  269.             if (_subkey == string.Empty || _subkey == null)  
  270.             {  
  271.                 return false;  
  272.             }  
  273.   
  274.             ///检索注册表子项  
  275.             ///如果sKey 为null,说明没有该注册表项不存在,否则存在  
  276.             RegistryKey sKey = OpenSubKey(_subkey, regDomain);  
  277.             if (sKey == null)  
  278.             {  
  279.                 return false;  
  280.             }  
  281.             return true;  
  282.         }  
  283.   
  284.         /// <summary>  
  285.         /// 判断注册表项是否存在(请先设置SubKey 属性)  
  286.         /// 虚方法,子类可进行重写  
  287.         /// 例子:如regDomain 是HKEY_CLASSES_ROOT,subkey 是software\\higame\\,则将判断HKEY_CLASSES_ROOT\\software\\higame\\注册表项是否存在  
  288.         /// </summary>  
  289.         /// <param name="subKey">注册表项名称</param>  
  290.         /// <param name="regDomain">注册表基项域</param>  
  291.         /// <returns>返回注册表项是否存在,存在返回true,否则返回false</returns>  
  292.         public virtual bool IsSubKeyExist(string subKey, RegDomain regDomain)  
  293.         {  
  294.             ///判断注册表项名称是否为空,如果为空,返回false  
  295.             if (subKey == string.Empty || subKey == null)  
  296.             {  
  297.                 return false;  
  298.             }  
  299.   
  300.             ///检索注册表子项  
  301.             ///如果sKey 为null,说明没有该注册表项不存在,否则存在  
  302.             RegistryKey sKey = OpenSubKey(subKey, regDomain);  
  303.             if (sKey == null)  
  304.             {  
  305.                 return false;  
  306.             }  
  307.             return true;  
  308.         }  
  309.  
  310.         #endregion  
  311.  
  312.         #region 删除注册表项  
  313.   
  314.         /// <summary>  
  315.         /// 删除注册表项(请先设置SubKey 属性)  
  316.         /// 虚方法,子类可进行重写  
  317.         /// </summary>  
  318.         /// <returns>如果删除成功,则返回true,否则为false</returns>  
  319.         public virtual bool DeleteSubKey()  
  320.         {  
  321.             ///返回删除是否成功  
  322.             bool result = false;  
  323.   
  324.             ///判断注册表项名称是否为空,如果为空,返回false  
  325.             if (_subkey == string.Empty || _subkey == null)  
  326.             {  
  327.                 return false;  
  328.             }  
  329.   
  330.             ///创建基于注册表基项的节点  
  331.             RegistryKey key = GetRegDomain(_domain);  
  332.   
  333.             if (IsSubKeyExist())  
  334.             {  
  335.                 try  
  336.                 {  
  337.                     ///删除注册表项  
  338.                     key.DeleteSubKey(_subkey);  
  339.                     result = true;  
  340.                 }  
  341.                 catch  
  342.                 {  
  343.                     result = false;  
  344.                 }  
  345.             }  
  346.             ///关闭对注册表项的更改  
  347.             key.Close();  
  348.             return result;  
  349.         }  
  350.   
  351.         /// <summary>  
  352.         /// 删除注册表项(请先设置SubKey 属性)  
  353.         /// 虚方法,子类可进行重写  
  354.         /// </summary>  
  355.         /// <param name="subKey">注册表项名称</param>  
  356.         /// <returns>如果删除成功,则返回true,否则为false</returns>  
  357.         public virtual bool DeleteSubKey(string subKey)  
  358.         {  
  359.             ///返回删除是否成功  
  360.             bool result = false;  
  361.   
  362.             ///判断注册表项名称是否为空,如果为空,返回false  
  363.             if (subKey == string.Empty || subKey == null)  
  364.             {  
  365.                 return false;  
  366.             }  
  367.   
  368.             ///创建基于注册表基项的节点  
  369.             RegistryKey key = GetRegDomain(_domain);  
  370.   
  371.             if (IsSubKeyExist())  
  372.             {  
  373.                 try  
  374.                 {  
  375.                     ///删除注册表项  
  376.                     key.DeleteSubKey(subKey);  
  377.                     result = true;  
  378.                 }  
  379.                 catch  
  380.                 {  
  381.                     result = false;  
  382.                 }  
  383.             }  
  384.             ///关闭对注册表项的更改  
  385.             key.Close();  
  386.             return result;  
  387.         }  
  388.   
  389.         /// <summary>  
  390.         /// 删除注册表项  
  391.         /// 虚方法,子类可进行重写  
  392.         /// </summary>  
  393.         /// <param name="subKey">注册表项名称</param>  
  394.         /// <param name="regDomain">注册表基项域</param>  
  395.         /// <returns>如果删除成功,则返回true,否则为false</returns>  
  396.         public virtual bool DeleteSubKey(string subKey, RegDomain regDomain)  
  397.         {  
  398.             ///返回删除是否成功  
  399.             bool result = false;  
  400.   
  401.             ///判断注册表项名称是否为空,如果为空,返回false  
  402.             if (subKey == string.Empty || subKey == null)  
  403.             {  
  404.                 return false;  
  405.             }  
  406.   
  407.             ///创建基于注册表基项的节点  
  408.             RegistryKey key = GetRegDomain(regDomain);  
  409.   
  410.             if (IsSubKeyExist(subKey, regDomain))  
  411.             {  
  412.                 try  
  413.                 {  
  414.                     ///删除注册表项  
  415.                     key.DeleteSubKey(subKey);  
  416.                     result = true;  
  417.                 }  
  418.                 catch  
  419.                 {  
  420.                     result = false;  
  421.                 }  
  422.             }  
  423.             ///关闭对注册表项的更改  
  424.             key.Close();  
  425.             return result;  
  426.         }  
  427.  
  428.         #endregion  
  429.  
  430.         #region 判断键值是否存在  
  431.   
  432.         /// <summary>  
  433.         /// 判断键值是否存在(请先设置SubKey 和RegeditKey 属性)  
  434.         /// 虚方法,子类可进行重写  
  435.         /// .如果RegeditKey 为空、null,则返回false  
  436.         /// .如果SubKey 为空、null 或者SubKey 指定的注册表项不存在,返回false  
  437.         /// </summary>  
  438.         /// <returns>返回键值是否存在,存在返回true,否则返回false</returns>  
  439.         public virtual bool IsRegeditKeyExist()  
  440.         {  
  441.             ///返回结果  
  442.             bool result = false;  
  443.   
  444.             ///判断是否设置键值属性  
  445.             if (_regeditkey == string.Empty || _regeditkey == null)  
  446.             {  
  447.                 return false;  
  448.             }  
  449.   
  450.             ///判断注册表项是否存在  
  451.             if (IsSubKeyExist())  
  452.             {  
  453.                 ///打开注册表项  
  454.                 RegistryKey key = OpenSubKey();  
  455.                 ///键值集合  
  456.                 string[] regeditKeyNames;  
  457.                 ///获取键值集合  
  458.                 regeditKeyNames = key.GetValueNames();  
  459.                 ///遍历键值集合,如果存在键值,则退出遍历  
  460.                 foreach (string regeditKey in regeditKeyNames)  
  461.                 {  
  462.                     if (string.Compare(regeditKey, _regeditkey, true) == 0)  
  463.                     {  
  464.                         result = true;  
  465.                         break;  
  466.                     }  
  467.                 }  
  468.                 ///关闭对注册表项的更改  
  469.                 key.Close();  
  470.             }  
  471.             return result;  
  472.         }  
  473.   
  474.         /// <summary>  
  475.         /// 判断键值是否存在(请先设置SubKey 属性)  
  476.         /// 虚方法,子类可进行重写  
  477.         /// 如果SubKey 为空、null 或者SubKey 指定的注册表项不存在,返回false  
  478.         /// </summary>  
  479.         /// <param name="name">键值名称</param>  
  480.         /// <returns>返回键值是否存在,存在返回true,否则返回false</returns>  
  481.         public virtual bool IsRegeditKeyExist(string name)  
  482.         {  
  483.             ///返回结果  
  484.             bool result = false;  
  485.   
  486.             ///判断是否设置键值属性  
  487.             if (name == string.Empty || name == null)  
  488.             {  
  489.                 return false;  
  490.             }  
  491.   
  492.             ///判断注册表项是否存在  
  493.             if (IsSubKeyExist())  
  494.             {  
  495.                 ///打开注册表项  
  496.                 RegistryKey key = OpenSubKey();  
  497.                 ///键值集合  
  498.                 string[] regeditKeyNames;  
  499.                 ///获取键值集合  
  500.                 regeditKeyNames = key.GetValueNames();  
  501.                 ///遍历键值集合,如果存在键值,则退出遍历  
  502.                 foreach (string regeditKey in regeditKeyNames)  
  503.                 {  
  504.                     if (string.Compare(regeditKey, name, true) == 0)  
  505.                     {  
  506.                         result = true;  
  507.                         break;  
  508.                     }  
  509.                 }  
  510.                 ///关闭对注册表项的更改  
  511.                 key.Close();  
  512.             }  
  513.             return result;  
  514.         }  
  515.   
  516.         /// <summary>  
  517.         /// 判断键值是否存在  
  518.         /// 虚方法,子类可进行重写  
  519.         /// </summary>  
  520.         /// <param name="name">键值名称</param>  
  521.         /// <param name="subKey">注册表项名称</param>  
  522.         /// <returns>返回键值是否存在,存在返回true,否则返回false</returns>  
  523.         public virtual bool IsRegeditKeyExist(string name, string subKey)  
  524.         {  
  525.             ///返回结果  
  526.             bool result = false;  
  527.   
  528.             ///判断是否设置键值属性  
  529.             if (name == string.Empty || name == null)  
  530.             {  
  531.                 return false;  
  532.             }  
  533.   
  534.             ///判断注册表项是否存在  
  535.             if (IsSubKeyExist())  
  536.             {  
  537.                 ///打开注册表项  
  538.                 RegistryKey key = OpenSubKey(subKey);  
  539.                 ///键值集合  
  540.                 string[] regeditKeyNames;  
  541.                 ///获取键值集合  
  542.                 regeditKeyNames = key.GetValueNames();  
  543.                 ///遍历键值集合,如果存在键值,则退出遍历  
  544.                 foreach (string regeditKey in regeditKeyNames)  
  545.                 {  
  546.                     if (string.Compare(regeditKey, name, true) == 0)  
  547.                     {  
  548.                         result = true;  
  549.                         break;  
  550.                     }  
  551.                 }  
  552.                 ///关闭对注册表项的更改  
  553.                 key.Close();  
  554.             }  
  555.             return result;  
  556.         }  
  557.   
  558.         /// <summary>  
  559.         /// 判断键值是否存在  
  560.         /// 虚方法,子类可进行重写  
  561.         /// </summary>  
  562.         /// <param name="name">键值名称</param>  
  563.         /// <param name="subKey">注册表项名称</param>  
  564.         /// <param name="regDomain">注册表基项域</param>  
  565.         /// <returns>返回键值是否存在,存在返回true,否则返回false</returns>  
  566.         public virtual bool IsRegeditKeyExist(string name, string subKey, RegDomain regDomain)  
  567.         {  
  568.             ///返回结果  
  569.             bool result = false;  
  570.   
  571.             ///判断是否设置键值属性  
  572.             if (name == string.Empty || name == null)  
  573.             {  
  574.                 return false;  
  575.             }  
  576.   
  577.             ///判断注册表项是否存在  
  578.             if (IsSubKeyExist())  
  579.             {  
  580.                 ///打开注册表项  
  581.                 RegistryKey key = OpenSubKey(subKey, regDomain);  
  582.                 ///键值集合  
  583.                 string[] regeditKeyNames;  
  584.                 ///获取键值集合  
  585.                 regeditKeyNames = key.GetValueNames();  
  586.                 ///遍历键值集合,如果存在键值,则退出遍历  
  587.                 foreach (string regeditKey in regeditKeyNames)  
  588.                 {  
  589.                     if (string.Compare(regeditKey, name, true) == 0)  
  590.                     {  
  591.                         result = true;  
  592.                         break;  
  593.                     }  
  594.                 }  
  595.                 ///关闭对注册表项的更改  
  596.                 key.Close();  
  597.             }  
  598.             return result;  
  599.         }  
  600.  
  601.         #endregion  
  602.  
  603.         #region 设置键值内容  
  604.   
  605.         /// <summary>  
  606.         /// 设置指定的键值内容,不指定内容数据类型(请先设置RegeditKey 和SubKey 属性)  
  607.         /// 存在改键值则修改键值内容,不存在键值则先创建键值,再设置键值内容  
  608.         /// </summary>  
  609.         /// <param name="content">键值内容</param>  
  610.         /// <returns>键值内容设置成功,则返回true,否则返回false</returns>  
  611.         public virtual bool WriteRegeditKey(object content)  
  612.         {  
  613.             ///返回结果  
  614.             bool result = false;  
  615.   
  616.             ///判断是否设置键值属性  
  617.             if (_regeditkey == string.Empty || _regeditkey == null)  
  618.             {  
  619.                 return false;  
  620.             }  
  621.   
  622.             ///判断注册表项是否存在,如果不存在,则直接创建  
  623.             if (!IsSubKeyExist(_subkey))  
  624.             {  
  625.                 CreateSubKey(_subkey);  
  626.             }  
  627.   
  628.             ///以可写方式打开注册表项  
  629.             RegistryKey key = OpenSubKey(true);  
  630.   
  631.             ///如果注册表项打开失败,则返回false  
  632.             if (key == null)  
  633.             {  
  634.                 return false;  
  635.             }  
  636.   
  637.             try  
  638.             {  
  639.                 key.SetValue(_regeditkey, content);  
  640.                 result = true;  
  641.             }  
  642.             catch  
  643.             {  
  644.                 result = false;  
  645.             }  
  646.             finally  
  647.             {  
  648.                 ///关闭对注册表项的更改  
  649.                 key.Close();  
  650.             }  
  651.             return result;  
  652.         }  
  653.   
  654.         /// <summary>  
  655.         /// 设置指定的键值内容,不指定内容数据类型(请先设置SubKey 属性)  
  656.         /// 存在改键值则修改键值内容,不存在键值则先创建键值,再设置键值内容  
  657.         /// </summary>  
  658.         /// <param name="name">键值名称</param>  
  659.         /// <param name="content">键值内容</param>  
  660.         /// <returns>键值内容设置成功,则返回true,否则返回false</returns>  
  661.         public virtual bool WriteRegeditKey(string name, object content)  
  662.         {  
  663.             ///返回结果  
  664.             bool result = false;  
  665.   
  666.             ///判断键值是否存在  
  667.             if (name == string.Empty || name == null)  
  668.             {  
  669.                 return false;  
  670.             }  
  671.   
  672.             ///判断注册表项是否存在,如果不存在,则直接创建  
  673.             if (!IsSubKeyExist(_subkey))  
  674.             {  
  675.                 CreateSubKey(_subkey);  
  676.             }  
  677.   
  678.             ///以可写方式打开注册表项  
  679.             RegistryKey key = OpenSubKey(true);  
  680.   
  681.             ///如果注册表项打开失败,则返回false  
  682.             if (key == null)  
  683.             {  
  684.                 return false;  
  685.             }  
  686.   
  687.             try  
  688.             {  
  689.                 key.SetValue(name, content);  
  690.                 result = true;  
  691.             }  
  692.             catch (Exception ex)  
  693.             {  
  694.                 result = false;  
  695.             }  
  696.             finally  
  697.             {  
  698.                 ///关闭对注册表项的更改  
  699.                 key.Close();  
  700.             }  
  701.             return result;  
  702.         }  
  703.   
  704.         /// <summary>  
  705.         /// 设置指定的键值内容,指定内容数据类型(请先设置SubKey 属性)  
  706.         /// 存在改键值则修改键值内容,不存在键值则先创建键值,再设置键值内容  
  707.         /// </summary>  
  708.         /// <param name="name">键值名称</param>  
  709.         /// <param name="content">键值内容</param>  
  710.         /// <returns>键值内容设置成功,则返回true,否则返回false</returns>  
  711.         public virtual bool WriteRegeditKey(string name, object content, RegValueKind regValueKind)  
  712.         {  
  713.             ///返回结果  
  714.             bool result = false;  
  715.   
  716.             ///判断键值是否存在  
  717.             if (name == string.Empty || name == null)  
  718.             {  
  719.                 return false;  
  720.             }  
  721.   
  722.             ///判断注册表项是否存在,如果不存在,则直接创建  
  723.             if (!IsSubKeyExist(_subkey))  
  724.             {  
  725.                 CreateSubKey(_subkey);  
  726.             }  
  727.   
  728.             ///以可写方式打开注册表项  
  729.             RegistryKey key = OpenSubKey(true);  
  730.   
  731.             ///如果注册表项打开失败,则返回false  
  732.             if (key == null)  
  733.             {  
  734.                 return false;  
  735.             }  
  736.   
  737.             try  
  738.             {  
  739.                 key.SetValue(name, content, GetRegValueKind(regValueKind));  
  740.                 result = true;  
  741.             }  
  742.             catch  
  743.             {  
  744.                 result = false;  
  745.             }  
  746.             finally  
  747.             {  
  748.                 ///关闭对注册表项的更改  
  749.                 key.Close();  
  750.             }  
  751.             return result;  
  752.         }  
  753.  
  754.         #endregion  
  755.  
  756.         #region 读取键值内容  
  757.   
  758.         /// <summary>  
  759.         /// 读取键值内容(请先设置RegeditKey 和SubKey 属性)  
  760.         /// .如果RegeditKey 为空、null 或者RegeditKey 指示的键值不存在,返回null  
  761.         /// .如果SubKey 为空、null 或者SubKey 指示的注册表项不存在,返回null  
  762.         /// .反之,则返回键值内容  
  763.         /// </summary>  
  764.         /// <returns>返回键值内容</returns>  
  765.         public virtual object ReadRegeditKey()  
  766.         {  
  767.             ///键值内容结果  
  768.             object obj = null;  
  769.   
  770.             ///判断是否设置键值属性  
  771.             if (_regeditkey == string.Empty || _regeditkey == null)  
  772.             {  
  773.                 return null;  
  774.             }  
  775.   
  776.             ///判断键值是否存在  
  777.             if (IsRegeditKeyExist(_regeditkey))  
  778.             {  
  779.                 ///打开注册表项  
  780.                 RegistryKey key = OpenSubKey();  
  781.                 if (key != null)  
  782.                 {  
  783.                     obj = key.GetValue(_regeditkey);  
  784.                 }  
  785.                 ///关闭对注册表项的更改  
  786.                 key.Close();  
  787.             }  
  788.             return obj;  
  789.         }  
  790.   
  791.         /// <summary>  
  792.         /// 读取键值内容(请先设置SubKey 属性)  
  793.         /// .如果SubKey 为空、null 或者SubKey 指示的注册表项不存在,返回null  
  794.         /// .反之,则返回键值内容  
  795.         /// </summary>  
  796.         /// <param name="name">键值名称</param>  
  797.         /// <returns>返回键值内容</returns>  
  798.         public virtual object ReadRegeditKey(string name)  
  799.         {  
  800.             ///键值内容结果  
  801.             object obj = null;  
  802.   
  803.             ///判断是否设置键值属性  
  804.             if (name == string.Empty || name == null)  
  805.             {  
  806.                 return null;  
  807.             }  
  808.   
  809.             ///判断键值是否存在  
  810.             if (IsRegeditKeyExist(name))  
  811.             {  
  812.                 ///打开注册表项  
  813.                 RegistryKey key = OpenSubKey();  
  814.                 if (key != null)  
  815.                 {  
  816.                     obj = key.GetValue(name);  
  817.                 }  
  818.                 ///关闭对注册表项的更改  
  819.                 key.Close();  
  820.             }  
  821.             return obj;  
  822.         }  
  823.   
  824.         /// <summary>  
  825.         /// 读取键值内容  
  826.         /// </summary>  
  827.         /// <param name="name">键值名称</param>  
  828.         /// <param name="subKey">注册表项名称</param>  
  829.         /// <returns>返回键值内容</returns>  
  830.         public virtual object ReadRegeditKey(string name, string subKey)  
  831.         {  
  832.             ///键值内容结果  
  833.             object obj = null;  
  834.   
  835.             ///判断是否设置键值属性  
  836.             if (name == string.Empty || name == null)  
  837.             {  
  838.                 return null;  
  839.             }  
  840.   
  841.             ///判断键值是否存在  
  842.             if (IsRegeditKeyExist(name))  
  843.             {  
  844.                 ///打开注册表项  
  845.                 RegistryKey key = OpenSubKey(subKey);  
  846.                 if (key != null)  
  847.                 {  
  848.                     obj = key.GetValue(name);  
  849.                 }  
  850.                 ///关闭对注册表项的更改  
  851.                 key.Close();  
  852.             }  
  853.             return obj;  
  854.         }  
  855.   
  856.         /// <summary>  
  857.         /// 读取键值内容  
  858.         /// </summary>  
  859.         /// <param name="name">键值名称</param>  
  860.         /// <param name="subKey">注册表项名称</param>  
  861.         /// <param name="regDomain">注册表基项域</param>  
  862.         /// <returns>返回键值内容</returns>  
  863.         public virtual object ReadRegeditKey(string name, string subKey, RegDomain regDomain)  
  864.         {  
  865.             ///键值内容结果  
  866.             object obj = null;  
  867.   
  868.             ///判断是否设置键值属性  
  869.             if (name == string.Empty || name == null)  
  870.             {  
  871.                 return null;  
  872.             }  
  873.   
  874.             ///判断键值是否存在  
  875.             if (IsRegeditKeyExist(name))  
  876.             {  
  877.                 ///打开注册表项  
  878.                 RegistryKey key = OpenSubKey(subKey, regDomain);  
  879.                 if (key != null)  
  880.                 {  
  881.                     obj = key.GetValue(name);  
  882.                 }  
  883.                 ///关闭对注册表项的更改  
  884.                 key.Close();  
  885.             }  
  886.             return obj;  
  887.         }  
  888.  
  889.         #endregion  
  890.  
  891.         #region 删除键值  
  892.   
  893.         /// <summary>  
  894.         /// 删除键值(请先设置RegeditKey 和SubKey 属性)  
  895.         /// .如果RegeditKey 为空、null 或者RegeditKey 指示的键值不存在,返回false  
  896.         /// .如果SubKey 为空、null 或者SubKey 指示的注册表项不存在,返回false  
  897.         /// </summary>  
  898.         /// <returns>如果删除成功,返回true,否则返回false</returns>  
  899.         public virtual bool DeleteRegeditKey()  
  900.         {  
  901.             ///删除结果  
  902.             bool result = false;  
  903.   
  904.             ///判断是否设置键值属性,如果没有设置,则返回false  
  905.             if (_regeditkey == string.Empty || _regeditkey == null)  
  906.             {  
  907.                 return false;  
  908.             }  
  909.   
  910.             ///判断键值是否存在  
  911.             if (IsRegeditKeyExist(_regeditkey))  
  912.             {  
  913.                 ///以可写方式打开注册表项  
  914.                 RegistryKey key = OpenSubKey(true);  
  915.                 if (key != null)  
  916.                 {  
  917.                     try  
  918.                     {  
  919.                         ///删除键值  
  920.                         key.DeleteValue(_regeditkey);  
  921.                         result = true;  
  922.                     }  
  923.                     catch  
  924.                     {  
  925.                         result = false;  
  926.                     }  
  927.                     finally  
  928.                     {  
  929.                         ///关闭对注册表项的更改  
  930.                         key.Close();  
  931.                     }  
  932.                 }  
  933.             }  
  934.   
  935.             return result;  
  936.         }  
  937.   
  938.         /// <summary>  
  939.         /// 删除键值(请先设置SubKey 属性)  
  940.         /// 如果SubKey 为空、null 或者SubKey 指示的注册表项不存在,返回false  
  941.         /// </summary>  
  942.         /// <param name="name">键值名称</param>  
  943.         /// <returns>如果删除成功,返回true,否则返回false</returns>  
  944.         public virtual bool DeleteRegeditKey(string name)  
  945.         {  
  946.             ///删除结果  
  947.             bool result = false;  
  948.   
  949.             ///判断键值名称是否为空,如果为空,则返回false  
  950.             if (name == string.Empty || name == null)  
  951.             {  
  952.                 return false;  
  953.             }  
  954.   
  955.             ///判断键值是否存在  
  956.             if (IsRegeditKeyExist(name))  
  957.             {  
  958.                 ///以可写方式打开注册表项  
  959.                 RegistryKey key = OpenSubKey(true);  
  960.                 if (key != null)  
  961.                 {  
  962.                     try  
  963.                     {  
  964.                         ///删除键值  
  965.                         key.DeleteValue(name);  
  966.                         result = true;  
  967.                     }  
  968.                     catch  
  969.                     {  
  970.                         result = false;  
  971.                     }  
  972.                     finally  
  973.                     {  
  974.                         ///关闭对注册表项的更改  
  975.                         key.Close();  
  976.                     }  
  977.                 }  
  978.             }  
  979.   
  980.             return result;  
  981.         }  
  982.   
  983.         /// <summary>  
  984.         /// 删除键值  
  985.         /// </summary>  
  986.         /// <param name="name">键值名称</param>  
  987.         /// <param name="subKey">注册表项名称</param>  
  988.         /// <returns>如果删除成功,返回true,否则返回false</returns>  
  989.         public virtual bool DeleteRegeditKey(string name, string subKey)  
  990.         {  
  991.             ///删除结果  
  992.             bool result = false;  
  993.   
  994.             ///判断键值名称和注册表项名称是否为空,如果为空,则返回false  
  995.             if (name == string.Empty || name == null || subKey == string.Empty || subKey == null)  
  996.             {  
  997.                 return false;  
  998.             }  
  999.   
  1000.             ///判断键值是否存在  
  1001.             if (IsRegeditKeyExist(name))  
  1002.             {  
  1003.                 ///以可写方式打开注册表项  
  1004.                 RegistryKey key = OpenSubKey(subKey, true);  
  1005.                 if (key != null)  
  1006.                 {  
  1007.                     try  
  1008.                     {  
  1009.                         ///删除键值  
  1010.                         key.DeleteValue(name);  
  1011.                         result = true;  
  1012.                     }  
  1013.                     catch  
  1014.                     {  
  1015.                         result = false;  
  1016.                     }  
  1017.                     finally  
  1018.                     {  
  1019.                         ///关闭对注册表项的更改  
  1020.                         key.Close();  
  1021.                     }  
  1022.                 }  
  1023.             }  
  1024.   
  1025.             return result;  
  1026.         }  
  1027.   
  1028.         /// <summary>  
  1029.         /// 删除键值  
  1030.         /// </summary>  
  1031.         /// <param name="name">键值名称</param>  
  1032.         /// <param name="subKey">注册表项名称</param>  
  1033.         /// <param name="regDomain">注册表基项域</param>  
  1034.         /// <returns>如果删除成功,返回true,否则返回false</returns>  
  1035.         public virtual bool DeleteRegeditKey(string name, string subKey, RegDomain regDomain)  
  1036.         {  
  1037.             ///删除结果  
  1038.             bool result = false;  
  1039.   
  1040.             ///判断键值名称和注册表项名称是否为空,如果为空,则返回false  
  1041.             if (name == string.Empty || name == null || subKey == string.Empty || subKey == null)  
  1042.             {  
  1043.                 return false;  
  1044.             }  
  1045.   
  1046.             ///判断键值是否存在  
  1047.             if (IsRegeditKeyExist(name))  
  1048.             {  
  1049.                 ///以可写方式打开注册表项  
  1050.                 RegistryKey key = OpenSubKey(subKey, regDomain, true);  
  1051.                 if (key != null)  
  1052.                 {  
  1053.                     try  
  1054.                     {  
  1055.                         ///删除键值  
  1056.                         key.DeleteValue(name);  
  1057.                         result = true;  
  1058.                     }  
  1059.                     catch  
  1060.                     {  
  1061.                         result = false;  
  1062.                     }  
  1063.                     finally  
  1064.                     {  
  1065.                         ///关闭对注册表项的更改  
  1066.                         key.Close();  
  1067.                     }  
  1068.                 }  
  1069.             }  
  1070.   
  1071.             return result;  
  1072.         }  
  1073.  
  1074.         #endregion  
  1075.  
  1076.         #endregion  
  1077.  
  1078.         #region 受保护方法  
  1079.   
  1080.         /// <summary>  
  1081.         /// 获取注册表基项域对应顶级节点  
  1082.         /// 例子:如regDomain 是ClassesRoot,则返回Registry.ClassesRoot  
  1083.         /// </summary>  
  1084.         /// <param name="regDomain">注册表基项域</param>  
  1085.         /// <returns>注册表基项域对应顶级节点</returns>  
  1086.         protected RegistryKey GetRegDomain(RegDomain regDomain)  
  1087.         {  
  1088.             ///创建基于注册表基项的节点  
  1089.             RegistryKey key;  
  1090.  
  1091.             #region 判断注册表基项域  
  1092.             switch (regDomain)  
  1093.             {  
  1094.                 case RegDomain.ClassesRoot:  
  1095.                     key = Registry.ClassesRoot; break;  
  1096.                 case RegDomain.CurrentUser:  
  1097.                     key = Registry.CurrentUser; break;  
  1098.                 case RegDomain.LocalMachine:  
  1099.                     key = Registry.LocalMachine; break;  
  1100.                 case RegDomain.User:  
  1101.                     key = Registry.Users; break;  
  1102.                 case RegDomain.CurrentConfig:  
  1103.                     key = Registry.CurrentConfig; break;  
  1104.                 case RegDomain.DynDa:  
  1105.                     key = Registry.DynData; break;  
  1106.                 case RegDomain.PerformanceData:  
  1107.                     key = Registry.PerformanceData; break;  
  1108.                 default:  
  1109.                     key = Registry.LocalMachine; break;  
  1110.             }  
  1111.             #endregion  
  1112.   
  1113.             return key;  
  1114.         }  
  1115.   
  1116.         /// <summary>  
  1117.         /// 获取在注册表中对应的值数据类型  
  1118.         /// 例子:如regValueKind 是DWord,则返回RegistryValueKind.DWord  
  1119.         /// </summary>  
  1120.         /// <param name="regValueKind">注册表数据类型</param>  
  1121.         /// <returns>注册表中对应的数据类型</returns>  
  1122.         protected RegistryValueKind GetRegValueKind(RegValueKind regValueKind)  
  1123.         {  
  1124.             RegistryValueKind regValueK;  
  1125.  
  1126.             #region 判断注册表数据类型  
  1127.   
  1128.             switch (regValueKind)  
  1129.             {  
  1130.                 case RegValueKind.Unknown:  
  1131.                     regValueK = RegistryValueKind.Unknown; break;  
  1132.                 case RegValueKind.String:  
  1133.                     regValueK = RegistryValueKind.String; break;  
  1134.                 case RegValueKind.ExpandString:  
  1135.                     regValueK = RegistryValueKind.ExpandString; break;  
  1136.                 case RegValueKind.Binary:  
  1137.                     regValueK = RegistryValueKind.Binary; break;  
  1138.                 case RegValueKind.DWord:  
  1139.                     regValueK = RegistryValueKind.DWord; break;  
  1140.                 case RegValueKind.MultiString:  
  1141.                     regValueK = RegistryValueKind.MultiString; break;  
  1142.                 case RegValueKind.QWord:  
  1143.                     regValueK = RegistryValueKind.QWord; break;  
  1144.                 default:  
  1145.                     regValueK = RegistryValueKind.String; break;  
  1146.             }  
  1147.  
  1148.             #endregion  
  1149.   
  1150.             return regValueK;  
  1151.         }  
  1152.  
  1153.         #region 打开注册表项  
  1154.   
  1155.         /// <summary>  
  1156.         /// 打开注册表项节点,以只读方式检索子项  
  1157.         /// 虚方法,子类可进行重写  
  1158.         /// </summary>  
  1159.         /// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在,则返回null,否则返回注册表节点</returns>  
  1160.         protected virtual RegistryKey OpenSubKey()  
  1161.         {  
  1162.             ///判断注册表项名称是否为空  
  1163.             if (_subkey == string.Empty || _subkey == null)  
  1164.             {  
  1165.                 return null;  
  1166.             }  
  1167.   
  1168.             ///创建基于注册表基项的节点  
  1169.             RegistryKey key = GetRegDomain(_domain);  
  1170.   
  1171.             ///要打开的注册表项的节点  
  1172.             RegistryKey sKey = null;  
  1173.             ///打开注册表项  
  1174.             sKey = key.OpenSubKey(_subkey);  
  1175.             ///关闭对注册表项的更改  
  1176.             key.Close();  
  1177.             ///返回注册表节点  
  1178.             return sKey;  
  1179.         }  
  1180.   
  1181.         /// <summary>  
  1182.         /// 打开注册表项节点  
  1183.         /// 虚方法,子类可进行重写  
  1184.         /// </summary>  
  1185.         /// <param name="writable">如果需要项的写访问权限,则设置为 true</param>  
  1186.         /// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在,则返回null,否则返回注册表节点</returns>  
  1187.         protected virtual RegistryKey OpenSubKey(bool writable)  
  1188.         {  
  1189.             ///判断注册表项名称是否为空  
  1190.             if (_subkey == string.Empty || _subkey == null)  
  1191.             {  
  1192.                 return null;  
  1193.             }  
  1194.   
  1195.             ///创建基于注册表基项的节点  
  1196.             RegistryKey key = GetRegDomain(_domain);  
  1197.   
  1198.             ///要打开的注册表项的节点  
  1199.             RegistryKey sKey = null;  
  1200.             ///打开注册表项  
  1201.             sKey = key.OpenSubKey(_subkey, writable);  
  1202.             ///关闭对注册表项的更改  
  1203.             key.Close();  
  1204.             ///返回注册表节点  
  1205.             return sKey;  
  1206.         }  
  1207.   
  1208.         /// <summary>  
  1209.         /// 打开注册表项节点,以只读方式检索子项  
  1210.         /// 虚方法,子类可进行重写  
  1211.         /// </summary>  
  1212.         /// <param name="subKey">注册表项名称</param>  
  1213.         /// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在,则返回null,否则返回注册表节点</returns>  
  1214.         protected virtual RegistryKey OpenSubKey(string subKey)  
  1215.         {  
  1216.             ///判断注册表项名称是否为空  
  1217.             if (subKey == string.Empty || subKey == null)  
  1218.             {  
  1219.                 return null;  
  1220.             }  
  1221.   
  1222.             ///创建基于注册表基项的节点  
  1223.             RegistryKey key = GetRegDomain(_domain);  
  1224.   
  1225.             ///要打开的注册表项的节点  
  1226.             RegistryKey sKey = null;  
  1227.             ///打开注册表项  
  1228.             sKey = key.OpenSubKey(subKey);  
  1229.             ///关闭对注册表项的更改  
  1230.             key.Close();  
  1231.             ///返回注册表节点  
  1232.             return sKey;  
  1233.         }  
  1234.   
  1235.         /// <summary>  
  1236.         /// 打开注册表项节点,以只读方式检索子项  
  1237.         /// 虚方法,子类可进行重写  
  1238.         /// </summary>  
  1239.         /// <param name="subKey">注册表项名称</param>  
  1240.         /// <param name="writable">如果需要项的写访问权限,则设置为 true</param>  
  1241.         /// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在,则返回null,否则返回注册表节点</returns>  
  1242.         protected virtual RegistryKey OpenSubKey(string subKey, bool writable)  
  1243.         {  
  1244.             ///判断注册表项名称是否为空  
  1245.             if (subKey == string.Empty || subKey == null)  
  1246.             {  
  1247.                 return null;  
  1248.             }  
  1249.   
  1250.             ///创建基于注册表基项的节点  
  1251.             RegistryKey key = GetRegDomain(_domain);  
  1252.   
  1253.             ///要打开的注册表项的节点  
  1254.             RegistryKey sKey = null;  
  1255.             ///打开注册表项  
  1256.             sKey = key.OpenSubKey(subKey, writable);  
  1257.             ///关闭对注册表项的更改  
  1258.             key.Close();  
  1259.             ///返回注册表节点  
  1260.             return sKey;  
  1261.         }  
  1262.   
  1263.         /// <summary>  
  1264.         /// 打开注册表项节点,以只读方式检索子项  
  1265.         /// 虚方法,子类可进行重写  
  1266.         /// </summary>  
  1267.         /// <param name="subKey">注册表项名称</param>  
  1268.         /// <param name="regDomain">注册表基项域</param>  
  1269.         /// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在,则返回null,否则返回注册表节点</returns>  
  1270.         protected virtual RegistryKey OpenSubKey(string subKey, RegDomain regDomain)  
  1271.         {  
  1272.             ///判断注册表项名称是否为空  
  1273.             if (subKey == string.Empty || subKey == null)  
  1274.             {  
  1275.                 return null;  
  1276.             }  
  1277.   
  1278.             ///创建基于注册表基项的节点  
  1279.             RegistryKey key = GetRegDomain(regDomain);  
  1280.   
  1281.             ///要打开的注册表项的节点  
  1282.             RegistryKey sKey = null;  
  1283.             ///打开注册表项  
  1284.             sKey = key.OpenSubKey(subKey);  
  1285.             ///关闭对注册表项的更改  
  1286.             key.Close();  
  1287.             ///返回注册表节点  
  1288.             return sKey;  
  1289.         }  
  1290.   
  1291.         /// <summary>  
  1292.         /// 打开注册表项节点  
  1293.         /// 虚方法,子类可进行重写  
  1294.         /// </summary>  
  1295.         /// <param name="subKey">注册表项名称</param>  
  1296.         /// <param name="regDomain">注册表基项域</param>  
  1297.         /// <param name="writable">如果需要项的写访问权限,则设置为 true</param>  
  1298.         /// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在,则返回null,否则返回注册表节点</returns>  
  1299.         protected virtual RegistryKey OpenSubKey(string subKey, RegDomain regDomain, bool writable)  
  1300.         {  
  1301.             ///判断注册表项名称是否为空  
  1302.             if (subKey == string.Empty || subKey == null)  
  1303.             {  
  1304.                 return null;  
  1305.             }  
  1306.   
  1307.             ///创建基于注册表基项的节点  
  1308.             RegistryKey key = GetRegDomain(regDomain);  
  1309.   
  1310.             ///要打开的注册表项的节点  
  1311.             RegistryKey sKey = null;  
  1312.             ///打开注册表项  
  1313.             sKey = key.OpenSubKey(subKey, writable);  
  1314.             ///关闭对注册表项的更改  
  1315.             key.Close();  
  1316.             ///返回注册表节点  
  1317.             return sKey;  
  1318.         }  
  1319.  
  1320.         #endregion  
  1321.  
  1322.         #endregion  
  1323.     }