Verwaltung aller Forms eines Programms

[EmWieMichael]

Hallo hgf,

ich arbeite aktuell an einer Neuprogrammierung einer Anwendung, bei der bisher quasi alle Fenster im modalen Modus geöffnet werden. Jetzt soll der Anwender die Möglichkeit haben, einzelne Arbeitsbereiche auch mehrfach öffnen zu können.
Ich registriere die Fenster (TForm) in einer eigenen Liste, die aktuell so aussieht:

Delphi-Quellcode:

  TWindowListData = Record
    WinTyp               : Integer;
    WinId                : Integer;
    WinObject            : TObject;
    MessageHandle        : HWND;
    TheMessage           : Word;
  end;

  PWindowListItem = ^TWindowListItem;
  TWindowListItem = Record
    Data                 : TWindowListData;
    Prev                 : PWindowListItem;
    Next                 : PWindowListItem;
  end;

Das Anlegen und Anzeigen eines Fensters erledigt eine globale Funktion. Owner eines jeden Fensters ist das Hauptformular. Soll ein Fenster geschlossen werden (durch Anwender) sendet das betreffende Fenster eine für den Fenstertyp individuelle Nachricht mit der Id des Fensters an das Hauptformular (z.B. WM_RELEASE_PERSFORM). Anhand der Id wird der entsprechende Record aus der Liste geholt und das Fenster gelöscht. Die Attribute MessageHandle und TheMessage dienen hier für eine optionale Nachricht, die an ein bestimmtes Fenster gerichtet werden soll, wenn das Fenster geschlossen wird (z. B. an ein aufrufendes Fenster).
Die o. g. individuelle Nachricht ist nicht unbedingt notwendig; wichtig ist nur, dass beim Schließen für das Typecasting der Fenstertyp bekannt ist, und das wird mit der Angabe in TWindowListData.WinTyp bereits erledigt.

[Rollo62]

Wäre es nicht besser die Forms gleich dynamisch zu generieren, und OnDemand zu generieren und zu starten ?
Das würde mit einer kleinen Scriptsprache, oder einer intelligenten Basis-Form oder Frame doch kaum Aufwand sein.

[TiGü]

Ich werfe eine erste Idee in den Raum, ausgehend davon, was wir schon wissen.
Geht bestimmt noch besser, eleganter, flexibler und/oder nehme-doch-dieses-Framework-ist-ja-alles-schon-drin.
Ist nur eine Diskussionsgrundlage.

Delphi-Quellcode:

program FormManagerDemo;

uses
  Vcl.Forms,
  FormManager in 'FormManager.pas',
  Unit1 in 'Unit1.pas' {MainForm},
  Unit2 in 'Unit2.pas' {Form2},
  Unit3 in 'Unit3.pas' {Form3};

{$R *.res}

begin
  ReportMemoryLeaksOnShutdown := DebugHook <> 0;
  Application.Initialize;
  Application.MainFormOnTaskbar := True;
  Application.CreateForm(TMainForm, MainForm);
  GetFormManager.RegisterForm(TForm2);
  GetFormManager.RegisterForm(TForm3);
  Application.Run;
end.

Delphi-Quellcode:

unit FormManager;

interface

uses
  System.SysUtils, System.Classes,
  System.Generics.Collections,
  Vcl.Forms;

type
  TFormManager = class(TObject)
  private
    class constructor Create;
    class destructor Destroy;
  private
    FContainer: TObjectDictionary<TFormClass, TForm>;
  public
    constructor Create;
    destructor Destroy; override;

    function GetForm<T: class, constructor>: T;
    procedure RegisterForm(const AFormClass: TFormClass);
  end;

function GetFormManager: TFormManager;

implementation

var
  _FormManager: TFormManager;

function GetFormManager: TFormManager;
begin
  Result := _FormManager;
end;

constructor TFormManager.Create;
begin
  inherited;
  FContainer := TObjectDictionary<TFormClass, TForm>.Create([doOwnsValues]);
end;

class constructor TFormManager.Create;
begin
  _FormManager := TFormManager.Create;
end;

class destructor TFormManager.Destroy;
begin
  _FormManager.Free;
end;

destructor TFormManager.Destroy;
begin
  FContainer.Free;
  inherited;
end;

function TFormManager.GetForm<T>: T;
var
  LForm: TForm;
begin
  if FContainer.TryGetValue(TFormClass(T), LForm) then
  begin
    if not Assigned(LForm) then
    begin
      LForm := TFormClass(T).Create(nil);
      FContainer.AddOrSetValue(TFormClass(T), LForm);
    end;
    Result := T(LForm);
  end else
  begin
    Result := nil;
  end;
end;

procedure TFormManager.RegisterForm(const AFormClass: TFormClass);
begin
  FContainer.Add(AFormClass, nil);
end;

end.

Delphi-Quellcode:

unit Unit1;

interface

uses
  System.Classes,
  Vcl.Controls, Vcl.Forms, Vcl.StdCtrls,
  Unit2, Unit3;

type
  TMainForm = class(TForm)
    btnForm2: TButton;
    btnForm3: TButton;
    procedure btnForm2Click(Sender: TObject);
    procedure btnForm3Click(Sender: TObject);
  private
  public
  end;

var
  MainForm: TMainForm;

implementation

{$R *.dfm}

procedure TMainForm.btnForm2Click(Sender: TObject);
begin
  Form2.ShowModal;
end;

procedure TMainForm.btnForm3Click(Sender: TObject);
begin
  Form3.ShowModal;
end;


end.

Delphi-Quellcode:

unit Unit2;

interface

uses
  System.SysUtils, System.Classes,
  Vcl.Controls, Vcl.Forms, FormManager;

