Generics: Instanz-Erzeugung in generischer Klasse

[stahli]

Hmm, ich hätte auch gedacht, dass T in dem Fall TButton entspricht und entsprechend T.Create(nil) möglich sein müsste.
Ist das dann als Bug bzw. fehlendes Feature anzusehen oder geht das Problem vom Konzept her völlig in Ordnung?

[himitsu]

Also, du mußt auf jeden Fall "irgendwie" das virtuelle Create(...) der TComponents aufrufen.

Das ist eben ein krankes Problem der Generics ... du hast zwar gesagt, es sollen nur TComponent und Nachfolger sein, aber scheinbar bieten dir die Generigs nur TObject und Nachfolger an, beim Zugriff auf Methoden, also nur das standardmäßige Create des TObjekts (ohne Vererbung).

Ich würde auch zu TComponentClass(T).Create(nil) tendieren. (wenn ich nicht ständig Probleme bei Typecasts hätte)


Das T(GetTypeData(Info)^.ClassType.Create); geht jedenfalls genauso wenig, da es ebenso wieder nur das Standard-TObject-Create aufruft.
Wenn, dann muß man sich über die RTTI schon das richtige Create besorgen.

Wäre ja schön gewesen, wenn man in TObject das Create virtuell gemacht hätte, dann könnte man dort das Standard-Create auf das entsprechende Create der entsprechenden Komponentenklasse umleiten können. (bei TComponent hätte man Create auf Create(nil) weiterleiten können, wärend bei "ältesten" Create(nil) dann auf inherited Create geleitet)

[Sir Rufo]

Jo, merci erst mal ... obschon das alles nicht zum Ziel geführt hat ... mich dünkt wohl auch warum ...

Zitat von stahli:

Hmm, ich hätte auch gedacht, dass T in dem Fall TButton entspricht und entsprechend T.Create(nil) möglich sein müsste.
Ist das dann als Bug bzw. fehlendes Feature anzusehen oder geht das Problem vom Konzept her völlig in Ordnung?

Ich denke mal nicht, denn in der generischen Klasse ist TButton nicht bekannt sondern nur abstrakt als T (irgendwas ab TComponent).
Nachfahren von TComponent können aber auch den Constructor überschreiben:

Delphi-Quellcode:

TMyComponent = class(TComponent)
public
  constructor Create; reintroduce;
end;

und schon gibt es für diese Ableitung kein Create(AOwner:TComponent) mehr.

Womöglich ist das so nicht anders machbar, aber da ich auch keine Lust habe für jedwede Ableitung von TComponent ein Interface zu implementieren, behelfe ich mir nun so, dass ich einfach eine Dummy-Instanz beim Erzeugen mitgebe.
(Diese Dummy-Instanz wird dann am Schluss von selbiger einfach ins Nirwana geschickt)

Delphi-Quellcode:

var
  MyButton : IGenericLink<TButton>;
begin
  MyButton := TGenericLink<TButton>.Create( TButton.Create( nil ) );
  MyButton.Link.OnClick := ButtonClick; // jetzt rummst auch nix mehr ... logisch
end;

Nicht schön, aber funktioniert

[r2c2]

Zitat von Sir Rufo:

Ich denke mal nicht, denn in der generischen Klasse ist TButton nicht bekannt sondern nur abstrakt als T (irgendwas ab TComponent).

Genau das ist das Problem, ja.

Zitat:

Nachfahren von TComponent können aber auch den Constructor überschreiben:

Delphi-Quellcode:

TMyComponent = class(TComponent)
public
  constructor Create; reintroduce;
end;

und schon gibt es für diese Ableitung kein Create(AOwner:TComponent) mehr.

Das stimmt nicht. Du siehst doch schon am reintroduce, dass hier nichts überschrieben, sondern maximal verdeckt wird. Der alte Konstruktor existiert also weiterhin. Zudem unterscheiden sich die Signaturen, was bedeutet, dass das reintroduce unnötig ist, da noch nichtmal verdeckt, sondern nur überladen wird.

Was mich ja eher irritiert, ist dass das der Compiler TButton hier überhaupt zulässt. Ich bin jetzt kein experte in Delphi-Generics, aber TGenericLink<T: TComponent, Constructor> bedeutet doch wohl, dass T einen parameterlosen Konstruktor haben muss. Und TButton hat AFAIR keinen. Das sollte der Compiler doch eigentlich bemeckern. Oder wo ist mein Denkfehler?

