Textdatei in Liste laden

[Schnittcher]

Hallo,

ich speicher meine Liste so:

Delphi-Quellcode:

procedure TForm1.cmdListSpeichernClick(Sender: TObject);
var
  i: integer;
  pAuto: IAuto;
  myfile: TextFile;
  temp, temp2, temp3: string;
begin
  try
    if AutoList = nil then
      raise
        EBerechnung.Create('Wenn es keine Liste gibt, kann man sie auch nicht speichern.');
    if SaveDialog1.Execute then
      AssignFile(myFile, SaveDialog1.FileName);
    Rewrite(myFile);
    for i := 0 to AutoList.Count - 1 do
    begin
      pAuto := AutoList.Items[i];
      temp := pAuto.ErgebnisName;
      temp2 := FloatToStr(pAuto.ErgebnisKW);
      temp3 := FloatToStr(pAuto.ErgebnisPS);
      WriteLn(myfile, 'Name:    ', temp, 'KW:    ', temp2, 'PS:    ',
        temp3);
    end;
    CloseFile(myFile);
  except
    on E: EBerechnung do
      MessageDlg(E.Message, mtInformation, [mbOK], -1);
  end;
end;

Wie kann ich diese Liste jetzt wieder laden?

Gruß,
Schnittcher

[Forlan]

Read etc...
Ansonsten könnte man auch direkt nach "Textdatei laden" googlen oder hier suchen.

MfG

[Schnittcher]

Hallo,

vielleicht hätte ich dabei schreiben sollen, dass ich das mit dem OpenDialog machen wollte.

Und das ist eine IInterfacedList.

Gruß,
Schnittcher

[DeddyH]

Da es sich ja eh um reine Textspeicherung handelt, könnte man auch eine TStringlist verwenden. Außerdem fällt mir auf, dass da wohl noch ein begin-end fehlt.

Zitat:

Delphi-Quellcode:

if SaveDialog1.Execute then
      AssignFile(myFile, SaveDialog1.FileName);
    Rewrite(myFile);

Wenn der Dialog abgebrochen wird, dürfte das Rewrite in die Hose gehen. Desweiteren würde ich einen try-finally-Block einsetzen, in dessen finally das CloseFile steht.

[himitsu]

Zitat:

Zitat von Schnittcher

vielleicht hätte ich dabei schreiben sollen, dass ich das mit dem OpenDialog machen wollte.

Und das ist eine IInterfacedList.

Das ist im Prinzip egal.

Du hast das Speichern schon und das Laden ist praktisch genau andersrum.

Rewrite > Reset
WriteLn > ReadLn
auch kann EoF helfen, wenn man die Anzahl der Einträge nicht gespeichert hat

dann den String vom ReadLn in seine Bestandteile zerlegen
eventuell noch das Objekt/Interfact in AutoList erzeugen
und dem Objekt/Interfact die Werte zuweisen

[Schnittcher]

Hallo,

kann mir denn einer sagen wie ich das mache, dass ich

Delphi-Quellcode:

