[XE5]: Nutzung des Datenmoduls

[Kralle]

Hallo,

ich habe das Problem, das ich den Inhalt einer Variablen in mehreren Units nutzen will und diese Units nicht gegenseitig in die uses eintragen wiil.
Also, dachte ich mir:"Nimm doch ein Datenmodul."
Also, ein Datenmodul erstellt und die eine Variable vom Typ integer darin definiert.
Wenn ich jetzt in Unit 1 der Variablen einen Wert zuweise, kann ich ihn auch in Unit 1 wieder auslesen.
Aber, in keinen anderen Unit.
Das Datenmodul ist in den uses der units eingetragen.

Habe ich einen Denkfehler? Kann man ein Datenmodul so nicht nutzen?

Ich habe das Problem auch schon in d.c.l.d.m.
https://groups.google.com/d/msg/de.c...M/O5lJiV8DjAcJ angesprochen, aber die Lösungsvorschläge (außer neues Projekt erstellen - habe ich noch nicht gemacht) brachten nicht.

Vieleicht habe ich ja ein grundsätzlichen Gedankenfehler (in Bezug auf die Datenmodule )den wir bisher übersehen haben.

Gruß Heiko

[himitsu]

Wozu soll das Datenmodul gut sein, wenn es garnicht benutzt und nichtmal irgendwo instanziiert wird?
Eine globale Variable kann man auch so deklarieren.

Im Endeffekt läuft dein gezeigter Code darauf hinaus
und dieser ist eigentlich korrekt, auch wenn nicht unbedingt schön.

Delphi-Quellcode:

unit meineschrottigenglobalenvariablen;

interface

var
  MaxLine: integer;
  Symboltyp: Integer;

implementation

end.

Wie und wo verwendest du diese Variablen?

Antwort: Mit deinem Datenmodul ist alles in Ordnung, da es nichts macht.
Aber da du sonst alles Wichtige über die Variablen verschweigst, kann dir Keiner helfen.

[fillibuster]

Hallo,

für solche Zwecke reicht eine Unit völlig aus. Du möchtest programmweit erreichbare (also globale) Variablen:

Delphi-Quellcode:

unit globalsUnit;

interface

var
  UserId             : integer;
  UserRoleId         : integer;
  UserName           : string;


implementation

end.

Ein Datenmodul ist ja eher ein nonvisuelles Form - ich pack da immer alle meine Datenbankobjekte rein.

Viele Grüße ….

[Sir Rufo]

Als globalen Speicher immer ein Singleton (Klasse oder Interface) benutzen.

Warum:

• Zugriff kann threadsicher gemacht werden
• Auf Änderungen kann reagiert werden (im Setter)
• Abhängigkeiten zwischen den Variablen können automatisiert werden
• Speichern und Laden kann direkt in die Klasse integriert werden
• ...

Hört sich kompliziert an, ist es aber nicht.

Delphi-Quellcode:

unit GlobalStore;

interface

type
  Global = class
  private
    class var FUserID : Integer;
    class var FUserRoleID : Integer;
    class var FUsername : string;
    class procedure SetUserID( const Value : Integer );
    class procedure SetUsername( const Value : string ); static;
    class procedure SetUserRoleID( const Value : Integer ); static;
  public
    class property UserID : Integer read FUserID write SetUserID;
    class property UserRoleID : Integer read FUserRoleID write SetUserRoleID;
    class property Username : string read FUsername write SetUsername;
  end;

implementation

{ Global }

procedure Global.SetUserID( const Value : Integer );
begin
  FUserID := Value;
end;

class procedure Global.SetUsername( const Value : string );
begin
  FUsername := Value;
end;

class procedure Global.SetUserRoleID( const Value : Integer );
begin
  FUserRoleID := Value;
end;

end.

über ein Interface

Delphi-Quellcode:

unit GlobalStore;

interface

type
  IGlobal = interface
    ['{F0A0B4C5-44CF-401A-983E-B68CF010A0AD}']
    function GetUserID : Integer;
    procedure SetUserID( const Value : Integer );
    property UserID : Integer read GetUserID write SetUserID;
    function GetUserRoleID : Integer;
    procedure SetUserRoleID( const Value : Integer );
    property UserRoleID : Integer read GetUserRoleID write SetUserRoleID;
    function GetUsername : string;
    procedure SetUsername( const Value : string );
    property Username : string read GetUsername write SetUsername;
  end;

