Variablen/Objecte Applicationsweit verfügbar machen

[himitsu]

Durchreichen hat aber den Vorteil, dass alle Programmmodule unabhängig, wiederverwenbar und einzeln Testbar/austauschbar sind,
wenn die keine Verbindung zur TForm1 haben.

Klar, manche kommen jetzt vielleicht auch auf die Idee überall Unit1 einzubinden und dann über Form1.TestListe drauf zuzugreifen (die Variable oder ein Property in Public),
anstatt diese Variable in eine gemeinsame Unit auszulagern und sie überall einzubinden.


Mal ein Beispiel für
* Klassen-Methoden/Property statt globalen Variablen
* Klassen-Konstructororen statt Initialization

Die Delphi-Programme würden schneller starten und, bräuchten weniger RAM und hätten kleinere EXEn, wenn die RTL/VCL/FMX nicht ständig alles in Initialiazation machen würden, was dann eh fast niemand braucht, aber durch das Initialization ständig mit eingebunden wird.

Kann man auch in einen Record oder die TTestList-Klasse einfügen.

Delphi-Quellcode:

type
  TTestObject = class
  private
    Fblabla: string;
    procedure Setblabla(const Value: string);
  published
    property blabla: string read Fblabla write Setblabla;

  private class var
    FTestListe: TObjectList<TTestObject>;
  private
    class function GetTestListe: TObjectList<TTestObject>; static;
  public
    //class constructor Create;  // statt des initialization, aber wird nur aufgerufen, wenn die Klasse TTestObject auch im Programm verwendet wird
    //property TestListe: TObjectList<TTestObject> read FTestListe;
    class property TestListe: TObjectList<TTestObject> read GetTestListe;  // erst erzeugen, wenn auch wirklich gebraucht wird (alternativ eben schon im class constructor)
    class destructor Destroy;  // statt des finalization, aber wird nur aufgerufen, wenn die Klasse TTestObject auch im Programm verwendet wurde
  end;

implementation

{ TTestObject }

procedure TTestObject.Setblabla(const Value: string);
begin
  Fblabla := Value;
end;

class function TTestObject.GetTestListe: TObjectList<TTestObject>;
begin
  if not Assigned(FTestListe) then
    FTestListe := TTestList.Create(True);
  Result := FTestListe;
end;

class destructor TTestObject.Destroy;
begin
  FreeAndNil(TestListe);  // bei globalen Variablen besser immer FreeAndNil, statt Free ... dann knallt es schöner, wenn jemand nach Freigabe nochmal grauf zugreift
end;

Und zum Thema Synchronisation, falls aus mehreren Threads zugegriffen wird, wurde schon viel geschrieben,
aber ich erwähne auch mal die TThreadList.