WriteLn(myfile, 'Name:    ', temp, 'KW:    ', temp2, 'PS:    ',

'Name: '
'KW: '
'PS: '

teile und die werte davon in

pAuto.ErgebnisName
pAuto.ErgebnisKW
pAuto.ErgebnisPS

eintrage?

Gruß,
Schnittcher

[DeddyH]

Mit Pos() und Copy() könntest Du die Zeile wieder zerlegen. Allerdings wäre es IMHO einfacher, typisierte Dateien statt Textdateien zu verwenden, das spart die ganze Stringfrickelei samt Konvertierung.

[Schnittcher]

Hallo,

Zitat:

Zitat von DeddyH

Mit Pos() und Copy() könntest Du die Zeile wieder zerlegen. Allerdings wäre es IMHO einfacher, typisierte Dateien statt Textdateien zu verwenden, das spart die ganze Stringfrickelei samt Konvertierung.

könntest du mir das mal genauer erklären?

Gruß,
Schnittcher

[Klaus01]

Zitat:

Zitat von DeddyH

Mit Pos() und Copy() könntest Du die Zeile wieder zerlegen. Allerdings wäre es IMHO einfacher, typisierte Dateien statt Textdateien zu verwenden, das spart die ganze Stringfrickelei samt Konvertierung.

.. oder eine kleine Datenbank (SqLite o.ä) nehmen

Grüße
Klaus

[DeddyH]

@Klaus: Das Thema Datenbank hatte ich bewusst vermieden :zwinker:
@Schnittcher: Was genau soll ich Dir erklären?

[Schnittcher]

Hallo,

wenn du die Zeit dazu hast das hier:

Zitat:

Zitat von DeddyH

Allerdings wäre es IMHO einfacher, typisierte Dateien statt Textdateien zu verwenden, das spart die ganze Stringfrickelei samt Konvertierung.

Gruß,
Schnittcher

[Klaus01]

Delphi-Quellcode:

// einen Record (datensatz) Type angelegt
// ein Record ist eine Datenstruktur (ein Zusammenschluß von Daten)
type
  TFahrzeugdaten = packed record
    fahrzeugName : String[50];
    kw   : single;
    ps   : single;
  end;

Delphi-Quellcode:

procedure TForm1.cmdListSpeichernClick(Sender: TObject);
var
  i: integer;
  pAuto: IAuto;
  myfile: File of TFahrzeugdaten;  // ein Dateivariable deklariert 
  datenSatz : TFahrzeugdaten;      // eine Variable zur Aufnahme der Daten deklariert
 
begin
  try
    if AutoList = nil then
      raise
        EBerechnung.Create('Wenn es keine Liste gibt, kann man sie auch nicht speichern.');
    if SaveDialog1.Execute then
      AssignFile(myFile, SaveDialog1.FileName);
    Rewrite(myFile);
    for i := 0 to AutoList.Count - 1 do
    begin
      pAuto := AutoList.Items[i];
      // zuweisen der Daten
      datensatz.fahrzeugName := pAuto.ErgebnisName;
      datensatz.kw := pAuto.ErgebnisKW;
      datensatz.ps := pAuto.ErgebnisPS;
      // Daten in die Datei schreiben
      Write(myfile,datensatz);
    end;
    CloseFile(myFile);
  except
    on E: EBerechnung do
      MessageDlg(E.Message, mtInformation, [mbOK], -1);
  end;
end;

Für zum Speichern sollte es ungefähr wie oben beschrieben aussehen.

Grüße
Klaus

[Schnittcher]

Hallo,

erstmal danke für die Umstellung meines Codes.
Aber könntest du mir auch noch erklären was du da jetzt getan hast?

Wenn ich das richtig verstehe hast du alles in ein "Paket" gespeichert.
Dann kann ich das also auch so wieder ausgeben?

Gruß,
Schnittcher

[DeddyH]

Ich bin im Moment krank geschrieben, von daher hab ich jede Menge Zeit ;)
Also: wie der Name schon sagt, besteht eine typisierte Datei aus Datensätzen eines bestimmten Typs. Dieser ist im Normalfall als Record definiert. Beispiel:

Delphi-Quellcode:

type 
  TMyRec = record
    Name: shortstring; //NICHT string, da sonst nur der Zeiger gespeichert würde
    Nummer: integer;
    ZahlmitKomma: double;
  end;

...

var MyFile: file of TMyRec; //file of Datentyp --> typisierte Datei

Will man nun z.B. ein Array of TMyRec abspeichern, kann man das so machen (Fehlerbehandlung mal außen vor gelassen):

Delphi-Quellcode:

AssignFile(MyFile,Dateiname);
//Datei überschreiben
Rewrite(MyFile);
//Jeden einzelnen Datensatz in Datei schreiben
for i := Low(MyRecArray) to High(MyRecArray) do
  write(MyFile,MyRecArray[i]);
CloseFile(MyFile);

Andersherum (Einlesen):

Delphi-Quellcode:

AssignFile(MyFile,Dateiname);
Reset(MyFile);
//Anzahl der Datensätze ermitteln und Arraygröße entsprechend setzen
SetLength(MyRecArray, FileSize(MyFile));
i := 0;
while not EOF(MyFile) do
  begin
    //aktuellen Datensatz einlesen
    read(MyFile,MyRecArray[i]);
    //Array-Index erhöhen
    inc(i);
  end;
CloseFile(MyFile);

Das war jetzt alles aus dem Kopf getippt, muss daher nicht unbedingt so funktionieren, aber ich hoffe, Du hast das Prinzip verstanden. AFAIK gibt es dazu auch ein Tutorial hier in der DP, wo Du noch einmal genauer nachlesen kannst.

[Schnittcher]

Hallo,

danke für die Antwort.

Könntest du vll. mal kurz in den Chat kommen?

Gruß,
Schnittcher

[Klaus01]

Zitat:

Zitat von DeddyH

Ich bin im Moment krank geschrieben, von daher hab ich jede Menge Zeit ;)

Gute Besserung

Grüße
Klaus

[DeddyH]

Danke Dir.

[Schnittcher]

Hallo,

so von mir auch noch gute Besserung.

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  i: integer;
  aRec: TFahrzeugdaten;
  pAuto: IAuto;
begin
    if OpenDialog1.Execute then
    AssignFile(MyFile, OpenDialog1.FileName);
  Reset(MyFile);
