(TRegistry) Sinn von CurrentKey

[Caps]

Hallöle,

ich verwende TRegistry. Wenn ich RootKey auf einen gültigen Wert setze und den Schlüssel mit OpenKey öffne, so bekommt CurrentKey den selben Wert - ok.
Wenn ich aber einen RegPath angebe, d.h. unter dem RootKey einen weiteren Schlüssel öffne (z.B. HKEY_CURRENT_USER\AppEvents), dann besitzt CurrentKey irgendeinen Zahlenwert. Schließe ich den Schlüssel und öffne ihn direkt danach erneut, so ist der Zahlenwert (meist?) ein anderer.
Was soll dieser Wert bedeuten? Was sagt er mir?

Caps

[Sir Rufo]

Schon in die Doku geschaut?

TRegistry.CurrentKey

[baumina]

:gruebel:

Zitat:

Mit CurrentKey wird der Schlüssel ermittelt, der aktuell in der Registrierdatenbank geöffnet ist. Alle Operationen von TRegistry betreffen nur diesen Schlüssel. Vor dem Zugriff auf einen anderen Schlüssel muss die Methode OpenKey oder OpenKeyReadOnly aufgerufen werden.

[Caps]

Zitat:

Zitat von baumina (Beitrag 1219165)

:gruebel:

Zitat:

Mit CurrentKey wird der Schlüssel ermittelt, der aktuell in der Registrierdatenbank geöffnet ist. Alle Operationen von TRegistry betreffen nur diesen Schlüssel. Vor dem Zugriff auf einen anderen Schlüssel muss die Methode OpenKey oder OpenKeyReadOnly aufgerufen werden.

So ging's mir auch, nachdem ich die Doku (die ziemlich identisch mit der Delphi-OH ist) gelesen hatte. Mir ist nicht ganz klar, wie das in irgendeinem Zusammenhang mit der tatsächlichen Funktionalität der Eigenschaft CurrentKey steht. Oder wie interpretierst Du (Sir Rufo) die Doku in Anbetracht der Fakten? Ich kann mir leider immernoch keinen Reim drauf machen.

lg Caps

[DeddyH]

CurrentKey ist vom Typ HKEY, welcher wiederum ein Handle und somit eine Zahl ist. Für die RootKeys sind Konstanten definiert, die der Compiler anscheinend auflösen kann, was bei Unterschlüsseln nicht möglich ist.

[Caps]

Ok, dann kann ich den Wert von CurrentKey eigentlich nicht verwenden (wofür auch...?), zumal beim zweimaligen Öffnen ein und desselben Schlüssels verschiedene Werte für CurrentKey zurückkamen... :gruebel:

Die Beschreibung von RootKey ist auch eher wunderlich als deutlich:

Zitat:

Mit RootKey wird die Hierarchie der Unterschlüssel definiert, auf die eine Anwendung zugreifen kann, oder es wird der Hauptschlüssel der Anwendung definiert.
[...]
Hinweis
Bei einigen Operationen, wie z.B. LoadKey oder RegistryConnect, muß die Anwendung eventuell den Vorgabewert von RootKey ändern.

Was soll das bedeuten - es wird eine Hierarchie der Unterschlüssel definiert? Wie definiert man mit einer einzigen Zahl eine Hierarchie? Durch Gödelisierung vielleicht...
Ich benutze weder LoadKey noch RegistryConnect und setze RootKey dennoch auf verschiedene Werte, damit ich halt-eben-nunmal auf diese Stellen zugreifen kann, oder verstehe ich hier was falsch?
RootKey ist doch der einzige Weg, dem Registry-Objekt mitzuteilen, dass man in einen bestimmten Root-Schlüssel einsteigen möchte. Eine andere Möglichkeit existiert doch gar nicht, oder? :freak:

Verwirrt,
Caps

[baumina]

Also wenn es ein HKEY (ein Handle) ist, ist weniger verwunderlich, dass unterschiedliche Zahlen beim auf-, zu- und wieder aufmachen rauskommen, oder?

[Caps]

Zitat:

