Objekte aus Textdatei erstellen

[jaenicke]

Darauf passt das Factory-Pattern, d.h. eine Factory, bei der sich die Klassen z.B. selbst registrieren (z.B. in initialization der Units). Diese Factory kennt dann die Klassen und kann die auch erstellen, wenn du dort dann nach einer Klasse anfragst.

[Acuaplano]

Zitat von jaenicke:

Darauf passt das Factory-Pattern, d.h. eine Factory, bei der sich die Klassen z.B. selbst registrieren (z.B. in initialization der Units). Diese Factory kennt dann die Klassen und kann die auch erstellen, wenn du dort dann nach einer Klasse anfragst.

Ich hab mich jetzt etwas in das Thema eingelesen und werd's noch etwas tun, aber entweder hab ich noch nicht den richtigen Teil gefunden oder das verschiebt mein Problem nur...
Am Beispiel aus dem Internet:

Delphi-Quellcode:

if ASelector = 'Furniture' then
    Result := TFurniture.Create
  else if ASelector = 'Chair' then
    Result := TChair.Create
  else if ASelector = 'Cupboard' then
    Result := TCupboard.Create
  else if ASelector = 'Coffee Table' then
    Result := TCoffeeTable.Create
  else if ASelector = 'Kitchen Table' then
    Result := TKitchenTable.Create
  else if ASelector = 'Table' then
    Result := TTable.Create

Dieser Teil wird ja bei der Factory sozusagen "ausgelagert", wobei jedoch die if-anweisungen bleiben. Problem beim Spiel wird's aber sein, dass ganz viele Objekte dazukommen werden und 100 if-Anweisungen unpraktisch wären. Mein Wunsch wär es ja jetzt das auf ein paar Zeilen zu reduzieren.
Wie gesagt, ich bin noch grad' am Lesen.

[stahli]

Vielleicht mal etwas allgemeiner:

Man kann seine Klassen registrieren, damit Objekte dieser Klasse zur Laufzeit erzeugt werden können. Das ist aber etwas aufwendig.

Ungefähr läuft das dann so ab:

Delphi-Quellcode:

// nur smbolischer Code, die genauen Funktionen habe ich nicht im Kopf
VorbereitungFuerBaum;
VorbereitungFuerHaus;
RegisterClass(TBaum, THaus);
...
Baum := CreateObject(TBaum);
Haus := CreateObject(THaus);

(Such mal ggf. nach "Objekte nach Klassennamen erzeugen" o.ä.)


Einfacher kannst Du das natürlich auch selbst in die Hand nehmen:

Delphi-Quellcode:

function GetNewObject(aClassName: String): TObject;
begin
  if aClassName = 'TBaum' then
    Exit(TBaum.Create(Self));
  if aClassName = 'THaus' then
    Exit(THaus.Create(Self));
  if aClassName = 'Irgendwas' then
    Exit(TXYZ.Create(Self));
  Result := nil;
end;

Wenn alle Objekte von einer bestimmten Basisklasse abgeleitet werden, dann kann man geschickter Weise diese Basisklasse als Rückgabetyp der Funktion wählen.

Vielleicht nützt das als praktischer Ansatz.

[Acuaplano]

Zitat von stahli:

Vielleicht mal etwas allgemeiner:

Man kann seine Klassen registrieren, damit Objekte dieser Klasse zur Laufzeit erzeugt werden können. Das ist aber etwas aufwendig.

Ungefähr läuft das dann so ab:

Delphi-Quellcode:

// nur smbolischer Code, die genauen Funktionen habe ich nicht im Kopf
VorbereitungFuerBaum;
VorbereitungFuerHaus;
RegisterClass(TBaum, THaus);
...
Baum := CreateObject(TBaum);
Haus := CreateObject(THaus);

(Such mal ggf. nach "Objekte nach Klassennamen erzeugen" o.ä.)

Meinst Du damit das Thema mit GetClass & Co?
Das scheint nämlich ein guter Ansatz zu sein . Jedenfalls hab ich mich eben auch noch daran versucht und nicht so ganz weit gekommen. Zunächst aber etwas zur "Basisklasse":
Die Hierarchie sieht im Moment so aus:

