wie abspeichern?

[glkgereon]

hi
ich hab im team ein krankenhaus-simulator geproggt
da will ich jetzt die patienten abspeichern

also so in etwa:

Info (temperatur, herzfrequenz, atemfrequenz...)
Kurzinfo (Wird als Lauftext ausgegeben)
Story (was passiert ist, zb unfall mit 30-tonner, etc, gut und gern ne halbe din A4 seite)
Tipps (Was amn besten gemacht wird, um ihn zu heilen, auch bi zu ner halöben din A4 seite)

da ich doch so einige fälle haben wollte, min 50, stand ich vor der frage, wie speicher ich das ab?

soll ich alles in eine datei tuen, die dann aber auch ziemlich gross wird, und dann jeden abschnitt mit nem einmaligen stichwort einleiten?

oder in eine datei immer 10, und dann die dateien durchnummerieren?

oder doch einen ordner, wo für jeden patienten eine datei reinkommt, die logisch benannt ist, zb wie die laufschrift?

Wieviel haltet ihr von welcher idee?
ich kann keine idee als abwegig verwerfen, aber keine davon ist wesentlich einfacher als alle anderen...

[Phoenix]

Ich würde vorschlagen, Du packst das in eine XML - Datei.

Da kannst Du X Patienten schön getrennt mit allen Angaben in einen Node stecken und gut ist.
Und die Dateiverwaltung übernimmt im Regelfall noch die XML-Komponente für Dich.

[citybreaker]

Du könntest das ganze mit Ini Dateien machen und für jeden Patienten zum
Beispiel eine Datei anlegen.

[xineohp]

moin,

@citybreaker: Es ist nicht ganz einfach längere Texte in einer Ini-Datei zuspeichern...

[glkgereon]

wie mach ich das mit xml?
gibts da ein tut für?
hört sich irgendwie gut an

aber die datei wird dann ziemlich groß....

[Chris1986]

warum so kompliziert? Deine "Patientenakte" liegt doch wahrscheinlich in einem Array, oder?

Ich würde das so speichern

Delphi-Quellcode:

File of TPatientenakte

Jetzt musst du nur noch mit assign einen Dateinamen anbinden und mit rewrite die Datei schreiben lassen. Anschließend mittels for-Schleife und write die einzelnen Akten einfügen. Fertig

Mit den Filepointer-Operationen hast du auch noch umfangreiche Suchmöglichketen, etc.

MfG
Christian

[Edit]Tippfehler[/Edit]

[yankee]

Für XML gibt es Komponenten (wenn ich nmich recht erinnere www.openxml.org, wenn das falsch ist, dann such mal nach OpenXML.

Ich emphele dir die ganze Story und die Missionen und was es sonst nochso an statischen Daten gibt in anderen Dateien festzuhalten (du hast es doch nicht etwa in den Quelltext geschreiben???)

Dann musst du in dem Spielstand nur noch sehr wenige Sachen festhalten (Eigentlich nur das momentane Level...)

[glkgereon]

Zitat:

Jetzt musst du nur noch mit assign einen Dateinamen anbinden und mit rewrite die Datei schreiben lassen. Anschließend mittels for-Schleife und write die einzelnen Akten einfügen. Fertig

ja ich wills ja auch wieda auslesen und das ist da nicht soo einfach, und ich hatte nach der einfachsten lösung gefragt....

@yankee: es geht um die storys :-)
und im qt stehen die nicht...noch gibts keine....
ma gucken mit xml...

[Phoenix]

OpenXML gibt es hier.

Ansonsten kannst Du auch MS XML nehmen (braucht aber neinstallierte Version davon auf dem Zielrechner). Eigentlich müsstest Du dazu auch hier in der DP recht schnell fündig werden.

Zu der Dateigrösse: XML ist plain text. Du kannst also zum Beispiel mit der zlib die .xml - Datei nach dem schreiben noch Komprimieren, da die Kompressionsrate bei Textdateien immer recht hoch ist (da nur sehr weniger der möglichen Zeichen verwendet werden).

Auch OpenOffice speichert zum Beispiel alle Dokumente in XML - Format (mehrere XML-Dateien in einem .zip - Archiv). Der Benutzer merkt davon jedoch eigentlich gar nichts. Kannst ja mal ein OpenOffice-Dokument in .zip umbenennen und entpacken :-).