Zitat von baumina (Beitrag 1219234)

Also wenn es ein HKEY (ein Handle) ist, ist weniger verwunderlich, dass unterschiedliche Zahlen beim auf-, zu- und wieder aufmachen rauskommen, oder?

Ja, aber nur in Bezug auf die Unterschlüssel des Root-Schlüssels, denn bei dem muss das Handle ja immer gleich sein, damit die fest definierten Konstanten (HKEY_...) passen. Also ist der Wert von CurrentKey nur im Spezialfall "ich öffne Root-Schlüssel" festgelegt und sinnvoll verwendbar, in allen anderen Fällen (der überragenden Mehrzahl) nutzlos. Und im Falle "ich öffne Root-Schlüssel" sagt mir die Eigenschaft RootKey bereits alles was ich wissen will. Den Rest erfahre ich dann über CurrentPath. CurrentKey ist in meinen Augen überflüssig.
Das soll einer verstehen... ich geh jetzt heim.
Schönen Abend! :-)

lg Caps

[CCRDude]

Immer diese pauschalen Aussagen... nutzlos für Dich vielleicht. Aber es gibt noch eine Reg*-API-Aufrufe, die nicht in TRegistry gekapselt sind, und wenn man die haben möchte, braucht man ein Handle eines geöffneten Schlüssels. Auch die implementierten Aufrufe sind nicht vollständig, vielleicht will man mal andere als die drei simplen Registry-Datentypen lesen oder schreiben, ohne gleich alles direkt mit der API zu implementieren. Oder man kommuniziert über Delphi-Grenzen hinweg etwa mit gelinkten DLLs.

[jaenicke]

Nebenbei kann man theoretisch aus diesem Handle auch wieder den Pfad herausholen. Dafür kann man NtQueryKey mit KeyNameInformation als Typ benutzen...

Normalerweise braucht man das Handle aber natürlich wirklich nur für die passenden API Aufrufe.

[Caps]

In der Tat, da kann es Anwendungsfälle geben. Ich wunderte mich bloß, weil in der Hilfe nichts darüber stand.

Alles klar
lg Caps

[Schwedenbitter]

Ich muss mich hier mal einklinken und das Thema wieder aufmachen. Denn man gelangt hierhin, wenn man CurrentKey und/oder CurrentPath in der Suche eingibt:

Weiter oben wurde

Delphi-Quellcode:

   property CurrentPath: string read FCurrentPath;

schon angesprochen. Bei einem von mir verwendeten Code (Siehe das Thema hier) ist CurrentPath aber immer leer. Der Code-Schnipsel dazu sieht wie folgt aus:

Delphi-Quellcode:

Procedure TMainForm.SearchReg;
Var
   SearchStr   : String;

   Procedure EnumAllKeys(hkey: THandle);
   Var
      l         : TStringList;
      n         : Integer;
      S         : String;
   Begin
      With TRegistry.Create Do
      Try
         RootKey:=hkey;
         OpenKeyReadOnly(EmptyStr);
         l:=TStringList.Create;
         Try
            GetKeynames(l);
            CloseKey;
            For n:=0 To Pred(l.Count) Do
            Begin
               S:=l[n];
               If Pos(SearchStr, UpperCase(S)) > 0 Then
                  LBRegistry.Items.Append(CurrentPath + '#'); // Warum ist das leer???
               If OpenKeyReadOnly(S) Then
               Begin
                  EnumAllKeys(CurrentKey);
                  CloseKey;
               End;
            End;
         Finally
            l.Free
         End;
      Finally
         Free;
      End;
   End;

Begin
   SearchStr:=UpperCase(EDSearch.Text);
   LBRegistry.Items.Clear;
   LBRegistry.Items.BeginUpdate;
   Try
//   EnumAllKeys(HKEY_CLASSES_ROOT    );
//   EnumAllKEys(HKEY_CURRENT_USER    );
      EnumAllKEys(HKEY_LOCAL_MACHINE   );
