Mehrdimensionales dynamisches Array aus Datei auslesen

[kenuvis]

Hallo,

ich hab nun gegooglet und hier geschaut, ausprobiert und was weiß ich nicht alles, aber ich finde echt keine Lösung. Nach langem hin und her hab ich es geschafft mein Array zu speichern.

Liste: Array of Array of Array of TStringList; ich speichere nun wie folgt:

Delphi-Quellcode:

var
  f: TFileStream;
  a,b,c,d: integer;
  temp: String;
begin
  f := TFileStream.Create(ExtractFilePath(Application.ExeName)+'ArrayDatei',fmCreate);
  try
    for a := 0 to Length(Liste)-1 do
      for b := 0 to Length(Liste[a])-1 do
        for c := 0 to Length(Liste[a,b])-1 do
          for d := 0 to Liste[a,b,c].Count-1 do begin
            temp := Liste[a,b,c][d];
            f.Write(temp,Length(temp));
          end;
  finally
    f.free;
  end;

nun meine Frage, wie bekomm ich die dinger wieder aus der Datei?

MfG Kenu

[marabu]

Guten Morgen,

wenn du Daten aus einer Struktur persistent machst, dann musst du in der Regel auch die Meta-Information persistent machen. In deinem Fall muss also aus den gespeicherten Daten hervorgehen, an welcher Stelle deines mehrdimensionalen Arrays sie wieder eingebaut werden sollen. Darüberhinaus musst du die Länge der einzelnen Strings kenntlich machen - durch Voranstellen einer Längeninformation oder durch Begrenzungszeichen.

Hast du dich schon entschieden, ob du ein binäres oder textuelles Speicherformat verwenden möchtest? Ich würde beim Textformat ein strukturiertes Format (XML) wählen, aber du kannst ein multidimensionales Array auch linear speichern:

Delphi-Quellcode:

type
  i, j, k, index: Integer;
begin
  // ...
    temp := IntToStr(Length(Liste)) + sLineBreak;
    f.Write(temp[1], Length(temp));
    for i := 0 to Pred(Length(Liste)) do
    begin
      temp := IntToStr(Length(Liste[i])) + sLineBreak;
      f.Write(temp[1], Length(temp));
      for j := 0 to Pred(Length(Liste[i])) do
      begin
        temp := IntToStr(Length(Liste[i, j])) + sLineBreak;
        f.Write(temp[1], Length(temp));
        for k := 0 to Pred(Length(Liste[i, j])) do
        begin
          temp := IntToStr(Liste[i, j, k].Count) + sLineBreak;
          f.Write(temp[1], Length(temp));
          for index := 0 to Pred(Liste[i, j, k].Count) do 
          begin
            temp := Liste[i, j, k][index] + sLineBreak;
            f.Write(temp[1], Length(temp));
          end;
end;

Wenn du dir die erzeugte Ausgabedatei in einem Editor anschaust und ich nicht zuviele Tippfehler eingebaut habe, dann erkennst du, dass die Dimensionsangaben und die Items deiner StringListen zeilenweise so abgelegt sind, dass du beim Wiedereinlesen zuerst die Information erhältst, die du zum Dimensionieren des Arrays benötigst.

Grüße vom marabu

[Jens Schumann]

Hallo,
ich habe einen anderen Lösungsvorschlag für Dich. Wenn Du das Dateiformat selbst bestimmen kannst ist die Lösung
über die dpcollection ein nicht uninteressanter Weg. Die Lösung scheint auf den ersten Blick wesentlich komplizierter. Die Einarbeitung lohnt sich.
Für die Lösung mit der dpCollection wird das Array nicht über dynamische Array's sondern mit entsprechend verschachtelten
Nachfahren von TCollection und TCollectionItem realisiert.

Die dpCollection setzt auf dem Delphi Streamingsystem auf. Die einzelnen Strings kannst Du in einem Object als published property
angelegen. Das Delphi Streamingsystem speichert alle als published angelegten properties automatisch.

Jetzt kommt der entscheidende Vorteil:
Wenn Du das Dateiformat erweitern möchtest brauchst Du nur ein paar published properties anlegen und fertig.
Die Lösung ist sogar abwärts kompatibel.