Zu unbekanntem Klassenderivat casten?

[blackdrake]

Hallo.

Ich habe folgendes Problem: Ich möchte ein Objekt kopieren, weiß aber zur Laufzeit nicht, um welche Klasse es sich handelt.

Der Code sieht in etwa so aus:

Delphi-Quellcode:

type
  TBasis = class(TObject);
  TAbleitungA = class(TBasis);
  TAbleitungB = class(TBasis);

var
  test, kopie: TBasis;

begin
  test := GibtMirWas(); // gibt entweder TAbleitungA oder TAbleitungB

  // Versuche: Kopie anlegen
  {Versuch 1} kopie := test.ClassType.Create; // Problem: Wie TObject nach "test.ClassType.ClassName" casten? Ich will am Ende aber ein TAbleitungX und kein TBasis haben...
  {Versuch 1} kopie := test.NewInstance; // Problem: Das selbe

  kopie.feld := 'ABC'; // wegen dieser Veränderung darf die originale Klasse nicht verwendet werden.

  MeineFunktion(kopie);
end;

Wie kann ich das machen?

Gruß
blackdrake

[_frank_]

bei Kompoenenten geht das so wie in diesem Auszug aus meinem DFM-Editor:

Delphi-Quellcode:

function CreateComponent(aName,aType:string;Parent:TWinControl;Owner:TComponent):TComponent;
var
  classe:TpersistentClass;
  CC: TComponentClass;
begin
  result:=nil;
  classe:=getclass(AType);
  if assigned(classe) then
  begin
    CC:=TComponentClass(classe);
    result:=cc.Create(owner);
  end;
end;

bei einem reinen TObject, ist mir keine ähnliche Variante bekannt

HTH Frank

[Dax]

Du könntest deiner TBasis eine abstrakte Clone-Methode hinzufügen, die eine TBasis-Instanz zurückgibt, die eine Kopie der aufgerufenen Instanz zu sein hat. Ganz offensichtlich ist ja alles, was du ändern willst, in TBasis

[himitsu]

test.ClassType.Create

das Problem hierbei ist, daß ClassType vom Typ TClass ist, was der Klassentyp von TObject ist.
leider wird hier wohl vom Compiler .Create mit dem "Variablen"-Type hat verlinkt, also TClass.Create verwendet und demnach wird ein TObject erstellt.



meine schnelle Lösung war es eine "neue" Function einzuführen siehe Function CreateInstance in
http://www.delphipraxis.net/internal...t.php?t=151373

du mußt ja kein Interface nehmen (TObject oder TBasis reichen auch)

Delphi-Quellcode:

Function TBasis.CreateInstance: TBasis; Virtual; Abstract;

Function TAbleitungA.CreateInstance: TBasis; Override;
  Begin
    Result := TAbleitungA.Create;
  End;

und das würde dann in jeder Ableitung entsprechend überschrieben.



was auch geht, wäre: (ist aber nicht grad flexibel )

Delphi-Quellcode:

if test.ClassType is TAbleitungA then kopie := TAbleitungA.Create
else if test.ClassType is TAbleitungB then kopie := TAbleitungB.Create
.....

[edit] da hat dächschen wohl schneller getippt
[edit2] abstract hatte ich es ... zumindestens im programm

[Dax]

Dein zweiter Vorschlag ist ja wohl ein absolutes Antipattern, himi Und abstrakt sollte diese virtuelle Methode auf jeden Fall sein, sonst könnte jemand das nicht überschreiben und die Semantik der Methode stören.

[himitsu]

Zitat von Dax:

Dein zweiter Vorschlag ist ja wohl ein absolutes Antipattern, himi

aber es funktioniert zumindestens

ok, abstract hatte ich vergessen zu schreiben

[stoxx]

Metaklassen sind Dein Stichwort ...

soo ...

Delphi-Quellcode:

type

TBaseClassType = class of TBasis;



var 

 aBaseClass : TBaseClassType;
 aBaseObj : TBasis;
 
