dynamisch Klassenkonstruktor aufrufen

[luisk]

Hallo,

ich will dynamisch entscheiden, von welcher Klasse ich Instanzen erzeugen will.

Ist das möglich ?
Dem Konstruktor sollen dabei auch Parameter übergeben werden.

[BUG]

Wer zu allgemeine Fragen stellt, bekommt auch zu allgemeine Antworten: Gut dir mal die mal die Creational-Pattern an.

[hoika]

Hallo,

< Ist das möglich ? >
Ja, das ist möglich ...

Um solche Klasse aber verwenden zu können,
muss entweder mit Interfaces oder mit einer gemeinsamen Basisklasse gearbeitet werden.

Oder mit vielen if's.


Heiko

[Stevie]

Dafür bietet Delphi Klassenreferenzen an:

Delphi-Quellcode:

type
  TPet = class
    constructor Create(const name: string); virtual;
  end;
  TPetClass = class of TPet;
  
  TDog = class(TPet);
  TCat = class(TPet);
  TParrot = class(TPet);

function CreateNewPet(petClass: TPetClass; const name: string): TPet;
begin
  Result := petClass.Create(name);
end;

...

var
  myDog: TDog;
  myParrot: TParrot;
begin
  myDog := CreateNewPet(TDog, 'Rex') as TDog;
  myParrot := CreateNewPet(TParrot, 'Polly') as TParrot;

Wenn das noch dynamischer gehen soll und es Klassen aus unterschiedlichen Vererbungshierarchien mit unterschiedlichen Parametern beim Konstruktor sind, dann bleibt noch die erweiterte RTTI (ab Delphi 2010).

[Dejan Vu]

Mit einer Classfactory geht das problemlos:

Delphi-Quellcode:

unit ClassFactory;

interface
uses
  SysUtils, Classes, Contnrs, SyncObjs;
Type
  TClassFactory = Class
  private
    fCS : TCriticalSection;
    fClasses : TClassList;
    fNames : TStringList;
  public
    Constructor Create;
    Destructor Destroy; Override;
    Procedure RegisterClass(Const aClassName : String; aClass : TClass);
    Function GetClass (Const aClassName : String) : TClass;
    Function GetInstance (Const aClassName : String) : TObject;
  End;

implementation

{ TClassFactory }

procedure TClassFactory.RegisterClass(const aClassName: String; aClass: TClass);
begin
  fCS.Enter;
  Try
    if fNames.IndexOf(aClassName)<>-1 then
      Raise exception.CreateFmt('Class %s already registered',[aClassname]);
    fNames.Add(aClassName);
    fClasses.Add(aClass);
  Finally
    fCS.Leave;
  End;
end;

constructor TClassFactory.Create;
begin
  fClasses := TClassList.Create;
  fNames := TStringList.Create;
  fNames.CaseSensitive := False;
  fCS := TCriticalSection.Create;
end;

destructor TClassFactory.Destroy;
begin
  fClasses.Free;
  fNames.Free;
  fCS.Free;
  inherited;
end;

function TClassFactory.GetClass(const aClassName: String): TClass;
Var
  i : Integer;

begin
  fCS.Enter;
  Try
    i := fNames.IndexOf(aClassName);
    if i=-1 then
      Raise Exception.CreateFmt('Class %s not registered',[aClassName])
    else
      Result := fClasses[i];
  Finally
    fCS.Leave;
  End;
end;

function TClassFactory.GetInstance(const aClassName: String): TObject;
Var
  c : TClass;

begin
  c := GetClass (aClassname);
  Result := C.Create;
end;

end.

Verwendung:

Delphi-Quellcode:

Var
  myClassFactory : TClassFactory;
  anApple, aPear : TObject;

begin
  myClassFactory := TClassFactory.Create;
  myClassFactory.RegisterClass('Apfel', TAppleClass);
  myClassFactory.RegisterClass('Birne', TPearClass);
  ...
  anApple := myClassFactory.GetInstance ('Apfel');
  aPear := myClassFactory.GetInstance('Birne');
...

Allerdings ist die Verwendung dieser Klassen irgendwie sinnlos, denn Du kennst ja die konkrete Schnittstelle nicht, weswegen der Zusatz von Hoika so wichtig ist.

Zitat von hoika:

