Klassische vs. generische Objektliste: auf eine Methode irgendeiner Liste zugreifen

[Bbommel]

Hallo zusammen,

ich habe langsam einen kleinen Knoten im Kopf. Möglicherweise geht das, was ich will, auch einfach gar nicht, möglicherweise kenne ich aber auch einfach nur irgendwelche Sprachfeatures nicht richtig. Ich möchte mehrere Objektlisten in einer "Ober-Liste" sammeln und dann diese Ober-Liste durchgehen und in jeder der einzelnen Liste eine bestimmte Methode aufrufen, wie z.B. "Clear". Mit einer klassichen TObjectList geht das problemlos.

Folgendes Beispiel zur Veranschaulichung:

Delphi-Quellcode:

unit Unit1;

interface

uses
  System.Contnrs, System.Generics.Collection;

type
  TBaseClass = class
    someValue: string;
  end;

  TFirstClass = class(TBaseClass)
    otherThings: string;
  end;

  TSecondClass = class(TBaseClass)
    moreThings: string;
  end;

  TThirdClass = class(TBaseClass)
    funnyThings: string;
  end;

  TAllData = class
  private
    ListOfAllLists: TObjectList;
  public
    FirstList: TObjectList;
    SecondList: TObjectList;
    ThirdList: TObjectList;

    constructor Create;
    destructor Destroy;
    function CreateAndAddList: TObjectList;
    procedure ClearAll;
  end;

implementation

{ TAllData }

constructor TAllData.Create;
begin
  ListOfAllLists:=TObjectList.Create;
  FirstList:=CreateAndAddList;
  SecondList:=CreateAndAddList;
  ThirdList:=CreateAndAddList;
end;

destructor TAllData.Destroy;
begin
  ListOfAllLists.Free;
end;

function TAllData.CreateAndAddList: TObjectList;
begin
  Result:=TObjectList.Create;
  ListOfAllLists.Add(Result);
end;

procedure TAllData.ClearAll;

var
  i: integer;

begin
  for I := 0 to ListOfAllLists.Count-1 do
    TObjectList(ListOfAllLists[i]).Clear;
end;

end.

So, nun könnte man ja auf die Idee kommen: hey, nehmen wir doch mal so modernes Zeug wie ein TObjectList<T>, weniger casten, mehr Typsicherheit, feine Sache. Die Deklaration von AllData wäre dann also in etwa so:

Delphi-Quellcode:

  TAllData = class
  private
    ListOfAllLists: TObjectList;
  public
    FirstList: TObjectList<TFirstClass>;         // <--- hier die Änderung!
    SecondList: TObjectList<TSecondClass>;       // <--- hier die Änderung!
    ThirdList: TObjectList<TThirdClass>;         // <--- hier die Änderung!

    constructor Create;
    destructor Destroy;
    function CreateAndAddList: TObjectList;
    procedure ClearAll;
  end;

Abgesehen davon, dass sich auch das Erstellen des Objekts und seiner Listen ändern muss, schauen wir hier jetzt nur mal beispielhaft auf das ClearAll:

Delphi-Quellcode:

procedure TAllData.ClearAll;

var
  i: integer;

begin
  for I := 0 to ListOfAllLists.Count-1 do
    TObjectList<T>(ListOfAllLists[i]).Clear;
end;

So wie es hier steht, also mit einem Cast auf "TObjectList<T>" geht es schon mal nicht, weil es "T" nicht gibt - okay, logisch. Würde ein Cast auf "TObjectList<TBaseClass>" sinnvoll sein? Kann man das überhaupt machen, irgendwie sinnvoll casten? Ich möchte ja auf die Methoden der Liste selbst zugreifen, d.h. der Typ der Elemente in der Liste ist mir an der Stelle ja völlig wurscht.

Ich möchte da jetzt auch keinen riesigen Aufwand drumherum reinstecken - zur Not werden halt die einzelnen Listen doch separat aufgerufen oder ich nehme klassische Objektlisten, wäre beides kein Drama. Aber dennoch will ich natürlich wissen: geht das?

Danke fürs Lesen bis hierher!

Bis denn
Bommel

[mkinzler]

ListOfAllLists: TObjectList<TBaseClass>; sollte funktionieren

[Neutral General]

Zitat von mkinzler:

ListOfAllLists: TObjectList<TBaseClass>; sollte funktionieren

Leider nicht.
TObjectList<TBaseClass> gilt nicht als Basisklasse von TObjectList<TFirstClass> etc.
Anmerkung: Es wird wahrscheinlich funktionieren, aber nur weil das Layout der Methoden aller generischen Objektlisten im Speicher identisch ist und Clear nichts T-spezifisches tut.
Genauso würde

TObjectList<TButton>(ListOfAllLists[i]).Clear;

funktionieren

[Bbommel]

Zitat von Neutral General:

TObjectList<TBaseClass> gilt nicht als Basisklasse von TObjectList<TFirstClass> etc.
Anmerkung: Es wird wahrscheinlich funktionieren, aber nur weil das Layout der Methoden aller generischen Objektlisten im Speicher identisch ist und Clear nichts T-spezifisches tut.

Danke euch für ein erstes Feedback! Genau so etwas habe ich mir auch schon gedacht, dass das so gehen könnte. Aber da es eigentlich darum gehen sollte, den Code etwas eleganter und "schöner" zu machen, fände ich eine solche Konstruktion für den Zweck nicht so richtig zielführend.

[Stevie]

Einfach einen Alias machen: type TObjectList = TObjectList<TObject>; und schon kannst den hardcast so lassen. System.Contnrs sollte dann natürlich nicht mehr parallel eingebunden und genutzt werden.

Alternativ kannst du natürlich auch ListOfAllLists: TObjectList<TObjectList<TObject>>; deklarieren. Allerdings musst du dann wegen der fehlenden generischen Varianz nicht einfach deine FirstList, SecondList und ThirdList da rein packen

In Spring4D haben wir das mit dem IObjectList Interface gelöst - siehe: http://delphisorcery.blogspot.de/201...-variance.html

[Bbommel]

Hallo Stevie, Danke für den Link - das hat als Hintergrundinfo zum Verständnis sehr geholfen!