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:

zusammenfalten · markieren

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

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

markieren

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.

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

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

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

Etwa so:

zusammenfalten · markieren

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;

Zitat von 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.

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

zusammenfalten · markieren

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:

markieren

Delphi-Quellcode:

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

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

Zitat von stahli:

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

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.

Zitat von Uwe Raabe:

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

zusammenfalten · markieren

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

Zitat von 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.

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