Unicode String in FileStream speichern/auslesen

[hansklok]

Hallo,

ich versuche grade (wahrscheinlich wie viele andere auch) mein altes Projekt dem neuen Delphi 2010/XE anzupassen.

Ich habe folgende Klassenstruktur:

Delphi-Quellcode:

  { Adressen }
  TAddress = class
  private
    fAddress,              { Adresszeile 1 }
    fAddressLine1,         { Adresszeile 2 }
    fAddressLine2,         { Adresszeile 3 }
    fAddressLine3,         { Adresszeile 4 }
    fCity,                 { Stadt }
    fState,                { Staat }
    fPostalCode,           { Postleitzahl }
    fCountry:      Utf8String; { Land }
    fPhone:        array[1..MaxPhoneNumbers] of Utf8String;   { Telefonnummern }
    fFax:          array[1..MaxFaxNumbers] of Utf8String;     { Faxnummern }
    fEmail:        array[1..MaxEmailAddresses] of Utf8String; { E-Mail Adressen }
    fWeb:          array[1..MaxWebpages] of Utf8String;       { Webseiten }

    procedure setPhone(Index: Integer; APhoneNumber: Utf8String);
    procedure setEmail(Index: Integer; AEmailAddress: Utf8String);
    procedure setFax(Index: Integer; AFaxNumber: Utf8String);
    procedure setWeb(Index: Integer; AWebpage: Utf8String);

    function getPhone(Index: Integer): Utf8String;
    function getEmail(Index: Integer): Utf8String;
    function getFax(Index: Integer): Utf8String;
    function getWeb(Index: Integer): Utf8String;
  public
    property ADDR: Utf8String read fAddress write fAddress;
    property ADR1: Utf8String read fAddressLine1 write fAddressLine1;
    property ADR2: Utf8String read fAddressLine2 write fAddressLine2;
    property ADR3: Utf8String read fAddressLine3 write fAddressLine3;
    property CITY: Utf8String read fCity write fCity;
    property STAE: Utf8String read fState write fState;
    property POST: Utf8String read fPostalCode write fPostalCode;
    property CTRY: Utf8String read fCountry write fCountry;
    property PHON[Index: Integer]: Utf8String read getPhone write setPhone;
    property EMAIL[Index: Integer]: Utf8String read getEmail write setEmail;
    property FAX[Index: Integer]: Utf8String read getFax write setFax;
    property WWW[Index: Integer]: Utf8String read getWeb write setWeb;

    procedure Save(s: TStream);
    procedure Load(s: TStream);

    function hasAddress: Boolean;
    function hasAddressLine1: Boolean;
    function hasAddressLine2: Boolean;
    function hasAddressLine3: Boolean;
    function hasCity: Boolean;
    function hasState: Boolean;
    function hasPostalCode: Boolean;
    function hasCountry: Boolean;
    function hasPhone(Index: Integer): Boolean;
    function hasFax(Index: Integer): Boolean;
    function hasEmail(Index: Integer): Boolean;
    function hasWeb(Index: Integer): Boolean;
  end;

Nun möchte ich eine Adresse in einer Datei mittels TFileStream speichern.

Um die UnicodeStrings zu speichern haben ich mir wie von Embacadero vorgeschlagen den folgenden Code verwendet:

Delphi-Quellcode:

var
  Size: Integer;

procedure StrToStream(AString: String; AStream: TStream);
begin
  { Richtig für Unicode-Daten }
  AStream.Write(Pointer(AString)^, Length(AString) * SizeOf(Char));
end;

procedure StrFromStream(var AString: String; AStream: TStream);
begin
  { Richtig für Unicode-String-Daten }
  AStream.Read(Size, SizeOf(Integer));
  SetLength(AString, Size);
  AStream.Read(Pointer(AString)^, Size * SizeOf(Char));
end;

Im Testprojekt sieht das ganze so aus:

Delphi-Quellcode:

procedure TForm1.FormCreate(Sender: TObject);
var
  fs: TFileStream;
  adr: TAddress;
