Problem bei Speichen von Filestream

[Klausi1305]

Hallo,

Ich fingere zur Zeit an einem Simulator für die Berrechnung von Gefechten rum. Ich erstelle zu erst ein Objekt Einheit und will es später weiterverwenden.
Ich wollte bis jetzt die Sache in einem TFilestream verwenden. jedoch scheint es Probleme beim Speichern des Streams zu geben.
Ich lese von Comboboxen den gewählten Itemindex aus und wandle diese in einen String um und übergebe diese Variable an mein Objekt...(Ich weiss nicht wie ich direkt Integerwerte in einen Streaj speicher). Dies läuft auch einwandfrei..Trotz zig maliger Beobachtung der Speicherung im Debugger,welches auch scheinbar das macht, was es soll, werden irgendwie auf mir unersichtliche Weise die Werte "um eine Position" verschoben. Bsp aus Combobox6 wird der Index 4 in der Variable eigentlich gespeichert, jedoch beim laden hat Combobox6 den Wert 0 dafür aber Combobox7 den Wert....

Ich bin am verzweifeln...
Ich verwende Turbo Delphi 2006 und Vista

alle Variablen sind vom Typ AnsiString....

Hier die Procedure zum Speichern der Werte ins Object und dessen Speicherung in einen TFilestream:

Delphi-Quellcode:

//Einstellungen speichern
procedure TForm2.Button1Click(Sender: TObject);

var Einheit : TEinheitTyp;
    Stream  : TFilestream;
    i : Integer;
    S : String;