//Anzahl der Datensätze ermitteln und Arraygröße entsprechend setzen
  i := 0;
  while not EOF(MyFile) do
  begin
    read(MyFile, aRec);
    pAuto := TBackupClassesFactory.Auto;
    pAuto.PS := aRec.ps;
    pAuto.KW := aRec.kw;
    pAuto.Name := aRec.fahrzeugName;
  end;

end;

Er schreibt beim öffnen nichts in meine Liste.

Gruß,
Schnittcher

[jfheins]

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject); 
var 
  i: integer; 
  aRec: TFahrzeugdaten; 
  pAuto: IAuto; 
begin 
    if OpenDialog1.Execute then 
        AssignFile(MyFile, OpenDialog1.FileName); // Diese Zeile Code nur Ausführen,
                                                  //wenn im Dialog "OK" geklickt wurde

// Folgendes immer ausführen
  Reset(MyFile); 
//Anzahl der Datensätze ermitteln und Arraygröße entsprechend setzen 
  i := 0; 
  while not EOF(MyFile) do 
  begin 
    read(MyFile, aRec); 
    pAuto := TBackupClassesFactory.Auto; 
    pAuto.PS := aRec.ps; 
    pAuto.KW := aRec.kw; 
    pAuto.Name := aRec.fahrzeugName; 
  end; 

end;

Fällt dir was auf?

[Klaus01]

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  i: integer;
  aRec: TFahrzeugdaten;
  pAuto: IAuto;
begin
    if OpenDialog1.Execute then
    AssignFile(MyFile, OpenDialog1.FileName);
  Reset(MyFile);
//Anzahl der Datensätze ermitteln und Arraygröße entsprechend setzen
  i := 0;
  while not EOF(MyFile) do
  begin
    read(MyFile, aRec);
    //pAuto := IAuto.create;  // keine Ahnung ob das bei Interfaces so geht
    pAuto := TBackupClassesFactory.Auto;  // ist das sowas wie create?
    pAuto.PS := aRec.ps;
    pAuto.KW := aRec.kw;
    pAuto.Name := aRec.fahrzeugName;
    autoList.items.add(pAuto);  // Object in die Liste einfügen
  end;

end;

Grüße
Klaus

[DeddyH]

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  i: integer;
  aRec: TFahrzeugdaten;
  pAuto: IAuto;
begin
  if OpenDialog1.Execute then
    begin //<-- wichtig!  
      AssignFile(MyFile, OpenDialog1.FileName);
      Reset(MyFile);
      while not EOF(MyFile) do
        begin
          read(MyFile, aRec);
          pAuto := TBackupClassesFactory.Auto;
          pAuto.PS := aRec.ps;
          pAuto.KW := aRec.kw;
          pAuto.Name := aRec.fahrzeugName;
        end;
      CloseFile(MyFile); //<-- nicht vergessen
    end; //s.o.
end;

[Schnittcher]

Hallo,

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  Auto: IAuto;
  datensatz: TFahrzeugdaten;
  MyFile: file of TFahrzeugdaten;
begin
  Auto := TBackupClassesFactory.Auto;
  AutoList := TbackupClassesFactory.AutoList;
  if OpenDialog1.Execute then
  begin
    AssignFile(MyFile, OpenDialog1.FileName);
    Reset(MyFile);
    while not EOF(MyFile) do
    begin
      read(MyFile, datensatz);
      Auto.PS := datensatz.ps;
      Auto.KW := datensatz.kw;
      Auto.Name := datensatz.fahrzeugName;
        //  [DCC Warning] Unit1.pas(135): W1057 Implicit string cast from 'ShortString' to 'string'
      Auto.kmh := 0;
      Auto.mph := 0;
      AutoList.add(Auto);
      lbEintraege.Caption := IntToStr(AutoList.Count);
    end;
    CloseFile(MyFile);
  end;
end;

Mir wird jetzt immer der gleiche Eintrag angezeigt.
Kann jemand einen Fehler finden.

Gruß,
Schnittcher

[Klaus01]

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  Auto: IAuto;
  datensatz: TFahrzeugdaten;
  MyFile: file of TFahrzeugdaten;
begin
  Auto := TBackupClassesFactory.Auto;
  AutoList := TbackupClassesFactory.AutoList;
  if OpenDialog1.Execute then
  begin
    AssignFile(MyFile, OpenDialog1.FileName);
    Reset(MyFile);
    while not EOF(MyFile) do    // <-- hier mal einen Breakpoint setzen und mit F8 schrittweise den Code abarbeiten
    begin
      read(MyFile, datensatz);  
      Auto.PS := datensatz.ps;  // Datensatz.ps markieren und Ctrl+F5 drücken
      Auto.KW := datensatz.kw;  // Datensatz.kw markieren und Ctrl+F5 drücken
      Auto.Name := datensatz.fahrzeugName; // Datensatz.fahrzeugName markieren und Ctrl+F5 drücken
      Auto.kmh := 0;
      Auto.mph := 0;
      AutoList.add(Auto);
      lbEintraege.Caption := IntToStr(AutoList.Count);
    end;
    CloseFile(MyFile);
  end;