TImageSprite (vorgegeben durch Engine)
|
TObjekt
|
TUnbenutzbar
|
TBaum1 (hier würden dann auch die ganzen anderen Objekte stehen)

Ob das jetzt so sinnvoll ist weiß ich nicht, aber es beizubehalten wär schon ganz nett. Daher würde eine Basisklasse auch wegfallen. Man sollte aber wissen, dass alles ab TObjekt in einer anderen Unit ausgelagert ist.
Jetzt aber GetClass:
Was mache ich falsch? Wär das überhaupt so möglich?
CRef := GetClass('TBaum1'); Bei mir ist CRef immer leer (ohne direkte Registrierung der Klasse). Registrieren kann ich es nicht, weil er mir dann immer ne Fehlermeldung ausgibt, dass das keine "persistent class" ist. Aber laut dem Linkhier müsste es doch auch gehen, wenn die Klasse in der Unit deklariert wurde ("Form classes and component classes that are referenced in a form declaration (instance variables) are automatically registered when the form is loaded."), oder hab ich da was falsch verstanden?
Fragen über Fragen... Tut mir leid, wenn es jetzt ganz einfach ist, ich bin noch ziemlich unerfahren .

[stahli]

So, jetzt mit mehr Zeit etwas genauer.

Du kannst Klassen folgendermaßen registrieren (am Beispiel der TodPanel):

Delphi-Quellcode:

// Klassenunit
unit odPanel;

interface

type

  TodPanel = class(TPanel)
  ...
  end;

  TodPanelClass = class of TodPanel;

procedure Register; // wenn Du das Control für die IDE registrieren willst

implementation

procedure Register;
begin
  RegisterComponents('odControls', [TodPanel]);
end;

initialization

RegisterClasses([TodPanel]);

end.

Und dann zur Laufzeit:

Delphi-Quellcode:

FindClass('TodPanel');
odPanel := TodPanelClass(GetClass('TodPanel')).Create(Self);

In dieser Richtung solltest Du mal schauen.
Ach so, es hängt ggf. auch von Deiner Delphiversion ab.

[Acuaplano]

Ich nehme mal an, dass ich für meine Klassen stattdessen "RegisterClasses" nehmen soll.
Aber das Problem ist jetzt dabei, dass TImageSprite keine "persistent class" ist und ich die deshalb nicht registrieren kann. Ich versteh auch im Moment nicht wo jetzt der Sinn dahinter ist. Gäbe es denn ne andere Möglichkeit, als die Klassenvererbung zu ändern? Falls nicht, wovon müsst ich theoretisch TImageSprite ableiten?

[jaenicke]

Theoretisch von TPersistant, aber ich würde die Registrierung einfach bei einem eigenen Factory-Objekt machen wie schon geschrieben. Sprich:

Delphi-Quellcode:

MyFactory.RegisterClass(TBaum);
...

Und in MyFactory das ganze in ein TDictionary<string, TClass> werfen, wobei der Key der Klassenname als String der Klasse ist. Dann kannst du aus diesem Dictionary jederzeit über den Namen der Klasse die Klasse finden und kannst die entsprechend erzeugen.

[Sir Rufo]

@jaenicke

So könnte die Klasse aussehen

Delphi-Quellcode:

unit Entity;

TEntity = class

end;

TEntityClass = class of TEntity;

TEntityFactory = class
class procedure RegisterClass( const AName : string; AClass : TEntityClass ); overload;
class procedure RegisterClass( AClass : TEntityClass ); overload;
class function Construct( const AName : string ) : TEntity;
// oder mit Generics
class function Construct<T : TEntityClass>( const AName : string ) : T;
end;

das Registrieren dann wie schon erwähnt

Delphi-Quellcode:

unit Baum;

uses
  Entity;

TBaum = class( TEntity )
end;

TBusch = class( TEntity )
end;

initialization

TEntityFactory.RegisterClass( 'Baum', TBaum );
TEntityFactory.RegisterClass( 'Busch', TBusch );

end.

und erzeugen dann mit

Delphi-Quellcode:

var
  LBaum : TEntity;
  LBusch : TEntity;

LBaum := TEntityFactory.Construct( 'Baum' );
LBusch := TEntityFactory.Construct( 'Busch' );