Contructor des verbten Forms aufrufen

[Kostas]

Ich bin jetzt ein Stück weiter gekommen. Zumindest wirds kompiliert.
Aber es gibt eine Exception beim erzeugen des Forms.

Wie mus ich das bitte formulieren?

Delphi-Quellcode:

{------------------------------------------------------------------------------------------------------------}
{}function TfrMain2.StartChildForm(FormClass: TFormClass; Berechtigt:TBerechtigung; Params:TObject=nil):TForm;
{------------------------------------------------------------------------------------------------------------}

                    {-----------------------------------------}
                    {}procedure CreateAForm(var Result: TForm);
                    {-----------------------------------------}
                    begin
                      if FormClass.InheritsFrom(TfrMaster) then
                      begin
                        result := TfrMaster(FormClass).Create(Application,Params);  //hier gibt es eine exception
                      end else
                      if FormClass.InheritsFrom(TfrmBaseChild) then
                      begin
                        result := TfrmBaseChild(FormClass).Create(Application,Params);  
                      end;

                      if (result<>nil) then
                      begin
                        AdvToolBar1.AddMDIChildMenu(result);
                        Inc(FChildCount);
                        result.OnClose := ChildFormClose;
                        AdvOfficeMDITabSet1.AddTab(result);
                      end;
                    end;{StartChildForm}

begin
  CheckBerechtigtBis(Berechtigt);
  result := nil;

  if (GetKeyState(VK_LCONTROL)<0)then
  begin
    CreateAForm(Result);
  end else
  begin
    result := BringChildFormToFront(copy(FormClass.ClassName,2,Length(FormClass.ClassName)),'');
    if (result = nil)then
    begin
      CreateAForm(Result);
    end;{if}
  end;{if}
end;

//Das MasterForm aus diesem alle andere Forms erben.

Delphi-Quellcode:

unit Master;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs;

type
  TfrMaster = class(TForm)
  private
    { Private-Deklarationen }
//    FParams:TObject;
  public
    { Public-Deklarationen }
    Constructor Create(AOwner: TComponent; aParams:TObject); virtual;
  end;

var
  frMaster: TfrMaster;

implementation

{$R *.dfm}

{ TForm1 }


{ TfrMaster }

constructor TfrMaster.Create(AOwner: TComponent; aParams: TObject);
begin

end;

end.

//Das aktuelle ChildForm

Delphi-Quellcode:

unit Adressen;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Master;

type
  TfrAdressen = class(TfrMaster)
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
    FParams:TObject;

    Constructor Create(AOwner: TComponent; aParams:TObject); override;
  end;

var
  frAdressen: TfrAdressen;

implementation

{$R *.dfm}

constructor TfrAdressen.Create(AOwner: TComponent; aParams: TObject);
begin
  inherited create(AOwner, aParams);
  FParams := aParams;

end;


end.

[Sir Rufo]

In dein MasterForm Create gehört noch ein
inherited Create( AOwner ); rein

[Kostas]

habe ich eingefügt.
Im zweiten BaseForm hatte ich das drin.

Aber leider reicht es nicht aus. Das ist noch nicht die Ursache für die Exception.
Irgend eine Idee?

[sx2008]

Du musst nicht unbedingt einen eigenen Konstruktor erstellen.
Man kann Objekte und Daten auch über Properties und/oder Methoden übergeben.
Es gibt grundsätzlich 3 Wege über die man einem Objekt Daten mitgeben kann.
1.) Konstruktor (constructor injection)
2.) Properties (property injection)
3.) Methoden (method injection)

Normalerweise wählt man constructor injection.
Sollte das Probleme machen (und bei Delphi-Formularen macht das Probleme, weil es schon einen virtuellen Konstruktor gibt), dann kann man auch property injection oder method injection verwenden.

Delphi-Quellcode:

// Beispiel für Property Injection
TfrmMaster = class(TForm)
private 
  FMyParams : TMyParams;
public
  property MyParams:TMyParams read ... write ...;
end;

TfrmAdressen = class(TfrmMaster)
  ...
end;

// und später dann das erzeugen
var
  neuForm : TForm;
  fclass : TFormClass;
begin
  fclass := TfrmAdressen;

  neuForm := fclass.Create(Application);
  TfrmMaster(neuForm).MyParams := ....;

Dieses Einspeisen der Parameter über ein Property hat den Nachteil,
dass man das Setzen des Properties auch vergessen könnte.
Beim Konstruktor wird die Übergabe des Parameter-Objekts ja quasi vom Kompiler erzwungen.
Allerdings ist die Übergabe der Daten per Property deutlich einfacher;
insbesondere muss man keine Klimmzüge mit TFormClass & Co machen.

[Kostas]

Hallo,
warum ich TFormClass verwendet habe ist, es handelt sich um eine MDI-Anwendung. Bei MDI wir direkt nach dem Create sofort Show aufgerufen.
Ich habe also keine Möglichkeit der Form Parameter zu übergeben. Der Allgemeine Aufruf z.B.:
StartChildForm(TfrPositionsarten, Jeder, TObject(Ord(caNachFesteMasse))); hat den Vorteil dass ich über eine zentrale Methode jedes Child Form erzeugen und verwalten kann. Über das Object als Parameter kann ich
alles Mögliche als Parameter übergeben. Mache Form benötigt überhaupt keine Parameter, mache nur ein Integer und mache auch eine komplette
Liste. Damit ist alles abbildbar. Noch zudem habe ich in diesem Projekt aktuell zwei verschiedene Basisformulare aus denen geerbt wird.
Die StartChildForm soll jedoch so flexibel sein dass ich nur die Formklasse zu übergeben brauche und alles andere sollte die StartChildForm
für mich erledigen.

