Probleme beim Auslesen von Registry Keys

[Andidreas]

Hallo,

da in unserem aktuellen Projekt/Programm die Windows Oberfläche ausgeblendet wird würden wir gern über die Registry prüfen ob im Hintergrund Windows Updates installiert wurden.

Lt. Internet gibt es hier einen Eintrag in der Registry der den genauen Update Status (AUState) wiedergibt dieser ist im folgenden Pfad gespeichert:
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\Curr entVersion\WindowsUpdate\Auto Update\

Ich versuche gerade mit dem folgenden Source an die Info ranzukommen:

Delphi-Quellcode:

procedure TForm1.Button30Click(Sender: TObject);

var
regKey  : TRegistry;

begin

  Try
    //Create Object
    regKey := TRegistry.Create;

    //Set Root Key
    regKey.RootKey := HKEY_CURRENT_USER;

    //Open Registry Key
    If Not(regKey.OpenKey('SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update', False)) Then
    Begin
      MessageDlg('Could not open Registry Key!', mtError, [mbOK], 0);
    End Else
    Begin
      //Read Registry Key
      ShowMessage(regKey.ReadString('AUState'));
    End;

    //Close Registry Key
    regKey.CloseKey();
  Finally
    regKey.Free;
  End;

end;

Leider scheitere ich schon am OpenKey... hat jemand eine Idee warum? Liegt das evtl. an den Leerzeichen im Pfad?

[Andidreas]

Zusatz Info:

Das OpenKey klappt bis zu "CurrentVersion" sobald ich "WindowsUpdates" hinzufüge funktioniert das OpenKey nicht mehr!

[Sir Rufo]

Den Zweig findest du ja auch in HKEY_LOCAL_MACHINE (siehe deinen Quellcode, der sucht woanders) ;)

Im Übrigen ist der bei einem x64-OS NUR in dem originalen Zweig zu finden. Also obacht, wenn man auf einem x64-OS mit einer x32-Anwendung diesen Zweig abfragen möchte!

[ernschd]

Hast du überprüft, ob der Schlüssel "Auto Update" überhaupt vorhanden ist?
Bei mir funktioniert der Code bis zu "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\Cur r entVersion\WindowsUpdate\". Darunter habe ich keinen weiteren Eintrag in der Registry.

[himitsu]

Und dort dann auch mit KEY_READ, KEY_WOW64_64KEY und OpenKeyReadOnly :stupid:

Delphi-Quellcode:

regKey := TRegistry.Create;

gehört vor das Try
und warum hörst du nicht auf die Warnungen deines Compilers?

[Andidreas]

Zitat:

Zitat von Sir Rufo (Beitrag 1317901)

Den Zweig findest du ja auch in HKEY_LOCAL_MACHINE (siehe deinen Quellcode, der sucht woanders) ;)

Im Übrigen ist der bei einem x64-OS NUR in dem originalen Zweig zu finden. Also obacht, wenn man auf einem x64-OS mit einer x32-Anwendung diesen Zweig abfragen möchte!

Sorry "HKEY_CURRENT_USER" stand noch drin vom Testen ob ich überhaupt mit meinem Source an Registry Werte rankomm! Mit HKEY_LOCAL_MACHINE funktioniert es ebenfalls nicht...

bezgl. "NUR im originalen Zweig"... Dieser Pfad den ich Verwende müsste ja der Originale Pfad sein?!?

Zitat:

Zitat von ernschd (Beitrag 1317903)

Hast du überprüft, ob der Schlüssel "Auto Update" überhaupt vorhanden ist?
Bei mir funktioniert der Code bis zu "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\Cur r entVersion\WindowsUpdate\". Darunter habe ich keinen weiteren Eintrag in der Registry.

Ja der Pfad ist vorhanden!

Zitat:

Zitat von himitsu (Beitrag 1317904)

Und dort dann auch mit KEY_READ, KEY_WOW64_64KEY und OpenKeyReadOnly :stupid:

Delphi-Quellcode:

regKey := TRegistry.Create;

gehört vor das Try
und warum hörst du nicht auf die Warnungen deines Compilers?

