Globale Variablen und Sichtbarkeit

[Benedikt Magnus]

Zitat von Amicello:

Eine Unit greift hier auf die Funktionen der anderen zu - und natürlich umgekehrt, aber die Units gegenseitig in die Uses-Blöcke einzutragen ist natürlich Käse.

Zirkuläre Unitnutzung ist in einem Falle wie deinem durchaus angebracht. Das geht in Delphi, indem du nicht die Usesblöcke im interface-Abschnitt nutzt, sondern sie im implementation-Abschnitt einträgst. Wenn du im interface auf eine andere Unit zugreifst, dann natürlich im interface eintragen. Nur bei lediglich einer von beiden muss es im implementation-Teil sein. Zirkuläre Zugriffe im interface-Teil lassen sich aber in aller Regel vermeiden.

Delphi-Quellcode:

unit Unit1;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics, Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls;

type
  TForm1 = class(TForm)
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

uses
  Unit2, Unit3;

{$R *.dfm}

end.

[Bjoerk]

Du hast Logik und Darstellung ja schon getrennt. Fein.

Wie wär es, wenn TMainform die Instanzen der Klassen erstellt und sie an die anderen Formulare verteilt. Am besten gleich über den Konstruktor, (die automatische Erzeugung dieser Formulare dann aus den Projektoptionen heraus nehmen).

Beispiel:

Delphi-Quellcode:

procedure TMainForm.FormCreate(Sender: TObject);
begin  
  FSomeClass := TSomeClass.Create;
  Form2 := TForm2.Create(Self, FSomeClass);
end;

procedure TMainForm.FormDestroy(Sender: TObject);
begin
  FSomeClass.Free;
end;

In TForm2 überschreiben wir den Konstruktor der Form:

Delphi-Quellcode:

type
  TForm2 = class(TForm)
  private
    FSomeClass: TSomeClass;
  public
    constructor Create(AOwner: TComponent; const Value: TSomeClass); reintroduce; overload;
  end;

var
  Form2: TForm2;

implementation

{$R *.DFM}

constructor TForm2.Create(AOwner: TComponent; const Value: TSomeClass);
begin
  inherited Create(AOwner);
  FSomeClass := Value;
end;

[jaenicke]

Zitat von Benedikt Magnus:

Zirkuläre Unitnutzung ist in einem Falle wie deinem durchaus angebracht.

Möglich ist das sicher, aber angebracht oder sinnvoll nicht. Denn dadurch verzahnt man Code miteinander viel zu sehr. Dadurch ist er dann kaum testbar oder wartbar.
Denn wie willst du Code sinnvoll testen, der nicht eine Eingabe bekommt und ein Ergebnis liefert, sondern der auf einer GUI etwas mit einem Control macht?
(Klar muss man auch so etwas testen, aber das ist dann nicht die Businesslogik, sondern die GUI-Logik.)

Wie es sauber geht hat BUG ja oben schon geschrieben, mit Interfaces.