end;

Mit ctrl+F5 kannst Du dir Variablen in der Watchlist anschauen
ändern sich da die Werte?
Zählt AutoList.count hoch?

Sind in der Datei auch unterschiedliche Werte gespeichert?

Grüße
Klaus

[Der.Kaktus]

Zitat:

Zitat von DeddyH

Ich bin im Moment krank geschrieben, von daher hab ich jede Menge Zeit ;)

Gute Besserung
:cheers: ..war ich auch letzten 2 Wochen ;-)

[DeddyH]

Danke, Kaki :cheers:

[Schnittcher]

Hallo,

ja die Werte ändern sich, dass hätte ich vielleicht auch schreiben sollen.

Die Anzahl der Einträge geht auch nach oben.

Was könnte es sein?

Gruß,
Schnittcher

[Klaus01]

Guten Morgen Schnittcher,

ich würde eigentlich erwarten, das pro eingelesen Datensatz auch
ein Object/Interface vom Typ Auto generiert wird.

nun weiß ich leider nicht was diese Zeilen machen:

Delphi-Quellcode:

  
  Auto := TBackupClassesFactory.Auto;
  AutoList := TbackupClassesFactory.AutoList;

Wird da ein "Auto" angelegt?
Wird da eine leere AutoList angelegt?

Wenn das nun alles mit "normalen" Objecten laufe würde,
würde ich es so machen:

Delphi-Quellcode:

type
  TAuto = class(TObject)
   ...
  end;

  TAutoList = class(TObjectList);
  ...
  end;

procedure TForm1.Button1Click(Sender: TObject);
var
  Auto: TAuto;
  datensatz: TFahrzeugdaten;
  MyFile: file of TFahrzeugdaten;
begin
  //Auto := TBackupClassesFactory.Auto;
  AutoList := TAutoList.create(true);       // eine leere Liste erstellen
  if OpenDialog1.Execute then
  begin
    AssignFile(MyFile, OpenDialog1.FileName);
    Reset(MyFile);
    while not EOF(MyFile) do    // <-- hier mal einen Breakpoint setzen und mit F8 schrittweise den Code abarbeiten
    begin
      read(MyFile, datensatz); 
      Auto : TAuto.create;           // neue Autoinstanz erstellen
      Auto.PS := datensatz.ps;  
      Auto.KW := datensatz.kw;  
      Auto.Name := datensatz.fahrzeugName;
      Auto.kmh := 0;
      Auto.mph := 0;
      AutoList.add(Auto);  // Der Liste hinzufügen
      lbEintraege.Caption := IntToStr(AutoList.Count);
    end;
    CloseFile(MyFile);
  end;
end;

Mit Interfaces habe ich mich bisher noch nicht beschäftigt
aber ich denke das es eigentlich da ähnlich sein sollte.

Grüße
Kalus

Grüße
Klaus

[Schnittcher]

Hallo Klaus,

ich möchte mich jetzt erstmal dafür bedanken das du die die Zeit nimmst mir zu helfen, ich möchte auch DeddyH danken, der mir gestern noch sehr lange per PN und im Chat geholfen hat.

Delphi-Quellcode:

Auto := TBackupClassesFactory.Auto;
  AutoList := TbackupClassesFactory.AutoList;

da steht das hier hinter:

Delphi-Quellcode:

class function TBackupClassesFactory.AutoList: IAutoList;
begin
  Result := TautoList.Create;
end;

class function TBackupClassesFactory.Auto: IAuto;
begin
  Result := TAuto.Create;
end;

also die Liste und das Auto werden erstellt.

Gruß,
Schnittcher

[Klaus01]

Zitat:

Zitat von Schnittcher

Delphi-Quellcode:

class function TBackupClassesFactory.Auto: IAuto;
begin
  Result := TAuto.Create;
end;

also die Liste und das Auto werden erstellt.

Gruß,
Schnittcher

es wird aber nur ein Auto erstellt.

Du musst pro gelesenen "Datensatz" ein Auto generieren,
ansonsten verweisen Deine Instanzen in der Liste alle
auf die gleiche Instanz und alle Werte Deiner Liste
haben die Werte des zuletzt gelesenen Datensatzes.

Grüße
Klaus

[Schnittcher]

Hallo,

kannst du mal kurz in den Chat kommen?

Gruß,
Schnittcher