internal static extern int RegSetValueEx(
     SafeRegistryHandle hKey,
     String lpValueName,
     int Reserved,
     RegistryValueKind dwType,
     String lpData,
     int cbData);

 static void UnmapRegistryKey(RegistryKey registryKey)
 {
     using (var emptyHandle = new SafeRegistryHandle(IntPtr.Zero, true))
     {
         Win32Api.Registry.RedirectRegistryKey(registryKey.Handle, emptyHandle);
     }
 }

 public IRegistryKey FromHandle(
     SafeRegistryHandle handle,
     RegistryView view
 )
 {
     return new RegistryKeyWrap(RegistryKey.FromHandle(handle, view));
 }

 internal static extern int RegQueryValueEx(
     SafeRegistryHandle hKey,
     String lpValueName,
     int[] lpReserved,
     ref int lpType,
     [Out]StringBuilder lpData,
     ref int lpcbData);

 internal unsafe static extern int RegEnumKeyEx(
     SafeRegistryHandle hKey,
     int dwIndex,
     char* lpName,
     ref int lpcbName,
     int[] lpReserved,
     [Out]StringBuilder lpClass,
     int[] lpcbClass,
     long[] lpftLastWriteTime);

 internal static extern unsafe int RegEnumValue(
     SafeRegistryHandle hKey,
     int dwIndex,
     char* lpValueName,
     ref int lpcbValueName,
     IntPtr lpReserved_MustBeZero,
     int[] lpType,
     byte[] lpData,
     int[] lpcbData);

 internal static extern int RegCreateKeyEx(
     SafeRegistryHandle hKey,
     String lpSubKey,
     int Reserved,
     String lpClass,
     int dwOptions,
     int samDesired,
     ref SECURITY_ATTRIBUTES secAttrs,
     out SafeRegistryHandle hkResult,
     out int lpdwDisposition);

 internal static extern int RegQueryInfoKey(
     SafeRegistryHandle hKey,
     [Out]StringBuilder lpClass,
     int[] lpcbClass,
     IntPtr lpReserved_MustBeZero,
     ref int lpcSubKeys,
     int[] lpcbMaxSubKeyLen,
     int[] lpcbMaxClassLen,
     ref int lpcValues,
     int[] lpcbMaxValueNameLen,
     int[] lpcbMaxValueLen,
     int[] lpcbSecurityDescriptor,
     int[] lpftLastWriteTime);

 private RegistryKey(SafeRegistryHandle hkey, bool writable, bool systemkey, bool remoteKey, bool isPerfData, RegistryView view)
 {
     this.hkey = hkey;
     this.keyName = "";
     this.remoteKey = remoteKey;
     this.regView = view;
     if (systemkey)
     {
         this.state |= 2;
     }
     if (writable)
     {
         this.state |= 4;
     }
     if (isPerfData)
     {
         this.state |= 8;
     }
     ValidateKeyView(view);
 }

 internal void Persist(SafeRegistryHandle hKey, string keyName)
 {
     new RegistryPermission(RegistryPermissionAccess.NoAccess, AccessControlActions.Change, keyName).Demand();
     base.WriteLock();
     try
     {
         AccessControlSections accessControlSectionsFromChanges = this.GetAccessControlSectionsFromChanges();
         if (accessControlSectionsFromChanges != AccessControlSections.None)
         {
             bool flag;
             bool flag2;
             base.Persist(hKey, accessControlSectionsFromChanges);
             base.AccessRulesModified = flag = false;
             base.AuditRulesModified = flag2 = flag;
             base.OwnerModified = base.GroupModified = flag2;
         }
     }
     finally
     {
         base.WriteUnlock();
     }
 }

        /// <summary>
        /// Creates a RegistryKey.
        /// This key is bound to hkey, if writable is <b>false</b> then no write operations
        /// will be allowed. If systemkey is set then the hkey won't be released
        /// when the object is GC'ed.
        /// The remoteKey flag when set to true indicates that we are dealing with registry entries
        /// on a remote machine and requires the program making these calls to have full trust.
        /// </summary>
        private RegistryKey(SafeRegistryHandle hkey, bool writable, bool systemkey, bool remoteKey, bool isPerfData, RegistryView view)
        {
            ValidateKeyView(view);

            _hkey = hkey;
            _keyName = "";
            _remoteKey = remoteKey;
            _regView = view;

            if (systemkey)
            {
                _state |= StateFlags.SystemKey;
            }
            if (writable)
            {
                _state |= StateFlags.WriteAccess;
            }
            if (isPerfData)
            {
                _state |= StateFlags.PerfData;
            }
        }

 public static RegistryKey FromHandle(SafeRegistryHandle handle)
 {
     return FromHandle(handle, RegistryView.Default);
 }

 public RegistryHandler(int hKey)
 {
     key_found = false;
     SafeRegistryHandle safeRegistryHandle = new SafeRegistryHandle(new IntPtr(hKey), true);
     root_key = RegistryKey.FromHandle(safeRegistryHandle);
 }

		public RegistryKey FromHandle (SafeRegistryHandle handle)
		{
			// At this point we can't tell whether the key is writable
			// or not (nor the name), so we let the error check code handle it later, as
			// .Net seems to do.
			return new RegistryKey (handle.DangerousGetHandle (), String.Empty, true);
		}

 /// <summary>
 /// Override a registry hive key to another registry key.
 /// </summary>
 /// <param name="key">Handle of the key to override.</param>
 /// <param name="newKey">Handle to override key.</param>
 internal static void RedirectRegistryKey(SafeRegistryHandle key, SafeRegistryHandle newKey)
 {
     if (0 != RegOverridePredefKey(key, newKey))
     {
         throw new Exception();
     }
 }

 internal static extern int RegOpenKeyEx(IntPtr hKey, String lpSubKey,
             int ulOptions, int samDesired, out SafeRegistryHandle hkResult);

		public static RegistryKey FromHandle (SafeRegistryHandle handle)
		{
			if (handle == null)
				throw new ArgumentNullException ("handle");

			return RegistryApi.FromHandle (handle);
		}

 internal static extern int RegDeleteKey(SafeRegistryHandle hKey, String lpSubKey);

 internal static extern int RegDeleteKeyEx(SafeRegistryHandle hKey, String lpSubKey,
             int samDesired, int Reserved);

 static extern int RegOverridePredefKey(SafeRegistryHandle key, SafeRegistryHandle newKey);