FormularArray den richtigen Create aufrufen! Wie?

[Mavarik]

SUPER! Danke...

TFormClass kannte ich bisher noch nicht...

Hab das bis heute auch noch nie gebraucht...

Danke auf für das FormFactry Beispiel. Soll so was ähnliches werden.

Grüsse Mavarik

[Sir Rufo]

Zitat von Mavarik:

TFormClass kannte ich bisher noch nicht...

Wenn es das nicht geben würde, dann würde es man sich einrichten - was man auch macht, wenn man vererbte Klassen ohne Standard-Konstruktor hat

Delphi-Quellcode:

type
  TFoo = class;

  TFooClass = class of TFoo;

  TFoo = class
    constructor Create( ABar : TBar ); virtual;
    class function CreateFoo( AFooClass : TFooClass; ABar : TBar  ) : TFoo; overload;
    // Registrieren von Nachfahren und erzeugen über den Klassen- oder Alias-Namen
    class procedure RegisterClass( AFooClass : TFooClass ); overload;
    class procedure RegisterClass( const AAlias : string; AFooCLass : TFooClass );
    class function CreateFoo( const AName : string; ABar : TBar ) : TFoo; overload;
  end;

  TSomeFoo = class( TFoo )
  end;

  TConcreteFoo = class( TFoo )
    constructor Create( Bar : TBar ); override;
  end;

class function TFoo.CreateFoo( AFooCLass : TFooClass; ABar : TBar ) : TFoo;
begin
  Result := AFooCLass.Create( ABar );
end;

function CreateFooInstance( AFooClass : TFooClass; ABar : TBar ) : TFoo;
begin
  Result := AFooClass.Create( ABar );
end;

var
  LFoo : TFoo;
  LBar : TBar;

// Erzeugt eine TConcreteFoo-Instanz
LFoo := CreateFooInstance( TConcreteFoo, LBar );
LFoo := TFoo.CreateFoo( TConcreteFoo, LBar );
// Erzeugt eine TSomeFoo-Instanz
LFoo := CreateFooInstance( TSomeFoo, LBar );
LFoo := TFoo.CreateFoo( TSomeFoo, LBar );

[himitsu]

TFormClass selber mußt du nicht unbedingt kennen.

Delphi-Quellcode:

type
  TFormClass = class of TForm;

Das ist ein Typ, in den keine Instantzen des Typs reinkommen (wie bei TForm, wo TForm.Create und Nachkommen rein kommt),
sondern wo Typen reinkommen, welche z.B. davon abgeleitet sind.

Das Wichtigste dabei ist nur, daß die gewünschte Methode (wie z.B. Create) im Basistyp virtual oder dynamic sein muß.

[Jumpy]

Geht das nicht irgendwie in Richtung factory patterns? Quasi eine "Formfactory"?


Edit: Wahrsch. hab ich die Frage nicht verstanden, dann vergesst den ganzen Rest.


Sowas hab ich mit Tips von hier mal für Frames gemacht.

Delphi-Quellcode:

unit uFrameFactory;

interface

uses Projekt,
     fBaseFrame, fLAFrame, fKSTFrame, fSTOFrame,
     Controls, Classes, ADODB;

Type TBaseFrameClass = class of TBaseFrame;

Type TBaseFrameClassRec = record
  Name:String;
  Header:String;
  Klasse:TBaseFrameClass;
  end;

const FrameClassList: Array[0..8{ggf. erhöhen}] of TBaseFrameClassRec =
      (
       (Name: 'LA';   Header: 'Lohnarten'; Klasse: TLAFrame),
       (Name: 'KST'; Header: 'Kostenstellen'; Klasse: TKSTFrame),
       //...
      );

Type
  TFrameFactory = class
    private
      fParent : TWinControl;
      fOwner : TComponent;
      fCon : TADOConnection;
      //...
      function GetClassFromName(FrameName:String):TBaseFrameClass;
      function GetHeaderFromName(FrameName:String):String;
    public
      constructor create(Owner:TWinControl);overload;
      property Owner:TComponent read fOwner;
      property Parent:TWinControl read fParent write fParent;
      property Con:TADOConnection read fCon write fCon;
      function GetFrame(FrameName:String):TBaseFrame;
  end;


implementation

{ TFrameFactory }

constructor TFrameFactory.create(Owner: TWinControl);
begin
  inherited create;
  fOwner:=Owner;
end;

function TFrameFactory.GetClassFromName(FrameName: String): TBaseFrameClass;
var
  i: Integer;
begin
  Result:=nil;
  for i := 0 to High(FrameClassList) do
    if FrameClassList[i].Name = FrameName then
      begin
      Result := FrameClassList[i].Klasse;
      break;
      end;
end;

function TFrameFactory.GetHeaderFromName(FrameName: String): String;
var
  i: Integer;
begin
  Result:='';
  for i := 0 to High(FrameClassList) do
    if FrameClassList[i].Name = FrameName then
      begin
      Result := FrameClassList[i].Header;
      break;
      end;
end;

function TFrameFactory.GetFrame(FrameName: String): TBaseFrame;
var f:TBaseFrame;
begin
  f:=GetClassFromName(FrameName).Create(Owner);
  f.Parent:=Parent;
  f.Align:=alClient;
  f.Con:=Con;
  f.Header:=GetHeaderFromName(FrameName);
  //...
  Result:=f;
end;


end.