[Chris1986]

Zitat:

Zitat von glkbkk

ja ich wills ja auch wieda auslesen und das ist da nicht soo einfach

Auch wenn du dich schon für XML entschieden hast :lol: :

Beim auslesen machst du nicht viel mehr als write durch read zu ersetzen, um das Array beim Start der Simulation wieder zu füllen :zwinker:

[glkgereon]

aber ich hätte dann eine datei in der form:

Code:

[Name]
Unfall mit 30-Tonner
[Lauftext]
35-Jähriger erleidet schwere verletzungen an armen und beinen
[Text]
blablabla
.....
blablabla
.....
blablabla
.....
[Tipp]
mach dies
mach das
oder dies
oder das

und das ist nicht soo einfach.... :wink:

wo gibts denn zlib?

is dasn externes prog oder is das ne compo, bzw ne unit, wo entsprechende procedures drin sind?

[Jens Schumann]

Hallo,
ich gehe mal davon aus, das die Patienten in einer Collection (Array, verkettet Liste o TList usw)
gespeichert sind. Dann haben wir hier einen ganz klaren Anwendungsfall der Klasse

Code:

TmxJsCollection

aus der CodeLib
Die einzelnen Patienteneigenschaften sind published properties eines Nachfahren von
TCollectionItem. Dann ist das Speichern eines Memos auch gar kein Problem mehr. Wenn
man sich entschließt noch ein paar Patienteneigenschaften hinzuzufügen bekommt der
TCollection-Nachfahre noch ein paar published properties (können auch Bitmaps sein !!!)
und das wars. Um das Speichern der zusätzlichen properties muss man sich nicht kümmern.
Läuft automatisch!!!

[glkgereon]

also ich benutz diese unit, und dann?

als was muss ich meine "datenbank" dann deklarieren bzw wie kann ich diese benutzen?

[Jens Schumann]

Zitat:

Zitat von glkbkk

also ich benutz diese unit, und dann?

als was muss ich meine "datenbank" dann deklarieren bzw wie kann ich diese benutzen?

Ich vermute mal, du meinst mich.
Es reicht natürlich nicht die unit zu verwenden. Du musst Dir auch das Beispiel anschauen und
nachvollziehen. Der Aufwand lohnt sich. Wenn Du den Source und die OOP dahinter verstanden
hast, wirst Du erkennen, dass das Gespann TCollection/TCollectionItem einfach genial ist.

Jeder Patient wird durch ein Objekt repräsentiert. (Das sollte in den Zeiten der OOP natürlich
selbstverständlich sein). D.h. alle Patienteneigenschaften werden in den published properties
eines TCollectionItem-Nachfahren repräsentiert. TmxJsCollection verwaltet dann die einzelnen
PatientenObjekte.

Jetzt kommt der MegaVorteil der Sache!!!!!!!!
Wenn Du Dich entschließt zu den Patienten ein Bild zu speichern erweiterst Du das PatientenObjekt
um eine TBitmap Eigenschaft (natürlich im published Abschnitt). Das wars!!! Das Bild wird automatisch gespeichert. Wenn Du noch Dateien mit alten Patientendaten (ohne Bild) hast können die Dateien trotzdem gelesen werden. Das wäre bei einer typisierten Datei nicht der Fall.

[maximov]

Genau,

TmxJsCollection kann ich dir auch nur empfehlen! Da kannst du quasi vollautomatisch das dfm-persistenzierung-system benutzen, das einzige was du machen ist: SaveToFile/loadFromFile :wink:

@Jens: Hab für unsere collection ein template erstellt, womit die collection ein user-typ interface hat. Sehr geil, weil man nirgends mehr casten braucht. Werd ich demnächst mal posten.

[Eisenherz]

Zitat:

Zitat von Jens Schumann

Dann haben wir hier einen ganz klaren Anwendungsfall der Klasse

Code:

TmxJsCollection

aus der CodeLib

Wenn blkbkk damit Leben kann, dass er von TCollectionItem ableiten muss und nicht zu erwarten ist, dass die Datenstrukturen komplizierter werden, dann dürfte das der einfachste Weg sein. Ich finde es gut, dass mal jemand daran gedacht hat, dass man auch noch alte Dateiformate einlesen kann.

