Klasse nach Vergleich mit Feld in Klasse erzeugen

[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).

[DeddyH]

Ja eben, nach einem Blick auf sein Profil fiel mir auch gleich RTTI ein, da muss man dann nicht soviel selbst machen.

[Blup]

Im Prinzip muss die Factory die zu erzeugenden Klassen nicht einmal konkret kennen.
So kann man später beliebige Unterklassen ableiten, ohne TParentClass zu ändern:

Delphi-Quellcode:

unit UnitParentClass;

interface

uses
  Classes, Contnrs, SysUtils;

type
  TChildClassParams = record
    {...}
  end;

  TParentClass = class;
  TChildClassType = class of TParentClass;

  TParentClass = class
  private
    class var
      FClassList: TClassList;
    class procedure FreeList;
  protected
    class procedure Register(AClassType: TChildClassType);
    class function New(AParams: TChildClassParams; var AInstance: TParentClass): Boolean; virtual; abstract;
  public
    class function CreateInstance(AParams: TChildClassParams): TParentClass;
  end;

implementation

{ TParentClass }

class function TParentClass.CreateInstance(AParams: TChildClassParams): TParentClass;
var
  p: Pointer;
begin
  Result := nil;
  if Assigned(FClassList) then
  begin
    for p in FClassList do
    begin
      if TChildClassType(p).New(AParams, Result) then
        Exit;
    end;
  end;
end;

class procedure TParentClass.FreeList;
begin
  FreeAndNil(FClassList);
end;

class procedure TParentClass.Register(AClassType: TChildClassType);
begin
  if not Assigned(FClassList) then
    FClassList := TClassList.Create;

  FClassList.Add(AClassType);
end;

initialization

finalization
  TParentClass.FreeList;

end.

Delphi-Quellcode:

unit UnitChildClass;

interface

uses
  UnitParentClass;

type
  TChildClass = class(TParentClass)
  protected
    class function New(AParams: TChildClassParams; var AInstance: TParentClass): Boolean; override;
  end;

implementation

{ TChildClass }

class function TChildClass.New(AParams: TChildClassParams;
  var AInstance: TParentClass): Boolean;
begin
  Result := {AParams = ???} True;
  if Result then
    AInstance := Self.Create;
end;

initialization
  TChildClass.Register(TChildClass);

end.

[ChEeTaH]

Zitat von shmia:

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)

Genau das würde mich interessieren. Ich habe bis jetzt eine TObjectList implementiert, wenn man das ohne manuelles einfügen der Objekte in die TObjectList lösen kann wäre das sehr praktisch.