begin
  if not FileExists('test.mcgen') then
    begin
      fs:= TFileStream.Create('test.mcgen', fmCreate);
      adr:= TAddress.Create;
      adr.ADDR:= 'Heidi Hase';
      adr.ADR1:= 'Talstraße xxx';
      adr.CITY:= 'Talbach';
      adr.POST:= '00000';
      adr.PHON[1]:= '00000 / 00 00000';
      adr.PHON[2]:= '00000 / 00 00000';
      adr.EMAIL[1]:= '[e-mail]';
      adr.Save(fs);
      fs.Free;
    end else
    begin
      fs:= TFileStream.Create('test.mcgen', fmOpenRead);
      adr:= TAddress.Create;
      adr.Load(fs);
      Memo1.Lines.Add(adr.ADDR);
      Memo1.Lines.Add(adr.ADR1);
      Memo1.Lines.Add(adr.CITY);
      Memo1.Lines.Add(adr.POST);
      Memo1.Lines.Add(adr.PHON[1]);
      Memo1.Lines.Add(adr.PHON[2]);
      Memo1.Lines.Add(adr.EMAIL[1]);
      Caption:= adr.EMAIL[1];
      fs.Free;
    end;
end;

In die Datei wird auch etwas geschrieben, aber sie lässt sich nicht auslesen bzw. nur fehlerhaft oder es erscheint eine Fehlermeldung "Out of memory".

Was hab ich falsch gemacht, ich verzweifel fast.

Danke und VG hansklok

[wicht]

Du musst in StrToStream() die Länge des Strings in den Stream schreiben, bevor du den String schreibst. Du ließt die Länge ja auch aus, an der Stelle passt es scheinbar.

HTH

[ak-ac]

Du rufst deine beiden funktionen doch gar nicht auf, oder?
Sieht mir eher so aus, als ob du deine Einträge in eine Textdatei schreibst...

[himitsu]

Zitat:

Um die UTF8Strings zu speichern haben ich mir wie von Embacadero vorgeschlagen den folgenden Code verwendet:

Willst du nun UTF8Strings oder UnicodeStrings speichern?

Wenn du schon deine UTF-Strings speichern willst, dann sollte die Speicherfunktion auch auf UTF8 ausgelegt sein.

Delphi-Quellcode:

procedure StrToStream(AString: UTF8String; AStream: TStream);
var
  Size: LongInt;
begin
  Size := Length(AString);
  AStream.Write(Size, SizeOf(Size));
  AStream.Write(PAnsiChar(AString)^, Size);
end;

procedure StrFromStream(var AString: UTF8String; AStream: TStream);
var
  Size: LongInt;
begin
  { Richtig für Unicode-String-Daten }
  AStream.Read(Size, SizeOf(Size));
  SetLength(AString, Size);
  AStream.Read(PAnsiChar(AString)^, Size);
end;

Beim speichern von Binärdaten sollte man sowieso keine dynamischen Datentypen (String, Integer, Char) verwenden, sondern nur auf Native (AnsiString, WideString, UnicodeString, LongInt usw.) zurückgreifen.


PS: Existieren noch alte Dateien, welche mit dem neuen Programm ausgelesen werden sollen?
Wenn, ja dann kannst du das Streamformat der Datei nicht einfach so ändern.

PSS: Brauchst du jetzt unbedingt noch UTF8Strings in deinem neuen Delphi?
Ich denk mal, für de weitere Verarbeitung im Programm kann es einfacher/optimaler sein, wenn du da String/UnicodeString nutzt.

[hansklok]

@Wicht: Das ist komisch, weil ich das genauso übernommen habe, wie es Embacadero auf den Hilfeseiten vorschlägt, komisch.
@ak-ac: Wie meinst du das? Naja, wenn ich will, kann ich die Datei schon mit einem Texteditor öffnen, nur sollte ich nichts daran ändern, weil die Datei sofort unlesbar wird. Außerdem können ja in einem FileStream auch noch andere Werte gespeichert werden (Boolean, Integer etc.) und das funktioniert wunderbar. Gib mal bitte ein beispiel, damit ich weiß, was du meinst.

@himitsu: Du hast recht, da habe ich mich falsch ausgedrückt, natürlich möchte ich UnicodeStrings speichern, sonst würde ja die ganze Umstellung gar keinen Sinn machen. Wie müsste es da aussehen, wie gesagt, ich habe den Source komplett von Embacadero übernommen.