Wenn die Datenstrukturen aber komplexer werden, dann vermute ich, dass TmxJsCollection an seine Grenzen stoßen wird.

Da wäre z.B. Polymorphie.
Nehmen wir an blkbkk würde von der Klasse TPatient die Klassen TKassenPatient und TPrivatPatient ableiten. Er könnte die Instanzen dieser Klassen nicht in einer Collection halten, da Collections nur die Instanzen einer Klasse halten können.

Datenkapselung:
Es können nur published-Properties automatisch gespeichert werden. Das Speichern von Daten mit einer anderen Sichtbarkeit ist dann nicht mehr ganz so einfach.

Und was macht man, wenn man aus irgendeinem Grund nicht von TCollectionItem ableiten kann?

[Jens Schumann]

Zitat:

Zitat von Eisenherz

Wenn die Datenstrukturen aber komplexer werden, dann vermute ich, dass TmxJsCollection an seine Grenzen stoßen wird.

Eben nicht. TmxJsCollection kann n-dimensionale Strukturen speichern. Außerdem können die published
Properties auch wiederum Objekte sein. Diese Objekte müssen aber min von TPersistent abgeleitet sein.

Zitat:

Zitat von Eisenherz

Da wäre z.B. Polymorphie.
Nehmen wir an blkbkk würde von der Klasse TPatient die Klassen TKassenPatient und TPrivatPatient ableiten. Er könnte die Instanzen dieser Klassen nicht in einer Collection halten, da Collections nur die Instanzen einer Klasse halten können.

Aber genau das ist der klassische Anwendungsfall von Polymorphie (also der innerste Sinn der OOP)
Die Collection verwaltet dann Klassen vom Type TPatient. Da TKassenPatient und TPrivatPatient Nachfahren
von TPatient sind gibt es hier keine Probleme. Die Klassen müssen naturlich OOP mäßig gestylt sein.
Siehe TStrings und ff.

Zitat:

Zitat von Eisenherz

Datenkapselung:
Es können nur published-Properties automatisch gespeichert werden. Das Speichern von Daten mit einer anderen Sichtbarkeit ist dann nicht mehr ganz so einfach.

Wozu auch. Dann deklariert man die Properties eben als published. Wenn man unbedingt möchte das public properties gestreamt werden kann man noch mit DefineProperties arbeiten (überschreiben).

Zitat:

Zitat von Eisenherz

Und was macht man, wenn man aus irgendeinem Grund nicht von TCollectionItem ableiten kann?

Dann hat man wohl Pech gehabt. :wink:

[maximov]

Zitat:

Zitat von Jens Schumann

...Aber genau das ist der klassische Anwendungsfall von Polymorphie (also der innerste Sinn der OOP)
Die Collection verwaltet dann Klassen vom Type TPatient. Da TKassenPatient und TPrivatPatient Nachfahren
von TPatient sind gibt es hier keine Probleme. Die Klassen müssen naturlich OOP mäßig gestylt sein.
Siehe TStrings und ff.

Ich weiss nicht ob ich dich richtig verstehe, oder ob du eisenherz richtig verstehst :stupid: , aber du kannst tatsächlich nur item von einer klasse in einer kollektion halten! Was dir sicher auch bewust ist? ..das hatte eisenherz nämlich angeprangert.


Wenn man hierarchische strukuren will und verschiedene klassen, dann muss man halt TComponent nehmen oder selbst was schreiben :wink:

[Jens Schumann]

Zitat:

Zitat von maximov

Zitat:

Zitat von Jens Schumann

...Aber genau das ist der klassische Anwendungsfall von Polymorphie (also der innerste Sinn der OOP)
Die Collection verwaltet dann Klassen vom Type TPatient. Da TKassenPatient und TPrivatPatient Nachfahren
von TPatient sind gibt es hier keine Probleme. Die Klassen müssen naturlich OOP mäßig gestylt sein.
Siehe TStrings und ff.

Ich weiss nicht ob ich dich richtig verstehe, oder ob du eisenherz richtig verstehst :stupid: , aber du kannst tatsächlich nur item von einer klasse in einer kollektion halten! Was dir sicher auch bewust ist? ..das hatte eisenherz nämlich angeprangert.

