Windows, Stream und String hin her convert fehler

[freimatz]

Zitat von KodeZwerg:

Debuggen fällt mir total schwer, da blick ich noch nicht durch, habe mal mit breakpoints rumprobiert aber bin nicht wirklich schlauer dadurch geworden.

Hilft so was vielleicht?
https://www.youtube.com/watch?v=Oyd0ksN8cRs

Wichtig ist es schon. Ohne Debuggen ist es so wie Autos reparieren ohne die Motorhaube zu öffnen.

[Luckie]

Breakpunkt setzen, mit Mauszeuger 0ber Variablec fahren und Wert ablesen. Oder mit F7 in Einzelschritten durchgehen. Was ist daran so schwer?

[scrat1979]

Ich habe mir dazu mal einen Streamhelper geschrieben, funktioniert bislang problemlos...

Delphi-Quellcode:

[...}
type
  TStreamHelper = class helper for TStream
  public
    procedure ReadString(var Target : string);
    procedure WriteString (const s: string);
end;

[...]

procedure TStreamHelper.ReadString(var Target: String);
var
  len : Integer;
begin
  ReadBuffer(len, SizeOf(len));
  SetLength(Target, len);
  if (len > 0) then
    ReadBuffer(Target[1], len * SizeOf(Char));
end;


procedure TStreamHelper.WriteString (const s: string);
var
  len : Integer;
begin
  len := Length(s);
  WriteBuffer(len, SizeOf(len));
  if (len > 0) then
    WriteBuffer(s[1], len * SizeOf(Char));
end;

[p80286]

Zitat von Neutral General:

Ein Char ist 2 Byte groß, daher ist ein String der Länge X = X * 2 (SizeOf(Char)) Bytes groß:

Sicher? ist es nicht eher langByte=length(instring)*sizeof(char); Ggf. muß noch an die abschließenden CRLF gedacht werden also langByte=length(instring)*sizeof(char)+sizeof(linebreak);
Gruß
K-H

[Schokohase]

Wenn es um Text, Stream und Encoding geht dann liest man doch immer wieder Sachen die stark nach Schlangenöl riechen.

Nochmals zur Info:

TStreamWriter und TStreamReader sind extra und nur für den einzigen Zweck gebaut worden um Text in einen Stream zu schreiben und von dort wieder zu lesen. (Die sind nicht von ungefähr von der abstrakten Klasse TTextWriter bzw. TTextReader abgeleitet)

Man gibt den Stream und das gewünschte Encoding an und kann Schreiben bis der Stream aus allen Nähten platzt. Das Lesen geht analog (Stream, Encoding) und Lesen bis der Arzt kommt.

Zitat von p80286:

Ggf. muß noch an die abschließenden CRLF gedacht werden also langByte=length(instring)*sizeof(char)+sizeof(linebreak);

Da fröstelt es mich doch ganz doll ...

[p80286]

war da nicht vor nicht so langer Zeit jemand, der mit readln gelesen hat, und sich dann gewundert hat, das nach dem zurückschreiben (nicht mit writeln ) der Text etwas unleserlich war?

Gruß
K-H

[KodeZwerg]

Danke für den Hinweis mit SizeOf(Char) !

Das funktioniert bei mir genau so wie ich es mir gewünscht habe ohne das ich auf etwas anderes umsteigen musste.
Tschuldigung, encoding, CRLF usw ist bei mir nicht so tragend/entscheidend.
String vom Edit sollte rein, Stream mit dem sollte raus und rückwärtsrum genauso.

Nach anpassung (Danke nochmal an Michael), klappts bei mir prima!

Delphi-Quellcode:

function TKlasse.StringToStream ( const InputString: String; var ResultStream: TMemoryStream ): Boolean;
var
  i: Integer;
begin
// falls was schiefgeht, erstmal falsen
  Result := False;
// wenn nix reinkommt, muss auch nix rauskommen
  if (Length(InputString) <= 0) then
    Exit;
// falls stream inexistent ist, einen erstellen, ansonsten auf null position stellen
  if (ResultStream = NIL) then
    ResultStream := TMemoryStream.Create
    else
    ResultStream.Position := 0;
// vor dem try den zähler auf null setzen damit compiler keine warnung wirft
  i := 0;
  try
// stream beschreiben
    i := ResultStream.Write(InputString[1], Length(InputString) * SizeOf(Char));
  finally
// entweder haben wir es geschafft, oder auch nicht :-)
    if (i = Length(InputString) * SizeOf(Char)) then
      Result := not False
      else
      Result := False
  end;
end;

function TKlasse.StreamToString ( const InputStream: TMemoryStream; var ResultString: String ): Boolean;
begin
// falls was schiefgeht, erstmal falsen
  Result := False;
// wenn stream inexistent oder leer ist, mach nichts
  if ((InputStream <> NIL) and (InputStream.Size > 0)) then
    begin
      try
// stream position auf null setzen
        InputStream.Position := 0;
// stringlänge anpassen
        SetLength(ResultString, InputStream.Size div SizeOf(Char));
// stream inhalt in string schreiben
        InputStream.Read(ResultString[1], InputStream.Size);
      finally
// entweder haben wir es geschafft, oder auch nicht :-)
        if (Length(ResultString) = InputStream.Size div SizeOf(Char)) then
          Result := not False
          else
          Result := False
      end;
    end;
end;

procedure TKlasse.btnKnopfClick(Sender: TObject);
var
  tmp: TMemoryStream;
  s: String;
begin
  Memo.Lines.Add('Converting "' + Edit.Text + '" to stream');
  try
    if (StringToStream( Edit.Text, tmp )) then
      if (StreamToString( tmp, s )) then
        Memo.Lines.Add(s);
  finally
    s := '';
    tmp.Free;
  end;
end;

[Schokohase]

Zitat von KodeZwerg:

Tschuldigung, encoding, CRLF usw ist bei mir nicht so tragend/entscheidend.
String vom Edit sollte rein, Stream mit dem sollte raus und rückwärtsrum genauso.

Genau das sagt man sich bei Emba auch immer wieder. Hauptsache es kompiliert, dann ist es fertig zum Verkaufen.

Und das mit dieser gesonderten Betrachtung von CRLF (so wie hier in diesem Thread beschreiben) ist eher ein Indiz von "Ich habe überhaupt gar nichts verstanden" und man sollte den Worten eher keine Beachtung schenken.

Wenn es dich irgendwann dann doch treffen sollte, dann frag einfach nochmal nach, wie man es denn wirklich machen sollte (zudem der Code auch noch kürzer wird).

[TiGü]

Das

Delphi-Quellcode:

        if ... then
          Result := not False
          else
          Result := False

verursacht Flimmern vor meinen Augen!

[Schokohase]

Zitat von TiGü:

Das

Delphi-Quellcode:

        if ... then
          Result := not False
          else
          Result := False

verursacht Flimmern vor meinen Augen!

Über solche Kinkerlitzchen rege ich mich schon nicht mehr auf.

Aber auch dieser Code verrät so einiges ... und es drängt sich die Frage auf, warum daraus nicht einfach ein Result := ...; gemacht wird.

Wahrscheinlich viel zu kurz und viel zu wenig verschwurbelt.