Unicodestring für SendMessage verpacken?

[PeterPanino]

Hallo! Ich verwende folgenden Code, um einen string von Programm A nach Programm B zu senden:

Senderprogramm:

Delphi-Quellcode:

type  
  TCopyDataStruct = packed record
    dwData: DWORD;
    cbData: DWORD;
    lpData: Pointer;
  end;

  private
    procedure SendString(const stringToSend: string; const ReceiverHandle: HWND);

implementation

procedure TformSender.SendString(const stringToSend: string; const ReceiverHandle: HWND);
var
  copyDataStruct: TCopyDataStruct;
begin
  copyDataStruct.dwData := 0;
  copyDataStruct.cbData := 1 + (Length(stringToSend) * 2); // ?
  copyDataStruct.lpData := PWideChar(stringToSend);
  
  SendMessage(ReceiverHandle, WM_COPYDATA, Integer(Handle), Integer(@copyDataStruct));
end;

procedure TformSender.Button1Click(Sender: TObject);
var
  EmpfaengerHandle: HWND;
begin
  EmpfaengerHandle := FindWindow(PWideChar('TformEmpfaenger'), PWideChar('Empfängerprogramm'));
  if EmpfaengerHandle <> 0 then
    SendString('Meine Nachricht', EmpfaengerHandle);
end;

Empfängerprogramm:

Delphi-Quellcode:

type
  TWMCopyData = packed record
    Msg: Cardinal;
    From: HWND;
    CopyDataStruct: PCopyDataStruct;
    Result: Longint;
  end;

  private
    procedure WMCopyData(var Msg: TWMCopyData); message WM_COPYDATA;

implementation

procedure TformEmpfaenger.WMCopyData(var Msg: TWMCopyData);
var
  s: string;
begin
  s := PWideChar(Msg.CopyDataStruct.lpData);
  MessageDlg('"' + s + '"', mtInformation, [mbOK], 0);
  Msg.Result := 6666;
end;

Das funktioniert auf meinem Computer auch sehr gut. ABER: Ich habe im Senderprogramm die Länge des strings so angegeben:

1 + (Length(stringToSend) * 2),

weil der string mit PWideChar ja in einen Unicode-string verpackt wird, und ich annehme (räusper), dass bei Unicode jedes Zeichen 2 Bytes enthält - deshalb der Multiplikator 2. Wenn ich den Multiplikator nicht verwende, kommt beim Empfänger teilweise Zeichensalat heraus.

ABER es könnte ja sein, dass auf einem anderen Computer mit einem anderen Windows-Betriebssystem die Byte-Länge für ein Zeichen anders ist. Würde dieses Programm dann dort auch funktionieren?

[Bernhard Geyer]

Zitat von PeterPanino:

ABER es könnte ja sein, dass auf einem anderen Computer mit einem anderen Windows-Betriebssystem die Byte-Länge für ein Zeichen anders ist.

Dazu müsst es erstmal dieses Windows geben das auch in einer als typlos definierten Struktur deinen String erkennt und ihn dann modifiziert.

[TiGü]

Delphi-Quellcode:

  copyDataStruct.cbData := 1 + (Length(stringToSend) * SizeOf(Char)); // !!!
  copyDataStruct.lpData := PChar(stringToSend);

So müsste das halbwegs zukunftssicher sein!
Char ist im modernen Delphi auf WideChar (Size: 2 Byte) gemappt und PChar auf PWideChar.
In älteren Delphis ist es ANSI.
Andere Umgebungen erfordern eh ein neu compilieren für diese Plattform, oder?

[Iwo Asnet]

Blöd nur, wenn die eine Anwendung mit neuerem Delphi und die andere mit älterem Delphi kompiliert wurde.

Wieso nicht einfach per (z.B.) UTF8 kodieren? Dann hat man gar keine Kompatibilitätsprobleme mehr.

[PeterPanino]

Zitat von TiGü:

Delphi-Quellcode:

  copyDataStruct.cbData := 1 + (Length(stringToSend) * SizeOf(Char)); // !!!
  copyDataStruct.lpData := PChar(stringToSend);

So müsste das halbwegs zukunftssicher sein!
Char ist im modernen Delphi auf WideChar (Size: 2 Byte) gemappt und PChar auf PWideChar.
In älteren Delphis ist es ANSI.
Andere Umgebungen erfordern eh ein neu compilieren für diese Plattform, oder?

Vielen Dank! SizeOf(Char) ist eine gute Idee.

Aber wie ist das, wenn ich für die Adresse der Datenstruktur einen Integertyp verwende: Integer(@copyDataStruct)
Könnte das nicht in einem 64bit-Adressraum möglicherweise zu einem Fehler führen?

[TiGü]

Zitat von PeterPanino:

Aber wie ist das, wenn ich für die Adresse der Datenstruktur einen Integertyp verwende: Integer(@copyDataStruct) Könnte das nicht in einem 64bit-Adressraum möglicherweise zu einem Fehler führen?

Verwende lieber die Alias-Typen WPARAM und LPARAM, die wachsen nämlich mit, da sie von (U)INT_PTR abgeleitet werden:

SendMessage(ReceiverHandle, WM_COPYDATA, WPARAM(Handle), LPARAM(@copyDataStruct));

[himitsu]

Kodier den String als UTF-8 und fertig.

Somit kann sich jeder das von/nach Unicode oder ANSI umkodieren, wie er lustig ist ... solange es bei der Übertragung als UTF-8 definiert ist.

(natürlich bleibt dann weiterhin das Problem, daß beim Umwandeln von UTF-8 nach ANSI Informationen verloren gehen könnten, aber das würde ja auch passieren, wenn du von Unicode nach ANSI umwandeln läßt.)


Oder du überträgst es immer als Unicode (WideString), was am Ende auf's Selbe hinausläuft.


Man überträgt/speichert eben keine dynamischen Daten.
Jedenfalls nicht, ohne das Format auch noch mit zu übertragen, damit der Empfänger weiß wie er das zu interpretieren hat.

Zitat:

Delphi-Quellcode:

procedure TformSender.SendString(const stringToSend: string; const ReceiverHandle: HWND);
...
  copyDataStruct.lpData := PWideChar(stringToSend);

Aber das war schonmal total falsch. *dir auf die Pfoten hau*

String, bzw. Char ist nicht immer PWideChar, bzw. 2.

String > Char > PChar > SizeOf(Char)
WideString > WideChar > PWideChar > 2=SizeOf(WideChar)
AnsiString > AnsiChar > PAnsiChar > 1=SizeOf(AnsiChar)
aber niemals vermischt