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