Klasse nach Vergleich mit Feld in Klasse erzeugen

[DeddyH]

Ja eben, nach einem Blick auf sein Profil fiel mir auch gleich RTTI ein, da muss man dann nicht soviel selbst machen.

[Blup]

Im Prinzip muss die Factory die zu erzeugenden Klassen nicht einmal konkret kennen.
So kann man später beliebige Unterklassen ableiten, ohne TParentClass zu ändern:

Delphi-Quellcode:

unit UnitParentClass;

interface

uses
  Classes, Contnrs, SysUtils;

type
  TChildClassParams = record
    {...}
  end;

  TParentClass = class;
  TChildClassType = class of TParentClass;

  TParentClass = class
  private
    class var
      FClassList: TClassList;
    class procedure FreeList;
  protected
    class procedure Register(AClassType: TChildClassType);
    class function New(AParams: TChildClassParams; var AInstance: TParentClass): Boolean; virtual; abstract;
  public
    class function CreateInstance(AParams: TChildClassParams): TParentClass;
  end;

implementation

{ TParentClass }

class function TParentClass.CreateInstance(AParams: TChildClassParams): TParentClass;
var
  p: Pointer;
begin
  Result := nil;
  if Assigned(FClassList) then
  begin
    for p in FClassList do
    begin
      if TChildClassType(p).New(AParams, Result) then
        Exit;
    end;
  end;
end;

class procedure TParentClass.FreeList;
begin
  FreeAndNil(FClassList);
end;

class procedure TParentClass.Register(AClassType: TChildClassType);
begin
  if not Assigned(FClassList) then
    FClassList := TClassList.Create;

  FClassList.Add(AClassType);
end;

initialization

finalization
  TParentClass.FreeList;

end.

Delphi-Quellcode:

unit UnitChildClass;

interface

uses
  UnitParentClass;

type
  TChildClass = class(TParentClass)
  protected
    class function New(AParams: TChildClassParams; var AInstance: TParentClass): Boolean; override;
  end;

implementation

{ TChildClass }

class function TChildClass.New(AParams: TChildClassParams;
  var AInstance: TParentClass): Boolean;
begin
  Result := {AParams = ???} True;
  if Result then
    AInstance := Self.Create;
end;

initialization
  TChildClass.Register(TChildClass);

end.

[ChEeTaH]

Zitat:

Zitat von shmia (Beitrag 1158702)

Anstatt jede einzelne Klasse zu testen kann man auch alle registrierten Klassen in einer Schleife testen (aber dazu benötigt man fortgeschrittene Techniken, die ich im Moment nicht erklären möchte)

Genau das würde mich interessieren. Ich habe bis jetzt eine TObjectList implementiert, wenn man das ohne manuelles einfügen der Objekte in die TObjectList lösen kann wäre das sehr praktisch.

[himitsu]

Du kannst deine Klassen bei einer generischen

Delphi-Quellcode:

TList<TChildClassType>

registrieren und dann diese durchsuchen.

Man könnte auch z.B. ein

Delphi-Quellcode:

TDictionary<string, TChildClassType>

nutzen, wo dann der der "Schlüssel" nicht in der Klasse steht, sondern in der Liste.
Dort würde dann eine einzige Suchanfrage an diese Liste sofort die Klasse liefern.

[shmia]

Zitat:

Zitat von ChEeTaH (Beitrag 1158725)

Zitat:

Zitat von shmia (Beitrag 1158702)

Anstatt jede einzelne Klasse zu testen kann man auch alle registrierten Klassen in einer Schleife testen (aber dazu benötigt man fortgeschrittene Techniken, die ich im Moment nicht erklären möchte)

Genau das würde mich interessieren.

Das ist genau das, was Blup im Beitrag #12 gezeigt hat.
Jede Child-Klasse muss zunächst registriert werden.
Er hat dann aber einen etwas indirekten Weg über die virtuelle Methode New eingeschlagen um ein Objekt einer bestimmten Klasse zu erzeugen.
Der Standardweg wäre aber einen virtuellen Konstruktor in der Basisklasse einzuführen, der dann in allen Child-Klassen überschrieben werden muss.

So macht es z.B. die VCL mit der Klasse TComponent.
Der Konstruktor ist virtuell damit zur Laufzeit immer der richtige Code ausgeführt wird.
Die hat aber zur Konsequenz dass es nur noch einen Konstruktor geben darf.