//   EnumAllKEys(HKEY_USERS           );
//   EnumAllKEys(HKEY_PERFORMANCE_DATA);
//   EnumAllKEys(HKEY_CURRENT_CONFIG  );
//   EnumAllKEys(HKEY_DYN_DATA        );
   Finally
      LBRegistry.Items.EndUpdate;
   End;
End;

Was an meiner Code-Variante ist falsch?

[edit]
Es scheint ein Problem mit CurrentPath zu geben. Anders lässt sich nicht erklären, warum z.B. in diesem Code der jeweilige Pfad durchgereicht und in

Delphi-Quellcode:

KeyName_

zwischengespeichert wird.
Ich wäre für Erhellung trotzdem dankbar.
[/edit]

Gruß, Alex

[himitsu]

Wieso sollte das ein Fehler sein?

Delphi-Quellcode:

OpenKeyReadOnly(EmptyStr);

aka

Delphi-Quellcode:

OpenKeyReadOnly('');

, womit der Pfad also wirklixh

Delphi-Quellcode:

''

ist. :roll:

Und da vorher auch noch

Delphi-Quellcode:

CloseKey;

aufgerufen wurde, ist das erst Recht

Delphi-Quellcode:

''

, denn dieses Property wird beim Schließen leergemacht.

Es wird zwar danach nochmal der Key geöffnet, aber auch gleich wieder geschlossen, so daß es im nächsten Schleifendurchgang auch wieder korrekt

Delphi-Quellcode:

''

ist.



PS: OpenKeyReadOnly hat nicht umsonst ein Result.

[Schwedenbitter]

Zitat:

Zitat von himitsu (Beitrag 1247465)

Wieso sollte das ein Fehler sein?

Ich habe doch garnicht das Wort "Fehler" benutzt. Ich habe doch bloß um Erhellung gebeten und die Antwort auch gern zur Kenntnis genommen; also das Problem verstanden. Dafür danke.
Ich habe jetzt eine weitere lokale Variable definiert und darin an mehreren Stellen

Delphi-Quellcode:

CurrentPath

abgefragt - Ergebnis: immer leer. Das wiederum verstehe ich nicht. Denn wenn die Procedure rekursiv aufgerufen und

Delphi-Quellcode:

Rootkey:=hkey;

gesetzt wurde, wäre nach meinem Verständnis der aktuelle (Unter)Schlüssel geöffnet. In CurrentPath sollte also nach meinem Verständnis was sinnvolles stehen; tut es aber nicht.
Also formuliere ich meine Frage mal um/anders:

Wie komme ich an den aktuelle Pfad?

Wenn ich den gesuchten String gefunden habe, will ich ja die Fundstelle auch ausgeben.

[himitsu]

Da wo der Key offen ist und wo er nicht mit

Delphi-Quellcode:

''

geöffnet wurde, da ist in CurrentKey auch das enthalten, was reingegeben wurde. (der relative Pfad zum RootKey)

An der Stelle, wo du CurrentKey auslesen wolltest, da kannst du auch direkt

Delphi-Quellcode:

l[n]

, bzw.

Delphi-Quellcode:

S

verwenden, welches dem CurrentKey entspricht, innerhalb des nachfolgenden IFs.

Delphi-Quellcode:

               S:=l[n];
               If OpenKeyReadOnly(S) Then
               Begin
                  If Pos(SearchStr, UpperCase(S)) > 0 Then
                     LBRegistry.Items.Append(CurrentPath + '#'); // Warum ist das leer???
                  EnumAllKeys(CurrentKey);
                  CloseKey;
               End;

Delphi-Quellcode:

               S:=l[n];
               If Pos(SearchStr, UpperCase(S)) > 0 Then
                  LBRegistry.Items.Append(S + '#'); // Warum ist das leer???
               If OpenKeyReadOnly(S) Then
               Begin
                  EnumAllKeys(CurrentKey);
                  CloseKey;
               End;

[Volker Z.]

Hallo,

Zitat:

Denn wenn die Procedure rekursiv aufgerufen und

Delphi-Quellcode:

Rootkey:=hkey;

gesetzt wurde, wäre nach meinem Verständnis der aktuelle (Unter)Schlüssel geöffnet