begin


  aBaseClass := TAbleitungA;
  
   // constructor create von TBASIS muss virtual deklariert sein (oder virutal; abstract)
   // constructor create von TAbleitungA muss als override; deklariert werden
  
  aBaseObj := aBaseClass.Create;  
  Showmessage(aBaseObj.Classname);
  
  
  
end;

[blackdrake]

Hallo.

Vielen Dank für eure zahlreichen Antworten!

Sowohl die Meta-Klassen als auch die virtuell-abstrakten Clone-Methoden haben funktioniert:

Delphi-Quellcode:

type
  TBasis = class(TObject)
    Test: string;
    constructor Create;
    function Clone: TBasis; virtual; abstract;
  end;

  TAbleitung = class(TBasis)
    Test: string;
    constructor Create;
    function Clone: TBasis; override;
  end;

  TBaseClassType = class of TBasis;

{ TForm1 }

procedure TForm1.CloneVariant(Sender: TObject);
var
  Original, Kopie: TBasis;
  TempType: TBaseClassType;
begin
  Original:= TAbleitung.Create; // Dynamisch ermittelt, Derivat unbekannt
  Original.Test := 'Hubbi';

  TempType := TBaseClassType(Original.ClassType);

  Kopie := TBasis(TempType.Create);
  Kopie.Test := 'Flubby';

  showmessage(Original.Test);
  showmessage(Original.ClassName);
  showmessage(Kopie.Test);
  showmessage(Kopie.ClassName);

  // Ausgegeben:
  // Create Ableitung; Create Basis; Create Basis;
  // Hubbi; TAbleitung; Flubby; TAbleitung (OK)
end;

procedure TForm1.MetaClassVariant(Sender: TObject);
var
  Original, Kopie: TBasis;
begin
  Original := TAbleitung.Create; // Dynamisch ermittelt, Derivat unbekannt
  Original.Test := 'Hubbi';

  Kopie := Original.Clone;
  Kopie.Test := 'Flubby';

  showmessage(Original.Test);
  showmessage(Original.ClassName);
  showmessage(Kopie.Test);
  showmessage(Kopie.ClassName);

  // Ausgegeben:
  // Create Ableitung; Create Basis; Create Ableitung; Create Basis;
  // Hubbi; TAbleitung; Flubby; TAbleitung (OK)
end;

{ TBasis }

constructor TBasis.Create;
begin
  showmessage('Create Basis');
  inherited;
end;

{ TAbleitung }

constructor TAbleitung.Create;
begin
  showmessage('Create Ableitung');
  inherited;
end;

function TAbleitung.Clone: TBasis;
begin
  result := TAbleitung.Create;
  result.Test := Test;
end;

Ich denke, dass ich die Metaklassen verwenden werde, da dadurch mein Code aufgrund der nicht zu implementierenden Clone-Methoden etwas schlanker bleibt.

Ist das jetzt alles OK, was ich hier gemacht habe?

@stoxx: Mein Code funktioniert scheinbar, obwohl ich nicht folgende Hinweise beachtet habe:

Zitat:

// constructor create von TBASIS muss virtual deklariert sein (oder virutal; abstract)
// constructor create von TAbleitungA muss als override; deklariert werden

Wieso ist das so? Ist mein Code damit noch nicht in Ordnung und sollte ich etwas ändern?

Gruß
blackdrake

[Blup]

Die Bezeichnungen für CloneVariant und MetaClassVariant sind vertauscht.

In deiner Variante ohne Clone wird der falsche Konstruktor nähmlich immer der von TBasis aufgerufen (weil nicht virtuell).
Außerdem werden die Variablen der Kopie nicht mit den Werten des Orginals vorbelegt.

Die Klasse Abteilung hat 2 Variablen mit dem Namen "Test". Eine geerbte von TBasis und eine eigene.


Hier noch ein Vorschlag für die Clone-Variante:

Delphi-Quellcode:

type
  TBasis = class(TObject)
    constructor Create; virtual;
  protected
    FName String;
  public
    property Name: string read FName write FName;
    procedure Assign(AObject: TBasis); virtual;
    function Clone: TBasis; virtual;
  end;

  TAbleitung = class(TBasis)
  protected
    FFunktion: String;
  public
    property Funktion: string read FFunktion write FFunktion;
    procedure Assign(AObject: TBasis); override;
  end;

  TSonderAbteilung = class(TAbleitung)
    constructor Create; override;
  protected
    FSonderfunktion: string;
  public
    property Sonderfunktion: String read FSonderfunktion write FSonderfunktion;
    procedure Assign(AObject: TBasis); override;
  end;

constructor TBasis.Create;
begin
  showmessage('constructor TBasis für ' + ClassName);
end;

procedure TBasis.Assign(AObject: TBasis);
begin
  FName := AObject.Name;
end;

function TBasis.Clone: TBasis;
begin
  Result := ClassType.Create;
  Result.Assign(Self);
end;

procedure TAbleitung.Assign(AObject: TBasis);
begin
  inherited;
  if AObject is TAbleitung then
    FFunktion := TAbleitung(AObject).Funktion;
end;

constructor TSonderAbteilung.Create;
begin
  inherited;
  showmessage('constructor TSonderAbteilung für ' + ClassName);
end;

procedure TSonderAbteilung.Assign(AObject: TBasis);
begin
  inherited;
  if AObject is TSonderAbteilung then
    FSonderfunktion := TSonderAbteilung(AObject).Sonderfunktion;
end;

[blackdrake]

Hallo.

Vielen Dank für die Antwort. Ich habe wie gesagt in diesem Fall jetzt die Metaklassen-Variante vorgezogen, weil ich mir hierdurch viel Codezeilen an Clone()-Funktionen spare.

Ich habe bei der Implementierung selbst herausgefunden, wieso das virtual+override doch wichtig war. Ich hatte 4 Varianten durchprobiert, die sich kompilieren liesen und auf dem ersten Blick zu funktionieren schienen:

1. Kopie := TBasis(Original.NewInstance);
2. Kopie := TBasis(Original.ClassType.Create);
3. Kopie := TBasis(Original.ClassType).Create;
4. Kopie := TBasis(Original.ClassType).Create; // + TBasis.Create als virtual;

Die Instanz wurde bei allen vier Programmen korrekt initialisiert und erhielt einen eigenen Speicherabschnitt.

Aber: Felder, die im Konstruktor deklariert waren, waren bei Variante 1-3 leer! Deswegen war noch Variante 4 die korrekte Lösung.

Hier noch mein kompletter Probecode:

Delphi-Quellcode:

type
  TBasisClass = class of TBasis;

  TBasis = class(TObject)
    F: String;
    Test: string;
    constructor Create; virtual;
  end;

  TAbleitung = class(TBasis)
    constructor Create; override;
  end;

procedure TForm1.Button2Click(Sender: TObject);
var
  Original, Kopie: TBasis;
begin
  Original := TAbleitung.Create;
  Original.Test := 'A';

  Kopie := TBasisClass(Original.ClassType).Create;
  Kopie.Test := 'B';

  showmessage('Feld Original: ' + Original.F); // "Ableitung"
  showmessage('Feld Kopie: ' + Kopie.F); // "Ableitung" (nur bei virtual constructor)
end;

constructor TBasis.Create;
begin
  inherited;
  F := 'Basis';
end;

constructor TAbleitung.Create;
begin
  inherited;
  F := 'Ableitung';
end;

Jetzt weiß ich auch endlich, was virtual bedeutet: Die Adresse der Methode wird zur Laufzeit ermittelt und nicht zur Compilerzeit. Das ist ja bei mir notwendig, da ich eine Instanz eines unbekannten Derivats erzeugen will. Man lernt nie aus.

Gruß
blackdrake