Serialisieren eines Objektes unter D7

[Jens Schumann]

Zitat:

Zitat von Mr_G

Also:
Ich hab ein Objekt das von TCollectionItem abstammt. Dieses hat eine Property welche ein array vom Typ eines anderen Objektes ist. Und wenn das vom Typ TCollection abstammt geht das? :?:

*mal rum bastelt*

TCollection verwaltet die einzelnen Objekte. Der Zugriff sieht aus wie bei einem Zugriff auf ein Array. Wenn dein TCollectionItem Nachfahre eine published property vom Type TCollection hat ist das kein Problem. D.h. das Array realisierst Du ebenfalls mit der Kombination TCollection/TCollectionItem

[Robert_G]

Zitat:

Zitat von Jens Schumann

Wenn dein TCollectionItem Nachfahre eine published property vom Type TCollection hat ist das kein Problem. D.h. das Array realisierst Du ebenfalls mit der Kombination TCollection/TCollectionItem

Das ist IMHO nicht nur viel sauberer und "hübscher" als ein olles Array, es ist auch komfortabler für dich. ;)
Bei einem Array musst du viel zu Fuss machen um Objekte zu entfernen oder hinzuzufügen, eine Collection bringt dir diese Funktionen frei Haus. ;)

[Mr_G]

Oki...
Ich geb mich geschlagen...
Leider im doppelten Sinne: Ich scheitere an der Umsetzung. Vielliecht könnt ihr mir nochmal helfen. :wiejetzt:

Also ich hab 3 Objekte.
- Objekt(2) hat eine Eigenschaft (-> array, Collection oder wie auch immer) aufgebaut aus Objekten(3)
- Objekt(1) hat eine Eigenschaft (-> array, Collection oder wie auch immer) aufgebaut aus Objekten(2)

Wer muss nun welchen Typ haben?
Sry aber ich blickt durch das System nich so ganz durch... :wall: :wall: :wall:

[Jens Schumann]

Hallo,
in der zip-Datei aus der Codelibrary ist eine Powerpoint Datei enthalten.
CollectionsItems.ppt. Da habe ich versucht zu zeigen, wie man ein 2-dimensionales "Array"
aufbaut.

[Jens Schumann]

Hallo,
ich habe mal ein kleines Beispiel gebastelt.
Hier die unit für das 2-dimensionale Array:

Delphi-Quellcode:

unit TwoD_Array;

interface

uses classes, dpcollection;


Type

  TDimension_2 = class(TCollectionItem)
  private
    FText: String;
  public
    procedure   Assign(Source : TPersistent); override;
  published
    property Text: String read FText write FText;
  end;

  TDimension_1 = class(TCollectionItem)
  private
    FD2Collection : TJsCollection;
    FName: String;
  public
    constructor Create(Collection: TCollection); override;
    destructor  Destroy; override;
    procedure   Assign(Source : TPersistent); override;
  published
    property Name : String read FName write FName;
    property D2 :  TJsCollection read FD2Collection write FD2Collection; // Dies ist die 2. Dimension !!!
  end;

implementation

{ TDimension_1 }

procedure TDimension_1.Assign(Source: TPersistent);
{Wenn Assign nicht überschrieben wird, werden die eigenen Eigenschaft
 bei einem Aufruf von Assign auch mit erfasst}
begin
  If Source is TDimension_1 then
    begin
    FName:=TDimension_1(Source).Name;
    FD2Collection.Assign(TDimension_1(Source).D2);
    end
      else
        inherited Assign(Source);
end;

constructor TDimension_1.Create(Collection: TCollection);
begin
  inherited Create(Collection);
  FD2Collection:=TJsCollection.Create(TDimension_2);
end;

destructor TDimension_1.Destroy;
begin
  FD2Collection.Free;
  inherited Destroy;;
end;

{ TDimension_2 }

procedure TDimension_2.Assign(Source: TPersistent);
begin
  If Source is TDimension_2 then
    begin
    FText:=TDimension_2(Source).Text;
    end
      else
        inherited Assign(Source);
end;

end.

Das ist grundsätzlich alles !!!!!!!!!
TDimension_1 ist die 1. Dimension des "Arrays". Dieses Objekt kann hier lediglich einen Namen aufnehmen. Das wäre vergleichbar mit

Delphi-Quellcode:

sArray : TArray of String;

Jetzt hat TDimension_1 die Eigenschaft D2. Das ist die 2. Dimension. Über D2 können dem Element (Objekt) aus TDimension_1 beliebig viele Strings (Eigenschaft Text von TDimension_2) zugeordnet werden.

Jetzt kommt der Source des Beispiels. Ich habe alle Codezeilen, die nichts mit der Anwendung
von dbCollection zutun haben weggelassen.

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, TwoD_Array, dpcollection, StdCtrls, XPMan;

type
  TForm1 = class(TForm)
  ...
  private
    { Private-Deklarationen }
    FApplicationPath : String;
    FCollection      : TJsCollection;
    FD1_Item         : TDimension_1;
    ...
  public
    { Public-Deklarationen }
  end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  FCollection:=TJsCollection.Create(TDimension_1); //X
  ...
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  FCollection.Free; //X
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  // erzeuge ein Element (Objekt) in der 1. Ebene
  FD1_Item:=FCollection.Add as TDimension_1; //X
  FD1_Item.Name:=edtName.Text; //X
