The Delphi Bug List

From the help :
-----------------------------------
property Access: LongWord;

Description
Use Access to specify the level of security access to use when opening keys. The OpenKey method uses the value of Access when opening a registry key. Access is initialized by the TRegistry constructor, but can be altered before calling OpenKey.
--------------------------------------

This is a good feature, but the problem here is that when you use OpenKeyReadOnly it sets the Access property to KEY_READ and leaves it set as KEY_READ. This mean that you can no longer write to the registry without resetting the Access property.

Is this what was intended by Borland ? I can see no reason for doing this. Note that the Access property is not used by OpenKeyReadOnly, merely altered to KEY_READ.

This breaks a large portion of our code since we often read keys "read only" and then modify them later. Does Borland expect us the reset the access parameter every time or were we wrong in reading the keys read only?

As far as I can see this is a Bug.

function TRegistry.OpenKeyReadOnly(const Key: String): Boolean;
var
  TempKey: HKey;
  S: string;
  Relative: Boolean;
begin
  S := Key;
  Relative := IsRelative(S);
   if not Relative then Delete(S, 1, 1);
  TempKey := 0;
  Result := RegOpenKeyEx(GetBaseKey(Relative), PChar(S), 0,
      KEY_READ, TempKey) = ERROR_SUCCESS;
  if Result then
  begin
--> FAccess := KEY_READ;
    if (CurrentKey <> 0) and Relative then S := CurrentPath + '\' + S;
    ChangeKey(TempKey, S);
  end;
end;

Bug #588 is still present in Delphi 6.0, but it has been
documented to work this way. From the help:
"Note: after a successful call to OpenKeyReadOnly the Access property of the registry component is automatically changed to KEY_READ, regardless of what that property was set to prior to the method call."
This is not entirely true however. If the RegOpenKeyEx call does
not succeed with KEY_READ, it continues to try with
STANDARD_RIGHTS_READ or KEY_QUERY_VALUE or KEY_ENUMERATE_SUB_KEYS,
then it tries KEY_QUERY_VALUE before giving up.
This can be seen as a feature. Examining the Access property
after calling OpenKeyReadOnly will tell you what kind of
access you have to that key... Maybe not very useful. The
cleanest workaround is probably to write a simple wrapper
routine that saves the old value of the Access property
before the call and restores it afterwards.