Datei an Datei anhängen

[SirThornberry]

Um das ganze mit einem Texteditor lesen zu können ist das sicher eine schöne Variante. Da aber auch ein JPEG mit in die Datei soll bietet es sich an alles binär zu speichern.

ungetesteter Code:

Delphi-Quellcode:

var
  lStream: TStream;
  lStartPos: Int64;
  lDataSize: Cardinal;
begin
  lStream := TFileStream.Create(YourFileName, fmCreate);
  try
    // Memo speichern
    lStartPos := 0;
    lStream.Position := lStream.Position + sizeof(lDataSize);
    YourMemo.Lines.SaveToStream(lStream);
    lDataSize := lStream.Position - lStartPos - sizeof(lDataSize);
    lStream.Position := lStartPos;
    lStream.Write(lDataSize, sizeof(lDataSize));
    // JPG speichern
    lStartPos := lStream.Size;
    lStream.Position := lStream.Position + sizeof(lDataSize);
    YourJPG.SaveToStream(lStream);
    lDataSize := lStream.Position - lStartPos - sizeof(lDataSize);
    lStream.Position := lStartPos;
    lStream.Write(lDataSize, sizeof(lDataSize));
  finally
    lStream.Free;
  end;

[Edit]
Wenn etwas unklar ist am Quelltext bitte nachfragen (nichts ist schlimmer als einfach abzutippen anstelle zu verstehen)

[mkinzler]

-Länge 1. datei
-Inhalt 1. datei
-Länge 2. Datei
-Inhalt 2. Datei
...

[sx2008]

Du hast die Wahl zwischen:
1.) das Rad neu erfinden

du denkst dir ein eigenes Format aus (Mit einem Header, der Länge und Name der Datei enthält)

2.) professionelle Vorgehensweise

a.) sich für ein Standard-Archivformat entscheiden
(z.B. .zip, *.cab, *.tar,..)
b.) Komponenten oder Klasse für das Archivformat besorgen
(z.B. auf Torry's)

[MiniMax]

Den code werde ich nachher gelich mal testen --> thx dafür.

Wie bekomme ich denn die Datein wieder Getrennt und in einen Memo und ein Image geladen?

[SirThornberry]

Ich würde das ganze nicht als "Rad neu erfinden" bezeichnen sondern als Lösung maßgeschneiderte Lösung. Denn wozu soll man das ganze noch packen und den Quelltext mit verschiedenen Algorythmen des Formates aufblähen wenn man letzendlich nur mehrere Daten in einem Stream speichern will.

Wenn du den Code verstanden hast weißt du auch wie der umgekehrte Weg lautet (lesen aus einem Stream geht mit read anstelle von write)
Deswegen auch mein Kommentar das du nachfragen sollst wenn du am Code etwas nicht verstehst.

[Luckie]

Zitat von MiniMax:

Ist dass so richtig?

Probiere aus, ob du es wieder geladen bekommst. Aber ich würde kein Trennzeichen nehmen, denn das muss man bei Laden erst wieder suchen. Schreibe stattdessen an den Anfang die Länge des Textes.

[SirThornberry]

Zudem kann es vorkommen dass, das Trennzeichen in den Daten vorkommt. Entsprechend macht es mehr Arbeit das Trennzeichen zu suchen und in den Daten zu ersetzen als gleich darauf zu verzichten.
Natürlich kann man das ganze auch kombinieren in dem man die Länge + Trennzeichen nutzt aber das ist bei binärer Speicherung der Länge eben nicht notwendig.

[MiniMax]

Ok dann frage ich ma:

Delphi-Quellcode:

var
  lStream: TStream;
  lStartPos: Int64;
  lDataSize: Cardinal;
begin
  lStream := TFileStream.Create(YourFileName, fmCreate); //stream erstellen?
  try
    // Memo speichern
    lStartPos := 0; //wozu die Position heraus finden?
    lStream.Position := lStream.Position + sizeof(lDataSize); //was wird hier gemacht?
    YourMemo.Lines.SaveToStream(lStream); //is klar wird gespeichert
    lDataSize := lStream.Position - lStartPos - sizeof(lDataSize); //was wird hier gemacht`?
    lStream.Position := lStartPos; //warum den Zeiger verstellen?
    lStream.Write(lDataSize, sizeof(lDataSize)); //was wird hier reingeschrieben?

    // JPG speichern
    lStartPos := lStream.Size; //größe setzen wo der stream begginnt?
    lStream.Position := lStream.Position + sizeof(lDataSize); //was wird hier gemacht?
    YourJPG.SaveToStream(lStream); // Speichern is klar
    lDataSize := lStream.Position - lStartPos - sizeof(lDataSize); //??
    lStream.Position := lStartPos; //Warum den Zeiger Verstellen?
    lStream.Write(lDataSize, sizeof(lDataSize)); //was wird hier gemacht
  finally
    lStream.Free; //is klar
  end;

Warum ich so viele Fragen habe, ich habe noch nie mit streams gearbeitet

[rollstuhlfahrer]

Mit TFilestream die Datei wieder öffnen. Dann kannst du die Länge wieder auslesen. Nachdem du die Länge hast, schreibst du alles, was sich danach befindet in dein Memo. Allerdings nur so oft, wie in der Länge angegeben. Selbiges machst du mit dem JPEG.

Delphi-Quellcode:

procedure Laden();
var
  lStream: TStream;
  lStartPos: Int64;
  lDataSize: Cardinal;
  TextStream, JPEGStream: TMemoryStream;
begin
  lStream := TFileStream.Create(YourFileName, fmOpenRead);
  try
    // Länge lesen
    lStream.Read(lDataSize, sizeOf(lDataSize));

    TextStream := TMemoryStream.Create;
    TextStream.Size = lDataSize;
    // Text auslesen
    lStream.Read(TextStream.Memory, lDataSize);
    YourMemo.Lines.LoadFromStream(TextStream);
    TextStream.Free;

    // Bild laden
    lStream.Position := sizeof(lDataSize) + lDataSize; // Diese Zeile sollte weggelassen werden können, da der Stream ja schon die richtige Position hat.

    // Länge lesen
    lStream.Read(lDataSize, sizeOf(lDataSize));

    JPEGStream := TMemoryStream.Create;
    JPEGStream.Size = lDataSize;
    // Text auslesen
    lStream.Read(JPEGStream.Memory, lDataSize);
    YourJPEG.LoadFromStream(JPEGStream);
    JPEGStream.Free;
  finally
    lStream.Free;
  end;
end;

ungetestet, sollte aber funktionieren.

Bernhard

ADD: Was der Code von SirThornberry macht ist eigentlich nicht schwer: Er erstellt einen Stream (Filestream zum Lesen/Schreiben von Dateien). In diesen Stream wird eine 0 (Datentyp: Cardinal) geschrieben. Dann kommt der Text rein. Streamlänge - Länge von Cardinal = Textlänge. Diese Textlänge wird jetzt ganz vorne hingeschrieben. Danach macht er hintendran weiter: 0 (Cardinal) reinschreiben, dann das Bild hintendran. Jetzt noch die Länge des Bildes berechnen und die 0 vor dem Bild ersetzen, fertig.

[MiniMax]

Woher weiß den der Code, wie lang der Text ist und das jpg? Der kennt doch nur die gesamt länge?