Im übrigen gibt es mit ziemlicher Sicherheit eine schönere Lösung, als dein Workaround. Vermutlich über RTTI. Sowas in der Art macht Delphi ja bei den Formulardaten, die aus den dfms gelesen werden. Auch da müssen TComponent-Nachfahren dynamisch erzeugt werden, ohne, dass die konkrete Klasse zur Designzeit schon klar wäre.

mfg

Christian

[Stevie]

Zitat von Sir Rufo:

Ich denke mal nicht, denn in der generischen Klasse ist TButton nicht bekannt sondern nur abstrakt als T (irgendwas ab TComponent).
Nachfahren von TComponent können aber auch den Constructor überschreiben:

Delphi-Quellcode:

TMyComponent = class(TComponent)
public
  constructor Create; reintroduce;
end;

und schon gibt es für diese Ableitung kein Create(AOwner:TComponent) mehr.

Das stimmt so nicht ganz. Du kannst immernoch TMyComponent.Create(MyOtherComponent) aufrufen. Zusätzlich sollte man niemals den Konstruktor eines TComponent ohne den Owner überschreiben, denn diesen benutzt auch die IDE, wenn man die Komponente auf dem Form platziert. Auch wenn du keine in der IDE registrierte Komponente baust.

Manchmal muss man, wenn man weiß, dass T von einem bestimmten Typ ist (da man ihn ja als Type constraint angegeben hat) trotzdem noch herumtricksen, da man nicht einfach alle Methoden dieses Typs benutzen kann.

TComponent(T).Create(nil) geht auf jeden Fall nicht.

Das hier geht:

Delphi-Quellcode:

type
  TGenericLink<T: TComponent> = class
  private
    FLink: T;
    function CreateComponent(AClass: TComponentClass): TComponent;
  public
    constructor Create;
    property Link: T read FLink;
  end;

function TGenericLink<T>.CreateComponent(AClass: TComponentClass): TComponent;
begin
  FLink := T(AClass.Create(nil));
end;

constructor TGenericLink<T>.Create;
begin
  CreateComponent(TComponentClass(T));
end;

Zitat von r2c2:

Im übrigen gibt es mit ziemlicher Sicherheit eine schönere Lösung, als dein Workaround. Vermutlich über RTTI. Sowas in der Art macht Delphi ja bei den Formulardaten, die aus den dfms gelesen werden. Auch da müssen TComponent-Nachfahren dynamisch erzeugt werden, ohne, dass die konkrete Klasse zur Designzeit schon klar wäre.

Delphi macht da nix über RTTI (was das Erzeugen des Objects angeht). Das geht nämlich erst mit der neuen RTTI ab 2010. Vorher gingen nur published Methoden und der Constructor ist nicht published. Es wird also genauso über die TComponentClass gemacht.

[Sir Rufo]

@Stevie
You Made My Day

[Stevie]

Always a pleasure

Mir fiel gerade noch auf, dass es doch mit nem "einfachen" cast ohne den Umweg über die extra Methode geht:

Delphi-Quellcode:

constructor TGenericLink<T>.Create;
begin
  FLink := T(TComponentClass(T).Create(nil));
end;

[webcss]

Zitat von Stevie:

Always a pleasure

Mir fiel gerade noch auf, dass es doch mit nem "einfachen" cast ohne den Umweg über die extra Methode geht:

Delphi-Quellcode:

constructor TGenericLink<T>.Create;
begin
  FLink := T(TComponentClass(T).Create(nil));
end;

Was ich bereits in Beitrag Nr.1 gesagt hatte, allerdings hatte ich das Class an TComponent vergessen, war halt schon spät

[SebE]

FLink := T(TComponentClass(T).Create(nil)); Ich habe hier ein Verständnisproblem.
Wird hier nicht nur TComponentClass erzeugt?
Wenn T "größer" sein sollte (T abgeleitet von TComponentClass), dann fehlt doch die Hälfte nach der Instanziierung, oder nicht?

Im Übrigen gibt es genau dieses Problem in C# auch.
Ich habe leider keine bessere Lösung als Delegates der Form:

Code:

{ return new myType(...); }

gefunden.