Ist ist mir bewußt. Dummerweise aber nicht in dem Moment als ich die Antwort geschrieben habe. :wall:

[Eisenherz]

Zitat:

Zitat von Jens Schumann

Eben nicht. TmxJsCollection kann n-dimensionale Strukturen speichern. Außerdem können die published
Properties auch wiederum Objekte sein. Diese Objekte müssen aber min von TPersistent abgeleitet sein.

Du gehst hier davon aus, dass die Datenstrukturen hierarchisch sind. Solange das der Fall ist und man wirklich von TPersistent ableiten kann, ist deine Lösung super.
Aber oft hat man es mit relationalen Datenstrukturen zu tun. Objekte haben nur Reverenzen auf andere Objekte und sind nicht der Besitzer des anderen Objektes. Man kann sicherlich auch das mit TmxJsCollection lösen, dann ist es aber vorbei mit einfach nur published machen.

Zitat:

Zitat:

Zitat von Eisenherz

Datenkapselung:
Es können nur published-Properties automatisch gespeichert werden. Das Speichern von Daten mit einer anderen Sichtbarkeit ist dann nicht mehr ganz so einfach.

Wozu auch. Dann deklariert man die Properties eben als published.

Lass das bloß keinen OO-Fanatiker lesen. :zwinker:

Zitat:

Wenn man unbedingt möchte das public properties gestreamt werden kann man noch mit DefineProperties arbeiten (überschreiben)

Das meinte ich mit "nicht mehr ganz so einfach". Mit DefineProperties konnte ich mich nie richtig anfreunden.

Zitat:

Zitat:

Zitat von Eisenherz

Und was macht man, wenn man aus irgendeinem Grund nicht von TCollectionItem ableiten kann?

Dann hat man wohl Pech gehabt. :wink:

Nicht ganz, denn dafür habe ich eine Alternative anzubieten.

[glkgereon]

:gruebel: Ähh Ja, sicher doch :wiejetzt:

ich versteh jetzt nicht ganz was ihr meint, bzw worüber iohr euch grade im detail streitet, mir scheint aber das die kritikpunkte für mich total sekundär sind

ich will einfach nur 1 array haben

ich will das so in etwa haben (jetzt ausm kopf):

Code:

TZustand = record
             atem, herzschlag:integer
           end;
TPatient = record
             name, lauftext:string;
             story, tipps:TStringlist;
             zustand:TZustand;
           end;

...

var
Patienten:array of TPatient;

also das wär meine lösung (ich bin ein record-fanatiker *g*)

geht das mit dem package schnell und einfach?

[maximov]

Arrays sind binärer blödsinn und zum persistenzieren von datensätzen, die sich evtl. erweitern, verdammt lästig. Versteh mich nicht falsch, ich hab auch jahrelang mit typisierten dateien gearbeitet, aber irgendwann sieht man ein, dass das mehr ärger als nutzen bringt...

und JA das geht schnell und einfach! Leite einfach eine klasse von TCollectionItem (TPatient) ab und leite eine klasse von TPersistent ab (TZustand). Alle daten die du speichern willst deklariest du als published properties und erzeugst im konstruktor des items die nötigen unterobjekte (TZustand und die stringlisten). Dann nimmst du die TmxJsCollection (dpCollection unit -> codeLib) und fütterst sie mit der item-klasse. dann collection.saveToFile/loadfromFile...und alles wird gut :stupid:

[Jens Schumann]

Zitat:

Zitat von glkbkk

... bzw worüber iohr euch grade im detail streitet,...

Ich hatte nicht das Gefühl, dass wir uns hier gestritten haben.
Das Problem war nur, dass ich vorschnell in einem Zustand der völligen geistigen
Umnachtung (Blackout) eine Antwort geschrieben habe.

maximov hat Recht. Höre auf in Records zu Denken. Ich verwende Records nur noch wenn
es nicht anders geht. Z.B. wenn API's Records als Parameter erwarten.


P.S. Selbst hochgestellte Persönlichkeiten des öffentlichen Lebens
hatten schon das eine oder andere Blackout. Da kann ich mir so ein kleines
bestimmt leisten.

[Jens Schumann]

Hallo glkbkk,
ich habe Dir mal ein kleines Beispiel zusammengebastelt.
Hier ist die Umsetzung der Records in Klassen bzw. in Nachfahren von TPersistent
und TCollectionItem:

