Hallo,

ich habe eine meine eigene Unterklasse TMyObjectList von TObjectList erstellt. Von TMyObjectList gbit es wiederrum eine Unterklasse TTestList, die TTestItems enthalten kann. Ein TTestItem kann ein TTestItemSubA oder TTestItemSubB sein. (Ich hab hier nur alle relevanten Teile gepostet, die echte Struktur ist komplexrer, daher muss die Aufteilung der Klassen so sein, wie sie ist.)

Wenn ich nun z.B. wie in Button2Click ein mit TTestItemSubB.Create ein TTestItemSubB erstelle, werden alle Konstruktoren in der Vererbungsreihenfolge aufgerufen:

TMyPersistent.Create
TTestItem.Create
TTestItemSubB.Create

Wenn ich nun allerdings wie z.B. in Button2Click / TMyObjectList<T>.LoadFromFile die Klasse mit T(MyClass.Create) erzeuge, wird KEINER der Konstruktoren aufgerufen. Warum? In TMyObjectList<T>.LoadFromFile möchte ich die Item-Klassen anhand ihres Namens erstellen, der als String aus einer Datei ausgelesen wird. Vermutlich liegt an der Stelle der Fehler?!

Vielen Danke für eure Hilfe!

zusammenfalten · markieren

Delphi-Quellcode:

unit Unit1;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, System.Contnrs, System.Generics.Collections, Vcl.StdCtrls;

type

  TMyPersistent = class(TPersistent)
  public
    constructor Create; virtual;
  end;

  TMyObjectList<T: TMyPersistent, constructor> = class(TObjectList<T>)
  public
    procedure LoadFromFile;
  end;

  TTestItem = class(TMyPersistent)
  public
    constructor Create; override;
  end;

  TTestItemSubA = class(TTestItem)
  public
    constructor Create; override;
  end;

  TTestItemSubB = class(TTestItem)
  public
    constructor Create; override;
  end;

  TTestList = class(TMyObjectList<TTestItem>)
  end;

  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}


procedure TForm1.Button1Click(Sender: TObject);
var
  TestList: TTestList;
begin
  TestList := TTestList.Create;
  try
    TestList.LoadFromFile;
  finally
    TestList.Free;
  end;
end;

procedure TForm1.Button2Click(Sender: TObject);
var
  TestList: TTestList;
  Item: TTestItemSubB;
begin
  TestList := TTestList.Create;
  try
    Item := TTestItemSubB.Create;
    TestList.Add(Item);
  finally
    TestList.Free;
  end;
end;

procedure TMyObjectList<T>.LoadFromFile;
var
  Item: T;
  NewClass: string;
  MyClass: TPersistentClass;
begin
  Clear;

  NewClass := 'TTestItemSubB'; //das wird für jedes Item aus einer Datei gelesen. Damit es einfacher ist, hier als fester String...
  MyClass := GetClass(NewClass);
  if Assigned(MyClass) then
  begin
    Item := T(MyClass.Create); <-- !!!! hier wird KEIN Konstruktor aufgerufen !!!
    Add(Item);
  end;

end;

constructor TTestItemSubA.Create;
begin
  inherited;
  ShowMessage('TTestItemSubA.Create');
end;

constructor TTestItemSubB.Create;
begin
  inherited;
  ShowMessage('TTestItemSubB.Create');
end;

constructor TMyPersistent.Create;
begin
  inherited;
  ShowMessage('TMyPersistent.Create');
end;

constructor TTestItem.Create;
begin
  inherited;
  ShowMessage('TTestItem.Create');
end;

initialization

RegisterClasses([TTestItemSubA, TTestItemSubB]);

end.

GetClass gibt TClass zurück.
Du mußt das erst nach TPersistent casten, um dessen virtuellen Constructor nutzen zu können, da TClass diesen nicht kennt.

[edit]
Hmmm, neee, GetClass stimmt.
Und der Cast T sollte diesen Constructor auch kennen, aber vielleicht klappt das nicht da TObjectList<T> nur TObject/TClass kennt und der Generic deswegen hier mal wieder nicht richtig funktioniert?

Ein kleiner Hack zum Testen?
TPersistent(Item) := MyClass.Create;

