Verständnisfrage zu Unit: Initialization und Finalization

[DeddyH]

Initialization und Finalization kommen vor das abschließende "end." der entsprechenden Unit. Innerhalb dieser kannst Du nur auf "globale" Dinge zugreifen, z.B. globale Variablen initialisieren. Die Abschnitte werden aufgerufen, sobald die enthaltende Unit eingebunden wird bzw. als letztes bei Programmende (vereinfacht ausgedrückt).
Beispiel (aus dem Hut, kann daher Fehler enthalten):

Delphi-Quellcode:

unit Dings;

interface

type
  //Kleine Klasse
  TTest = class
    //weiteren Code brauchen wir hier nicht
  end;

var
  //globale Instanzvariable der Klasse
  Test: TTest;

implementation

//Direkt beim Einbinden Instanz von TTest erzeugen
initialization
  Test := TTest.Create;

//Ganz am Ende Instantz wieder freigeben
finalization
  Test.Free;

end.

[Ghostwalker]

Kleine Anmerkung noch:

Das ganze funktioniert natürlich auch in DLL's. Sobald also die DLL geladen wird, wird INITIALIZATION ausgeführt, beim freigeben der FINALIZATION teil.

[SebastianZ]

*zweite seite übersehen*:roll:

[hoika]

Hallo,
ich würde das nur benutzen, wenn es wirklich einen wichtigen Grund gibt.

Warum?
die Reihenfolge des Codes wird durch die uses-Reihenfolge,
also die Einbindungs-Reihenfolge der Units bestimmt.

Viel Spaß beim Debuggen von Abhängigkeiten zwischen Units.

(Unit A benutzt ein Unique-Pattern aus Unit B, wass zu früh freigegeben wird.)

[TRomano]

Ja, so etwas sollte man nur benutzen, wenn der Code, die Strukturen in dieser Unit komplett unabhängig vom Programm sind.
z.B. für System-Units wie CPU auslesen, OS-Versionen usw.

[himitsu]

Für "Komponenten" verwende ich stattdessen lieber Class-Constructor und Class-Destructor.

Grund: So kann der Compiler Linker die Klasse/Komponente wegoptimieren.
Über Initialization wird die Klasse/Komponente immer einkompilert/initialisiert, selbst wenn sie nicht verwendet wird. (sieht man zu gut an der RTL/VCL, wo man ständig allen Müll mitschleppt und sich jeder über große EXEn beschwert)

Leider ist bei Ressourcen der Linker zu doof.

[ConnorMcLeod]

gugl ist Dein Freund... erster Treffer bei der Suche nach "Delphi initialization" ;-)
https://www.delphi-treff.de/object-p...rogrammaufbau/

[Blup]

Ich verwende Initialization und Finalization, da es im Delphi2007 Class-Constructor und Class-Destructor noch nicht gibt.

Beispiel:

Delphi-Quellcode:

unit MyFactory;

interface

uses
  Contnrs;

type
  TMyObject = class abstract(TObject)
  end;

  TMyClass = class of TMyObject;

  TMyFactory = class(TObject)
  private
    class var
      FClassList: TClassList;
  protected
    class procedure Initialize;
    class procedure Finalize;
  public
    class procedure RegisterClass(AClass: TMyClass);
    class procedure UnRegisterClass(AClass: TMyClass);
  end;

implementation

class procedure TMyFactory.Initialize;
begin
  FClassList := TClassList.Create;
end;

class procedure TMyFactory.Finalize;
begin
  FClassList.Free;
end;

class procedure TMyFactory.RegisterClass(AClass: TMyClass);
begin
  FClassList.Add(AClass);
end;

class procedure TMyFactory.UnRegisterClass(AClass: TMyClass);
begin
  FClassList.Remove(AClass);
end;

initialization
  TMyFactory.Initialize;

finalization
  TMyFactory.Finalize;

end.