Registry auslesen unsicher

[HomerGER]

hallo ich hab mir ein Function zusammengebaut
sie funktiniert auch soweit nur bei multisz bin ein bischen unsicher
zwar lese ich nur bin, dw, sz und multi aus aber ganz wohl bin ich bei der sache nicht
ich habe den multi jetzt bei unbekannt eingesetzt
aber das ist zu unsicher
kann mir jemand sagen wie ich das besser machen kann ?

//Type (öffentlich)
type
reg1_r = Record
s1 : HKEY;
s2 : String;
s3 : String;
end;

Code:

//******************************************************************************
//ÜbergabeFunction
//Wert Reg aus der Registry lesen
Function Reg_Lesen_RYU(input_r : reg1_r) : reg_wert_r;
const bufsize = 100;
var
Reg : TRegistry;
output_s : String;
string_s : String;
integer_i : Integer;
byte_buffer_dab : Array of Byte;
byte_ausgabe_s : String;
byte_size_i : integer;
byte_len_i : Integer;
i : Integer;
multi_type_c: Cardinal;
multi_size_c: Cardinal;
multi_str_s: String;
begin
    Reg := TRegistry.Create;
    output_s := '';
    string_s := '';

    try
        //HKEY lesen
        Reg.RootKey := input_r.s1;

        //Schlüssel lesen
        if  not Reg.OpenKey(input_r.s2, False) then
        begin
            //Kein Schlüssel vorhanden
            output_s := 'nokey';
            Result.s1 := output_s;
            Result.s2 := '';
        end
        else
        begin
            //Wert lesen
            if Reg.ValueExists(input_r.s3) = False then
            begin
                 //Kein Wert vorhanden
                output_s := 'novalue';
                Result.s1 := output_s;
                Result.s2 := '';
            end
            else
            begin
            //String
                if (Reg.GetDataType(input_r.s3) = rdString) then
                begin
                    string_s := Reg.readstring(input_r.s3);
                    Result.s1 := 'sz';
                    Result.s2 := string_s;
                end
            //Integer
                else if (Reg.GetDataType(input_r.s3) = rdInteger) then
                begin
                    integer_i := Reg.readinteger(input_r.s3);
                    Result.s1 := 'dw';
                    Result.s2 := IntToStr(integer_i);
                end
            //Binary
                else if (Reg.GetDataType(input_r.s3) = rdBinary) then
                begin
                    SetLength(byte_buffer_dab, byte_size_i);

                    byte_len_i := Reg.ReadBinaryData(input_r.s3, PChar(byte_buffer_dab)^, byte_size_i);

                    byte_ausgabe_s := '';
                    for i := 0 to byte_len_i - 1 do
                    begin
                        if Length(IntToStr(byte_buffer_dab[i])) = 1 then
                        begin
                            byte_ausgabe_s := byte_ausgabe_s + '0' + IntToStr(byte_buffer_dab[i]);
                        end
                        else
                        begin
                            byte_ausgabe_s := byte_ausgabe_s + IntToStr(byte_buffer_dab[i]);
                        end;
                    end;
                    Result.s1 := 'bi';
                    Result.s2 := byte_ausgabe_s;
                end
            //Erweiterter String
                else if (Reg.GetDataType(input_r.s3) = rdExpandString) then
                begin
                    string_s := Reg.readstring(input_r.s3);
                    Result.s1 := 'es';
                    Result.s2 := string_s;
                end
            //Mehrzeiliger String
                else if (Reg.GetDataType(input_r.s3) = rdUnknown) then
                begin
                    multi_size_c := 0;
                    RegQueryValueEx(Reg.CurrentKey, PChar(input_r.s3), nil, @multi_type_c, nil, @multi_size_c);
                   
                    SetLength(multi_str_s, multi_size_c - 1);
                    if multi_size_c > 1 then
                    begin
                    RegQueryValueEx(Reg.CurrentKey, PChar(input_r.s3), nil, @multi_type_c, PByte(multi_str_s), @multi_size_c);
                    end;
                    
                    for i := Length(multi_str_s) downto 1 do
                    begin
                        if multi_str_s[i] = #0 then
                        begin
                            multi_str_s[i] := #13;
                        end;
                    end;
                    if (multi_str_s <> '') then
                    begin
                        Result.s1 := 'mz';
                        Result.s2 := multi_str_s;
                    end;
                end
            //Fehler
                else
                begin
                    //Fehler kein Typ gefunden
                end;
            end;
        Reg.CloseKey;
        end;
    finally
    Reg.Free;
    end;
end;

der teil um den es mir geht ist der hier
//Mehrzeiliger String
else if (Reg.GetDataType(input_r.s3) = rdUnknown) then
begin
multi_size_c := 0;
RegQueryValueEx(Reg.CurrentKey, PChar(input_r.s3), nil, @multi_type_c, nil, @multi_size_c);

SetLength(multi_str_s, multi_size_c - 1);
if multi_size_c > 1 then
begin
RegQueryValueEx(Reg.CurrentKey, PChar(input_r.s3), nil, @multi_type_c, PByte(multi_str_s), @multi_size_c);
end;

for i := Length(multi_str_s) downto 1 do
begin
if multi_str_s[i] = #0 then
begin
multi_str_s[i] := #13;
end;
end;
if (multi_str_s <> '') then
begin
Result.s1 := 'mz';
Result.s2 := multi_str_s;
end;
end

[Christian Seehase]

Moin HomerGER,

erst einmal herzlich willkommen hier in der Delphi-PRAXiS.

