reg speichern

[wenglewski]

Kann mir jemand sagen, wie ich die ganze registry speichern kann?

 

[mfk]

Hallo,
folgender Code exportiert rekursiv ab einer beliebigen Stelle
ich benutze ihn in einer für mich etwas umgebauten Version für einzelne Äste, jedoch kann man das ja schnell z.B. auch auf alle RootKeys erweitern.

unit RegExpo; 

interface 

uses 
  Windows, rRegistry, Classes, SysUtils; 

{$I-} 
{$LONGSTRINGS ON} 

{ 
  Regexpo 

  Author : Arthur Hoornweg (arthur.hoornweg@email.de) 
  Version : 1.00, May 1998 
  O/S : Windows 95, 98, ME, NT, 2000, XP 
        Delphi 2+ 
  Function : 
    This unit allows you to backup a branch of the registry into a *.REG file, 
    that is compatible with "regedit". 
    Double-clicking such a file in the explorer will import it. 


  Example: 
    ExportRegistryBranch(HKEY_LOCAL_MACHINE,'SOFTWARE\Borland\Delphi','A:\DELPHI.REG') 

  (c) 1998 A.M. Hoornweg. All rights reserved. 

  You may use this software for all purposes, both commercial and 
  noncommercial, as long as proper credit is given. The sourcecode may be distributed 
  freely, as long as this copyright is included and no more than a marginal fee is 
  asked. 


  Disclaimer: 

  I accept no responsibility whatsoever for any damages caused by these 
  routines. Use them at your own risk. If you find any bugs, please let me know. 
} 


procedure ExportRegistryBranch(Rootsection: Integer; regroot: string; 
  FileName: string); 

implementation 

function dblBackSlash(t: string): string; 
var 
  k: longint; 
begin 
  Result := t; {Strings are not allowed to have} 
  for k := Length(t) downto 1 do {single backslashes} 
    if Result[k] = '\' then Insert('\', Result, k); 
end; 


procedure ExportRegistryBranch(rootsection: Integer; Regroot: string; 
  FileName: string); 
var 
  reg: TRegistry; 
  f: Textfile; 
  p: PChar; 

  procedure ProcessBranch(root: string); {recursive sub-procedure} 
  var 
    values, keys: TStringList; 
    i, j, k: longint; 
    s, t: string; {longstrings are on the heap, not on the stack!} 
  begin 
    Writeln(f); {write blank line} 
    case rootsection of 
      HKEY_CLASSES_ROOT: s   := 'HKEY_CLASSES_ROOT'; 
      HKEY_CURRENT_USER: s   := 'HKEY_CURRENT_USER'; 
      HKEY_LOCAL_MACHINE: s  := 'HKEY_LOCAL_MACHINE'; 
      HKEY_USERS: s          := 'HKEY_USERS'; 
      HKEY_PERFORMANCE_DATA: s := 'HKEY_PERFORMANCE_DATA'; 
      HKEY_CURRENT_CONFIG: s := 'HKEY_CURRENT_CONFIG'; 
      HKEY_DYN_DATA: s       := 'HKEY_DYN_DATA'; 
    end; 
    Writeln(f, '[' + s + '\' + root + ']'); {write section name in brackets} 

    reg.OpenKey(root, False); 
    try 
      values := TStringList.Create; 
      try 
        keys := TStringList.Create; 
        try 
          reg.GetValuenames(values); {get all value names} 
          reg.GetKeynames(keys); {get all sub-branches} 

          for i := 0 to values.Count - 1 do {write all the values first} 
          begin 
            s := values[i]; 
            t := s; {s=value name} 
            if s = '' then s := '@' {empty means "default value", write as @} 
            else 
              s := '"' + s + '"'; {else put in quotes} 
            Write(f, dblbackslash(s) + '='); {write the name of the key to the file} 

            case reg.Getdatatype(t) of {What type of data is it?} 

              rdString, rdExpandString: {String-type} 
                Writeln(f, '"' + dblbackslash(reg.ReadString(t) + '"')); 

              rdInteger: {32-bit unsigned long integer} 
                Writeln(f, 'dword:' + IntToHex(reg.readinteger(t), 8)); 

             {write an array of hex bytes if data is "binary." Perform a line feed 
              after approx. 25 numbers so the line length stays within limits} 

              rdBinary: 
                begin 
                  Write(f, 'hex:'); 
                  j := reg.GetDataSize(t); {determine size} 
                  GetMem(p, j); {Allocate memory} 
                  reg.ReadBinaryData(t, p^, J); {read in the data, treat as pchar} 
                  for k := 0 to j - 1 do 
                  begin 
                    Write(f, IntToHex(Byte(p[k]), 2)); {Write byte as hex} 
                    if k <> j - 1 then {not yet last byte?} 
                    begin 
                      Write(f, ','); {then write Comma} 
                      if (k > 0) and ((k mod 25) = 0) {line too long?} then 
                        Writeln(f, '\'); {then write Backslash +lf} 
                    end; {if} 
                  end; {for} 
                  FreeMem(p, j); {free the memory} 
                  Writeln(f); {Linefeed} 
                end; 
              else 
                Writeln(f, '""'); {write an empty string if datatype illegal/unknown} 
            end;{case} 
          end; {for} 
        finally 
          reg.CloseKey; 
        end; 

      finally 
        {value names all done, no longer needed} 
        values.Free; 
      end; 

      {Now al values are written, we process all subkeys} 
      {Perform this process RECURSIVELY...} 
      for i := 0 to keys.Count - 1 do 
        ProcessBranch(root + '\' + keys[i]); 
    finally 
      keys.Free; {this branch is ready} 
    end; 
  end; { ProcessBranch} 


begin 
  if RegRoot[Length(Regroot)] = '\' then {No trailing backslash} 
    SetLength(regroot, Length(Regroot) - 1); 
  Assignfile(f, FileName); {create a text file} 
  Rewrite(f); 
  if ioResult <> 0 then Exit; 
  Writeln(f, 'REGEDIT4'); {"magic key" for regedit} 

  reg := TRegistry.Create; 
  try 
    reg.Rootkey := Rootsection; 
    {Call the function that writes the branch and all subbranches} 
    ProcessBranch(Regroot); 
  finally 
    reg.Free; {ready} 
    Close(f); 
  end; 
end; 

end.

Ich hoffe, ich konnte weiterhelfen,
Grüsse
Kai

 

[wenglewski]

Danke für den Beitrag. Es muss doch aber auch anders möglich sein, die ganze Registry zu speichern. Geht in der Registry ja auch(Registry exportieren->alles).

Wenn wer ne Idee hat wär ich sehr dankbar