Zitat von himitsu:

Ein kleiner Hack zum Testen?
TPersistent(Item) := MyClass.Create;

Kein einziger Konstruktor wird aufgerufen. Komisch oder?

Nee nicht komisch.

markieren

Delphi-Quellcode:

MyClass: TPersistentClass; // Sollte das nicht eher sowas wie TMyPersistentClass sein?
// Also
Type TMyPersistentClass = class of TMyPersistent;

TPersistentClass ist ja class of TPersistent also wird der constructor von Persistent aufgerufen

Genau das. In TPersistent ist der Konstruktor ja auch nicht virtuell. Wäre er es, wäre es was anderes, aber so...

PS: Warum nicht einfach T.Create() ?

Zitat von Der schöne Günther:

PS: Warum nicht einfach T.Create() ?

Weil T ein TTestItem ist. Siehe hier: TTestList = class(TMyObjectList<***TTestItem***>)
Ich möchte aber Unterklassen von T erzeugen. Und zwar entweder TTestItemSubA oder TTestItemSubB. So wie es aus der Datei kommt, die ausgelesen wird.

T.Create würde mir also nur ein TTestItem erzeugen und nicht meine benötigten Unterklassen von T.

Ach stimmt, falsch gesehn.

markieren

Delphi-Quellcode:

TMyPersistent = class(TPersistent)
public
  constructor Create; virtual;
end;

Entweder das ist override aus TPersistent oder davor, dann kannst du TPersistent für das Create verwenden.

Ansonsten mußt du es vorher nach TMyPersistentClass casten und da dann das Create aufrufen.
Im prinzip

Zitat:

Item := TC(MyClass).Create; // TC = class of T;

, aber da sowas bei den Generics nicht geht, dann eben Item := T(TMyPersistentClass(MyClass).Create);


TPersistent oder war es TComponent , hat aber schon einen virtuellen Constructor und jenen solltest du unbedingt verwenden, da deine Klassen sonst mörderisch abrauchen, sollten sie jemals mit dem FormDesigner, bzw. dem DFM-Streaming im Berührung kommen,

Zitat von himitsu:

TPersistent oder war es TComponent , hat aber schon einen virtuellen Constructor und jenen solltest du unbedingt verwenden, da deine Klassen sonst mörderisch abrauchen, sollten sie jemals mit dem FormDesigner, bzw. dem DFM-Streaming im Berührung kommen,

Persistent hat keinen virtuellen constructor.

Type TMyPersistentClass = class of TMyPersistent;

Wenn Er den Classtype so deklariert hat genügt
es MyClass.Create aufzurufen. Kein casten oder ähnliches notwendig.
Ich würde in dem Fall sogar ein ebene höher gehen
und MyClass als TTestItemClass definieren.

Zitat von Fritzew:

Ich würde in dem Fall sogar ein ebene höher gehen
und MyClass als TTestItemClass definieren.

Vom Prinzip ändert es aber nichts.

Das was aus GetClass raus kommt muß früher oder später gecastet werden, um an den richtigen Constructor ranzukommen.

Zitat:

Kein einziger Konstruktor wird aufgerufen. Komisch oder?

Und um dass nochmal zu kommentieren.
Doch, es wurde definitiv ein Constructor aufgerufen ... nur halt nicht Deine(r).
> TObject.Create


PS: Der Constructor muß nicht unbedingt Create heißen.
Zum Testen kannst du ihn gern MyIrgendwas nennen und dann schauen was dabei passiert. (den "falschen" Create erwischst dann ja nicht mehr)
Im TMyPersistent.Create dann natürlich mit inherited Create; .

Benötigt man nicht in jedem Fall eine Klassenreferenz?

Hier wird das als Ergebnis festgestellt: https://www.delphipraxis.net/160537-...-erzeugen.html

Zitat:

Wenn ich den Aufruf so gestalte (...) habe ich
keinen Plusgewinn. Ich müsste dann jedes mal die Klassenreferenz kennen.
Dann kann ich den Konstruktor auch selbst aufrufen.

Casten kann man nur Objekte die schon existieren, also bereits ihren Konstruktor ausgeführt haben, dieser Weg ist daher auch nicht gegeben ("Henne-Ei-Problem").