begin

   Einheit:= TEinheittyp.Create;  // neues Exemplar muss in die Liste
   Einheit.Init;
   //NeuerEinheitTyp.SetzeName(Edit1.Text);
   Einheit.SetzeName(Form2.Edit1.Text);
   Einheit.SetzeGrundTyp(IntToStr(ComboBox1.ItemIndex));
   Einheit.SetzeGeschwindigkeit(IntToStr(ComboBox2.ItemIndex));
   Einheit.SetzeBenzinGef(IntToStr(ComboBox3.ItemIndex));
   Einheit.SetzeBenzinBew(IntToStr(ComboBox4.ItemIndex));
   Einheit.SetzeMunGef(IntToStr(ComboBox5.ItemIndex));
   Einheit.SetzeGrösse(IntToStr(ComboBox13.ItemIndex));
   //Schreiben Landeinheit Werte
   Einheit.SetzePanzerAn(IntToStr(ComboBox6.ItemIndex));
   Einheit.SetzePanzerVer(IntToStr(ComboBox7.ItemIndex));
   Einheit.SetzeInfAn(IntToStr(ComboBox8.ItemIndex));
   Einheit.SetzeInfVer(IntToStr(ComboBox9.ItemIndex));
   Einheit.SetzeBoLuAn(IntToStr(ComboBox10.ItemIndex));
   Einheit.SetzeBoLuVer(IntToStr(ComboBox11.ItemIndex));
   Einheit.SetzeLandSpez(IntToStr(ComboBox12.ItemIndex));
   //Schreiben Lufteinheiten Werte;
   Einheit.SetzeLuLuAn(IntToStr(ComboBox14.ItemIndex));
   Einheit.SetzeLuLuVer(IntToStr(ComboBox15.ItemIndex));
   Einheit.SetzeLuBoAn(IntToStr(ComboBox16.ItemIndex));
   Einheit.SetzeLuBoVer(IntToStr(ComboBox17.ItemIndex));
   //Schreiben Marineeinheiten Werte;
   Einheit.SetzeSeeSeeAn(IntToStr(ComboBox18.ItemIndex));
   Einheit.SetzeSeeSeeVer(IntToStr(ComboBox19.ItemIndex));
   Einheit.SetzeSeeLuftAn(IntToStr(ComboBox20.ItemIndex));
   Einheit.SetzeSeeLuftVer(IntToStr(ComboBox21.ItemIndex));
   Einheit.SetzeSeeSpez(IntToStr(ComboBox22.ItemIndex));

   //Schreiben in Datei mit Filestream
   Stream := TFileStream.Create(Form1.programmpfad+'\Einheittyp\'+Einheit.GibName, fmCreate);
   Einheit.InDateiSchreiben(Stream,Form1.programmpfad+'\Einheittyp\'+Einheit.GibName);
   Stream.Free;
   Einheit.Free;

Hier die Procedure aus der Klasse Einheittyp zum speichern

Delphi-Quellcode:

procedure TEinheitTyp.InDateiSchreiben (var Fs : TFilestream; Filename : String);
(* -------------------------------------------------------------------- *)
var
   len : integer;

begin
  DeleteFile(Filename);
  //Allgemeine Werte
  FS.Position:=0;
   Len:=0;
  Len := Length(Name);
  FS.WriteBuffer(Len, SizeOf(Len));
  FS.WriteBuffer(PAnsiChar(Name)^, Len);
    Len:=0;
  Len := Length(GrundTyp);
  FS.WriteBuffer(Len, SizeOf(Len));
  FS.WriteBuffer(PAnsiChar(GrundTyp)^, Len);
    Len:=0;
  Len := Length(Geschwindigkeit);
  FS.WriteBuffer(Len, SizeOf(Len));
  FS.WriteBuffer(PAnsiChar(Geschwindigkeit)^, Len);
    Len:=0;
  Len := Length(BenzinGef);
  FS.WriteBuffer(Len, SizeOf(Len));
  FS.WriteBuffer(PAnsiChar(BenzinGef)^, Len);
     Len:=0;
   Len := Length(BenzinBew);
  FS.WriteBuffer(Len, SizeOf(Len));
  FS.WriteBuffer(PAnsiChar(BenzinBew)^, Len);
     Len:=0;
  Len := Length(MunGef);
  FS.WriteBuffer(Len, SizeOf(Len));
  FS.WriteBuffer(PAnsiChar(MunGef)^, Len);
     Len:=0;
  Len := Length(Grösse);
  FS.WriteBuffer(Len, SizeOf(Len));
  FS.WriteBuffer(PAnsiChar(Grösse)^, Len);
    Len:=0;
  Len := Length(BenzinGef);
  FS.WriteBuffer(Len, SizeOf(Len));
  FS.WriteBuffer(PAnsiChar(BenzinGef)^, Len);
     Len:=0;
  //Landeinheitwerte
  Len := Length(PanzerAn);
  FS.WriteBuffer(Len, SizeOf(Len));
  FS.WriteBuffer(PAnsiChar(PanzerAn)^, Len);
     Len:=0;
  Len := Length(PanzerVer);
  FS.WriteBuffer(Len, SizeOf(Len));
  FS.WriteBuffer(PAnsiChar(PanzerVer)^, Len);
         Len:=0;
  Len := Length(InfAn);
  FS.WriteBuffer(Len, SizeOf(Len));
  FS.WriteBuffer(PAnsiChar(InfAn)^, Len);
       Len:=0;
   Len := Length(InfVer);
  FS.WriteBuffer(Len, SizeOf(Len));
  FS.WriteBuffer(PAnsiChar(InfVer)^, Len);
     Len:=0;
  Len := Length(BoLuAn);
  FS.WriteBuffer(Len, SizeOf(Len));
  FS.WriteBuffer(PAnsiChar(BoLuAn)^, Len);
   Len:=0;
  Len := Length(BoLuVer);
  FS.WriteBuffer(Len, SizeOf(Len));
  FS.WriteBuffer(PAnsiChar(BoLuVer)^, Len);
    Len:=0;
  Len := Length(LandSpez);
  FS.WriteBuffer(Len, SizeOf(Len));
  FS.WriteBuffer(PAnsiChar(LandSpez)^, Len);
    Len:=0;
  //Lufteinheitwerte
  Len := Length(LuLuAn);
  FS.WriteBuffer(Len, SizeOf(Len));
  FS.WriteBuffer(PAnsiChar(LuLuAn)^, Len);
    Len:=0;
  Len := Length(LuLuVer);
  FS.WriteBuffer(Len, SizeOf(Len));
  FS.WriteBuffer(PAnsiChar(LuLuVer)^, Len);
    Len:=0;
  Len := Length(LuBoAn);
  FS.WriteBuffer(Len, SizeOf(Len));
  FS.WriteBuffer(PAnsiChar(LuBoAn)^, Len);
    Len:=0;
   Len := Length(LuBoVer);
  FS.WriteBuffer(Len, SizeOf(Len));
  FS.WriteBuffer(PAnsiChar(LuBoVer)^, Len);
    Len:=0;
  //Marineeinheitwerte
  Len := Length(SeeSeeAn);
  FS.WriteBuffer(Len, SizeOf(Len));
  FS.WriteBuffer(PAnsiChar(SeeSeeAn)^, Len);
     Len:=0;
  Len := Length(SeeSeeVer);
  FS.WriteBuffer(Len, SizeOf(Len));
  FS.WriteBuffer(PAnsiChar(SeeSeeVer)^, Len);
     Len:=0;
  Len := Length(SeeLuftAn);
  FS.WriteBuffer(Len, SizeOf(Len));
  FS.WriteBuffer(PAnsiChar(SeeLuftAn)^, Len);
     Len:=0;
   Len := Length(SeeLuftVer);
  FS.WriteBuffer(Len, SizeOf(Len));
  FS.WriteBuffer(PAnsiChar(SeeLuftVer)^, Len);
     Len:=0;
  Len := Length(SeeSpez);
  FS.WriteBuffer(Len, SizeOf(Len));
  FS.WriteBuffer(PAnsiChar(SeeSpez)^, Len);

end;

und hier die zum lesen aus der Klasse Einheittyp

Delphi-Quellcode:

procedure TEinheitTyp.AusDateiLesen (var Fs : TFilestream) ;
(* -------------------------------------------------------------------- *)
var
   len : integer;
begin
  Len:=0;
  //Allgemeine Werte
  FS.read(Len, SizeOf(Len));
  SetLength(Name, Len);
  FS.read(PChar(Name)^, Len);
  Len:=0;
  FS.read(Len, SizeOf(Len));
  SetLength(GrundTyp, Len);
  FS.read(PChar(GrundTyp)^, Len);
   Len:=0;
   FS.read(Len, SizeOf(Len));
  SetLength(Geschwindigkeit, Len);
  FS.read(PChar(Geschwindigkeit)^, Len);
  Len:=0;
  FS.read(Len, SizeOf(Len));
  SetLength(BenzinGef, Len);
  FS.read(PChar(BenzinGef)^, Len);
  Len:=0;
   FS.read(Len, SizeOf(Len));
  SetLength(BenzinBew, Len);
  FS.read(PChar(BenzinBew)^, Len);
  Len:=0;
  FS.read(Len, SizeOf(Len));
  SetLength(MunGef, Len);
  FS.read(PChar(MunGef)^, Len);
  Len:=0;
  FS.read(Len, SizeOf(Len));
  SetLength(Grösse, Len);
  FS.read(PChar(Grösse)^, Len);
  Len:=0;
  //Landeinheitwerte
  FS.read(Len, SizeOf(Len));
  SetLength(PanzerAn, Len);
  FS.read(PChar(PanzerAn)^, Len);
  Len:=0;
  FS.read(Len, SizeOf(Len));
  SetLength(PanzerVer, Len);
  FS.read(PChar(PanzerVer)^, Len);
  Len:=0;
  FS.read(Len, SizeOf(Len));
  SetLength(InfAn, Len);
  FS.read(PChar(InfAn)^, Len);
  Len:=0;
  FS.read(Len, SizeOf(Len));
  SetLength(InfVer, Len);
  FS.read(PChar(InfVer)^, Len);
   Len:=0;
  FS.read(Len, SizeOf(Len));
  SetLength(BoLuAn, Len);
  FS.read(PChar(BoLuAn)^, Len);
   Len:=0;
  FS.read(Len, SizeOf(Len));
  SetLength(BoLuVer, Len);
  FS.read(PChar(BoLuVer)^, Len);
  Len:=0;
  FS.read(Len, SizeOf(Len));
  SetLength(LandSpez, Len);
  FS.read(PChar(LandSpez)^, Len);
  Len:=0;
  //Lufteinheitwerte
  FS.read(Len, SizeOf(Len));
  SetLength(LuLuAn, Len);
  FS.read(PChar(LuLuAn)^, Len);
  Len:=0;
  FS.read(Len, SizeOf(Len));
  SetLength(LuLuVer, Len);
  FS.read(PChar(LuLuVer)^, Len);
   Len:=0;
  FS.read(Len, SizeOf(Len));
  SetLength(LuBoAn, Len);
  FS.read(PChar(LuBoAn)^, Len);
   Len:=0;
  FS.read(Len, SizeOf(Len));
  SetLength(LuBoVer, Len);
  FS.read(PChar(LuBoVer)^, Len);
   Len:=0;
  //Marineeinheitenwerte
  FS.read(Len, SizeOf(Len));
  SetLength(SeeSeeAn, Len);
  FS.read(PChar(SeeSeeAn)^, Len);
   Len:=0;
  FS.read(Len, SizeOf(Len));
  SetLength(SeeSeeVer, Len);
  FS.read(PChar(SeeSeeVer)^, Len);
   Len:=0;
  FS.read(Len, SizeOf(Len));
  SetLength(SeeLuftAn, Len);
  FS.read(PChar(SeeLuftAn)^, Len);
   Len:=0;
  FS.read(Len, SizeOf(Len));
  SetLength(SeeLuftVer, Len);
  FS.read(PChar(SeeLuftVer)^, Len);
   Len:=0;
  FS.read(Len, SizeOf(Len));
  SetLength(SeeSpez, Len);
  FS.read(PChar(SeeSpez)^, Len);
end;

[sx2008]

Zwei Anmerkungen von mir:

Delphi-Quellcode:

procedure TEinheitTyp.InDateiSchreiben (var Fs : TFilestream; Filename : String);
(* -------------------------------------------------------------------- *)
var
   len : integer;

begin
  DeleteFile(Filename);
  //Allgemeine Werte
  FS.Position:=0;
  ...

Denk mal drüber nach, was du hier genau tust.
Du hast einen geöffneten FileStream und versuchst genau diese Datei zu löschen.
= Ast absägen auf dem man sitzt

Schau dir mal diesen Code an:

Delphi-Quellcode:

Len := Length(PanzerVer {*});
FS.WriteBuffer(Len, SizeOf(Len));
FS.WriteBuffer(PAnsiChar(PanzerVer {*})^, Len);

Dieser Code wiederholt sich unzählige Male nur mit dem Unterschied, dass die
mit {*} markierte Variable jedesmal anderst ist.
Könnte man daraus nicht eine Unterfunktion machen und so jede Menge Codezeilen sparen?
Ja man kann und man sollte es auch unbedingt tun!!!

Delphi-Quellcode:

class procedure TEinheitTyp.WriteStringToStream(stream:TStream; const data:string);
var
  len : integer;
begin
  len := Length(data);
  stream.WriteBuffer(Len, SizeOf(Len));
  stream.WriteBuffer(PAnsiChar(data)^, Len);
end;

Und wenn du dir die Umkehrfunktion zum Lesen schreibst, dann brauchst du pro
Eigenschaft nur eine Zeile zum lesen.

Letztendlich wird der Sourcecode dann so klar lesbar, dass du sofort siehst,
an welcher Stelle du eine Eigenschaft beim Lesen oder Schreiben vergessen hast.

[DeddyH]

Zitat:

len := Length(data);

Das würde ich ändern:
len := Length(data) * SizeOf(Char); Stichwort Unicode

[edit] Und dann natürlich aus PAnsiChar PChar machen [/edit]

[Deep-Sea]

Wenn du sowieso alles als String hast (sind es nicht eigentlich alles Zahlen? ), wäre dann ein Textformat wie XML oder JSON zum speichern nicht besser geeignet?!

PS: Die Funktion procedure TEinheitTyp.InDateiSchreiben (var Fs : TFilestream; Filename : String); ist auch merkwürdig: Entweder man nennt es "InDateiSchreiben" und übergibt nur einen Dateinamen, weil die Funktion den FileStream selbst erzeugt und freigibt oder man nennt es "InStreamSchreiben" und übergibt eine Instanz, die von TStream abstammt ...

[DeddyH]

Zitat von Deep-Sea:

... oder man nennt es "InStreamSchreiben" und übergibt eine Instanz, die von TStream abstammt ...

Aber nicht als Var-Parameter

[Deep-Sea]

Zitat von DeddyH:

Aber nicht als Var-Parameter

Richtig

Fraglich ist auch, ob man das lesen und schreiben nicht sogar in eine Schleife packen könnte.
Fragen über Fragen

[ele]

Und wenn man allen benutzten Variablen, Labels und Komponenten einen aussagekräftigen Namen gibt, hilft das ungemein bei der Fehlersuche...

Z.B. ComboBox11? Du weisst ernsthaft was da drin ist, ohne jedesmal nachschauen zu müssen?

[p80286]

Zitat von Deep-Sea:

Wenn du sowieso alles als String hast (sind es nicht eigentlich alles Zahlen? ), wäre dann ein Textformat wie XML oder JSON zum speichern nicht besser geeignet?!

Dem kann ich nur zustimmen. Und wenn man sich nicht darin einarbeiten will, dann sollte man die Daten wenigstens ein wenig strukturieren. Z.B ein CRLF als Trenner zwischen den verschiedenen "Einheiten". Oder Einheit1,Wert1=xxxx,Wert2=yyyy.....
So wie es jetzt ist, ist das Chaos und der Ärger vorprogrammiert.

Gruß
K-H

[Klausi1305]

Danke erstmal für vielen Antworten...

Unterfunktion also noch einbauen, und die bemängelten Sachen ausmerzen, und den Code aufräumen....
Na dann werd ich mich mal an die Arbeit machen

[Jumpy]

Mal 'ne Frage von der Seite:

Ich benutze immer die TStringList um z.B. ellenlange SQL-Statements zu laden. Die kommt ja mit so einer Save- bzw. LoadFromFile-Methode. Ist das nicht hier auch möglich den Inhalt der Edit-Felder in so eine Liste zu packen und diese zu speichern bzw. zu laden? Man müsste dann nur wieder gucken, dass man in der selben Reihenfolge ein und auspackt.

Wenn man nun sinnige Namen für die Edit-Felder vergibt, wie kann man dann über diese Felder iterieren? Das müsste ja immer in der selben Reihenfolge passieren, damit schreiben und lesen zueinander passt.
Könnte man die Tags benutzen, um die Felder zu nummerrieren und dann über alle Komponenten iterieren und nach dem Edit mit dem i-ten Tag suchen? Oder ist das zu kompliziert gedacht?