Klassen-Konstruktion einmal anders...

[Ganymed]

Hi!

Ich bae ein paar Klassen, sagen wir mal

Code:

type
  TMyCustomClass = class(TObject);
  [...]
  TMyClassA = class(TMyCustomClass);
  [...]
  TMyClassB = class(TMyCustomClass);

Von TClassA und TClassB möchte ich nun einige Instanzen in einem Array verwalten:

Code:

aMyObjects: array of TMyCustomClass;

Dazu soll mit aber eine einzelne Prozedur dienen, der ich nur den Classen-Typ übergebe. Das müsste in etwa so ausssehen:

Code:

procedure AddObject(ObjectClass: TClass);
begin
  SetLength(aMyObjects, Length(aMyObjects) +1);
  aMyObjects[Length(aMyObjects) -1] := TMyCustomClass(ObjectClass).Create;
end;

Dass das nicht funktioniert ist ja klar, denn ich versuche eine TClass in eine TMyCumstomClass umzuwandeln und das kann ja nicht gehen.
Wie kann ich es aber erreichen, dass ich der Prozedur die Klasse übergebe, die ich erstellen möchte?

Hoffe, ich hab meine Problematik halbwegs nachvollziehbar dargestellt.

Ganymed

[Edit=Sakura]BBCode zugelassen[/Edit]

[Ganymed]

Hat sich erledigt :D

[sakura]

Hi,

erst einmal herzlich willkommen in der Delphi-PRAXiS.

Darf ich Dich noch um einen kleinen Gefallen bitten. Würdest Du Deine Lösung bitte kurz umschreiben, vielleicht hilft es ja mal jemanden, der auf die gleichen Sorgen stößt. ;-)

Danke,
...:cat:...

[Motzi]

Ganz einfach mit einem direkten aufruf von:

Delphi-Quellcode:

ObjectClass.Create

;)

[maynard]

Tach...

Ich habe gerade ein ähnliches Problem. Ich möchte verschieden Exceptions in einer TList speichern und diese dann bei Bedarf auslösen. Allerdings habe ich das kurze statement von Motzi nicht so ganz verstanden und weis nicht, wie ich aus einer Klassenreferenz eine gültige Instanz erzeugen kann?!?!

[maximov]

Zitat:

Zitat von maynard

... Allerdings habe ich das kurze statement von Motzi nicht so ganz verstanden und weis nicht, wie ich aus einer Klassenreferenz eine gültige Instanz erzeugen kann?!?!

Ganz einfach eigentlich, du benutzt die klassenReferenz so wie du sonst den klassen-identifier benutzen würdest, vorausgesetzt du du hast vorher den richtigen typ angelegt:

Delphi-Quellcode:

 type
  TExceptClass = class of exception;

var
  exceptClass:TExceptClass;

..
exceptClass := TDeineExceptKlasse_irgendeine;
..
raise exceptClass.create('Fieser fehler');

Finde solche lösungen sehr schön. Grade beim abstrahieren von systemen ist das sehr nützlich :-D

[maynard]

Tach...

Zuerstmal Danke für deine Hilfe, allerdings weiß ich noch nicht alles was ich wissen muß :lol:
Rein theoretisch müsste man dann in einer Klassenreferenz wie

Code:

TCustomExceptionReference = class of Exception;

auch Referenzen auf Derivate von Exception speichern können? Wenn ja, wäre auch eine Zuweisung ala

Code:

MyClassReference: TClass;
MyCustomExceptionReference: TCustomExceptionReference;
// ...
MyClassReference := MyCustomExceptionReferenc;

möglich.

Leider hab ich mit RTTI - Geschichten wenig Erfahrung, daher ist mir mir die Zuweisung etwas unklar:

Code:

MyCustomExceptionReference: TCustomExceptionReference;
// ...
MyCustomExceptionReference := @Exception;
// oder
MyCustomExceptionReference := Exception;

[maximov]

Zitat:

Zitat von maynard

Tach...

Leider hab ich mit RTTI - Geschichten wenig Erfahrung, daher ist mir mir die Zuweisung etwas unklar:

Code:

MyCustomExceptionReference: TCustomExceptionReference;
// ...
MyCustomExceptionReference := @Exception;
// oder
MyCustomExceptionReference := Exception;

Mit RTTI hat das nicht viel zu tun. Das nennt man imo MetaKlassen und deine zuweisung ohne das @ ist korrekt. Wie zu erwarten sind klassen refernezen auch nur pointer, die für kompatible klasse auch zuweisungskompatible sind - also alle ableitung, von der basis-deklaration.

So, und da das pointer sind kannst du die referenzen auch ganz normal in einer liste verwalten:

Delphi-Quellcode:

type
  TCustomExceptionReference = class of Exception;
...
var l:Tlist;

l.add(Exception);
l.add(EMyException);
...
// beim rausholen musst du dann casten
raise EMyException(l[1]).create('böser fehler');

wobei die frage wäre ob das sinn macht, da so die klassen ziemlich undifferenzierbar in der liste rum wabern. Eine stringliste macht da schon mehr sinn...ich weiss ja nicht was du vor hast?

[maynard]

Tach..

Zitat:

Zitat von maximov

Mit RTTI hat das nicht viel zu tun.

Dachte, dass fällt unter den Überbegriff RTTI, Metaklasse klingt allerdings plausibler ... Hamma wieder was gelernt :lol:

Zitat:

Zitat von maximov

// beim rausholen musst du dann casten

Zitat:

Zitat von maximov

Code:

type
  TExceptClass = class of exception;

var
  exceptClass:TExceptClass;

..
exceptClass := TDeineExceptKlasse_irgendeine;
..
raise exceptClass.create('Fieser fehler');

Habe noch keinen Weg probiert, bei der ersten Variante kommst du allerdings ohne cast aus :?: :!:

[maximov]

Zitat:

Zitat von maynard

Tach..
...

Habe noch keinen Weg probiert, bei der ersten Variante kommst du allerdings ohne cast aus :?: :!:

Na dann wird es mal zeit das du das einfach mal testest! Bei ersterer variante hab ich ja auch eine typisierte klassenvariable und bei der liste natürlich nicht, da sie ja nur aus pointern besteht.

Macht aber keinen sinn stundenlang drüber zu reden, wenn du nicht sagst was genau du vor hast. Denn meist gibt es einen eleganteren weg!