dynamisch erzeugte Forms richtig freigeben

[Sir Rufo]

Eine dynamische Dialog-Form gibt man einfach wieder frei:

Delphi-Quellcode:

procedure Foo;
var
  LForm: TForm;
begin
  LForm := TFooDialo.Create(nil);
  try
    case LForm.ShowModal of
      mrOK : 
        begin
          ...
        end;
      mrCancel :
        begin
          ...
        end;
      ...
    end;
  finally
    LForm.Free;
  end;
end;

Wenn in dem Dialog noch weitere Daten erfasst werden sollen, dann übergibt man vor dem Anzeigen diese Daten und holt sich diese im Erfolgsfall wieder ab:

Delphi-Quellcode:

type
  TFooData = class( TPersistent )
  public
    property SomeStr: string;
    property SomeBool: Boolean;
  end;

type
  TFooDialog = class( TForm )
    Edit1: TEdit;
    Checkbox1: TCheckBox;
  private
    procedure AssignTo( FooData: TFooData ); overload;
    procedure AssignFrom( FooData: TFooData );
  protected
    procedure AssignTo( Dest: TPersistent ); overload; override;
  public
    procedure Assign( Source: TPersistent ); override;
  end;

procedure TFooDialog.AssignTo( FooData: TFooData );
begin
  FooData.SomeStr := Edit1.Text;
  FooData.SomeBool := CheckBox1.Checked;
end;

procedure TFooDialog.AssignFrom( FooData: TFooData );
begin
  Edit1.Text := FooData.SomeStr;
  CheckBox1.Checked := FooData.SomeBool;
end;

procedure TFooDialog.AssignTo( Dest: TPersistent );
begin
  if Dest is TFooData then
    AssignTo( TFooData( Dest ) )
  else
    inherited;
end;

procedure TFooDialog.Assign( Source: TPersistent );
begin
  if Source is TFooData then
    AssignFrom( TFooData( Source ) )
  else
    inherited;
end;

und dann so

Delphi-Quellcode:

procedure Foo( FooData: TFooData );
var
  LDialog: TForm;
begin
  LDialog := TFooDialog.Create( nil );
  try
    LDialog.Assign( FooData ); // Daten an die Form schreiben
    if LDialog.ShowModal = mrOK then
      FooData.Assign( LDialog ); // Daten von der Form lesen
  finally
    LDialog.Free;
  end;
end;

[Hansa]

Wenn man von der Überschrift ausgeht :

Zitat:

dynamisch erzeugte Forms richtig freigeben

dann bin ich etwas erstaunt, dass bisher kein einziges mal das Wort caFree vorkam.

Wenn das OnClose so aussieht :

Delphi-Quellcode:

procedure Tfrm.FormClose(Sender: TObject; var Action: TCloseAction);
var FensterIni,
    SonstIni : TIniFile;
begin
  inherited;
// wenn nötig hier noch andere Aktionen ausführen.
  Action := caFree;
end;

dann ist die Form freigegeben und fertig. Egal, ob sie mit Alt-F4, Schliess-x usw. geschlossen wird.

[Sir Rufo]

Was sich bei einem Dialog - der auch noch dynamisch erzeugt wird und man den direkt an der festen Leine hat - richtig gut macht. Da ist der weg, bevor ich mir das Ergebnis nach dem ShowModal holen kann.

[BadenPower]

Zitat von Sir Rufo:

Da ist der weg, bevor ich mir das Ergebnis nach dem ShowModal holen kann.

Dann gehst Du den anderen Weg und läßt die Modal-Form vorher die Werte an den Aufrufer übergeben.

[Sir Rufo]

Zitat von BadenPower:

Zitat von Sir Rufo:

Da ist der weg, bevor ich mir das Ergebnis nach dem ShowModal holen kann.

Dann gehst Du den anderen Weg und läßt die Modal-Form vorher die Werte an den Aufrufer übergeben.

Ja, das würde schon gehen, allerdings ist es schwierig, das in einem robusten Code zu gießen.

Hier wird die Dialog-Instanz immer freigegeben:

Delphi-Quellcode:

LDialog := TDialog.Create(nil);
try
  LDialog.Assign( LDialogData );
  if LDialog.ShowModal = mrOK then
    LDialogData.Assign( LDialog );
finally
  LDialog.Free;
end;

wenn der Dialog sich selber aus dem Speicher räumt und vorher aber noch die Daten irgendwo hinschreiben soll, dann kann es aufgrund einer Exeption dazu kommen, dass die Instanz doch nicht freigegeben wird.

Gut ich kann dort natürlich im Dialog die Exception fangen und dann irgendwie durchreichen, oder so ... oder ich mache es mir einfach (s.o.) und bekomme dort alles mit und trotzdem ist alles immer sauber.

Jeder wie er mag, aber ich mag halt robust und sauber ...

[Stevie]

Zitat von Sir Rufo:

ich mag halt robust und sauber ...

Ich auch, aber bisher seh ich da eher 8 Zeilen Boilerplate code. Das kannst du doch besser, oder?

[redox]

Zitat von Stevie:

Zitat von Sir Rufo:

ich mag halt robust und sauber ...

Ich auch, aber bisher seh ich da eher 8 Zeilen Boilerplate code. Das kannst du doch besser, oder?

..und vor Allem mit einem Backup zu viel als einem Backup zu wenig

Wer weiß schon, was sich der ursprüngliche Programmierer gedacht hat bei seinem (eventuell bewußten?) Verzicht auf ShowModal...

LG