Delphi-Quellcode:

unit patient_impl;

interface

uses SysUtils, classes;

Type

  TZustand = class(TPersistent)
  private
    FAtem: Integer;
    FHerzschlag: Integer;
  public
    procedure Assign(Source : TPersistent); override; // Sollte immer überschrieben werden
  published
    property Atem       : Integer read FAtem write FAtem default 0;
    property Herzschlag : Integer read FHerzschlag write FHerzschlag default 0;
  end;

  TPatient = class(TCollectionItem)
  private
    FLaufText   : String;
    FName       : String;
    FTipps      : TStrings;
    FStory      : TStrings;
    FZustand    : TZustand;
    procedure SetStory(const Value: TStrings);
    procedure SetTipps(const Value: TStrings);
    procedure SetZustand(const Value: TZustand);
  public
    constructor Create(Collection : TCollection); override;
    destructor  Destroy; override;
    procedure   Assign(Source : TPersistent); override; // Sollte immer überschrieben werden
  published
    property Name     : String read FName write FName;
    property LaufText : String read FLaufText write FLaufText;
    property Story    : TStrings read FStory write SetStory;
    property Tipps    : TStrings read FTipps write SetTipps;
    property Zustand  : TZustand read FZustand write SetZustand;
  end;

implementation

{ TZustand }

procedure TZustand.Assign(Source: TPersistent);
begin
  If Source is TZustand then
    begin
    FAtem:=TZustand(Source).Atem;
    FHerzschlag:=TZustand(Source).Herzschlag;
    end;
  inherited Assign(Source);
end;

{ TPatient }

procedure TPatient.Assign(Source: TPersistent);
begin
  If Source is TPatient then
    begin
    FLaufText:=TPatient(Source).LaufText;
    FName:=TPatient(Source).Name;
    FTipps.Assign(TPatient(Source).Tipps);
    FStory.Assign(TPatient(Source).Story);
    FZustand.Assign(TPatient(Source).Zustand);
    end;
  inherited Assign(Source);
end;

constructor TPatient.Create(Collection: TCollection);
begin
  inherited Create(Collection);
  FZustand:=TZustand.Create;
  FTipps:=TStringList.Create;
  FStory:=TStringList.Create;
end;

destructor TPatient.Destroy;
begin
  FStory.Free;
  FTipps.Free;
  FZustand.Free;
  inherited Destroy;
end;

procedure TPatient.SetStory(const Value: TStrings);
begin
  FStory.Assign(Value);
end;

procedure TPatient.SetTipps(const Value: TStrings);
begin
  FTipps.Assign(Value);
end;

procedure TPatient.SetZustand(const Value: TZustand);
begin
  FZustand.Assign(Value);
end;

end.

[maximov]

Moin.

Darfs vielleicht noch ein template sein? Womit die benutzung entgültig einfacher nicht geht und tausendmal praktischer als irgend ein array ist (zur funktionsweise der templates siehe links im code):

Delphi-Quellcode:

{$IFNDEF TYPED_DP_COLLECTION_TEMPLATE}
unit dpCollection_tmpl;

// written by MaxHub (maximov) 10.07.2004

// dpCollection: [url]http://www.delphipraxis.net/topic28945_tcollection+und+tcollectionitem.html[/url]

// thanks to Thomas Mueller for his 'Object Pascal Templates' article
// -> [url]http://www.dummzeuch.de/delphi/object_pascal_templates/deutsch.html[/url]

// thanks to Rossen Assenov for the original narticle 'Templates in Object Pascal'
// -> [url]http://community.borland.com/article/0,1410,27603,00.html[/url]

interface

uses Classes, dpCollection;


type
  _COLLECTION_ITEM_ = TCollectionItem;
{$ENDIF TYPED_DP_COLLECTION_TEMPLATE}