Wo muss ihc das mit KEY_READ, KEY_WOW64_64KEY angeben?
Und wie meinst du das mit den Compiler Warnings?

OpenKeyReadOnly hab ich schon ausprobiert, half auch nichts!

[Andidreas]

Hier mal der aktualisierte und korrigierte Source Code:

Delphi-Quellcode:

procedure TForm1.Button30Click(Sender: TObject);

var
regKey  : TRegistry;

begin

  //Create Object
  regKey := TRegistry.Create(KEY_READ AND KEY_WOW64_64KEY);

  Try
    //Set Root Key
    regKey.RootKey := HKEY_LOCAL_MACHINE;

    //Open Registry Key
    If Not(regKey.OpenKeyReadOnly('SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate')) Then
    Begin
      MessageDlg('Could not open Registry Key!', mtError, [mbOK], 0);
    End Else
    Begin
      //Read Registry Key
      ShowMessage(regKey.ReadString('AUState'));
    End;

    //Close Registry Key
    regKey.CloseKey();
  Finally
    regKey.Free;
  End;

end;

[Sir Rufo]

Augen auf beim Eierlauf!

Delphi-Quellcode:

procedure TForm1.Button30Click(Sender: TObject);

var
regKey : TRegistry;

begin

  //Create Object
  regKey := TRegistry.Create(KEY_READ OR KEY_WOW64_64KEY);

  Try
    //Set Root Key
    regKey.RootKey := HKEY_LOCAL_MACHINE;

    //Open Registry Key
    If Not(regKey.OpenKeyReadOnly('SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update')) Then

[himitsu]

KEY_READ, KEY_WOW64_64KEY -> TRegistry.Create :angle2:

[edit] grad eben bag es noch keine Posts.

[Andidreas]

@Sir Rufo & himitsu

Danke für die Info, so gehts nun:

Delphi-Quellcode:

procedure TForm1.Button30Click(Sender: TObject);

var
regKey  : TRegistry;

begin

  //Create Object
  regKey := TRegistry.Create(KEY_READ OR KEY_WOW64_64KEY);

  Try
    //Set Root Key
    regKey.RootKey := HKEY_LOCAL_MACHINE;

    //Open Registry Key
    If Not(regKey.OpenKeyReadOnly('SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update')) Then
    Begin
      MessageDlg('Could not open Registry Key!', mtError, [mbOK], 0);
    End Else
    Begin
      //Read Registry Key
      ShowMessage(regKey.ReadString('NextDetectionTime'));
    End;

    //Close Registry Key
    regKey.CloseKey();
  Finally
    regKey.Free;
  End;

end;

Ich habe zum Testen den NextDetectionTime Schlüssel verwendet... An diesen Wert komm ich jetzt schon mal ran, jetzt muss ich das ganze nur noch auf einem Rechner mal Testen bei dem Updates anstehen und der AUState Schlüssel vorhanden ist

[Luckie]

Warum keine gescheite Fehlerbehandlung?

Delphi-Quellcode:

MessageDlg('Could not open Registry Key!', mtError, [mbOK], 0);

Damit weißt du so viel wie vorher. RaiseLastOSError gibt dir eine gescheite Fehlermeldung aus, womit du auch was anfangen kannst.

[Sir Rufo]

Zitat:

Zitat von Luckie (Beitrag 1317940)

Warum keine gescheite Fehlerbehandlung?

Delphi-Quellcode:

MessageDlg('Could not open Registry Key!', mtError, [mbOK], 0);

Damit weißt du so viel wie vorher. RaiseLastOSError gibt dir eine gescheite Fehlermeldung aus, womit du auch was anfangen kannst.

Definitiv Nein, so nicht. Denn du weißt nicht, was diese Klasse danach noch alles an API-Aufrufen veranstaltet. Aus diesem Grunde gibt es - ja ist komisch - TRegistry.LastError und die Exception löst man dann mit

Delphi-Quellcode:

RaiseLastOSError( regKey.LastError, sLineBreak + RegKeyStr );

und erhält eine ganz wunderbare Fehlermeldung.

Und wenn kein erfolgreicher OpenKey(ReadOnly), dann braucht es auch keinen CloseKey.

[Luckie]