Ich werde auch dein Vorschlag versuchen mit der Methode. Mich würde allerdings interessieren warum das erzeugen des Forms so wie es mache nicht funktioniert.

Schon mal besten Dank für die Hilfe.
Gruß Kostas

[Olli73]

Zitat von Kostas:

  result := TfrMaster(FormClass).Create(Application,Params); //hier gibt es eine exception

Wenn ich das richtig sehe, machst du hier hier einen Typecast einer Metaklasse auf eine Klasse?

Vielleicht hilft das hier:

Delphi-Quellcode:

  type TfrMasterClass = Class of TfrMaster;
  ...
  result := TfrMasterClass(FormClass).Create(Application, Params);  //hier gibt es hoffentlich keine exception (mehr)

[Kostas]

[QUOTE=Olli73;1201563]

Zitat von Kostas:

Vielleicht hilft das hier:

Delphi-Quellcode:

  type TfrMasterClass = Class of TfrMaster;
  ...
  result := TfrMasterClass(FormClass).Create(Application, Params);  //hier gibt es hoffentlich keine exception (mehr)

das habe ich auch schon versucht. Es läst sich kompilieren, aber beim ausführen gibt es eine Exception "access violation"

[Kostas]

Jetzt funkts einwandfrei.

Umgesetzt wie empfohlen über eine virtuelle Methode.
Jetzt kann ich jedes abgeleitete Form erzeugen zentral über die Methode StartChildForm erzeugen lassen und kann beliebige Parameter übergeben.

Tausend Dank für die großartige Hilfestellung.
Gruß Kostas

[Edit]
Was mit gerade wundert, ich habe mit Absicht die Methode SetMyParams aus dem Child Form entfernt. Das Form wird erzeugt ohne eine Exception!
Ich rufe ja hier die Methode SetMyParams auf.
Eigentlich müsste man ein Interface benutzen. Dann ist man gezwungen die Methode im ChildForm zu implementieren.

Delphi-Quellcode:

with result as TfrmBaseChild do
begin
  TfrmBaseChild(result).SetMyParams(Params);
end;

Delphi-Quellcode:

{------------------------------------------------------------------------------------------------------------}
{}function TfrMain2.StartChildForm(FormClass: TFormClass; Berechtigt:TBerechtigung; Params:TObject=nil):TForm;
{------------------------------------------------------------------------------------------------------------}
 
                    {-----------------------------------------}
                    {}procedure CreateAForm(var Result: TForm);
                    {-----------------------------------------}
                    begin
                      if FormClass.InheritsFrom(TfrMaster) then
                      begin
                        result := TFormClass(FormClass).Create(Application);
                      end;

                      if (result<>nil) then
                      begin
                        with result as TfrMaster do
                        begin
                          TfrMaster(result).SetMyParams(Params);

                        end;
                        AdvToolBar1.AddMDIChildMenu(result);
                        Inc(FChildCount);
                        result.OnClose := ChildFormClose;
                        AdvOfficeMDITabSet1.AddTab(result);
                      end;
                    end;{CreateAForm}

 
begin
   CheckBerechtigtBis(Berechtigt);   //führ Abort aus falls keine Berechtigung
   result := nil;
 
   if (GetKeyState(VK_LCONTROL)<0)then  //mit Absicht eine weitere Instanz des ChildForms erzeugen
   begin
     CreateAForm(Result);
   end else
   begin     
     //existierendes Form in den Vordergrund holen
     result := BringChildFormToFront(copy(FormClass.ClassName,2,Length(FormClass.ClassName)),'');

     //neues Form erzeugen
     if (result = nil)then
     begin
       CreateAForm(Result);
     end;{if}
   end;{if}
end;{StartChildForm}

//Das Masterformular aus dem geerbt wird

Delphi-Quellcode:

unit Master;
 
interface
 
uses
   Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
   Vcl.Controls, Vcl.Forms, Vcl.Dialogs;
 
type
   TfrMaster = class(TForm)
   private
     { Private-Deklarationen }
   public
     { Public-Deklarationen }
     procedure SetMyParams(const Value: TObject); virtual;
  end;
 
var
   frMaster: TfrMaster;
 
implementation
 
{$R *.dfm}
 
{ TForm1 }
 

procedure TfrMaster.SetMyParams(const Value: TObject);
begin
  inherited;

end;
 
end.

//Das ChildForm welches aus TfrMaster erbt

Delphi-Quellcode:

unit Adressen;
 
interface
 
uses
   Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
   Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Master;
 
type
   TfrAdressen = class(TfrMaster)
   private
     { Private-Deklarationen }
    FParams:TObject;
   public
     { Public-Deklarationen }
     procedure SetMyParams(const Value: TObject); override;

   end;
 
var
   frAdressen: TfrAdressen;
 
implementation
 
{$R *.dfm}
 
procedure TfrAdressen.SetMyParams(const Value: TObject);
begin
  inherited;
  FParams := value;

end;
 

end.