Danke

[Bernhard Geyer]

Zitat:

Zitat von hansklok (Beitrag 1081243)

@Wicht: Das ist komisch, weil ich das genauso übernommen habe, wie es Embacadero auf den Hilfeseiten vorschlägt, komisch.

Hast du einen Link darauf? Dann sollte man das melden das hier ein Fehler vorliegt.

[hansklok]

@Bernhard Geyer: Anwendungen für Unicode anpassen unter Aufrufe von Read/ReadBuffer-Methoden von TStream und Aufrufe von Write/WriteBuffer-Methoden von TStream.

[himitsu]

Zitat:

Zitat von hansklok (Beitrag 1081243)

natürlich möchte ich UnicodeStrings speichern, sonst würde ja die ganze Umstellung gar keinen Sinn machen.

Nee, ich meinte nur den Zusammenhang zwischen deinen UTF8Strings und der zugehörigen Speicherung als UnicodeString.

Natürlich kann man auch Unter Unicode als UTF8 speichern, was garnicht so abwägig ist.
- UTF8 benötigt werniger Speicher (bei der deutschen Sprache sind das bis zu 50% ersparnis)

UTF-8 = 8 Bit Unicode Transformation Format / UCS Transformation Format (Universal Character Set)


Wenn du im alten Projekt auch schon UTF-8 gespeichert hast, dann kann man das locker so belassen, da es dann kompatibel bleibt.

[hansklok]

@himitsu: Sorry ich bin grade durcheinander, also du empfiehlst mir zum Speichern und Laden den Source, den du oben gepostet hast, oder doch einen anderen?

[Bernhard Geyer]

Zitat:

Zitat von hansklok (Beitrag 1081247)

@Bernhard Geyer: Anwendungen für Unicode anpassen unter Aufrufe von Read/ReadBuffer-Methoden von TStream und Aufrufe von Write/WriteBuffer-Methoden von TStream.

Richtig falsch ist es ja nicht da primär nur die zu ändernde Codefragmente verglichen werden.

Aus

Delphi-Quellcode:

  Stream.Write(Pointer(S)^, Length(S));

Muss

Delphi-Quellcode:

  Stream.Write(Pointer(S)^, Length(S) * SizeOf(Char)); // Geben Sie die Puffergröße in Byte an

Wenn im Ursprungscode vorgesehen ist die Längenangabe vor dem String zu speichern so braucht die in der Unicodeversion nicht geändert zu werden. Sinnvoll ist es aber wie auch bei der Read-Methode anzugeben.

[himitsu]

Das kommt auf dich an.

Wie gesagt, es hat beides seine Vorteile und Nachteile und du kannst mit Beindem dein Unicode speichern.

Ob nun als UTF8 oder Unicode gepseichert ist also dir überlassen.
> UTF8String oder UnicodeString (notfalls WideString)

Wovon ich aber abrate, ist das Speichern von diesem dynamischem String.
Für eine kurzlebige Cache ist es voll OK und vermutlich Idealer, aber für langlebigere Daten vollkommen ungeeignet, da sich der String schnell mal ändern kann, wie man an der Ansi/Unicode-Umstellung gesehn hat. Und dann sind die Speicher-/Auslesefunktionen nicht mehr kompatibel zum gewählten Dateiformat.

Ja, auf UCS4 können wir, so wie ich BorCodaero kenne, noch shr viele Jahrzehnte warten können (OK, auch das OS wird es so schnell noch nicht standardmäßig anbieten), aber es könnte irgendwann mal kommen ... existieren tut es ja schon. :stupid:
Und das Integerdebakel, noch aus der 16/32-Bit-Umstellung bekannt, kommt ja auch demnächst auch nochmal, mit den 64 Bit ... also niemals dynamische Typen in externen Definitionen verwenden.

Dann kommt es noch darauf an, was du mit deiner Datenklasse machst ... wie gesagt, wenn du das UTF8 dort nicht zwingenst benötigst, dann würde ich String/UnicodeString empfehlen.

z.B.

Delphi-Quellcode:

Edit1.Text := Address.EMAIL;