Nö. Das Setzen der Eigenschaft RootKey bestimmt nur den Hauptschlüssel unter dem gelesen/geschrieben werden soll, also HKEY_LOCAL_MACHINE, HKEY_USERS, HKEY_CURRENT_USER etc. - mehr nicht. Die gewünschten Unterschlüssel musst Du schon noch mit

Delphi-Quellcode:

OpenKey

oder

Delphi-Quellcode:

OpenKeyReadOnly

entsprechend öffnen (vollständige "Pfadangabe"!).

Wenn Du einen Unterschlüssel öffnest, kannst Du bis zum nächsten

Delphi-Quellcode:

CloseKey

(sinnvoll) auf

Delphi-Quellcode:

CurrentPath

zugreifen - nach einem

Delphi-Quellcode:

CloseKey

steht dann aber nix mehr zur Verfügung.

Versuch es doch mal so:

Delphi-Quellcode:

procedure TForm3.Button1Click(Sender: TObject);
var
  SearchString : string;

  procedure EnumAllKeys (const Root : HKEY; const Key : string);
  var
    r : TRegistry;
    l : TStringList;
    i : Integer;
    s : string;
  begin
    r := TRegistry.Create;
    try
      r.RootKey := Root;

      if r.OpenKeyReadOnly (Key) then
        begin
          l := TStringList.Create;

          r.GetKeyNames (l);
          for i := 0 to l.Count - 1 do
            begin
              s := l [i];
              if Pos (SearchString, UpperCase (s)) > 0 then
                ListBox1.Items.Add (r.CurrentPath + '\' + s);

              EnumAllKeys (Root, r.CurrentPath + '\' + s)
            end;

          r.CloseKey
        end;
    finally
      FreeAndNil (r);
      FreeAndNil (l)
    end
  end;

begin
  SearchString := 'PRINT';
  EnumAllKeys (HKEY_CURRENT_CONFIG, '')
end;

Gruß

[himitsu]

Zitat:

Zitat von Volker Z. (Beitrag 1247482)

Hallo

Falls jemand den Code verwendet, beachtet er hoffentlich die Compiler-Warnung, welche meint das

Delphi-Quellcode:

L

nicht initialisiert sei.
Und das Derjenige den Fehler natürlich auch behebt.

[Schwedenbitter]

Der Code ist sehr schön, bestätigt aber meine Annahme:
Der Pfad zum Key wird mitgeschleift. Wozu dann CurrenPath?

Schlimmer noch ist der Umstand, dass ich CurrentPath jetzt testhalber mal unmittelbar vor dem rekursiven Aufruf eingefügt und mir ausgeben lasse. Es ist jetzt nicht mehr leer - immerhin ein Fortschritt. Aber CurrentPath ist identisch mit

Delphi-Quellcode:

s

bzw.

Delphi-Quellcode:

l[n]

und wirft damit wieder die Frage auf: Wozu dann CurrenPath?

Unter "path" verstehe ich eben nicht den aktuellen Key, sondern den gesamten Pfad.

Ich überlege auch, ob ich mein Problem nicht dadurch löse, dass ich mit

Delphi-Quellcode:

ShellExecute

einfach mal ein

Delphi-Quellcode:

reg query HKLM /d /k /v /f "10ec7b9.msp" /s > 10ec7b9.msp.txt

laufen lasse und dann die Ausgabe auswerte. Oder kennt jemand durch Zufall eine API-Funktion von Windows, mit der man die Registry nach einem Wert durchsuchen (lassen) kann?

[himitsu]

Weil sicht scheinbar aus einen HKEY kein Pfad auslesen lässt?

CurrentKey gibt immer nur "relativen" den Pfad zurück, welchen du namentlich geöffnet hast.
Wenn du mit RootKey immer nur mitten drin einsteigst, dann kann in der ersten Ebene nie etwas drin stehen.

Natürlich könntest du auch nur den Pfad weiterreichen und RootKey auf dem "Root" belassen, dann würde in CurrentKey auch der relative Pfad zum "Root" drinstehen. :stupid: