TImages verwalten

[Sir Rufo]

Zitat von mkinzler:

Als Result nur im gezeigten Code wird diese vorher freigegeben ( im finally), was imho keinen Sinn macht.

Die Form-Instanz wird eben nicht freigegeben, ausser es kommt innerhalb der Methode zu einer Exception, dann wird abgebrochen, demzufolge nichts zurückgegeben und darum durch das finally die Instanz freigegeben.

Das ist eigentlich eine sehr übliche und sinnvolle Vorgehensweise wenn man nicht auf Speicherlecks steht.

Delphi-Quellcode:

function FooFactory : TFoo;
var
  LFoo : TFoo;
begin
  LFoo := TFoo.Create;
  try
    ...
    Result := Lfoo;
    LFoo := nil; // auf nil setzen
  finally
    // bei einer Exception wird die Instanz freigegeben,
    // sonst nicht, denn dann zeigt LFoo ja auf nil ;o)
    LFoo.Free;
  end;
end;

Auch wenn es sich im Beispiel um eine Komponente mit Owner handelt, was für eine korrekte Freigabe durch den Owner sorgt. Eine ungenutzte Instanz im Speicher ist zuviel und solche Fehler (Speicher läuft im Betrieb voll) sind nachher nur schwer zu finden, denn beim Beenden gibt es kein Speicherleck, dafür ist irgendwann der Speicher voll und die Anwendung verabschiedet sich.

[Schwedenbitter]

Danke. Es wird langsam klarer und zeigt sich, dass es für Gelegenheitprogrammierer wie mich schwer werden dürfte. Ich habe jetzt folgendes zusammengebastelt. Allerdings weiß ich nicht, wie ich herausbekomme, ob der Benutzer ein Form selbst mit Close "zerstört" hat:

Delphi-Quellcode:

Type
   TMainForm   = Class(TForm)
                     BtnAdd   : TButton;
                     BtnInfo   : TButton;
                     PCPics   : TPageControl;
                     Procedure FormCreate(Sender: TObject);
                     Procedure BtnAddClick(Sender: TObject);
                     Procedure BtnInfoClick(Sender: TObject);
                     Procedure FormDestroy(Sender: TObject);
                 Protected
                     fCount   : Integer;
                     fPicList   : TList;
                 End;

Var
   MainForm      : TMainForm;

Implementation

{$R *.dfm}

Procedure TMainForm.FormCreate(Sender: TObject);
Begin
   fCount:=0;
   fPicList:=TList.Create;
End;

Procedure TMainForm.BtnAddClick(Sender: TObject);
Var
   aPNG         : TPngImage;
   lForm         : TDockForm;
Begin
   aPNG:=TPngImage.Create;
   Try
      aPNG.LoadFromFile('.TestBilder\_0001.png');
      aPNG.RemoveTransparency;
      lForm:=TDockFormClass.Create(PCPics);
      Try
         lForm.ManualDock(PCPics, nil, alClient);
         lForm.Visible:=True;
         LForm.IMGScan.Picture.Bitmap.Assign(aPNG);
         Inc(fCount);
         lForm.Caption:='Bild ' + FormatFloat('0,', fCount);
         fPicList.Add(lForm);   // <- in Liste merken
         lForm:=nil;            // 1:1 übernommen
      Finally
         lForm.Free;            // 1:1 übernommen
         PCPics.ActivePageIndex:=Pred(PCPics.PageCount);
      End;
   Finally
      aPNG.Free;
   End;
End;

Procedure TMainForm.BtnInfoClick(Sender: TObject);
Var
   I            : Integer;
   lDockForm         : TDockForm;