Ab welcher Version gibt es denn die Methode?

Und warum sollte ein Aufruf von RaiseLastOSError zu Problemen führen? Mit deiner Begründung dürfte man die Funktion nie aufrufen, egal in was für einen Code.

[Sir Rufo]

Zitat:

Zitat von Luckie (Beitrag 1317942)

Ab welcher Version gibt es denn die Methode?

Und warum sollte ein Aufruf von RaiseLastOSError zu Problemen führen? Mit deiner Begründung dürfte man die Funktion nie aufrufen, egal in was für einen Code.

Nun schauen wir an, was die Doku dazu sagt:

Zitat:

You should call the GetLastError function immediately when a function's return value indicates that such a call will return useful data. That is because some functions call SetLastError with a zero when they succeed, wiping out the error code set by the most recently failed function.

Und ohne eine genaue Analyse der Klasse

Delphi-Quellcode:

TRegistry

kann man nicht sagen, was da noch für API-Calls ausgeführt werden. Somit wäre das ein Fall von "kann funktionieren, muss aber nicht und vor allem kann irgendwann dann mal gar nicht mehr funktionieren".

Sinnvoll ist hier auch ein ClassHelper

Delphi-Quellcode:

interface

uses
  System.Win.Registry;

type
  HRegistry = class helper for TRegistry
    procedure ThrowLastError( const AdditionalInfo: string = '' );
    procedure OpenKeySafe( const Key: string; CanCreate: Boolean );
    procedure OpenKeyReadOnlySafe( const Key: string );
  end;

implementation

uses
  System.StrUtils,
  System.SysUtils;

{ HRegistry }

procedure HRegistry.OpenKeyReadOnlySafe( const Key: string );
begin
  if not OpenKeyReadOnly( Key )
  then
    ThrowLastError( Key );
end;

procedure HRegistry.OpenKeySafe( const Key: string; CanCreate: Boolean );
begin
  if not OpenKey( Key, CanCreate )
  then
    ThrowLastError( Key );
end;

procedure HRegistry.ThrowLastError( const AdditionalInfo: string );
begin
  if AdditionalInfo = ''
  then
    RaiseLastOSError( LastError )
  else
    RaiseLastOSError( LastError, sLineBreak + AdditionalInfo );
end;

Und dann sieht das so aus

Delphi-Quellcode:

procedure TForm1.Button30Click(Sender: TObject);

var
  regKey : TRegistry;
begin
  regKey := TRegistry.Create(KEY_READ OR KEY_WOW64_64KEY);
  Try
    regKey.RootKey := HKEY_LOCAL_MACHINE;
    regKey.OpenKeyReadOnlySafe('SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update');
    try 
      ShowMessage( regKey.ReadString( 'NextDetectionTime' ) );
    finally
      regKey.CloseKey();
    end;
  Finally
    regKey.Free;
  End;
end;

[Luckie]

Nun ja. Mit meinem Delphi kann ich von Helper Functions nur träumen. :?

[Sir Rufo]

Zitat:

Zitat von Luckie (Beitrag 1317944)

Nun ja. Mit meinem Delphi kann ich von Helper Functions nur träumen. :?

Na dann einfach ableiten und dort noch dazupacken ;)

[SlpLow]

Zitat:

Zitat von Luckie (Beitrag 1317944)

Nun ja. Mit meinem Delphi kann ich von Helper Functions nur träumen. :?

Code:

//Autor GunSmoker
resourcestring
  SMsgOSError = '%s' + sLineBreak + 'System Error.  Code: %d.' + sLineBreak + '%s';
  SMsgUnkOSError = '%s' + sLineBreak + 'A call to an OS function failed';

procedure RaiseLastOSError(LastError: Integer; const AMsg: String); overload;
var
  Error: EOSError;
begin
  if AMsg = '' then
    RaiseLastOSError(LastError);

  if LastError <> 0 then
    Error := EOSError.CreateResFmt(@SMsgOSError,
      [AMsg, LastError, SysErrorMessage(LastError)])
  else
    Error := EOSError.CreateResFmt(@SMsgUnkOSError, [AMsg]);
  Error.ErrorCode := LastError;
  raise Error;
end;