Globale Variable - Definition

[haentschman]

Hallo alle...

ich bin verwirrt... Entweder zu spät oder überarbeitet. :oops:

Ich habe eine Klasse welche über den gesamten Lebenszyklus der Anwendung existiert (Properties). Die einzige Instanz der Klasse soll von allen Formularen "erreichbar" sein. Da sowieso ein DataModule existiert dachte ich rein damit nach folgendem Muster.

Delphi-Quellcode:

.
.
type
  TDataModuleCommon = class(TDataModule)
    .
    .
    procedure DataModuleCreate(Sender: TObject);
    procedure DataModuleDestroy(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  DataModuleCommon: TDataModuleCommon;
  dBK: TdBK;
implementation

{$R *.dfm}

procedure TDataModuleCommon.DataModuleCreate(Sender: TObject);
begin
  dBK:= TdBK.Create;
end;

procedure TDataModuleCommon.DataModuleDestroy(Sender: TObject);
begin
  dBK.Free;
end;

die Frage: Zählt rein Definitionstechnisch die Instanz von dBK als globale Variable ?

Für Anregungen dankbar... :hi:

[nuclearping]

Ja, das sollte so funktionieren. Alternativ würde ich aber die Instanz von dBK im initialization / finalization Part der Unit verarbeiten.

[s.h.a.r.k]

Warum wirfst du die Variable dBK nicht in die Klasse TDataModuleCommon rein?

[haentschman]

Hatte ich zuerst. Da mußte aber noch jedesmal beim Aufruf DataModuleCommon davor.

Beispiel: DataModuleCommon.dBK.Properties.Database.Host war mir irgendwie zu lang jedesmal. Mit obigem Muster fällt dann im Aufruf DataModuleCommon weg. Nur ist das dann mit einer globalen Variable vergleichbar ?

Danke...

[s.h.a.r.k]

Ich mache es bisher immer so, dass ich Variablen in entsprechende Objekte kapsle. Bin ich dann mal zu faul es immer auszuschreiben baue ich mir eine "Shortcut"-Funktion, die mir eben das Objekt liefert :stupid: Ist vor allem dann hilfreich wenn ich Singleton-Pattern einsetze.

[himitsu]

Delphi-Quellcode:

type
  TDataModuleCommon = class(TDataModule)
    .
    .
    procedure DataModuleCreate(Sender: TObject);
    procedure DataModuleDestroy(Sender: TObject);
  private
    { Private-Deklarationen }
    FdBK: TdBK;
  public
    { Public-Deklarationen }
    property dBK: TdBK;
  end;

var
  DataModuleCommon: TDataModuleCommon;


// DataModuleCommon.dBK

Wenn die DB auch schon existieren soll, dann müßte/könnte man dieses als class var und class property deklarieren und in initialzation der Unit erstellen.

[haentschman]

Danke an alle...
@himi: das ist der normale Weg. Da hab ich immer noch DataModuleCommon davor. Ich bin halt schreibfaul und die Kettenaufrufe mag ich nicht. Mit Generics läßt sich das doch etwas verbessern... muß ich mal lesen.

[himitsu]

Ich wüßte jetzt nicht was hier jetzt die Generics helfen sollen,
aber die Generics funktionieren auch nur in Klassen.

[omata]

Wie wäre es mit einer eigenen Unit?

Delphi-Quellcode:

unit dBKU;

interface

type
  TdBK = class
   :
   :
  end;


function dBK: TdBK;

implementation

var
  gdBK: TdBK;

function dBK: TdBK;
begin
  Result:=gdBK;
end;

initialization
  gdBK:= TdBK.Create;

finalization
  gdBK.Free;

end.

So ist keine projekt-globale-Variable vorhanden.

[himitsu]

Delphi-Quellcode:

function dBK: TdBK;
begin
  if not Assigned(gdBK) then
    gdBK := TdBK.Create;
  Result := gdBK;
end;

initialization

finalization
  gdBK.Free;

end.

So sieht es doch auch nett aus.

[s.h.a.r.k]

Ich hab das immer so :stupid:

Delphi-Quellcode:

TSingletonClass = class(TObject)
private
  class var FInstance;
  class procedure Init();
  class procedure Finalize();
  constructor Create(); reintroduce;
public
  class function GetInstance(): TSingletonClass;
  destructor Destroy();
end;

function ShortcutName(): TSingletonClass;

implementation

class procedure TSingletonClass.Init();
begin
  { ... }
end;

class procedure TSingletonClass.Finalize();
begin
  { ... }
end;

class function TSingletonClass.GetInstance(): TSingletonClass;
begin
  if (not Assigned(TSingletonClass.FInstance)) then
    TSingletonClass.FInstance := TSingletonClass.Create();
  Resul := TSingletonClass.FInstance;
end;

function ShortcutName(): TSingletonClass;
begin
  Result := TSingletonClass.GetInstance();
end;

initialization
  TSingletonClass.Init();

finalization
  TSingletonClass.Finalize();

Bitte aber die ShortcutName()-Methode umbenennen ;)