Um solche Klasse aber verwenden zu können, muss entweder mit Interfaces oder mit einer gemeinsamen Basisklasse gearbeitet werden.

Das o.g. Pattern (die class factory) sollte man also für eine konkrete Basisklasse (oder noch besser: Interface) erstellen. Das geht über Generics sehr elegant.

[Stevie]

@Dejan Vu: Und wo werden da die Parameter übergeben? Außerdem wird durch den Aufruf von TClass.Create ein überschriebener Konstruktor niemals aufgerufen, weil immer der Konstruktor von TObject aufgerufen wird (weil er ja nicht virtual ist)

Zitat von Dejan Vu:

Das o.g. Pattern (die class factory) sollte man also für eine konkrete Basisklasse (oder noch besser: Interface) erstellen. Das geht über Generics sehr elegant.

Das versteh ich nicht. Was hat das jetzt mit Generics zu tun?

[Dejan Vu]

Ich wollte nur eine simples Code-Pattern für eine Klassenfabrik zeigen. Ich schrieb auch, das eine solche Fabrik zwar funktioniert, aber im konkreten Fall nichts taugt, und deshalb durch eine für eine konkrete Basisklasse implementierte Fabrik ersetzt werden muss. Diese 'Basisklasse' kann man (muss man aber nicht) mit Generics abbilden, sodaß eine Implementierung reicht. Verwendung in etwa so:

Delphi-Quellcode:

  myClass := myFactory<TFruit>.GetClass('Apfel');
  myInstance := myClass.Create('Booskop', Mittelgroß, FuerEinsFuffzichDasKilo);

Als konkrete Implementierung für Früchte kann ich dann (sofern der Konstruktor immer gleich ist), wieder mit GetInstance arbeiten.

Delphi-Quellcode:

  //
  myInstance := myFruitFactory.GetInstance('Booskop', Mittelgroß, FuerEinsFuffzichDasKilo);

Nun kann man vielleicht die Parameter als 'Array Of Const' übergeben, sodaß man die generische Factory auch mit einem 'GetInstance' verwenden kann, aber da weiss ich nicht, wie man einen Konstruktorparameter dynamisch aus einem 'Array Of Const' füttert (außer, der Konstruktor akzeptiert selbst ein 'Array Of Const', was aber blöd wäre).

Delphi-Quellcode:

  //
  myClass := myFactory<TFruit>.GetInstance('Apfel',['Booskop', Mittelgroß, FuerEinsFuffzichDasKilo]);

Du hast das bestimmt in deinem Spring-Framework gelöst (oder eben anders=besser).

Da man jedoch eine Factory auch fafür verwendet, Klassen stringent zu initialisieren, ist eine Implementierung über Generics vielleicht nicht das gelbe vom Ei.

[Stevie]

Ok, die Benutzung selber mit Generics aufpeppen ergibt Sinn. Ich hatte schon befüchtet, du willst die Klassen/Interfaces an sich irgendwie generisch machen

Zitat von Dejan Vu:

Nun kann man vielleicht die Parameter als 'Array Of Const' übergeben, sodaß man die generische Factory auch mit einem 'GetInstance' verwenden kann, aber da weiss ich nicht, wie man einen Konstruktorparameter dynamisch aus einem 'Array Of Const' füttert (außer, der Konstruktor akzeptiert selbst ein 'Array Of Const', was aber blöd wäre).

Geht, tut man sich aber keinen allzu großen Gefallen mit, da man vieles wieder auseinander pflücken muss.

Zitat von Dejan Vu:

Du hast das bestimmt in deinem Spring-Framework gelöst (oder eben anders=besser).

Es gibt dort den TActivator (der Activator Klasse aus .Net nachempfunden), mit der man das machen kann (entsprechend meines Hinweises auf enhanced RTTI weiter oben). Parameter werden über ein array of TValue weitergegeben.
Durch die operator Überladungen von TValue lässt sich das in vielen so Fällen benutzen, wie bei einem open array (array of const).

Generell sollte man aber genau die Anforderungen definieren. Wenn man sich auf eine gemeinsame Basisklasse einigen kann, ist das sicherlich sehr gut, da man dann Typensicherheit zur Compilezeit hat und sich das RTTI Gedöns sparen kann.