function Global : IGlobal;

implementation

type
  TGlobal = class( TInterfacedObject, IGlobal )
  private
    class var _Default : IGlobal;
  private
    FUserID : Integer;
    FUserRoleID : Integer;
    FUsername : string;
  public
    class function Default : IGlobal;
    function GetUserID : Integer;
    function GetUserRoleID : Integer;
    function GetUsername : string;
    procedure SetUserID( const Value : Integer );
    procedure SetUserRoleID( const Value : Integer );
    procedure SetUsername( const Value : string );
  end;

function Global : IGlobal;
begin
  Result := TGlobal.Default;
end;

{ TGlobal }

class function TGlobal.Default : IGlobal;
begin
  if not Assigned( _Default ) then
    _Default := TGlobal.Create;
  Result := _Default;
end;

function TGlobal.GetUserID : Integer;
begin
  Result := FUserID;
end;

function TGlobal.GetUsername : string;
begin
  Result := FUsername;
end;

function TGlobal.GetUserRoleID : Integer;
begin
  Result := FUserRoleID;
end;

procedure TGlobal.SetUserID( const Value : Integer );
begin
  FUserID := Value;
end;

procedure TGlobal.SetUsername( const Value : string );
begin
  FUsername := Value;
end;

procedure TGlobal.SetUserRoleID( const Value : Integer );
begin
  FUserRoleID := Value;
end;

end.

[Kralle]

Moin,

Zitat von himitsu:

Wozu soll das Datenmodul gut sein, wenn es garnicht benutzt und nichtmal irgendwo instanziiert wird?

Deshalb, frage ich ja hier um zu erfahren ob ich alles richtig gemachtr habe bei der Nutzung.

Zitat von himitsu:

Eine globale Variable kann man auch so deklarieren.

Ich will aber Werte die ich in einer Unit produziere in anderen Units nutzen und da sollte doch ein Datenmodul der schönere Weg sein - oder?

Zitat von himitsu:

Wie und wo verwendest du diese Variablen?

Hier wird sie gesetzt:

Delphi-Quellcode:

unit allgemein;

interface

uses
....    datenmodul;  // Einbinden um Felder deaktivieren zu können

  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form_Allgemein: TForm_Allgemein;

implementation

{$R *.dfm}


procedure TForm_Allgemein.CoB_SymboltypChange(Sender: TObject);
begin
 datenmodul.MaxLine:= CoB_Symboltyp.ItemIndex;
 CB_Activate_Symbol.Caption:=IntToStr(CoB_Symboltyp.ItemIndex)+'##'+inttostr(datenmodul.MaxLine);
end;


end.

und hier zum Beispiel genutzt:

Delphi-Quellcode:

unit anschluesse;

interface

uses
...,
   datenmodul;  // Einbinden um Felder deaktivieren zu können


  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form_Anschluesse: TForm_Anschluesse;

implementation

{$R *.dfm}


procedure TForm_Anschluesse.FormShow(Sender: TObject);
begin
 lbledt_AnzAnschluesse.EditLabel.Caption:=IntToStr(datenmodul.MaxLine);
 if  datenmodul.MaxLine in [7,8,9,10,11,12,13,14] then
   begin
     Form_Anschluesse.chklst_GAnschluesse.Enabled:=False;
     Form_Anschluesse.chklst_KAnschluesse.Enabled:= False;
     Form_Anschluesse.lbledt_AnzAnschluesse.Enabled:=False;
    end
 else

   if  datenmodul.MaxLine = 6 then
     begin
       Form_Anschluesse.chklst_GAnschluesse.Enabled:=False;
       Form_Anschluesse.chklst_KAnschluesse.Enabled:= True;
       Form_Anschluesse.lbledt_AnzAnschluesse.Enabled:=True;
     end
   else
     begin
       Form_Anschluesse.chklst_GAnschluesse.Enabled:=True;
       Form_Anschluesse.chklst_KAnschluesse.Enabled:=false;
       Form_Anschluesse.lbledt_AnzAnschluesse.Enabled:=False;
     end;