Wenn Du allgemein Daten aus der Registry auslesen willst, also auch über die von TRegistry unterstützten hinaus, halte ich es für sinnvoller dies direkt mit den API Funktionen zu tun, da TRegistry nur REG_SZ, REG_EXPAND_SZ, REG_BINARY, REG_DWORD und den Rest unterscheidet. Der Rest umfasst aber nicht nur REG_MULTI_SZ, so dass im Falle eines rdUnknown nicht sichergestellt ist, dass es sich um ein REG_MULTI_SZ handelt.

[HomerGER]

Danke für die nette begrüssung
also mit den api functionhab ich es schon versucht

Delphi-Quellcode:

if (RegOpenKeyEx(input_r.s1, PChar(input_r.s2), 0, KEY_READ, key) = ERROR_SUCCESS) then
            begin

                RegQueryValueEx(key, PChar(input_r.s3), nil, @vType, nil, @vLen);
                ShowMessage(inttostr(vType));
            end;

nur das ist merkwürdige das er nicht alle registry einträge erkennt
ich lese so 100 werte aus
er kennt aber nur 10, zwar richtig, aber leider nur die paar
die werte sie alle da
mit Reg.GetDataType erkennt er alle
hast du ne idee ?

Ps und habe ich
if (Reg.GetDataType(input_r.s3) = rdBinary) gegen
if (vType = REG_SZ) usw getauscht

[Christian Seehase]

Moin HomerGER,

hast Du Dir vorher auch mit RegQueryInfoKey die "Eckdaten" des Keys geholt?
Und hast Du daran gedacht, dass der letzte Parameter von RegQueryValueEx immer wieder neu gesetzt werden muss, da das Auslesen den Inhalt verändert?

[HomerGER]

hi Christian

Zitat:

Und hast Du daran gedacht, dass der letzte Parameter von RegQueryValueEx immer wieder neu gesetzt werden muss, da das Auslesen den Inhalt verändert?

da das eine Function ist werden die daten ja immer wieder neu geholt

Zitat:

hast Du Dir vorher auch mit RegQueryInfoKey die "Eckdaten" des Keys geholt?

reicht es nicht wenn ich prüfe ob der key ofen ist ?

öffne ich als erste HKEY
dann prüfe ich ob der SubKey vorhanden ist
und dann prüfe ich ob ein wert vorhanden ist - und hier frage ich nach den datatype

Hast du womöglich ein Beispiel ?
da die meisten Function sich auf die Delphi Function beziehen und nicht auf die API ist es für mich ein bischen schwierig - ich weiß nicht recht ob ich es alles richtig verstehe

meine Function gib als erstes den datatyp zurück dw,sz usw
und dann den wert als string
so ist es mir (wenn ich den DataType richtig auslese) möglich ohne in die registy zu gehen die daten zu lesen und dann zu schreiben ohne zu wissen welche datatype ich da habe

[Christian Seehase]

Moin HomerGER,

Zitat:

Zitat von HomerGER

da das eine Function ist werden die daten ja immer wieder neu geholt

nein, die Längenangabe wird nicht nur zurückgegeben, sondern man übergibt der Funktion damit auch zur Verfügung stehende Buffergrösse.
Deshalb muss der Wert immer wieder auf die Buffergrösse gesetzt werden.

Mit RegQueryInfoKey brauchst Du, u.a., um die erforderlichen Buffergrössen zu ermitteln.

Was Beispiele angeht:
Sollest Du, wieder erwarten, hier nichts passendes über die Suchfunktion ermitteln können, so kannst Du mal einen Blick in die RegTreeView Kompo werfen, die es hier zum Download gibt. Da hab' ich das mit Sicherheit verwendet.

[HomerGER]

Hi Christian
ich wäre ja froh wenn ich so weit wäre
ich hab hier mal angefangen

Delphi-Quellcode:

Function Reg_Lesen_RYU(input_r : reg1_r) : reg_wert_r;
var
key_hk : HKEY;
begin
    try
        if (RegOpenKeyEx(input_r.s1, PChar(input_r.s2), 0, KEY_READ, key_hk) = ERROR_SUCCESS) then
        begin
            Result.s1 := 'offen';
            Result.s2 := '';
        end
        else
        begin
            Result.s1 := 'zu';
            Result.s2 := '';
        end;

    finally
    RegCloseKey(key_hk);
    end;
end;

er zeigt mir von 65 Werten 6 nur 'offen' an obwohl die Key vorhanden sind
ich lese nochnicht mal werte
oder hab ich hier was vergessen ?

[Christian Seehase]

Moin HomerGER,

speicher Dir mal den Rückgabewert von RegOpenKeyEx und lass' ihn Dir den Fehlercode mal mit

Delphi-Quellcode:

ShowMessage(SysErrorMessage(<Worin der Rückgabewert gespeichert wurde>));

anzeigen.
Vielleicht lässt das die Ursache eingrenzen.

[HomerGER]

hatte ich schon schon - fehler code 161
hatte ich vergessen hier zu sagen - sorry asche auf ein haupt :oops:
wie gesagt mit den Tregistry geht es, aber nicht mit den api hmmmmm
bei MS bin ich nicht ganz sicher ob ich da richtig gesucht habe

ERROR_BAD_PATHNAME The specified path is invalid. 161

der path ist falsch ??!!!
Mulder hilf ???
ich lese in allen HKEY's

[Christian Seehase]

Moin HomerGER,

da TRegistry intern natürlich auch mit den API Funktionen arbeitet, frage ich mich, was eigentlich input_r.s1 enthält?