/// <summary>
        /// 转换注册表所需数据。
        /// </summary>
        /// <param name="is64BitRegistry">
        /// </param>
        /// <param name="lpType">
        /// 注册表键值类型。
        /// </param>
        /// <param name="lpData">
        /// 注册表键值。
        /// </param>
        /// <param name="lpcbData">
        /// 注册表键值所需内存。
        /// </param>
        /// <returns>
        /// 转换为已封装数据。
        /// </returns>
        protected RegKey ConvertData(bool is64BitRegistry, REG_KEY_TYPE lpType, IntPtr lpData, int lpcbData)
        {
            RegKey reg_key;

            if (lpType == REG_KEY_TYPE.REG_DWORD)
            {
                var lp_data_int = Marshal.ReadInt32(lpData);
                reg_key = new RegKey(this, lpType, lp_data_int);
            }
            else if (lpType == REG_KEY_TYPE.REG_QWORD)
            {
                var lp_data_long = Marshal.ReadInt64(lpData);
                reg_key = new RegKey(this, lpType, lp_data_long);
            }
            else if (lpType == REG_KEY_TYPE.REG_SZ ||
                     lpType == REG_KEY_TYPE.REG_EXPAND_SZ ||
                     lpType == REG_KEY_TYPE.REG_MULTI_SZ)
            {
                var lp_data_str = Marshal.PtrToStringUni(lpData);
                lp_data_str = lp_data_str?.Trim();
                reg_key     = new RegKey(this, lpType, lp_data_str);
            }
            else if (lpType == REG_KEY_TYPE.REG_BINARY)
            {
                var lp_data_bin = new byte[lpcbData];
                Marshal.Copy(lpData, lp_data_bin, 0, lpcbData);
                reg_key = new RegKey(this, lpType, lp_data_bin);
            }
            else
            {
                throw new DataException($"注册表访问失败\n注册表数据类型异常\n{nameof(ConvertData)}");
            }

            return(reg_key);
        }
        /// <summary>
        /// 获取注册表键信息。
        /// </summary>
        /// <exception cref="Exception">
        /// 非托管代码获取注册表时产生的异常,详情请参阅MSDN。
        /// </exception>
        /// <returns>
        /// 注册表键信息。
        /// </returns>
        public RegKey Get()
        {
            RegKey reg_key;

            try
            {
                var(phk_result, is_64_bit_registry) = RegOpenKey(KEY_ACCESS_TYPE.KEY_READ);
                var lp_cb_data = 0;
                NativeMethods.RegQueryValueEx(phk_result, LpValueName, IntPtr.Zero, out var lp_type, IntPtr.Zero, ref lp_cb_data);
                if (lp_cb_data == 0)
                {
                    NativeMethods.RegCloseKey(phk_result);
                    throw new InternalBufferOverflowException($"注册表访问失败\n无法获取缓冲区大小\n{nameof(Get)}");
                }
                var lp_data            = Marshal.AllocHGlobal(lp_cb_data);
                var reg_get_value_temp = NativeMethods.RegQueryValueEx(phk_result, LpValueName, IntPtr.Zero, out lp_type, lp_data, ref lp_cb_data);
                if (reg_get_value_temp != (int)ERROR_CODE.ERROR_SUCCESS)
                {
                    throw new Exception($"注册表访问失败\n错误代码:{reg_get_value_temp}\n{nameof(Get)}");
                }
                NativeMethods.RegCloseKey(phk_result);
                if (reg_get_value_temp != (int)ERROR_CODE.ERROR_SUCCESS)
                {
                    throw new Exception($"注册表访问失败\n错误代码:{reg_get_value_temp}\n{nameof(Get)}");
                }

                reg_key = ConvertData(is_64_bit_registry, (REG_KEY_TYPE)lp_type, lp_data, lp_cb_data);
                Marshal.FreeHGlobal(lp_data);
            }
            catch (Exception)
            {
                reg_key = new RegKey(this);
            }
            return(reg_key);
        }
Exemple #3
0
 /// <inheritdoc />
 /// <summary>
 /// 注册表键信息类复制构造函数。
 /// </summary>
 /// <param name="regKey">
 /// 注册表键信息类。
 /// </param>
 public RegKey(RegKey regKey) :
     base(regKey.RegPath)
 {
     LpType  = regKey.LpType;
     LpValue = regKey.LpValue;
 }