end;

Zitat von himitsu:

Antwort: Mit deinem Datenmodul ist alles in Ordnung, da es nichts macht.

Genau das ist das "Problem". Aber wenn es nichts macht, warum kann ich in der ersten Unit den Variableninhalt wieder auslesen und in der zweiten nicht?

Zitat von himitsu:

Aber da du sonst alles Wichtige über die Variablen verschweigst, kann dir Keiner helfen.

Nicht mit Vorsatz. Ich dachte ich hätte das Problem deutlich genug beschrieben ohne Quellcode posten zu müssen.

Gruß Heiko

[Kralle]

Moin,

Zitat von fillibuster:

Hallo,

für solche Zwecke reicht eine Unit völlig aus. Du möchtest programmweit erreichbare (also globale) Variablen:
Ein Datenmodul ist ja eher ein nonvisuelles Form - ich pack da immer alle meine Datenbankobjekte rein.

Viele Grüße ….

Aber, meine Variablen sind doch auch Nonvisuell.
Und da ich noch nicht weiß, was in der nächsten Ausbaustufe alles kommt, wollte ich halt jetzt schon alle "globalen" Datenspeicher an einem Ort zusammenfassen.

Gruß Heiko

[Kralle]

Moin,

Zitat von Sir Rufo:

Als globalen Speicher immer ein Singleton (Klasse oder Interface) benutzen.

Warum:

• Zugriff kann threadsicher gemacht werden
• Auf Änderungen kann reagiert werden (im Setter)
• Abhängigkeiten zwischen den Variablen können automatisiert werden
• Speichern und Laden kann direkt in die Klasse integriert werden
• ...

Hört sich kompliziert an, ist es aber nicht.

Zu mindest die "class"-Lösung kann ich was das Erstellen betrifft nachvollziehen.
Und packst Du das in eine "normale" Unit oder in ein Datenmodul?
Und wie greifst Du aus einer anderen Unit darauf zu?


Gruß HEiko

[Sir Rufo]

Bei der class Variante heißt die Klasse Global = class und bei der interface Variante gibt es eine function Global : IGlobal; .

Beide Varianten sind in der Benutzung identisch

Delphi-Quellcode:

unit Somewhere;

interface

procedure foo;

implementation

uses
  GlobalStore;

procedure foo;
begin
  if Global.UserID = 10 then
    ...
end;

[DeddyH]

Auch zu einem Datenmodul gehört eine Unit, das hat mit globalen Variablen nur sehr wenig zu tun. http://docwiki.embarcadero.com/Libra...es.TDataModule:

Zitat:

TDataModule zentralisiert die Behandlung von nicht-visuellen Komponenten in einer Anwendung.

Mit einem TDataModule-Objekt können Sie in einer Anwendung einen Ort für die zentralisierte Behandlung von nicht-visuellen Komponenten bereitstellen. In der Regel handelt es sich dabei um Datenzugriffskomponenten, wie TSQLDataSet und TSQLConnection. Datenmodule sind nicht auf Datenzugriffskomponenten beschränkt, sie können auch andere nicht-visuelle Komponenten, wie TTimer, TOpenDialog oder TImageList, enthalten.

Man nimmt also ein Datenmodul, klatscht da seine nicht-visuellen Komponenten drauf, stellt sie zur Designtime ein und kann zentral darauf zugreifen.

[TiGü]

Sir Rufo hat dir schon eine vollständige Lösung für dein Problem gezeigt.

Um sein letztes Beispiel nochmal zu verdeutlichen:

Delphi-Quellcode:

unit SomeOtherUnitFromYourProject;

interface

procedure BlaBla;

implementation

uses
  GlobalStore; //ja, das ist die gleiche Unit

procedure BlaBla;
begin
  GlobalStore.Global.UserID := 10;

  if GlobalStore.Global.UserName = 'Kralle' then
  begin
    Writeln('Brauche eigentlich für mein Problem kein Datenmodul!');
  end;
end;