Beste Speicherart ?

[edosoft]

es geht so:

Delphi-Quellcode:

FS{tfilestream} := TFileStream.Create(FileName{string, name unter welchem die datei geschbeichert werden soll}, fmCreate);

    //Text(string) speichern
    Buffer{string} := "text";
    FS.Write(Buffer[1], SizeOf(Buffer));

    //Zahl(integer) speichern
    //Tipp: ein integer verbraucht 4 bytes speicherplatz, wird also auf diese weise mit lediglich 4 byte speicherverbrauch gespeichert und ist mit notepad&co nicht darstellbar, schon das sürfte solche total-noobs abschrecken ;)
    BufferI{Integer} := 123;
    FS.Write(BufferI, SizeOf(Integer));

//text der variabel lang ist kann z.b. so gespeichert werde:
    Buffer := "Hallo. Dies ist ein Text, er kann beliebig lang sein.";
    {er kann natürlich net beliebig lang sein, nur 4 gigabyte groß!! ansonsten muss unten statt Integer Int64 verwendet werden, dann braucht das ganze ding mehr speicherplatz! und delphi hat glaubich auch ne maximallänge für strings oder?}
    BufferSize{Integer, wenn Buffer>4gb dann Int64} := Length(Buffer);
    FS.Write(BufferSize, SizeOf(Integer{/Int64}));
    FS.Write(Buffer[1], BufferSize);
//hier werden also zuerst in 4 bytes die länge des strings gespeichert und dann kann er spöäter nach bedarf ausgelesen werden.
//Diese methode braucht keinen Terminator und ich finds besser weil man _alle_ buchstaben speichern kann und nicht einen escapestring oder so hat.

//datei schließen
FS.Free;


////datei lesen
  FS := TFileStream.Create(FileName, fmOpenRead or fmShareDenyNone);

{buffer: struing}
{buffersize: integer}

//in der datei "rumspulen" - geht auch beim schreiben;)
FS.Seek(0, soFromBeginning); //an anfang der datei
FS.Seek(0, soFromEnd); //ans ende der datei
FS.Seek(8, soFromCurrent); //8 buchstaben weiter
FS.Seek(-3, soFromEnd); //3 buchstaben vorm ende
FS.Seek(-12, soFromCurrent); //12 buchsteben zurück

//string lesen
SetLength(Buffer, 5{wie lang ist der string?});
FS.Read(Buffer[1], 5{wie lang ist der string?});

//integer lesen
FS.Read(BufferI, SizeOf(Integer));

//lies die konstrkution von vorher wieder aus, also zuerst 4 bytes längenindikator, dann den string selber
    FS.Read(BufferSize{<-so lang ist der string}, SizeOf(Integer));
    SetLength(Buffer, BufferSize); //buffer mit #0's füllen
    FS.Read(Buffer[1], BufferSize); //buffer auslesen
//wenn man vorher In64 genommen hat muss man hier natürlich auch Int64 einsetzen!

fs.free;

//wenn man z.b. inner datei unbekannt viele integers speichert kann mans ja so machen alle auszulesen:
while FS.Position < FS.Size do
  FS.Read(BufferI, SizeOf(Integer));
  //mach was mit bufferI
end;

Also: wenn man 5 buchstaben liest oder schreibt(.Write/.Read) dann spults in der datei automatisch 5 buchstaben weiter, man braucht nicht immer mit .Seek rumspulen.

Tipp: dauerndes rumspulen mahcts programm langsam!!

Tipp2: nemht den TMemoryStream statt den Filestream(ist genau gleich, nur dass kein dateiname angegeben werden muss)->bedienung genau gleich aber alles wird statt inner datei nur im RAM gespeichert.
Es gibt ja auch noch den TZipStream(oder so ähnlich) der speichert alles glaub wie der memory stream im ram bloß er verpackts gleich mit ZIP
-Dominik