Delphi-PRAXiS - Problem bei Speichen von Filestream

Delphi-PRAXiS (https://www.delphipraxis.net/forum.php)

- Algorithmen, Datenstrukturen und Klassendesign (https://www.delphipraxis.net/78-algorithmen-datenstrukturen-und-klassendesign/)

- - Problem bei Speichen von Filestream (https://www.delphipraxis.net/157682-problem-bei-speichen-von-filestream.html)

Problem bei Speichen von Filestream

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;

AW: Problem bei Speichen von Filestream

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.

AW: Problem bei Speichen von Filestream

Zitat:

Delphi-Quellcode:

len := Length(data);

Das würde ich ändern:

Delphi-Quellcode:

len := Length(data) * SizeOf(Char);

Stichwort Unicode

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

AW: Problem bei Speichen von Filestream

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

PS: Die Funktion

Delphi-Quellcode:

			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 ...

AW: Problem bei Speichen von Filestream

Zitat:

Zitat von Deep-Sea (Beitrag 1076286)

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

Aber nicht als Var-Parameter ;)

AW: Problem bei Speichen von Filestream

Zitat:

Zitat von DeddyH (Beitrag 1076287)

Aber nicht als Var-Parameter ;)

Richtig :thumb:

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

AW: Problem bei Speichen von Filestream

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?

AW: Problem bei Speichen von Filestream

Zitat:

Zitat von Deep-Sea (Beitrag 1076286)

Wenn du sowieso alles als String hast (sind es nicht eigentlich alles Zahlen? :gruebel:), 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

AW: Problem bei Speichen von Filestream

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

AW: Problem bei Speichen von Filestream

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?

AW: Problem bei Speichen von Filestream

@Jumpy:
Sie dir mal die Eigenschaften Names und Values von TStrings an :wink:
Aber allgemein habe ich ja bereits erwähnt, dass man die Daten in einem Textformat speichern könnte ...

AW: Problem bei Speichen von Filestream

sag doch gleich INI-Datei

Gruß
K-H

AW: Problem bei Speichen von Filestream

Zitat:

Zitat von p80286 (Beitrag 1076373)

sag doch gleich INI-Datei

Wer wo was?
Eine Stringliste mit Namen-Werte-Paaren ist noch keine Ini-Datei, da es keine Sections unterstützt.
Und ich habe ja XML und JSON vorgeschlagen. Ini-Dateien nutze ich persönlich überhaupt nicht mehr, da ich keinen Sinn darin sehen mich selbst auf zwei Hierarchie-Ebenen zu beschränken ...

AW: Problem bei Speichen von Filestream

Ich wollte ja eigentlich nur mal was anderes probieren, nämlich mal eine eigene Klasse erstellen, und Stream ausprobieren...Bis vor zwei Wochen kannte ich nur das klassische Pascalsystem mit Assignfile, Read etc....

XML, INI...hört sich toll an. Aber ich sollte wohl erstmal die eine Baustelle fertig machen..Ausserdem habe ich von XML und INI mal gar keinen Schimmer

AW: Problem bei Speichen von Filestream

Zitat:

Zitat von Deep-Sea (Beitrag 1076370)

@Jumpy:
Sie dir mal die Eigenschaften Names und Values von TStrings an :wink:
...

Danke, echt wieder was gelernt. Es ist nämlich oft so:

Man hat ein Problem. Sucht welche Komponente kann das lösen. Dann benutzt man die. Das die Komponente eigentlich noch mehr kann, was man bestimmt auch mal irgendwann brauchen würde, geht dann unter.

Kommt nun ein anderes Problem, das diese Komponente auch lösen kann, guckt man sich die aber gar nicht mehr an, denn man "weiß" ja das die für was anderes ist.

Fazit, man sollte sich öfter mal mehr Zeit nehmen, sich die Komponenten/Klassen genauer anzuschauen. Aber da sitzt einem dann der Chefe im Nacken, bei dem es schnell schnell gehen muss. Das das gründliche Arbeiten und Lernen nachhaltiger ist und bewirkt, dass ich beim nächsten mal schneller eine Lösung habe zählt da nicht.

Wie ihr am klagenden Tonfall erkennt brauch ich Feierabend und Wochenende...

AW: Problem bei Speichen von Filestream

Zitat:

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

Ich habe dazu nochmal ne Frage, Was spricht dagegen, wenn man eine vorhandene Datei löscht, sie neu erzeugt und die geänderten Werte reinschreibt, oder muss das Deletefile viel eher kommen?? Ich speichere ja nur immer einen Block an Informationen in der Datei und nicht zehen Objekte hintereinander

AW: Problem bei Speichen von Filestream

Wenn Du die Datei löschen willst, musst Du dies tun, bevor der FileStream auf sie zugreift, d.h. bevor dieser erzeugt wird.

AW: Problem bei Speichen von Filestream

So liebe Mitleser und Wissende...

Als erstes habe ich eure Ratschläge berücksichtigt um die "InFileStreamladen" Prozedure innerhalb der Klasse bereinigt.
1. Es ergibt sich für mich jedoch nicht, was der Unterschied ist, wenn man in der Klasse 39 mal fast das selbe schreibt

Delphi-Quellcode:

			procedure TEinheitTyp.WriteStringToStream(stream:TFilestream; const data:string);

var

len : integer;

begin

len := Length(data) * SizeOf(Char);

stream.WriteBuffer(Len, SizeOf(Len));

stream.WriteBuffer(PChar(data)^, Len);

end;

oder ob ich dann in meinem Formular 39 mal steht

Delphi-Quellcode:

Einheit.WriteStringToStream(Stream,Hierkommtsrein);

schreibe, wenn ich das oben geschriebene als Prozedur schreibe
Weil Ich konnte es ja bisher auch über breakpoints innerhalb der Klasse überprüfen ob was schief lief....Demzufolge spar ich mir "fast" keinen Code..Ja ich bin Anfänger

2. Die ominöse Umkehrfunktion zum Lesen des Streams in der Klasse TEinheitTyp sieht bisher wie folgt aus:

Delphi-Quellcode:

			Procedure TEinheittyp.ReadStringFromStream(stream : TFilestream; Const data:String);

var

len : integer;

begin

stream.ReadBuffer(Len, SizeOf(Len));

Setlength(Data,Len);

stream.ReadBuffer(PChar(data)^, Len);

end;

1. Es kommt der Fehler "Konstantenobjekt kann nicht als Var-Parameter übergegeben werden (E2197) Dies ist eine reservierte Fehlermeldung."---Toll, danke liebe Hilfe
2. Ich will doch nur sowas verwirklichen

Delphi-Quellcode:

Form2.Edit1.Text :=Typ.readstringfromStream(SStream,Typ.GibName);

3. Was bewirke ich mit dem Const?...Ich habe sowas vorher noch nie Übergeben...Wo ist diese Konstante definiert?

AW: Problem bei Speichen von Filestream

Zitat:

Zitat von Klausi1305 (Beitrag 1076763)

Es ergibt sich für mich jedoch nicht, was der Unterschied ist, wenn man in der Klasse 39 mal fast das selbe schreibt...
oder ob ich dann in meinem Formular 39 mal steht...

Na, das ist ein Riesenunterschied.
Du bist ein Mensch und kein Computer, richtig?
Menschen haben nun mal eine begrenzte Wahrnehmungkapazität und können nicht unbegrenzt Texte optisch aufnehmen.
Daher tun sie sich viel einfacher, wenn sie eine einfache Liste lesen, als wenn sie sich durch einen Haufen visuellem Störfeuer kämpfen müssen.
Dem Computer ist es pupsegal wie verkorkst der Sourcecode ist.
Für Menschen zählt aber Klarheit und Einfachheit.

AW: Problem bei Speichen von Filestream

Zitat:

Zitat von Klausi1305 (Beitrag 1076763)

Es ergibt sich für mich jedoch nicht, was der Unterschied ist, wenn man in der Klasse 39 mal fast das selbe schreibt [...] oder ob ich dann in meinem Formular 39 mal steht [...]

Siehe sx2008's Post
Willst du die Schreib- bzw. Lesefunktion ändern, z.B. weil du einen Fehler entdeckt hast oder weil du noch andere Informationen speichern willst oder weil du ein anderes Format nutzen willst ... so musst du es nur ein einziges mal an einer Stelle ändern und nicht 39 mal :wink:

Zitat:

Zitat von Klausi1305 (Beitrag 1076763)

Ich will doch nur sowas verwirklichen

Delphi-Quellcode:

Form2.Edit1.Text :=Typ.readstringfromStream(SStream,Typ.GibName);

Dann musst du keine procedure nutzen, sondern eine function:

Delphi-Quellcode:

			function TEinheittyp.ReadStringFromStream(stream : TFilestream): String;

var

  len: integer;

begin

  stream.ReadBuffer(Len, SizeOf(Len));

  Setlength(Result, Len); // Die interne Variable Result ist der Schlüssel: Sie enthält den Rückgabewert ...

  stream.ReadBuffer(PChar(Result)^, Len);

end;

Was du allerdings mit dem "Typ.GibName" machen willst, weiß ich jetzt nicht ...

Const bewirkt eben genau das: Der Parameter wird zu einer Konstanten und kann somit nicht geändert werden. Darum auch der Fehler, weil du versuchst, Daten darin einzulesen. Wenn du es auf die Weise machen möchtest, müsstest du var oder out nutzen.