{$IFNDEF TYPED_DP_COLLECTION_TEMPLATE_SECOND_PASS}
type
  _COLLECTION_ = class (TmxJsCollection)
  protected  
    function  GetItem (const aIndex : Integer) : _COLLECTION_ITEM_;
    procedure SetItem (const aIndex : Integer;
                      const aValue : _COLLECTION_ITEM_);
    
  public
    constructor Create;

    function Add                                 : _COLLECTION_ITEM_;
    function FindItemID (const aID    : Integer) : _COLLECTION_ITEM_;
    function Insert     (const aIndex : Integer) : _COLLECTION_ITEM_;
    property Items      [const aIndex : Integer] : _COLLECTION_ITEM_ read GetItem write SetItem;
  end;


{$ENDIF TYPED_DP_COLLECTION_TEMPLATE_SECOND_PASS}

{$IFNDEF TYPED_DP_COLLECTION_TEMPLATE}
implementation
{$DEFINE TYPED_DP_COLLECTION_TEMPLATE_SECOND_PASS}
{$ENDIF TYPED_DP_COLLECTION_TEMPLATE}

{$IFDEF TYPED_DP_COLLECTION_TEMPLATE_SECOND_PASS}

{ TYPED_DP_COLLECTION }

constructor _COLLECTION_.Create;
begin
 inherited Create(_COLLECTION_ITEM_);
end;

function _COLLECTION_.Add : _COLLECTION_ITEM_;
begin
 Result := _COLLECTION_ITEM_ (inherited Add);
end;

function _COLLECTION_.FindItemID (const aID : Integer) : _COLLECTION_ITEM_;
begin
 Result := _COLLECTION_ITEM_ (inherited FindItemID (aID));
end;

function _COLLECTION_.GetItem (const aIndex : Integer) : _COLLECTION_ITEM_;
begin
 Result := _COLLECTION_ITEM_ (inherited GetItem (aIndex));
end;

function _COLLECTION_.Insert (const aIndex : Integer) : _COLLECTION_ITEM_;
begin
 Result := _COLLECTION_ITEM_ (inherited Insert (aIndex));
end;

procedure _COLLECTION_.SetItem (const aIndex : Integer;
                                const aValue : _COLLECTION_ITEM_);
begin
 inherited SetItem (aIndex, aValue);
end;

{$WARNINGS off}
{$IFNDEF TYPED_DP_COLLECTION_TEMPLATE}
end.
{$ENDIF TYPED_DP_COLLECTION_TEMPLATE}
{$ENDIF TYPED_DP_COLLECTION_TEMPLATE_SECOND_PASS}
{$DEFINE TYPED_DP_COLLECTION_TEMPLATE_SECOND_PASS}

Und einbinden kannst du es so:

Delphi-Quellcode:

interface

uses dpCollection, SysUtils, classes;

{!!! Hier die definitionen von jens -> TPatient etc. !!!}

{$define TYPED_DP_COLLECTION_TEMPLATE}
type
  _COLLECTION_ITEM_ = TPatient;     // typ der collectionItems festlegen
  {$INCLUDE 'dpCollection_tmpl.pas'}  // typisierte collection generieren
  TPatienten = _COLLECTION_;        // fertige collection eine sprechenden namen geben
  
...

mit der collection TPatienten kannst du kann alles machen und musst noch nicht mal casten :wink:

[glkgereon]

hmmm :gruebel: :gruebel:

den ersten code versteh ich eigentlich

aber den zweiten.... tut der dasselbe?

ich werd wohl ma den ersten nutzen....

thx :gruebel:

[maximov]

Zitat:

Zitat von glkbkk

hmmm :gruebel: :gruebel:

den ersten code versteh ich eigentlich

aber den zweiten.... tut der dasselbe?

ich werd wohl ma den ersten nutzen....

thx :gruebel:

Der trick ist, beide zu benutzen :wink: ..das template tust du einfach in eine extra datei ('dpCollection_tmpl.pas') und da wo ich geschrieben habe 'Und einbinden kannst du es so' das fügst in den code von jens ein, unterhalb der item deklaration. Als collection nimmst du dann TPatienten.

Ich bin mir nicht wirklich sicher, ob du das alles hier zu schätzen weisst. Naja egal...am besten du liest dir nochmal alles gut durch und vor allem die vielen kleinen anmerkungen, links und kommentare. Damit man nicht immer alles zweimal sagen muss :mrgreen:

[glkgereon]

vielleicht weiss ich es zu schätzen wenn ichs verstanden hab :wink:

ich wär euch erst m,al schon dankbar genug wenns einfach nur funzt....

