Wie kann ich den Klassentyp beim Create variabel lassen?

[idefix2]

Hallo,

ich habe eine Klasse TMyclass und von der abgeleitet mehrere Klassen TMyclass1, TMyclass2, TMyclass3 etc.

Jetzt würde ich eine Funktion createinstance brauchen, die ich mit einer Klassenbezeichnung als Parameter aufrufe, und die mir dann ein Objekt dieser Klasse erzeugt und als Ergebnis zurückliefert. Der springende Punkt ist, dass ich zum Zeitpunkt, wo ich die Funktion createinstance schreibe, noch gar nicht weiss, für welche abgeleiteten Klassen die Funktion später aufgerufen werden wird.

Also irgendwie so:

Delphi-Quellcode:

function CreateInstance (Klassenbezeichnung): TMyClass;
begin
Result := Klassenbezeichnung.Create (Parameter für constructor create von Tmyclass, alle abgeleiteten Klassen haben die gleichen Parameter); 
end;

var 
a: TMyclass1;
b: TMyclass2;

begin
a := CreateInstance(TMyclass1);
...

b := CreateInstance(Tmyclass2);
end;

Geht das irgendwie?

[implementation]

Delphi-Quellcode:

type
  TMyClassClass = class of TMyClass;

function CreateInstance(mcc: TMyClassClass): TMyClass;
begin
  Result := mcc.Create(...);
end;

...

MyClass := CreateInstance(TMyClass1);

Ein sehr schönes Feature von Delphi, das noch längst nicht alle verbreiteten Programmiersprachen haben. Ich wünschte es mir so manches mal in C#, wo es leider nur System.Type gibt... :(
Na gut, es ließe sich dort auch generisch lösen...

[himitsu]

Delphi-Quellcode:

a: TMyclass1;
b: TMyclass2;

begin
a := TMyclass1(CreateInstance(TMyclass1));
...
b := Tmyclass2(CreateInstance(Tmyclass2));

// bzw. 
a := CreateInstance(TMyclass1) as TMyclass1;
...
b := CreateInstance(Tmyclass2) as Tmyclass2;

Ob nun als String oder Klasse, ist hierbei egal.
PS: Bei der Klassenvariante sollte man den Constructor besser Virtual machen.

oder als typlosen Parameter:

Delphi-Quellcode:

procedure CreateInstance(mcc: TMyClassClass; out Result);
begin
  TMyClass(Result) := mcc.Create(...);
end;

procedure CreateInstance(MyClass: String; out Result);
begin
  case IndexText(MyClass, ['TMyClass1', 'TMyClass2']) of
    0: TMyClass(Result) := TMyClass1.Create(...);
    1: TMyClass(Result) := TMyClass2.Create(...);
    else TMyClass(Result) := nil;  // oder eine Exception auslösen
  end;

end;

[idefix2]

@implementation
Grossartig, so geht das tatsächlich - Delphi ist wirklich eine geniale Sprache. Ich habe die Frage gepostet, aber eigentlich nicht wirklich geglaubt, dass so ein Konstrukt möglich ist.

@himitsu
Danke, aber mit der Variante würde ich nicht weiterkommen, ich habe ja oben geschrieben: Der springende Punkt ist, dass ich zum Zeitpunkt, wo ich die Funktion createinstance schreibe, noch gar nicht weiss, für welche abgeleiteten Klassen die Funktion später aufgerufen werden wird.
D.h., ich kann kein Case Statement machen, weil ich die Einträge für das case noch gar nicht kenne.
edit: gerade bemerkt, natürlich geht nur Deine Stringvariante mit dem Case nicht, die andere entspricht der von Implementation :)

[himitsu]

Zitat:

Zitat von idefix2 (Beitrag 1035171)

aber mit der Variante würde ich nicht weiterkommen,

War schon klar, aber immerhin eine Variante, um über einen String zu gehn ... vielleicht hilft's ja anderen.

Aber bei der Variante über die Klasse, vergiß nicht den virtuellen Constructor, denn sonst kennt die Basisklasse (also der Parameter der Funktion, über welche die Instanz erstellt werden soll) nur ihren eigenen Constructor und nicht den des Nachfahren.

[igel457]

Falls du das mit dem String mal brauchen solltest, musst du folgendes tun:

Deine Basisklasse (TMyClass) muss ein indirekter oder direkter Nachfahre von "TPersistent" sein. Dann kannst du im Initialization Teil der Unit, die die Implementierungen beinhaltet (TMyClass1 etc.) diese mit der Funktion RegisterClass registrieren. Das würde dann zum Beispiel so aussehen:

Delphi-Quellcode:

unit MyClasses;

uses
  Classes;

interface
  TMyClass = class(TPersistent);
  TMyClassRef = class of TMyClass;

  TMyClass1 = class(TMyClass);
  TMyClass2 = class(TMyClass);

implementation

initialization
  RegisterClass(TMyClass1);
  RegisterClass(TMyClass2);

end.

An die Klassen kommst du dann wieder mit Hilfe der GetClass funktion dran. Das würde dann so aussehen:

Delphi-Quellcode:

function InstanciateMyClass(AName: string);
begin
  result := TMyClassRef(GetClass(AName)).Create();
end;

var
  myclass: TMyClass;
begin
 myclass := InstanciateMyClass('TMyClass1');
end;

Hoffe das hilft irgendjemandem mal.

Diese "Get-" und "Registerclass" Funktionen von Delphi sind natürlich kein Hexenwerk sondern eigentlich ganz einfach. Ich habe so etwas hier auch implementiert.

Andreas

[idefix2]

Ich habe es jetzt mit einer "class of" variable gemacht, aber es ist jedenfalls gut zu wissen, dass das für TPersistent-Nachkommen sogar mit den Klassennamen als String möglich ist.