Begin
   If (fPicList.Count = 0) Then Exit;
   I:=PCPics.ActivePageIndex;
   lDockForm:=fPicList.Items[I];// <- so greife ich jetzt zu.
   With lDockForm Do
   Try
      ShowMessage('Original' + #09 + BoolToStr(RBorgjpg.Checked, True));
   Finally
   End;
End;

Procedure TMainForm.FormDestroy(Sender: TObject);
Begin
   Try
      While (fPicList.Count > 0) Do fPicList.Delete(0);
   Finally
      fPicList.Free;
   End;
End;

End.

[edit]
Also der Zugriff klappt.
Bleibt die Frage, wie ich herausbekomme, ob der Benutzer eine Form gelöscht hat...
[/edit]

[himitsu]

Zitat von Sir Rufo:

Die Form-Instanz wird eben nicht freigegeben, ausser es kommt innerhalb der Methode zu einer Exception, dann wird abgebrochen,

Delphi-Quellcode:

LFoo := TFoo.Create;
try
  ...
  Result := Lfoo;
  LFoo := nil; // auf nil setzen
finally
  // bei einer Exception wird die Instanz freigegeben,
  // sonst nicht, denn dann zeigt LFoo ja auf nil ;o)
  LFoo.Free;
end;

Warum schreibt man den Code dann nicht so, wie das, was er machen soll und sparrt dabei auch gleich noch die leicht verwirrende doppelte Variable?

Delphi-Quellcode:

Result := TFoo.Create;
try
  ...
except
  Result.Free;
  raise;
end;

[Sir Rufo]

Ich habe das doch so geschrieben, wie das was er machen soll. Und try finally ist ein Ressourcen-Schutzblock - wenn ich mich da richtig erinnere - und genau den will ich haben und darum schreibe ich ihn so.

[himitsu]

Zitat von Sir Rufo:

das was er machen soll.

Also bei einem Fehler eine Aktion ausführen?

OK, es funktioniert Beides, aber IMHO ist es mit'm Finally etwas schneller missverständlicher.

Delphi-Quellcode:

LFoo := TFoo.Create;
try
  ...
  LFoo := nil; // Womöglich auch noch tief in irgendwelchen IFs versteckt auf nil setzen.
  ...
finally
  LFoo.Free;  // IMMER freigeben, außer irgendwo anders wurde vorher die Variable heimlich auf nil gesetzt.
end;

Delphi-Quellcode:

Result := TFoo.Create;
try
  ...
except
  Result.Free;  // NUR freigeben, wenn es geknallt hat.
  raise;
end;

Ich weiß, im Falle von Free muß nicht geprüft werden, da es das selber macht, aber irgenwie sollte man hier schon, beim Free, einen Hinweis geben ... sei es in Form eines Codes oder als Kommentar, daß sich oben irgendwo noch ein :=nil versteckt.

Delphi-Quellcode:

LFoo := TFoo.Create;
try
  ...
  LFoo := nil;
  ...
finally
  if Assigned(LFoo) then
    LFoo.Free;
end;

[Sir Rufo]

Das werde ich definitiv nicht machen, denn ich schreibe keine Kommentare, die sich auf Basis-Funktionalitäten (TObject.Free prüft selber auf assigned) beziehen, noch füge ich unnützen Code hinzu if (Assigned( LFoo ) then LFoo.Free; ). Ich schreibe keine Tutorials sondern Anwendungen und wer das verstehen möchte, der soll die Sprache beherrschen.

Wie man Instanzen aufräumt sollte eigentlich bekannt sein und gehört zum Basiswissen:

Delphi-Quellcode:

procedure Example;
var
  LFoo : TFoo;
  LBar : TBar;
begin
  LFoo := nil;
  LBar := nil;
  try
    LFoo := TFoo.Create;

    while LFoo.NeedsMore do
    begin
      LBar := TBar.Create;
      LFoo.InteractWith( LBar );
      FreeAndNil( LBar );
    end;

  finally
    LFoo.Free;
    LBar.Free;
  end;

[himitsu]

Dein finally LFoo.Free; end; wird immer ausgeführt, macht aber meistens (hoffentlich immer) nichts, was schon einen Kommentar wert wäre.

[Schwedenbitter]

Danke für Eure erhellenden Antworten. Natürlich lerne ich gern dazu. Einen "Krieg" anzuzetteln, war das Letzte, was ich mit meiner Fragestellung wollte.

Zitat von Sir Rufo:

...
Wie man Instanzen aufräumt sollte eigentlich bekannt sein und gehört zum Basiswissen:
...

Vermutlich bezog sich das auf mich. Und damit muss ich zugeben, dass mir Basiswissen fehlt. In der Regel lasse ich über meinen "fertigen" Code FastMM drüber laufen und evtl. Speicherlecks anzeigen. Bislang habe ich noch immer aufräumen können. Ich bin mir auch nicht wirklich sicher, ob wir nicht vom Selben reden. Denn das übliche Konstrukt ist mir trotzdem bekannt:

Delphi-Quellcode:

Procedure Example;
Var
   SL         : TIrgendwas;
Begin
   SL:=TIrgendwas.Create;
   Try
      SL.TuEtwas;
   Finally
      SL.Free;
   End;
End;

Ich habe jetzt aber konkret das Problem, dass meine (Object)Liste und die tatsächlich in den TabSheets vorhandenen Forms auseinanderfallen können. Denn mir fehlt immer noch das Wissen und auch eine Idee, wie die angedockte Form den Umstand des Schließens und damit das Löschen aus dem Tabsheet an das Hauptprgramm/-form weiterleitet.
Die Änderung des TabSheets wird mir über TPageControl.OnChange mitgeteilt. Aber wie filtere ich jetzt das verschwundene Fenster aus meiner Liste? Eine Idee wäre natürlich einen Zugriff zu machen, damit dann künstlich eine Exception zu erzeugen und das betreffende Fenster zu löschen; so klappt es jedenfalls. Ich kann mir aber kaum vorstellen, dass das so legitim ist:

Delphi-Quellcode:

Procedure TMainForm.PCPicsChange(Sender: TObject);
Var
   I            : Integer;
   lDockForm   : TDockForm;
Begin
   I:=0;
   While (fPicList.Count > I) Do
   Begin
      lDockForm:=fPicList.Items[I];
      Try
         lDockForm.RBorgjpg.Checked;
         Inc(I);   // <- hat geklappt, ist also noch vorhanden
      Except
         fPicList.Delete(I);
      End;
   End;
End;

Daher eben nochmal meine Frage, wie man das macht richtig?

Gruß, Alex

[Jumpy]

Die ganzen DockFormen werden ja im Hauptformular/Programm kreiert.
Da könntest du denen doch eine Callback-Funktion mitgeben, die im OnClose des DockFormulars ausgelöst wird. Methodenzeiger ist hier glaub ich das Stichwort.