Zugriff auf unitübergreifende Variablen

[Delphi-Laie]

Hallo Delphifreunde!

Über die Kahale-Diskussion gelangte ich zur Aufgabenstellung der FH Wedel und von dort blieb mein Interesse am Programmierstil Pascal und Programmierstil Delphi hängen. Folgendes war mir - mehr oder weniger - neu:

Für Pascal:

„Die Verwendung globaler Variablen ist zu vermeiden.
Der größte erlaubte Sichtbarkeitsbereich ist der Implementation-Teil einer Unit.“

Ersteres ist klar, auch wenn es (mir) nicht immer ganz gelingt. Aber ist eine für eine Unit (ab Implementation) definierte Variable nicht global? Global ist für mich alles, was außerhalb von Routinen definiert wird.

„Sollte ein größerer Sichtbarkeitsbereich benötigt werden, so finden Zugriffsfunktionen Verwendung.“

Konsistent wird das dann auch für Delphi erweitert:

„Keine Prozedur/Funktion greift direkt auf Komponenten (oder Variablen) in einem anderen Formular zu. Stattdessen wird eine Funktion des anderen Formulars nach einem Wert gefragt oder eine Prozedur aufgerufen, die die Änderungen einträgt.“

Das soll erstmal genügen.

Lange Rede, kurzer Sinn: Sind diese Programmieranforderungen eine persönliche Eigenliebe der Frau Dipl.-Ing. (FH) Gerit Kaleck (oder des Inhabers des Lehrstuhles, an dem sie wirkt), oder sind sie Allgemeingut, und gehört die Beachtung dieser Regeln demnach zum guten Programmierton?

[himitsu]

Dann unterscheide nicht nur Global und Lokal.
Es ist halt so seine Sache und sollte weiter differenziert werden.

Application-Global > Interface und Public-Var/Public-Class-Var
Unit-Global > Implementation und Private/Protected, sowie Public-Var/Public-Class-Var von Klassen-Definitionen in der Implementation.
Klassen-Global > Private Strict-Private und Protected Protected-Private
Prozedur-Global > in Prozedur (inkl. Parametern), aber vor Nested-Prozeduren
Lokal > in Prozedur, direkt vor dem ersten BEGIN


Alles Öffentliche von Klassen sollte immer als Property rausgegeben werden, auch wenn erstmal diret auf die Variable, also ohne Getter und Setter.

[Sir Rufo]

Wenn du wirklich etwas Globales benötigst, dann verwende eine statische Klasse mit Eigenschaften.

statt

Delphi-Quellcode:

unit uGlobal;

interface

var
  foo : Integer;

inmplementation

end.

das hier

Delphi-Quellcode:

unit uGlobal;

interface

type
  Globals = class abstract
  private
    class var _Foo: Integer;
    class function GetFoo; static;
    class procedure SetFoo( const Value: Integer ); static;
  public
    class property Foo : Integer read GetFoo write Setfoo;
  end;

implementation

class function Globals.GetFoo: Integer;
begin
  Result := _Foo;
end;

class procedure SetFoo( const Value: Integer );
begin
  _Foo := Value;
end;

end.

[DeddyH]

Das dürfte unter Delphi 5 aber schwierig werden ;)

[Delphi-Laie]

Leute, besten Dank, das muß ich erstmal wieder sacken lassen....