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