Contructor des verbten Forms aufrufen

[Kostas]

Hallo Zusammen,

sorry für den schlechten Titel.

Ich habe eine MDI Anwendung. Bei diesem Projekt gibt es ein leeres TfrMaster Form aus diesem alle andere Form erben.
Damit jeder Form auch Parameter beim Create übergeben werden kann, habe ich den Constructor von TfrMaster überschrieben
und erweitert.
Constructor Create(AOwner: TComponent; aParams:TObject); overload; Zusätzlich habe ich eine allgemeingültige Methode erstellt die jede Form erzeugen kann.
{}function TfrMain.StartChildForm(FormClass: TFormClass; Berechtigt:TBerechtigung; Params:TObject=nil):TForm; Was mir jetzt nicht klar ist, wie erzeuge ich das Form mit dem neuen Constructor und wie muss der Construktor im abgeleiteten Form
aussehen damit er aufgerufen wird?


Das ist das MasterForm aus diesem alle Andere Form erben sollen.

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); overload;
  end;

var
  frMaster: TfrMaster;

implementation

{$R *.dfm}

{ TForm1 }

constructor TfrMaster.Create(AOwner: TComponent; aParams: TObject);
begin
  //Wird bei jeder erzeugten Form aufgerufen
  inherited create(AOwner);
  FParams := aParams;

end;


end.

Das ist eine abgeleitete Form. Der Constructor wird nicht aufgerufen um die Parameter konsumieren zu können

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); overload;
  end;

var
  frAdressen: TfrAdressen;

implementation

{$R *.dfm}

constructor TfrAdressen.Create(AOwner: TComponent; aParams: TObject);
begin
  //Wird nicht aufgerufen!
  inherited create(AOwner);
  FParams := aParams;

end;


end.

Delphi-Quellcode:

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

                    {-----------------------------------------}
                    {}procedure CreateAForm(var Result: TForm);
                    {-----------------------------------------}
                    begin
                      //Wie das ChildForm erzeugen?
                      result := FormClass.Create(Application);  <<< so gehts, aber ohne Parameterübergabe
                      result := FormClass.Create(Application, Params);  <<< so gehts nicht. Typcast?
                      with  result as TfrMaster do
                      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;

Herzlichen Dank für die Hilfestellung.
Gruß Kostas

[Sir Rufo]

Deklariere den Constructor im Masterform als virtuell und in den abgeleiteten dann mit override

Dann klappts auch mit dem Nachbarn (Nachfahren)

[Kostas]

Dankeschön für die Torboschnelle Antwort.
Kanst du mir bitte auch noch behilflich sein beim erzeugen fes Forms in CreateAForm und bitte wie müsste der Constructor
in dem abgeleiteten Form aussehen ist der so in ordnung?

[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"