Klasse nach Vergleich mit Feld in Klasse erzeugen

[ChEeTaH]

Hallo,

ich habe mehrere Klassen, die von einer abstrakten Klasse geerbt haben.
Ich muss nun je nach Eingabewert unterscheiden, welche dieser Childklassen erzeugt werden und mit dem Ergebnis arbeiten. Ob diese Klasse das Ergebnis verarbeiten kann steht in der Klasse als Eigenschaft.
Ich habe hier versucht, zumindest teiwleise das Strategie Pattern umzusetzen.
Codebeispiel:

Delphi-Quellcode:

type TParentClass = class
  {iwas}
end;

type TChildclass(TParentclass)
  eineZahl: Integer;
  procedure eineMethode(asd: String);
end;

procedure choose;
var 
 EineChildclass: TChildclass;
begin
  If eineChildclass.eineZahl = 1 then
  begin
  EineChildclass := TChildclass.Create;
  EineChildclass.eineMethode('test';
  
  // WIe frage ich ab, welche Klasse erzeugt werden muss?
  end;
end;

Ich habe etwas von Methodenklassen gelesen, wäre dies der WEg zu Ziel, oder gibt es andere Lösungen?

[DeddyH]

Ich weiß nicht, ob es nur mir so geht, aber ich verstehe weder die Frage noch Deinen Code so richtig. Wie kannst Du ein Feld einer Instanz abfragen, die Du im Anschluss erst erzeugst?

[ChEeTaH]

Das genau ist ja der Knackpunkt. Ich möchte die Eigenschaft gerne in der Klasse kapseln, muss aber auch wissen, welche klasse ich nun genau benutzen muss. Der vergleiswert ist variabel, deswegen dieser umständliche weg.

[Bummi]

Suchst Du eine Class Function eineZahl ??

[DeddyH]

RTTI? Ich verstehe immer noch nicht ganz, was eigentlich die Anforderung ist, sry.

[Bummi]

ich vermute er such so etwas

Delphi-Quellcode:

unit Unit2;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs,jpeg, StdCtrls, ExtCtrls;

type

  TMasterClass=Class
    Class Function WasKannich:Integer;virtual;
  End;

  TMasterChildClass1=Class(TMasterClass)
    Class Function WasKannich:Integer;override;
  End;
  TMasterChildClass2=Class(TMasterClass)
    Class Function WasKannich:Integer;override;
  End;
  TMasterClassClass=Class of TMasterClass ;

  TForm2 = class(TForm)
    Button1: TButton;
    Image1: TImage;
    procedure Button1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form2: TForm2;

implementation

{$R *.dfm}

procedure TForm2.Button1Click(Sender: TObject);
var
  CK:TMasterClassClass;
begin

    if TMasterChildClass1.WasKannich=2 then CK := TMasterChildClass1
    else if TMasterChildClass2.WasKannich=2 then CK := TMasterChildClass2;
    With CK.Create do
      begin
        Showmessage(IntToStr(WasKannich));
        Free;
      end;

end;

{ TMasterChildClass2 }

class function TMasterChildClass2.WasKannich: Integer;
begin
  Result := 2;
end;

{ TMasterChildClass1 }

class function TMasterChildClass1.WasKannich: Integer;
begin
  Result := 1;
end;

{ TMasterClass }

class function TMasterClass.WasKannich: Integer;
begin
   Result := 0;
end;

end.

[shmia]

1.) die Basisklasse hat eine statische Methoden (in Delphi Klassenmethode genannt)
mit der man Abfragen kann ob eine Klasse bestimmte Eigenschaften hat bzw. über bestimmte Features verfügt.

2.) die Klassenmethode sollte virtuell sein; das bietet noch mehr Möglichkeiten

Delphi-Quellcode:

type 
TParentClass = class
public
  class function HasFeature(const name:string):boolean;virtual;
end;

TChildclass = class(TParentclass)
  class function HasFeature(const name:string):boolean;override;
end;

class function TChildclass.HasFeature(const name:string):boolean;
begin
   // die konkrete Klasse unterstützt die Features Secure und Hip
   result :=  (name='Secure') or (name='hip');
end;

3.) eine Factorymethode erzeugt aufgrund der gewünschten Features ein Objekt einer konkreten (Child-)Klasse:

Delphi-Quellcode:

function TMyFactory.CreateObject(const feature:string):TParentClass;
begin
  if TChildclass1.HasFeature(feature) then
    result := TChildclass1.Create
  else if TChildclass2.HasFeature(feature) then
    result := TChildclass2.Create
  ...
  else
     result := nil;
end;

Man kann auch mehrere Features prüfen um die passende Klasse zu finden.
Anstatt jede einzelne Klasse zu testen kann man auch alle registrierten Klassen in einer Schleife testen (aber dazu benötigt man fortgeschrittene Techniken, die ich im Moment nicht erklären möchte)

PS: der Bummi war natürlich mal wieder schneller

[Bummi]

@shmia

tschuldigkeit sonst schlägt mich immer DeddyH ....

[ChEeTaH]

Ja genau das habe ich gesucht. Danke an alle für die schnelle Hilfe

[himitsu]

Mit der neuen erweiterten RTTI kann man auch Attribute anlegen und auslesen, zu den Klassentypen (quasi ähnlich der virtuellen Klassenmethoden).