[RTTI/Generics] verschiedene Generische klassen in Dictionary?

[Edlmann]

Nachmittag DP,

ich versuche im Moment ein generisches System zu programmieren, welches mir Erlaubt, Variablen verschiedenen Typs nach Bedarf zu erstellen und insbesondere auch mithilfe einer Konsole zu verändern. Das Grundgerüst der Klasse sieht wie folgt aus (Prozeduren sind ziemlich selbsterklärend):

Delphi-Quellcode:

  TConVar<T> = class
    m_sName, m_sDesc: String;
    m_flags: ConVarFlags;
    m_value, m_default: T;
    m_type: TRTTIType;
  public
    function GetValue: T; overload;
    procedure SetValue(Value: T; Force: Boolean); overload;
    function TestFlag(flag: ConVarFlag): Boolean;

    property Name: String read m_sName;
    property Description: String read m_sDesc;
    property Flags: ConVarFlags read m_flags;
  end;

Nun möchte ich diese Klassen über ein TDictionary verwalten, also a la:

_convars: TDictionary<String, TConVar>;
In C ist es ja möglich, die Deklaration wie folgt aufzubauen:

private static Dictionary<string, ConVar> _convars = new Dictionary<string, ConVar>();
Delphi jedoch stellt sich da stur, da TConVar nun keinen generischen Typ übergeben bekommt. Ist die Deklaration so überhaupt möglich?
Oder wie funktioniert so etwas?

(P.S. ich arbeite mich zurzeit erst in Generics/RTTI ein, kann also sein dass ich da einfach irgendwas übersehen hab)

Ich habe schon eine Variante mit Variants fertig gestellt, doch da ich es in einer SpieleEngine benutzen möchte (irgendwann in ferner Zukunft ) kommen diese Aufgrund der Performance nicht in frage. (Schreiben/Lesen bis zu 10x schneller mit Generics)

[himitsu]

Die Vererbung bei den Generics ist echt sch***, bzw. garnicht vorhanden.
Es gibt keinen Basistypen ala TConVar für dein TConVar<irgendwas>.

Rate mal, warum TList und TList<T> nicht kompatibel sind.


Soll heißen, wenn du mehrere Typen von einer generischen Klasse ableitest, dann sind diese nicht zueinander kompatibel.

Du kannst sie höchstens in eine billige TList packen, bzw. in Listen, welche den Basistyp TObjekt benutzen.



Sowas währe kompatibel zueinander, da alles auf das selbe TConVar zurückgeht.

Delphi-Quellcode:

TConVar = class
    m_sName, m_sDesc: String;
    m_flags: ConVarFlags;
    m_value: Pointer;
    m_type: TRTTIType;
  public
    function GetValue<T>: T; overload;
    procedure SetValue<T>(Value: T; Force: Boolean); overload;
    function TestFlag(flag: ConVarFlag): Boolean;

    property Name: String read m_sName;
    property Description: String read m_sDesc;
    property Flags: ConVarFlags read m_flags;
    property vType: TRTTIType read m_type;
  end;

oder

Delphi-Quellcode:

TConVar = class
    m_sName, m_sDesc: String;
    m_flags: ConVarFlags;
    m_value: TObject;
    m_type: TRTTIType;
  public
    function GetValue<T: object>: T; overload;
    procedure SetValue<T: object>(Value: T; Force: Boolean); overload;
    function TestFlag(flag: ConVarFlag): Boolean;

    property Name: String read m_sName;
    property Description: String read m_sDesc;
    property Flags: ConVarFlags read m_flags;
    property vType: TRTTIType read m_type;
  end;

[Edlmann]

Hab mir schon gedacht dass das in Delphi nicht so einfach sein kann...Das wär einfach zu...richtig.

[Edit]
Mmh... so könnts tatsächlich gehen, werd das mal ausprobieren,
vielen Dank

[Uwe Raabe]

So sollte es aber eigentlich gehen:

Delphi-Quellcode:

  TConVar = class
  strict protected
    m_sName: String;
    m_sDesc: String;
    m_flags: ConVarFlags;
  public
    function TestFlag(flag: ConVarFlag): Boolean;
    property Description: String read m_sDesc;
    property Flags: ConVarFlags read m_flags;
    property Name: String read m_sName;
  end;

  TConVar<T> = class(TConVar)
  private
    m_value: T;
    m_default: T;
    m_type: TRTTIType;
  public
    function GetValue: T; overload;
    procedure SetValue(Value: T; Force: Boolean); overload;
  end;

  TConvarDict = TDictionary<string,TConVar>;

[Phoenix]

Zitat von himitsu:

Die Vererbung bei den Generics ist echt sch***, bzw. garnicht vorhanden.
Es gibt keinen Basistypen ala TConVar für dein TConVar<irgendwas>.

Rate mal, warum TList und TList<T> nicht kompatibel sind.

Soll heißen, wenn du mehrere Typen von einer generischen Klasse ableitest, dann sind diese nicht zueinander kompatibel.

Das ganze nennt sich Kovarianz bzw. Kontravarianz (covariance / contravariance) und kam auch in .NET erst einige Zeit nachdem Generics eingeführt wurden in (4.0).

Das Problem ist eigentlich nicht der Generic an sich, sondern das Problem der Kompatibiltät / Vererbunghierachie der generischen parameter.

Ein TConVar<string> und ein TConVar<MyCustomType> lassen sich in .NET dadurch höchstens auf TConVar<object> vereinheitlichen. Nutzt Du constraints kannst Du höchstens auf den Constraint-Typen gehen. Aber auch das muss der Compiler erst einmal 'wissen' und umsetzen, und bei nicht ganz so typsicheren Sprachen wie Delphi ist das dann nochmal ne ecke komplizierter als in einer Welt, wo zumindest mal sichergestellt ist, das wirklich ALLES von Object ableitet (selbst der Typ 'Type').

Hier gibts nochmal Hintergrundinfos über die komplette Problemklasse und wie sie in .NET funktioniert: http://msdn.microsoft.com/en-us/library/dd799517.aspx