Hallo,

ich habe mal wieder ein ganz spezielles Problem

Ich muss im Stream eine Variable übergeben, die z.B. durch eine Codierungsfunktion den Wert "#$1F'ÇøẢx߬" enthält.

Mit

markieren

Delphi-Quellcode:

Buffer := TMemoryStream.Create;
size := Length(xyz^.Wert);
Buffer.Write(size, SizeOf(Size));
Buffer.Write(PChar(Trim(xyz.Wert))^, size);

gibt es aber Probleme.
Die
PChar(Trim(xyz.Wert))^ ergibt nämlich statt #$1F'ÇøẢx߬ nur noch #$1F

Lass ich die Dereferenzierung ^ weg, klappt es. Wie kann ich jetzt aber den Wert in den Stream schreiben?

Danke für jeden mögliche Hinweis.
Schon einmal ein schönes Wochenende
wünscht Amigage

PChar hört bei einem Nullbyte auf. Wenn du also einen String kodierst und ein Nullbyte drinne vorkommt, dann vergiss es mit PChar.

zusammenfalten · markieren

Delphi-Quellcode:

Var
  s : String;
  lSize: Integer;
  lBuffer: TStream;
Begin
  lBuffer := TMemoryStream.Create;
  Try
    s := Trim(xyz.Wert);
    lSize := Length(s);

    lBuffer.Write(lSize, SizeOf(lSize));
    lBuffer.Write(s[1], lSize);
  Finally
    lBuffer.Free;
  End;
End;

/EDIT: Fehler beseitigt. Mensch ist das peinlich - noch so dumme Fehler...

Anmerkung: Das Trim bei einem verschlüsselten String, der wahrscheinlich mehr binäre Daten enthält als lesbaren Text, war für mich auch schon unverständlich - aber wenn der "Kunde" es so wünscht...

Hallo,

du schreibst einen durch Trim möglicherweise gekürzten String in seiner Originallänge in den Stream?

Ich würde es folgendermaßen versuchen:

markieren

Delphi-Quellcode:

Buffer := TMemoryStream.Create;
s := Trim(xyz.Wert);
size := Length(s);
Buffer.Write(size, SizeOf(size));
if (size > 0) then
  Buffer.Write(s[1], size);

Der Code zum Lesen sieht dann so aus:

markieren

Delphi-Quellcode:

Buffer.Read(size, SizeOf(Size));
SetLength (xyz^.Wert, size);
if (size > 0) then
  Buffer.Read(xyz^.Wert[1], size);

@Muetze1
Das erste Zeichen im String hat den Index 1.

Gruß Hawkeye

IMO, ist das, das Beste lösung:

zusammenfalten · markieren

Delphi-Quellcode:

type
  TmyFileStream = class(TFileStream)
    procedure WriteString( myString:string );
    procedure WriteInteger( myInteger:Integer );
    procedure WriteSingle( mySingle:Single );
    procedure WriteDouble( myDouble:Double);
    function ReadSingle():Single;
    function ReadDouble():Double;
    function ReadString():string;
    function ReadInteger():Integer;
  end;

implementation

{ TmyFileStream }

function TmyFileStream.ReadDouble: Double;
begin
  Read( Result, SizeOf( Double ) );
end;

function TmyFileStream.ReadInteger: Integer;
begin
  Read( Result, SizeOf( Integer ) );
end;

function TmyFileStream.ReadSingle: Single;
begin
  Read( Result, SizeOf( Single ) );
end;

function TmyFileStream.ReadString: string;
var
  len:Integer;
begin
  Read( len, SizeOf(len) );
  SetLength( Result, len );
  Read( Result[1], len );
end;

procedure TmyFileStream.WriteDouble(myDouble: Double);
begin
  Write( myDouble, SizeOf(myDouble) );
end;

procedure TmyFileStream.WriteInteger(myInteger: Integer);
begin
  Write( myInteger, SizeOf(myInteger) );
end;

procedure TmyFileStream.WriteSingle(mySingle: Single);
begin
  Write( mySingle, SizeOf(mySingle) );
end;

procedure TmyFileStream.WriteString(myString: string);
var
  len:Integer;
begin
  len := Length( myString );
  Write( len, SizeOf(len) );
  Write( myString[1], Len );
end;

Zitat von sniper_w:

IMO, ist das, das Beste lösung:

Nicht ganz:
Die Methoden "ReadString" und "WriteString" machen Probleme, falls der String leer ist.
Deswegen die Größe vor dem Laden und Speichern nochmal kontrollieren:

zusammenfalten · markieren

Delphi-Quellcode:

function TmyFileStream.ReadString: string;
var
  len:Integer;
begin
  Read( len, SizeOf(len) );
  SetLength( Result, len );
  if (len > 0) then
    Read( Result[1], len );
end;


procedure TmyFileStream.WriteString(myString: string);
var
  len:Integer;
begin
  len := Length( myString );
  Write( len, SizeOf(len) );
  if (len > 0) then
    Write( myString[1], Len );
end;

So sollte es besser sein.

Gruß,
pszopp

Zitat:

So sollte es besser sein.

Die Abfrage ist überflussig:if len > 0 then , denn falls len = 0 wird in Stream sowieso nichts geschrieben/gelesen.

Jo, die Überprüfung ist unnötig.

Noch eine Anmerkung: Alle Routinen die man hier sieht, sind eigentlich unnötig. Nutzt doch einfach den TReader/TWriter.

zusammenfalten · markieren

Delphi-Quellcode:

Begin
  lStream := TFileStream.Create(...);
  Try
    lHandler := TWriter.Create(lStream, 4096);
    Try
      lHandler.WriteIdent(s);
      lHandler.WriteInteger(24);
      ...
    Finally
      lHandler.Free;
    End;
  Finally
    lStream.Free;
  End;
End;

beim TReader entsprechend.

Zitat von sniper_w:

Die Abfrage ist überflussig:

Aber wird es bei Result[1] nicht trotzdem u.U. eine Zugriffsverletzung geben?
Schließlich wird dieser Pointer der Methode übergeben.
Auch wenn dann nichts gestreamt wird.

Gruß,
pszopp

Ok, ich nehme alles zurück und behaupte das Gegenteil: Die Abfrage ist doch nicht überflüssig. Der Pointer wäre illegal und der Index ist auch zu groß. Bei eingeschalteter Bereichsprüfung würde somit schon eine Exception kommen.

Zitat von Hawkeye219:

markieren

Delphi-Quellcode:

Buffer := TMemoryStream.Create;
s := Trim(xyz.Wert);
size := Length(s);
Buffer.Write(size, SizeOf(size));
if (size > 0) then
  Buffer.Write(s[1], size);

Ich habe mich hierfür entschieden und es funktioniert.
Danke für die schnelle Hilfe.