TObjectList mit gemeinsamen Eigenschaften

[norwegen60]

Hallo,

ich habe eine TObjectList die unterschiedliche Klassen verwaltet, die nicht auf eine gemeinsame Basis zurück geführt werden können.
Jetzt möchte ich jedem Eintrag in der Liste zusätzliche, für alle Einträge gleiche, Eigenschaften anhängen.

Geht das?

Beispiel:

Delphi-Quellcode:

  TAuto = class
    ..
  end;

  THaus = class
    ..
  end;

  TObjList = class(TObjectList<TObject>)
  private
    FId: Integer;
    FName: string;
  public
    property Id: Integer read FId write FId;
    property name: string read FName write FName;
  end;

Jetzt möchte ich z.B. jedes mal wenn die Liste erstellt wird, jedem Eintrag (also dem Auto, dem Haus, ...) die Uhrzeit anhängen wann der Eintrag in die Liste aufgenommen wurde. Sobald die Liste gelöscht wird, ist auch diese Information wieder gelöscht.
Das Beispile ist nur zum deutlich machen meines Anliegens und nicht um über Sinn oder Unsinn des Konstrukts zu diskutieren. Real geht es darum den Status einzelner Einträge in der Liste zu überwachen.
Wo immer möglich verwende ich schon heute klassifizierte Listen.


Grüße und Danke
Gerd

[stahli]

Wenn ich Dich richtig verstehe, könntest Du Deine Objekte kapseln...

Delphi-Quellcode:

MyRecordOderClass = record/class
  TS: TDateTime;
  State: Integer;
  MyObject: TObject;
end;

Dann müsstest Du immer dieses kapselnde Objekt speichern.


Oder Du benutzt an anderer Stelle ein Dictionary, in dem Du zu jedem Objekt den Zeitstempel+Status speicherst.

[norwegen60]

Das mit dem Kapseln wäre ein Ansatz, bedeutet aber einen ziemlichen Umstellungsaufwand da alle Zugriffe ja jetzt noch zusätzlich über MyClass müssen.

Bei einem parallel geführten Dictionary habe ich kein so gutes Gefühl. Lieber wäre mir alles in eine Klasse/Liste

Trotzdem Danke

[mkinzler]

Ein Class Helper für TObject wäre auch noch eine Option

[stahli]

Du kannst Dir natürlich auch eine TMyStateObjectList bauen, die die klassische Objektlist und das Dictionary sowie auch sämtliche Zugriffe kapselt.

Etwa so:

Delphi-Quellcode:

TMyState = record
  TS: TDateTime;
  State: Integer;
end;

TMyStateObjectList = class
  fObjectList: TObjectList;
  fDictionary: TDictionary(TObject/TMyState);
  procedure AddObject(aObject: TObject);
  function GetObject(aIndex: Integer): TObject;
  function GetState(aIndex: Integer): TMyState;
end;

[Uwe Raabe]

Zitat:

Zitat von norwegen60 (Beitrag 1402565)

Das mit dem Kapseln wäre ein Ansatz, bedeutet aber einen ziemlichen Umstellungsaufwand da alle Zugriffe ja jetzt noch zusätzlich über MyClass müssen.

Das kommt darauf an. Du könntest auch zusätzliche Zugriffsroutinen deklarieren:

Delphi-Quellcode:

type
  TAuto = class
  end;

  THaus = class
  end;

  TItem<T: class> = class
  private
    FInstance: T;
    FId: Integer;
    FName: string;
  public
    constructor Create(AInstance: T; AId: Integer; const AName: string);
    property Instance: T read FInstance;
    property Id: Integer read FId;
    property Name: string read FName;
  end;


  TObjList = class(TObjectList<TObject>)
  private
    FId: Integer;
    FName: string;
  public
    function Add<T: class>(AInstance: T): Integer;
    function AsItem<T:class>(Index: Integer): T;
    property Id: Integer read FId write FId;
    property name: string read FName write FName;
  end;

constructor TItem<T>.Create(AInstance: T; AId: Integer; const AName: string);
begin
  inherited Create;
  FInstance := AInstance;
  FId := AId;
  FName := AName;
end;

function TObjList.Add<T>(AInstance: T): Integer;
begin
  Result := inherited Add(TItem<T>.Create(AInstance, Id, name));
end;

function TObjList.AsItem<T>(Index: Integer): T;
begin
  Result := (Items[Index] as TItem<T>).Instance;
end;

Zugriff dann in etwa so:

Delphi-Quellcode:

myList.Add<TAuto>(MyAuto);
myList.Add<THaus>(MyHaus);

myAuto := myList.AsItem<TAuto>[idx];
myHaus := myList.AsItem<THaus>[idx + 1];

[norwegen60]

Zitat:

Zitat von stahli (Beitrag 1402567)

Du kannst Dir natürlich auch eine TMyStateObjectList bauen, die die klassische Objektlist und das Dictionary sowie auch sämtliche Zugriffe kapselt.

Auch eine gute Idee. Damit könnte ich auf die die Liste wie gehabt zugreifen und den Status eine Stufe höher umzustellen. Und dann sukzessive auf eine Ebene höher umstellen. Damit wäre es vielleicht sogar mögliche, das lästige Type casting in dies übergeordnete Klasse zu legen. Werde ich mir mal ein paar Gedanken zu machen.

Eigentlich hatte ich gehofft, dass es einen Weg gibt, dies neuen Eigenschaften direkt den neuen Listenelementen zuweisen zu können.

Danke
Gerd

[himitsu]

Jupp, über Class Helper "gleicheartige" Teile überall anhängen geht, aber dennoch muß dann immernoch für jede Klasse eine eigene Behandlung eingebaut werden und dazu auch ein harter Cast genau auf diese Typen.

Alternativ könnte man auch via RTTI auf "gleichnamige" Teile zugreifen, bzw. vorher auf deren Existenz prüfen, egal welche Klassen in der Liste sind.

[norwegen60]

Zitat:

Zitat von Uwe Raabe (Beitrag 1402576)

Das kommt darauf an. Du könntest auch zusätzliche Zugriffsroutinen deklarieren:

Das geht genau in die Richtung wie ich gerade geantwortet habe. Nur das mit dem

Delphi-Quellcode:

TItem<T: class> = class
  private
    FInstance: T;
    FId: Integer;
    FName: string;
  public
    constructor Create(AInstance: T; AId: Integer; const AName: string);
    property Instance: T read FInstance;
    property Id: Integer read FId;
    property Name: string read FName;
  end;

ist mir noch nicht ganz klar was das macht. Ich werde mich mal rein arbeiten. Ein Ansatzpunkt ist da

Danke

[norwegen60]

Zitat:

Zitat von himitsu (Beitrag 1402578)

Jupp, über Class Helper "gleicheartige" Teile überall anhängen geht, aber dennoch muß dann immernoch für jede Klasse eine eigene Behandlung eingebaut werden und dazu auch ein harter Cast genau auf diese Typen.

Das mit der Behandlung jeder Klasse habe ich ja jetzt schon. Das mit "Class Helper" geht wohl in die Richtung. Ich schaus mir an

[himitsu]

Class Helper ändert an der Art des Zugriffes nichts, aber es trennt den Code nach Klassen auf.
Also statt alles in eine große Zugriffsfunktion, ist dort dann nur noch ein IS, der Cast mit Zugriff auf den Helper (anstatt die Klasse abzuleiten und es da direkt einzubauen) und der Rest liegt dann in den jeweiligen Helpern (oder Ableitungen).