Generics, dynamische Listen und Kinds

[pustekuchen]

Hallo zusammen,

ich überlege mir grade für ein neues Projekt die Klassenstruktur und die vorgehensweise und habe dabei ein paar Probleme mit den Generics.

Es ist folgendermaßen:

Ich habe eine Aufzählung:

Delphi-Quellcode:

TObjectKind = (okNone, okFoo, okBar);

Für Foo und Bar gibt es auch eigene Klassen TFoo, TBar.

Nun möchte ich in einem weiteren Klasse den ObjektKind und eine TObjectList speichern. Dabei soll dann je nach ObjektKind eine Liste von diesem Typ erzeugt werden.

Delphi-Quellcode:

TMain = class(TObject)
private 
 FObjectKind: TObjectKind;
 FList: TObjectList<T??>; // Wie muss es hier deklariert werden?
public
 property List: TObjectList<T??> read FList write FList; // Und hier?
 constructor Create(AObjectKind: TObjectKind);
end;

implementation
constructor TMain.Create(AObjectKind: TObjectKind);
begin
 FObjectKind = AObjectKind;
 // Hier soll je nach ObjectKind dann die Liste erstellt werden 
 case FObjectKind of
  okFoo: FList := TObjectList<TFoo>;
  okBar: FList := TObjectList<TBar>;
end;
end;

Ich würde es gerne so machen, da das ganze dynamisch sein soll, wenn mal der ObjektKind erweitert wird.
Und den Zugriff auf die Listen vereinfachen, indem dann in einer anderen Klasse eine List<TMain> existiert in der alle Liste nach dem ObjectKind vorhanden sind.

Und wie könnte man das ganze mit einem TDictionary machen.

Delphi-Quellcode:

TDictionary<TObjectKind ,TObjectList<T??>>; // Für TFoo, TBar ?

Ich hoffe ich habe mich verständlich ausgedrückt :) Ich freue mich auf eure Antworten.

lg
pustekuchen

[Elvis]

Warum verpasst du TMain nicht auch ein T?

[Stevie]

Bei deinem ObjectKind hast du die Entscheidung zur Laufzeit, bei Generics zur Compilezeit.

Entweder du machst deine ganze TMain Klasse generisch und definierst darüber, was dort drin steht (und verzichtest auf das ObjectKind), sofern das zur Compiletime schon entschieden werden kann (verlagert evtl die Logik, ob foo, bar oder none). Oder du benutzt für foo und bar eine gemeinsame Basisklasse. Bringt allerdings einige eher unschöne hardcasts mit sich.

Ich würde hier also folgendes vorschlagen:

Delphi-Quellcode:

type
  TMain = class(TObject)
  // ...
  end;

  TMain<T> = class(TMain)
  private
    FList: TObjectList<T>;
  public
    constructor Create;
    property List: TObjectList<T> read FList; 
  end;

implementation

constructor TMain<T>.Create;
begin
  inherited Create;

  FList := TObjectList<T>;
end;

Wenn du bei TMain noch zur Laufzeit wissen willst, von welchem Typ T ist, kannst du dort noch eine Property von TClass oder PTypeInfo einführen, welche dann vom TMain<T> constructor übergeben wird.

[pustekuchen]

Danke für eure Antworten.

Foo und Bar haben eine gemeinsame Basisklasse(Ich sag jetzt einfach mal TBasic zur vereinfachung). Wie würde man dann vorgehen? Rein aus interesse.
Ich werde dann wahrscheinlich die TMain<T> Lösung bevorzugen, wenn es eleganter und sauberer ist.

Edit: Ein Problem gibt es jedoch. Da ich keine Zuordnung der ObjectKind zu den Klassen habe, kann ich die TMain Klasse nicht dynamisch erstellen. Die Frage ist, ob es überhaupt Sinn macht das dynamisch zu machen, da sich der ObjectKind ehr selten ändern wird.


Edit2: So ganz will das ganze noch nicht klappen. Er meckert bei TObjectList<T> nun :

Delphi-Quellcode:

E2511 Typparameter 'T' muss ein Klassentyp sein

Wenn ich

Delphi-Quellcode:

TMain<T: class>

nehme, erhalte ich diese Meldung:

Delphi-Quellcode:

E2010 Inkompatible Typen: 'System.Generics.Collections.TObjectList<Main.TMain<T>.T>' und 'class of System.Generics.Collections.TObjectList<Main.TMain<T>.T>'

Edit3: das .Create fehlte...

lg
pustekuchen