thx :thuimb:

[maximov]

OK! Zum mitschreiben :-D

Delphi-Quellcode:

unit patient_impl;

interface 

uses dpCollection, SysUtils, classes; 


Type

  TZustand = class(TPersistent) 
  private 
    FAtem: Integer; 
    FHerzschlag: Integer; 
  public 
    procedure Assign(Source : TPersistent); override; // Sollte immer überschrieben werden 
  published 
    property Atem       : Integer read FAtem write FAtem default 0; 
    property Herzschlag : Integer read FHerzschlag write FHerzschlag default 0; 
  end; 

  TPatient = class(TCollectionItem) 
  private 
    FLaufText   : String; 
    FName       : String; 
    FTipps      : TStrings; 
    FStory      : TStrings; 
    FZustand    : TZustand; 
    procedure SetStory(const Value: TStrings); 
    procedure SetTipps(const Value: TStrings); 
    procedure SetZustand(const Value: TZustand); 
  public 
    constructor Create(Collection : TCollection); override; 
    destructor  Destroy; override; 
    procedure   Assign(Source : TPersistent); override; // Sollte immer überschrieben werden 
  published 
    property Name     : String read FName write FName; 
    property LaufText : String read FLaufText write FLaufText; 
    property Story    : TStrings read FStory write SetStory; 
    property Tipps    : TStrings read FTipps write SetTipps; 
    property Zustand  : TZustand read FZustand write SetZustand; 
  end; 


// mit dem einbinden des templates erzeugst du eine collection,
// die auf deine eigene item-klasse spezialisiert ist. 
// Du musst nix mehr casten!!!

{$define TYPED_DP_COLLECTION_TEMPLATE} 
type 
  _COLLECTION_ITEM_ = TPatient;     // typ der collectionItems festlegen 
  {$INCLUDE 'dpCollection_tmpl.pas'}  // typisierte collection generieren 
  TPatienten = _COLLECTION_;        // fertige collection eine sprechenden namen geben   

implementation 

{$INCLUDE dpCollection_tmpl.pas}

{ TZustand } 

procedure TZustand.Assign(Source: TPersistent); 
begin 
  If Source is TZustand then 
    begin 
    FAtem:=TZustand(Source).Atem; 
    FHerzschlag:=TZustand(Source).Herzschlag; 
    end; 
  inherited Assign(Source); 
end; 

{ TPatient } 

procedure TPatient.Assign(Source: TPersistent); 
begin 
  If Source is TPatient then 
    begin 
    FLaufText:=TPatient(Source).LaufText; 
    FName:=TPatient(Source).Name; 
    FTipps.Assign(TPatient(Source).Tipps); 
    FStory.Assign(TPatient(Source).Story); 
    FZustand.Assign(TPatient(Source).Zustand); 
    end; 
  inherited Assign(Source); 
end; 

constructor TPatient.Create(Collection: TCollection); 
begin 
  inherited Create(Collection); 
  FZustand:=TZustand.Create; 
  FTipps:=TStringList.Create; 
  FStory:=TStringList.Create; 
end; 

destructor TPatient.Destroy; 
begin 
  FStory.Free; 
  FTipps.Free; 
  FZustand.Free; 
  inherited Destroy; 
end; 

procedure TPatient.SetStory(const Value: TStrings); 
begin 
  FStory.Assign(Value); 
end; 

procedure TPatient.SetTipps(const Value: TStrings); 
begin 
  FTipps.Assign(Value); 
end; 

procedure TPatient.SetZustand(const Value: TZustand); 
begin 
  FZustand.Assign(Value); 
end; 

end.

...ok. hatte das include im implementation-teil vergessen. Das hättest du aber schnell gesehen, wenn du dir mal die links angesehen hättest. Schwamm drüber. Funktionert super! Und zwar so:

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, patient_impl;

type
  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
    collection:TPatienten;
  end;

var
  Form1: TForm1;

implementation



{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
  collection:=TPatienten.Create;
  with collection.Add do
  begin
    Name := 'horst';
    LaufText := '...';
    Zustand.Atem := 42;
    Zustand.Herzschlag := 180;
  end;
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  collection.saveTiFile('c:/patienten.db.txt.dfm');
  collection.Free;
end;

end.

hoffe jetzt wirds klarer?