[omata]

gdBK sollte aber initialisiert werden!

Zitat:

Zitat von himitsu (Beitrag 1100835)

Delphi-Quellcode:

function dBK: TdBK;
begin
  if not Assigned(gdBK) then
    gdBK := TdBK.Create;
  Result := gdBK;
end;

initialization
  gdBK:=nil;

finalization
  gdBK.Free;

end.

[Wolfgang Mix]

Es ist zwar schon spät, aber fehlt da nicht ein ELSE-Teil?

[s.h.a.r.k]

Wo genau? Ich glaube aber nein. Das Objekt muss ja immer zurückgegeben werden. Wenn es bisher nur noch nicht existiert, dann muss es vorher noch erzeugt werden.

[Namenloser]

@s.h.a.r.k: So ähnlich mach ich es auch. Aber sollte nicht der Destruktor auch privat sein?

[himitsu]

Zitat:

Zitat von omata (Beitrag 1100840)

gdBK sollte aber initialisiert werden!

Globale Variablen und Variablen in Objekten werden immer automatisch initialisiert. (mit 0 / nil / #0 / '' )

Nur bei den lokalen Variablen sieht das anders aus, denn dort wird es aus Performancegründen oftmals nicht gemacht (außer bei String dyn. Array und Interface)
und bei vielem Anderem, was sonst noch von irgendwo anders herkommt (z.B. GetMem und Co.).

[s.h.a.r.k]

Zitat:

Zitat von NamenLozer (Beitrag 1100853)

@s.h.a.r.k: So ähnlich mach ich es auch. Aber sollte nicht der Destruktor auch privat sein?

So weit ich weiß geht das nicht. Hatte da schon viel probiert. Aber so ein richtiges Singleton Pattern kann Delphi leider nicht.

[himitsu]

Private kann der Destructer überhaupt nicht sein.
Denn wir überschreiben ja diesen und ein Nachfahre möchte dieses auch gerne tun können, was mit Private nicht möglich wäre :zwinker:

Aber Protected wäre ein gutes Fleckchen dafür.

[Namenloser]

Zitat:

Zitat von himitsu (Beitrag 1100868)

Private kann der Destructer überhaupt nicht sein.
Denn wir überschreiben ja diesen und ein Nachfahre möchte dieses auch gerne tun können, was mit Private nicht möglich wäre :zwinker:

Aber Protected wäre ein gutes Fleckchen dafür.

Hmm ja, ich habe dafür wahrscheinlich auch protected genommen. Private vermeide ich eher, weil jeder, der schon mal versucht hat, gewisse VCL-Klassen zu erweitern, weiß, wie ärgerlich es ist, wenn man später wider Erwarten doch noch mal Zugriff auf eine private Deklaration braucht...

[sx2008]

Zitat:

Zitat von s.h.a.r.k (Beitrag 1100867)

Aber so ein richtiges Singleton Pattern kann Delphi leider nicht.

Ist aber nicht schlimm oder sogar eher positiv zu sehen, denn wenn das Singleton Pattern gehäuft in einer Anwendung auftritt führt es zu negativen Effekten (z.B. mangelnde Testbarkeit, erschwerte Fehlersuche, starke Kopplung zwischen den Units,...).

Die Lösung der Probleme mit den globalen Variablen und Singleton bietet die Dependency Injection.
Es braucht aber einige Wochen oder Monate bis man es begriffen und akzeptiert hat.