end;

procedure TForm1.btnTextClick(Sender: TObject);
var
 D2_Item : TDimension_2;
begin
  // Hier wird jetzt die 2. Dimension gefüllt
  If FD1_Item<>Nil then
    begin
    D2_Item:=FD1_Item.D2.Add as TDimension_2; //X
    D2_Item.Text:=edtText.Text; //X
    end;
end;

procedure TForm1.btnSaveClick(Sender: TObject);
begin
  FCollection.SaveToFile(FApplicationPath+'Testdatei.clc'); //X
  // Die Endung .clc ist hier natürlich völlig willkürlich gewählt
end;

procedure TForm1.btnLoadClick(Sender: TObject);
begin
  FCollection.LoadFromFile(FApplicationPath+'Testdatei.clc'); //X
end;

end.

Wie hier zu erkennen ist reicht ein simples LoadFromFile / SaveToFile aus,
um das "Array" zu speichern oder zu laden.

Aber jetzt kommt der eigenliche Hammer !!!
Nehmen wir einmal an, Du möchtest zu jedem Element (Objekt) der 1. Dimension in der
2. Dimension beliebig viele Bitmaps speichern !!! MIt der dpCollection ist das überhaupt
kein Problem. Ich werde jetzt die Klasse TDimension_2 so erweitern das auch Bitmaps
gespeichert werden können. D.h. das Speichern und Laden geschieht dann völlig automatisch!

Delphi-Quellcode:

  TDimension_2 = class(TCollectionItem)
  private
    FText: String;
    FBitmap: TBitmap;
    procedure SetBitmap(const Value: TBitmap);
  public
    constructor Create(Collection: TCollection); override;
    destructor  Destroy; override;
    procedure   Assign(Source : TPersistent); override;
  published
    property Bitmap : TBitmap read FBitmap write SetBitmap;
    property Text: String read FText write FText;
  end;
...
constructor TDimension_2.Create(Collection: TCollection);
begin
  inherited Create(Collection);
  FBitmap:=TBitmap.Create;
end;

destructor TDimension_2.Destroy;
begin
  FBitmap.Free;
  inherited Destroy;
end;

procedure TDimension_2.Assign(Source: TPersistent);
begin
  If Source is TDimension_2 then
    begin
    FBitmap.Assign(TDimension_2(Source).Bitmap);
    FText:=TDimension_2(Source).Text;
    end
      else
        inherited Assign(Source);
end;

procedure TDimension_2.SetBitmap(const Value: TBitmap);
begin
  FBitmap.Assign(Value);
end;

Das ist alles !!!
So lassen sich alle Nachfahren von TPersistent speichern

Jetzt kommt der 2. Hammer!!!
Durch die Einführung der Bitmap wurde das Dateiformat geändert.
Mit einer typisierten Datei hätte man das Problem, dass das neue Programm
die alten Dateien nicht ohne weiteres lesen kann. Nicht so mit der dpCollection.
Die dpCollection verwendet das Delphi-Streamingsystem (das ist das Ding, das dafür sorgt,
das die Formulare mit all den Komponenten und Einstellungen die Ihr gemacht habt
in der dfm-Datei landen). D.h. es werden nur die Eigenschaften aus der Datei gelesen,
die auch in der Datei enthalten sind. Die Eigenschaften, die nicht in der Datei sind
erhalten den Standardwert. D.h. mit der dpCollection seit Ihr automatisch Abwärtskompatibel.

[Mr_G]

So...
Ich hab das ganze nochmal für mich nachvollziehbarer nach geproggt und muss sagen:
Respekt! :thumb:
Das ist wenn man es verstanden hat wirklich einfach!

Big Thx für eure große Hilfe! :dp:

[Mr_G]

Hmm...
Ein Problem hab ich doch noch:
Ich möchte in einer procedure von einem Item auf eine Eigenschaft des Objekts zugreifen, welches das Array mit eben diesem Item als Inhalt als property besitzt.

Falls ihr das verstanden habt: Geht das?

[Jens Schumann]

Zitat:

Zitat von Mr_G

...Falls ihr das verstanden habt: Geht das?

Tut mir Leid - ich habe es nicht verstanden

[Mr_G]

Also:
Ich habe ein Objekt(1) das hat eine Property vom Typ TjsCollection.
Dann habe ich ein Objekt(2) das von TCollectionItem abstammt und in dieser Collection-Property des anderen Objektes(1) ist.
Außerdem hat das Objekt(2) noch eine Prozedur.

Nun kommt das knifflige:
Ich möchte in dieser Prozedur aus Objekt(2) auf eine Property aus dem Objekt(1) zugreifen, in dem sich mein Aktuelles Objekt 2 als Item in der Property befindet.


Ich hab direkt ma ne Zeichnung gemacht :mrgreen:

[Jens Schumann]

Hallo,
wenn ich das richtig sehe möchtest Du von einem TCollectionItem aus auf eine Eigenschaft der Collection zurgreifen, die das TCollectionItem verwaltet.
Kein Problem. Dafür gibt es

Delphi-Quellcode:

TCollectionItem.Collection.HierDieEigenschaftAngeben