Delphi-PRAXiS - Delphi Daten per Streams in Datei schreiben

Hallo Leute!

Gleich vorweg: Ich habe noch nicht oft mit Streams gearbeitet.

Ich möchte per Stream verschiedene Daten in eine Datei schreiben und wieder lesen können.
Im Detail sind die Daten Klassen, welche irgendwelche Informationen enthalten (Beschreibung, etc...).
Die Klassen kennen sich untereinander nicht. Somit muss ich die Daten im Stream anhand von Headern identifizieren können.

In meiner Vorstellung sieht das so aus:
|_HeaderA_|_DataA___________|_HeaderB_|_DataB_____ ______|_HeaderC_|_DataC___________|

Nur leider habe ich keine Idee, wie ich das umsetzen kann :(
So sieht mein Testframe aus:

Delphi-Quellcode:

			unit FmStreamOperations;

interface

uses

  Winapi.Windows,

  Winapi.Messages,

  System.SysUtils,

  System.Variants,

  System.Classes,

  Vcl.Graphics,

  Vcl.Controls,

  Vcl.Forms,

  Vcl.Dialogs,

  Vcl.StdCtrls;

type

  (*

    This is the first record that should be saved to a file

      most important properties:

      @ version field that can be interpreted from reader classes

      @ conentlen field when the record ends and the next record begins

    NOTE: packed record because the memory alignment of regular records are

          subject to change between releases

  *)

  TDummyHeaderA = packed record

    // after structure changes increment this

    Version: Integer;

    // position of begin of content

    Pos: Integer;

    // Integer should be enough to prevent to low allocation for the content

    Len: LongInt;

    // do not use dynamic length; ShortString (String[255]) instead of String

    HeaderType: ShortString;

  end;

  (*

    This is the second record that should be saved to a file

      most important properties:

      @ version field that can be interpreted from reader classes

      @ conentlen field when the record ends and the next record begins

    NOTE: packed record because the memory alignment of regular records are

          subject to change between releases

  *)

  TDummyHeaderB = packed record

    // after structure changes increment this

    Version: Integer;

    // position of begin of content

    Pos: Integer;

    // Integer should be enough to prevent to low allocation for the content

    Len: Integer;

    // do not use dynamic length; ShortString (String[255]) instead of String

    HeaderType: ShortString;

  end;

  (*

    This is the third record that should be saved to a file

      most important properties:

      @ version field that can be interpreted from reader classes

      @ conentlen field when the record ends and the next record begins

    NOTE: packed record because the memory alignment of regular records are

          subject to change between releases

  *)

  TDummyHeaderC = packed record

    // after structure changes increment this

    Version: Integer;

    // position of begin of content

    Pos: Integer;

    // Integer should be enough to prevent to low allocation for the content

    Len: Integer;

    // do not use dynamic length; ShortString (String[255]) instead of String

    HeaderType: ShortString;

  end;

  (*

    This is a dummy class for testing the header TDatasetHeaderA

  *)

  TDummyA = class(TPersistent)

  private

    FValueA: Integer;

    FValueB: string;

    FValueC: Boolean;

  public

    constructor Create;

    destructor Destroy; override;

    property ValueA: Integer read FValueA write FValueA;

    property ValueB: string read FValueB write FValueB;

    property ValueC: Boolean read FValueC write FValueC;

  end;

  (*

    This is a dummy class for testing the header TDatasetHeaderB

  *)

  TDummyB = class(TPersistent)

  private

    FValueA: Int64;

    FValueB: ShortString;

    FValueC: PChar;

  public

    constructor Create;

    destructor Destroy; override;

    property ValueA: Int64 read FValueA write FValueA;

    property ValueB: ShortString read FValueB write FValueB;

    property ValueC: PChar read FValueC write FValueC;

  end;

  (*

    This is a dummy class for testing the header TDatasetHeaderC

  *)

  TDummyC = class(TPersistent)

  private

    FValueA: SmallInt;

    FValueB: Char;

    FValueC: Double;

  public

    constructor Create;

    destructor Destroy; override;

    property ValueA: SmallInt read FValueA write FValueA;

    property ValueB: Char read FValueB write FValueB;

    property ValueC: Double read FValueC write FValueC;

  end;

  (*

    Testframe form

  *)

  TFmTestframe = class(TForm)

    ButtonSave: TButton;

    ButtonLoad: TButton;

    procedure ButtonSaveClick(Sender: TObject);

    procedure ButtonLoadClick(Sender: TObject);

  private

    { Private-Deklarationen }

  public

    { Public-Deklarationen }

  end;

  (*

    constants

  *)

  const C_FILE_EXT = 'bin';

  const C_FILE_LOC = 'C:\';

var

  FmTestframe: TFmTestframe;

implementation

{$R *.dfm}

procedure TFmTestframe.ButtonLoadClick(Sender: TObject);

var

  Stream: TFileStream;

  FileName: string;

  HeaderA: TDummyHeaderA;

  DataA: TDummyA;

begin

  // Try to load TDummyHeaderA & TDummyA from file via stream to the objects

  FileName :=

    Format('%s.ExampleFileWrittenWithStream.%s', [C_FILE_LOC, C_FILE_EXT]);

  // !! don't forget to check if the file exist and is accessable in production builds

  Stream := TFileStream.Create(FileName, fmOpenRead);

  try

    // Stream.Read(...) <----- ??? What to do here?

  finally

    FreeAndNil(Stream);

  end;

end;

procedure TFmTestframe.ButtonSaveClick(Sender: TObject);

var

  Stream: TFileStream;

  HeaderA: TDummyHeaderA;

  DataA: TDummyA;

  FileName: string;

begin

  // Try it with TDummyHeaderA & TDummyA first

  // Fill TDummyHeaderA with data

  HeaderA.Version := 1;

  HeaderA.Pos := 0; { replace with start point of the content??? }

  HeaderA.Len := 0; { replace with the length of the content??? }

  HeaderA.HeaderType := '[Type] Dummy Header A';

  // TDummyA is filled with dummy data by the constructor

  DataA := TDummyA.Create;

  try

    // Try to save TDummyHeaderA & TDummyA into file via stream

    FileName :=

      Format('%s.ExampleFileWrittenWithStream.%s', [C_FILE_LOC, C_FILE_EXT]);

    // !! don't forget to check if the file exist and is accessable in production builds

    Stream := TFileStream.Create(FileName, fmCreate);

    try

      // Stream.Write(HeaderA, ...) <----- ??? What to do here?

      // ...

      // ..

      // .

    finally

      FreeAndNil(Stream);

    end;

  finally

    FreeAndNil(DataA);

  end;

end;

{ TDummyA }

constructor TDummyA.Create;

begin

  FValueA := 1;

  FValueB := 'DummyA Example Text';

  FValueC := True;

end;

destructor TDummyA.Destroy;

begin

  inherited;

end;

{ TDummyB }

constructor TDummyB.Create;

begin

  FValueA := 9823323232313;

  FValueB := 'Dummy B';

  FValueC := PChar('Pointer to string test');

end;

destructor TDummyB.Destroy;

begin

  inherited;

end;

{ TDummyC }

constructor TDummyC.Create;

begin

  FValueA := -1;

  FValueB := 'C';

  FValueC := 3.14;

end;

destructor TDummyC.Destroy;

begin

  inherited;

end;

end.

Es wäre nett, wenn mir jemand Hilfestellung geben könnte :stupid: