Dynam. Array Speichern,bzw. Laden

[Hallo_Thomas]

Hallo,
hatte mich schon ein bisschen belesen, was das Laden bzw,Speichern von Dynamischen Arrays angeht.
Nur Irgendwie will der Code nich klappen, abgespeichert wird irgendwas(keine Ahnnung was).

Und beim Laden ist hinterher nix in der Array;

Fehlermeldungen:nicht bekannt;

:gruebel: :gruebel:
Die Dynamische Array;

Delphi-Quellcode:

public
     MyListe                             :Array of Byte;

So wollte ichs speichern

Delphi-Quellcode:

procedure TForm1.Speichern1Click(Sender: TObject);
var FS : TFileStream;
  i:Integer;
begin
  with SaveDialog1 do
  begin
    Filter := 'Textdateien (*.TXT)|*.TXT';
    FileName := 'Firmenbrief.txt';
    DefaultExt := 'TXT';
    Options := [ofOverwritePrompt];     // Sicherheitsabfrage beim Überschreiben
    if Execute then
    begin
      FS := TFileStream.Create(filename ,fmCreate);
      try
         for i := Low(MyListe) to High(MyListe) do
          fs.write(Myliste[i], Length(Myliste) * SizeOf(Integer));
        finally
       FS.free
        //for i := 0 to length(MyListe)-1 do
        //FS.Write (MyListe[i], length(MyListe) * sizeof(MyListe[i]));
        //finally
        //FS.free ;
      end ;
    end;
  end;
end ;

Und so wollte ich die daten wieder Laden

Delphi-Quellcode:

procedure TForm1.ffnen1Click(Sender: TObject);
var
  itag,y,Spalte,Grenze              : Integer;
  FS                                : TFileStream;
begin
  with OpenDialog1 do
  begin
    Filter := 'Textdateien (*.TXT)|*.TXT';
    DefaultExt := 'TXT';
    if Execute then
    begin
      FS := TFileStream.Create(OpenDialog1.FileName,fmOpenRead);
      try
        FS.Read (MyListe[0], length(MyListe) * sizeof(Byte)) ;
      finally
      FS.free ;
      end ;
    end ;
 end;

[Angel4585]

Überdenke diese Zeile:

Delphi-Quellcode:

fs.write(Myliste[i], Length(Myliste) * SizeOf(Integer));

SizeOf(Byte) sollte reichen

Edit: Beim laden hast den gleichen Fehler

[Hallo_Thomas]

Zitat:

fs.write(Myliste[i], Length(Myliste) * SizeOf(Integer));

:lol: Jo war ein komischer Versuch :oops:

Aber trotzdem, wills irgendwie nich laufen?

[Khabarakh]

Überdenke auch mal dies:

Delphi-Quellcode:

