Hallo liebe Delphi-Gemeinde,

ich stehe leider vor dem Problem, eine beliebige Zeichenkette nach Unicode wandeln zu müssen, um sie dann in der Registry als reg_binary zu schreiben.

Irgendwie stehe ich auf dem Schlauch: Ich weiß, dass man Binärdaten mit procedure WriteBinaryData(const Name: String; var Buffer; BufSize: Integer); schreibt.
Reg.WriteBinaryData(Value, String[1], Length(String)); Aber irgendwie habe ich wohl Probleme, die Zeichenkette nach Unicode zu wandeln.
Für einen Link oder Hinweis wäre ich dankbar.

Registry ist doch Unicodefähig? Wieso willst du es denn dann als Binary Daten schreiben
In der Jedi gibt es AFAIK Unicodefähige Zugriffsfunktionen. Ansonsten TNTWare (oder D2009 )

WideString, statt String

markieren

Delphi-Quellcode:

var S: WideString;

Reg.WriteBinaryData(Value, S[1], Length(S) * 2);

und wehe hier fragt einer nach dem *2

Zitat von Bernhard Geyer:

Registry ist doch Unicodefähig?

jupp, ist sie, nur nutzt vor D2009 das TRegistry nur die Ansi-Version der WinAPI, also direkt damit bekommt man keinen UnicodeString, welcher auch noch UnicodeZeichen enthält, in die Registry, oder da wieder raus.

Aber die AnsiStrings werden Registry-intern als Unicode abgespeichert.

Zitat von himitsu:

jupp, ist sie, nur nutzt vor D2009 das TRegistry nur die Ansi-Version der WinAPI, also direkt damit bekommt man keinen UnicodeString, welcher auch noch UnicodeZeichen enthält, in die Registry, oder da wieder raus.

Und wie wäre es dann mit TNTWare oder eigenen kleinen Wrapper um Wide-Version der Registry-API (wie in meinem ersten Post angemerkt)

wäre möglich, also mit TNT ...

aber die Frage ob es denn nötig wäre, bleibt dennoch

also was möchte der Threadersteller erreichen und was ist eine "beliebige Zeichenkette"
wenn es eh nur ein AnsiString ist, dann kann man ja einfach .WriteString nutzen.

Falls es jemanden interessiert:

zusammenfalten · markieren

Delphi-Quellcode:

function GetStringValueFromRegistry(RootKey : HKEY; KeyName, ValueName : WideString;
  var RequestedValue : WideString) : boolean;
var
  Handle : HKEY;
  Buffer : Pointer;
  BufSize : Integer;
  DataType : Integer;
  ReturnValue : Integer;
begin
  Result := false;
  if RegOpenKeyExW(RootKey, PWideChar(KeyName), 0, KEY_QUERY_VALUE, Handle) = ERROR_SUCCESS then
    begin
      Buffer := nil;
      BufSize := 0;
      DataType := REG_SZ;

      repeat
        Inc(BufSize, 1024);
        ReallocMem(Buffer, BufSize);
        ReturnValue := RegQueryValueExW(Handle, PWideChar(ValueName), nil, @DataType, Buffer, @BufSize);
      until ReturnValue <> ERROR_MORE_DATA;

      if ReturnValue = ERROR_SUCCESS then
        begin
          Result := true;
          RequestedValue := WideString(PWideChar(Buffer));
        end;

      FreeMem(Buffer);
      RegCloseKey(Handle);
    end;
end;

function SetStringValueInRegistry(RootKey : HKEY; KeyName, ValueName, Value : WideString) : boolean;
var
  Handle : HKEY;
  ReturnValue : Integer;
begin
  Result := false;
  if RegCreateKeyExW(RootKey, PWideChar(KeyName), 0, nil, REG_OPTION_NON_VOLATILE, KEY_SET_VALUE or KEY_WRITE, nil, Handle, nil) = ERROR_SUCCESS
    then
      begin
        ReturnValue := RegSetValueExW(Handle, PWideChar(ValueName), 0, REG_SZ, PWideChar(Value), (Length(Value) + 1) * 2);
        result := ReturnValue = ERROR_SUCCESS;
        RegCloseKey(Handle);
      end;
end;

Ich fand TRegistry ohnehin schon immer totalen Overkill . Ich benutz übrigens die JEDI API Header. Kann gut sein, daß mit der "normalen" Windows Unit die ein oder andere Definition abweicht.

@0xF30FC7

Besten Dank für die beiden Funktionen. Das ist genau das, was ich in Kurzform gesucht habe.
Und wenn ich statt REG_SZ die Angabe REG_BINARY verwende, wird der Wert so hinterlegt, wie ich es wollte

Super!

aber, wie schon gesagt, REG_SZ selber ist schon ein UnicodeString. [nur zur info]