wird bei einem UTF8String als Feld/Propery intern implizit von Delphi als

Delphi-Quellcode:

Edit1.Text := UTF8Encode(Address.EMAIL);

dargestellt.

[Bernhard Geyer]

Zitat:

Zitat von hansklok (Beitrag 1081247)

@Bernhard Geyer: Anwendungen für Unicode anpassen

Habs jetzt mal an [e-mail] gemeldet.

[hansklok]

@himitsu: 1000 dank mit dem UTF8String und deiner Speicher- & Ladeprocedure funktioniert alles wunderbar, nur sobald ich die Strings als UnicodeString deklariere crasht es natürlich. Wie müsste ich da vorgehen?

@Bernhard Geyer: ..da wird sich Embacadero aber freuen :-)

VG

[ak-ac]

Ich habe seinerzeit das umgestellt wie folgt:

Stream.Write(Pointer(Value)^, Length(Value) * SizeOf(Char)); // Value: UnicodeString
Stream.Write(Pointer(Value)^, Length(Value) * SizeOf(AnsiChar)); // Value: AnsiString


(stand im der Delphi-Doku bzgl. Umstieg drin. Dabei ist

[Sir Rufo]

Ich würde zum Schreiben und Lesen einer Klasse in einen Stream immer TWriter und TReader nehmen. Das funktioniert eigentlich stressfrei.

Denn Delphi benutzt genau diese um Komponenten in einen Stream zu speichern. Somit würde diese Klasse auch bei neueren Versionen entsprechend angepasst und man ist raus aus der Nummer :stupid:

Das wäre dann nicht DRY sondern DRW (Don't Reinvent Wheel)

[hansklok]

So, ich habe die Speicher- & Lade-Prozedur von himitsu etwas abgeändert, damit ich, wenn ich das Projekt für Mac portiere nicht komplett umschreiben muss, was Variablen und Typenzuweisungen betrifft.

So sieht es aus:

Delphi-Quellcode:

StrToStream(AString: String; AStream: TStream);
var
  Size: LongInt;
  Text: UTF8String;
begin
  Text:= UTF8Encode(AString);
  { Richtig für Unicode-String-Daten }
  Size := Length(Text);
  AStream.Write(Size, SizeOf(Size));
  AStream.Write(PAnsiChar(Text)^, Size);
end;

procedure StrFromStream(var AString: String; AStream: TStream);
var
  Size: LongInt;
  Text: UTF8String;
begin
  { Richtig für Unicode-String-Daten }
  AStream.Read(Size, SizeOf(Size));
  SetLength(Text, Size);
  AStream.Read(PAnsiChar(Text)^, Size);
  AString:= UTF8ToString(Text);
end;

Allerdings sieht die Datei nachher anders aus, als wenn ich die Routinen von himitsu verwende. Die Sonderzeichen ä, ö, ü, ß etc. werden ganz normal angezeigt. Vorher, als ich alle String-Varuiablen als UTF8String definiert hatte, waren sie unleserlich in die Datei geschrieben, aber ordentlich ins Programm geladen worden.

Frage: Handelt es sich dennoch um eine Unicode-Datei, oder nicht mehr?

himitsus Quellcode sah so aus:

Delphi-Quellcode:

StrToStream(AString: UTF8String; AStream: TStream);
var
  Size: LongInt;
begin;
  { Richtig für Unicode-String-Daten }
  Size := Length(AString);
  AStream.Write(Size, SizeOf(Size));
  AStream.Write(PAnsiChar(AString)^, Size);
end;

procedure StrFromStream(var AString: UTF8String; AStream: TStream);
var
  Size: LongInt;
begin
  { Richtig für Unicode-String-Daten }
  AStream.Read(Size, SizeOf(Size));
  SetLength(AString, Size);
  AStream.Read(PAnsiChar(AString)^, Size);
end;

HG hansklok

[busybyte]

@hansklok

Danke!
Endlich kann ich wieder meine alten-d2006 dateien laden und kompatibel speichern.
UTF8-Umwandlung ist die Lösung.

OT:die Startseite im Projekt zu entfernen brachte auch die "keine Rückmeldung"-Lösung.
thx himitsu

You both made my day!