FS.Read (MyListe[0]

Oder wolltest du zum Testen nur das erste Item laden? Dann sollte es eigentlich korrekt sein, poste im Zweifelsfalle nochmal den korrigierten Code.

[Hallo_Thomas]

@ Khabarakh


Ich hab da nichts gefunden wie ichs schreiben könnte, da ich ja beim Laden nicht weis wie gross die Array ist? Es wird ja nicht mal das erste Item zugeordnet

[SirThornberry]

du müsstest dir möglichst noch im Stream die Länge des Arrays speichern, zumindest wenn du mal vor hast die mehr also nur ein Array of Byte zu verwenden.
Wenn es bei dem Array of Byte bleiben soll dann so:

Delphi-Quellcode:

//schreiben
Stream.Write(YourArray[0], Length(YourArray) * SizeOf(Byte));
//lesen
SetLength(YourArray, Stream.Size);
Stream.Read(YourArray[0], Length(YourArray) * SizeOf(Byte));

[Grishnak]

Du musst auf jeden Fall schon vor dem eigentlichen Laden per "FS.Read" wissen, wie groß das Array ist, da du es mittels "SetLength" einrichten musst!

Speichern:

Delphi-Quellcode:

len:=Length(MyListe);
FS.WriteBuffer(len, SizeOf(len));
for i:=0 to len-1 do
  FS.WriteBuffer(MyListe[i], SizeOf(Byte));

Laden:

Delphi-Quellcode:

FS.ReadBuffer(len, SizeOf(len));
SetLength(MyListe, len);
for i:=0 to len-1 do
  FS.ReadBuffer(MyListe[i], SizeOf(Byte));

!!!ungetestet!!!

[Angel4585]

Oder probier das mal, ebenfalls ungetestet:

Delphi-Quellcode:

SetLength(MyListe,0);
while not eof(fs) do
 begin
 SetLength(MyListe,Length(MyListe)+1);
 fs.read(MyListe[Pred(Length(MyListe))],SizeOf(Byte));
 end;

[Hallo_Thomas]

@ SirThornberry
Leider scheitere ich hier schon beim speicher.

Fehlermeldung:Zugriffsverletzung.........


Stream.Write(MyListe[0], Length(MyListe) * SizeOf(Byte));

[Hallo_Thomas]

So bevor ich weitermache, stelle ich hier mal einen Beispielcode herein

In der Unit1 zum Schluss sind die beiden Proceduren, die mir Kopfschmerzen machen.

[Hallo_Thomas]

@Grishnak

Hab hier ebenfalls eine Zugriffsverletzung

Delphi-Quellcode:

    if Execute then
    begin
     len:=Length(MyListe);
     FS.WriteBuffer(len, SizeOf(len));
     TRY
      for i:=0 to len-1 do
      FS.WriteBuffer(MyListe[i], SizeOf(Byte));
     finally

[marabu]

Hallo Thomas,

dein Programm musst du selbst anpassen, aber hier zwei Routinen, die ein dynamisches Byte-Array aus einer Datei laden und in eine Datei speichern. Vielleicht hilft es dir zu verstehen:

Delphi-Quellcode:

uses
  Types;

procedure ArrayLoad(var bda: TByteDynArray; fn: TFileName);
begin
  with TFileStream.Create(fn, fmOpenRead + fmShareDenyWrite) do
  begin
    SetLength(bda, Size);
    ReadBuffer(bda[0], Length(bda));
    Free;
  end;
end;

procedure ArraySave(bda: TByteDynArray; fn: TFileName);
begin
  with TFileStream.Create(fn, fmCreate) do
  begin
    WriteBuffer(bda[0], Length(bda));
    Free;
  end;
end;

Freundliche Grüße vom marabu

[Hallo_Thomas]

@marabu

Perfekt, sogar Read funkt ausgezeichnet

[Hallo_Thomas]

Ich weis zwar, das es fast ein neues Thema ist, aber ich willsr aufgrund meiner Speicher-Laden Problematik hier reinschreiben.

Ga ich die Array auch mah kürzen muss, wollte ich .Free verwenden. Doch irgendwie will TByteDynArray das ni. Wie bekomme ich das hin

Delphi-Quellcode:

MyArray:TByteDynArray;
MyArray[Index].Free;

[Muetze1]

Das bekommst du genauso hin, wie du es vergrösserst: Mit SetLength(). Damit einfach die neue Grösse setzen. Siehe die Lade-Routine.

[Hallo_Thomas]

Ich hab den Code genommen, das Free musste ich raus nehmen

Delphi-Quellcode:

procedure TForm1.ArrayDelete(MyArray:TByteDynArray;Index: Integer);
var
  i : Integer;
begin
  //MyArray[Index].Free;
  for i := Index to length(MyArray) - 2 do MyArray[i] := MyArray[i + 1];
  setlength(MyArray, length(MyArray) - 1);
end;

Mit Free Fehlermeldung: Record, Objekt oder Klassentyp erforderlich

[marabu]

Hallo Thomas,

hier ein paar Verbesserungsvorschläge zu deiner Prozedur:

• Was passiert, wenn beim Aufruf ein unsinniger Wert als index übergeben wird?
• Da die Prozeduren zur Manipulation von Arrays keinen Bezug zur VCL haben, würde ich sie auch nicht als Methoden der Form deklarieren.
• Die Zahl der zu löschenden Einträge würde ich zum Parameter machen.

Delphi-Quellcode:

// uses Types

procedure ArrayDelete(var bda: TByteDynArray; const index: Cardinal; size: Cardinal = 1);
var
  iTail: Integer;
begin
  if (size = 0) or (index >= Length(bda)) then
    Exit;
  if size > (Length(bda) - index) then
    size := Length(bda) - index;
  iTail := index + size;
  if (iTail < Length(bda)) then
    Move(bda[iTail], bda[index], Length(bda) - iTail);
  SetLength(bda, Length(bda) - size);
end;

Grüße vom marabu