type
  TForm2 = class(TForm)
  end;

  function Form2: TForm2;

implementation

{$R *.dfm}

function Form2: TForm2;
begin
  Result := FormManager.GetFormManager.GetForm<TForm2>;
end;

end.

Delphi-Quellcode:

unit Unit3;

interface

uses
  System.SysUtils, System.Classes,
  Vcl.Controls, Vcl.Forms, FormManager;

type
  TForm3 = class(TForm)
  end;

  function Form3: TForm3;

implementation

{$R *.dfm}

function Form3: TForm3;
begin
  Result := FormManager.GetFormManager.GetForm<TForm3>;
end;

end.

[Rollo62]

Als Anregung, wenn Du die Forms wirklich Alle schon statisch registrieren möchtest.
Mach das besser nicht in der DPR, sondern in jedem FormUnit, z.B. per initialization

Delphi-Quellcode:

unit Unit1;

interface

uses
  System.Classes,
  Vcl.Controls, Vcl.Forms, Vcl.StdCtrls,
  Unit2, Unit3
  , MyFormManager
  ;

type
  TMainForm = class(TForm)
  ...
  private
  public
  end;

var
  MainForm: TMainForm;

implementation

{$R *.dfm}

initialization
    TMyFormManager.RegisterForm( 'MainForm', TMainForm);

end.

So behältst Du die DPR sauber, und die Units registrieren sich selbst beim Einbinden der Unit,
ohne dass Du etwas dazu machen musst.

[TiGü]

Zitat von Rollo62:

Als Anregung, wenn Du die Forms wirklich Alle schon statisch registrieren möchtest.
Mach das besser nicht in der DPR, sondern in jedem FormUnit, z.B. per initialization

So behältst Du die DPR sauber, und die Units registrieren sich selbst beim Einbinden der Unit,
ohne dass Du etwas dazu machen musst.

Möglich, da waren wir aber vor sieben Jahren schon weiter bzw. war damals Stand der Dinge, dass dies keine gute Idee ist (ab Beitrag #14):
https://www.delphipraxis.net/178976-...gesucht-2.html

Das registrieren in der DPR wäre ja nur der erste Schritt, da dies mit suchen und ersetzen (Application.CreateForm -> IrgendwieDieReferenzAufDenFormManager.RegisterForm ) leicht zu realisieren ist.
An einen müßigen Nachmittag kann man das dann an natürlich verschieben.


Nach dem dritten Kaffee ist mir auch die Idee gekommen, das registrieren erst beim erstmaligen Aufruf zu realisieren.
So würde die Methode RegisterForm komplett wegfallen.
Das hätte in der richtigen Applikation den Vorteil, dass man ggf. neben der Mainform nur die Formulare erzeugt und registriert, die der Benutzer im jeweiligen "Durchlauf" wirklich benötigt.
Kennt ja jeder von sich selbst: Delphi-IDE, Excel und Word bieten eine Vielzahl an Oberflächen, für das schnelle Konsolenprogramm oder einen einfachen Brief brauche ich aber nichts weiter als das Hauptformular.

Der von mir vorgeschlagene Form-Manager verkürzt sich dann zu:

Delphi-Quellcode:

function TFormManager.GetForm<T>: T;
var
  LForm: TForm;
begin
  if not FContainer.TryGetValue(TFormClass(T), LForm) then
  begin
    LForm := TFormClass(T).Create(nil);
    FContainer.AddOrSetValue(TFormClass(T), LForm);
  end;
  Result := T(LForm);
end;

// TFormManager.RegisterForm und die Aufrufe können gelöscht werden

[Uwe Raabe]

Keine Ahnung, ob das relevant ist, aber der Ansatz hat den Nachteil, dass immer nur eine Instanz einer Form-Klasse existieren kann.

Ich sehe auch jetzt keinen wirklichen Vorteil in einem speziellen Form-Manager gegenüber der Nutzung von Screen.Forms[]. Jede TCustomForm/TForm-Instanz registriert sich in Screen.Forms/CustomForms in der InitializeNewForm Methode und entfernt sich im Destroy wieder. Eine simple Iteration findet ein Form nach jedem halbwegs sinnvollem Kriterium (Name, Klasse, ...). Will man es komfortabler, schreibt man einen Wrapper (z.B. class helper for TScreen). Der Regsutrierungs-Mechanismus ist vorhanden und erfordert keinen zusätzlichen Code. Warum sollte man das nicht nutzen?

Delphi-Quellcode:

type
  TScreenHelper = class helper for TScreen
  public
    function FindOrCreate<T:TForm>(const AName: string = ''): T;
  end;

function TScreenHelper.FindOrCreate<T>(const AName: string): T;
var
  frm: TForm;
  I: Integer;
begin
  for I := 0 to FormCount - 1 do begin
    frm := Forms[I];
    if (frm.ClassType = T) and ((AName = '') or SameText(AName, frm.Name)) then
      Exit(T(frm));
  end;
  Result := T.Create(nil);
  if AName > '' then begin
    Result.Name := AName;
  end;
end;

...

begin
  myForm := Screen.FindOrCreate<TMyForm>;
  myForm2 := Screen.FindOrCreate<TMyForm>('myForm2');
end;

[TiGü]

Immer wenn man denkt: "So, dass passt so, geht kaum noch einfacher", kommt Uwe und haut so einen Knüller raus.

Wobei ich aus Komfortgründen den Owner bei T.Create statt nil ggf. Application.MainForm mitgeben würde.
So spart man sich weitere Logik für das Freigeben.
Kommt aber natürlich auf den Anwendungsfall an.