[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 :-D )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:

Zitat von himitsu (Beitrag 1245572)

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:

Zitat von himitsu (Beitrag 1245572)

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:

Zitat von himitsu (Beitrag 1245572)

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:

Zitat von himitsu (Beitrag 1245572)

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:

Zitat von himitsu (Beitrag 1245572)

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:

Zitat von fillibuster (Beitrag 1245573)

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:

Zitat von Sir Rufo (Beitrag 1245575)

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

Delphi-Quellcode:

class

Variante heißt die Klasse

Delphi-Quellcode:

Global = class

und bei der

Delphi-Quellcode:

interface

Variante gibt es eine

Delphi-Quellcode:

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;

[Sir Rufo]

Und wenn man den GlobalStore mit ein wenig Logik versieht, dann wird beim Setzen von

Delphi-Quellcode:

Global.UserId

auch schon passend dazu

Delphi-Quellcode:

Global.UserRoleID

und

Delphi-Quellcode:

Global.Username

gesetzt.

Oder das passiert auch beim Setzen des Usernamen (UserID, UserRoleID).

UserRoleID könnte zudem auch ReadOnly sein :)

Oder alle Felder sind ReadOnly und es gibt noch eine Login-Methode die dann diese Felder setzt.
Oder ...

[sx2008]

Folgende zwei Codefragmente sind äquivalent:

Delphi-Quellcode:

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;

Das ist im Prinzip nix anderes wie 3 globale Variablen

Delphi-Quellcode:

var
  UserID : Integer;
  UserRoleID : Integer;
  Username : string;

Ob man jetzt noch ein Interface darüberlegt oder den Username automatisch mit der UserID setzt ändert nichts daran dass hier ein "Sack voller globaler Variablen" vorliegt.
Ich habe dazu ein Tutorial geschrieben das für den Einen oder Anderen interessant sein könnte.

[himitsu]

Der Vorteil es nicht nur als viele globale Variablen zu machen, ist der, daß man sich später problemlos da überall reinhängen kann, ohne daß am Aufrufenden Code etwas geändert werden muß.

Das reicht schon vollkommen.

Delphi-Quellcode:

type
  Global = class abstract
  private class var 
    FUserID : Integer;
    FUserRoleID : Integer;
    FUsername : string;
  public
    class property UserID : Integer read FUserID write FUserID;
    class property UserRoleID : Integer read FUserRoleID write FUserRoleID;
    class property Username : string read FUsername write FUsername;
  end;

Getter und Setter läßt sich nachträglich einfügen und schon kann man Code für eine Werte-Kontrolle der Felder integrieren, oder ein Logging oder oder oder...

Und viel mehr Aufwand ist es auch nicht.

Delphi-Quellcode:

type
  Global = class abstract
    class property UserID : Integer;
    class property UserRoleID : Integer;
    class property Username : string;
  end;

Nun nur noch Strg+Alt+C (Klassenvervollständigung) und fertig isses.


OK, abgesehn von dem BUG, welcher hier grade auftritt.
Denn so sollte das Ergebnis der Klassenvervollständigung wirklich nicht aussehn.

Delphi-Quellcode:

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

[Sir Rufo]

Zitat:

Zitat von sx2008 (Beitrag 1245658)

Folgende zwei Codefragmente sind äquivalent:
...
Das ist im Prinzip nix anderes wie 3 globale Variablen
...
Ob man jetzt noch ein Interface darüberlegt oder den Username automatisch mit der UserID setzt ändert nichts daran dass hier ein "Sack voller globaler Variablen" vorliegt.

Ja richtig, nur mit dem kleinen aber feinen Unterschied, dass globale Variablen unkontrollierbar und damit/darum böse sind.
In einer Klasse/Interface werden die aber kontrollierbar.

[Perlsau]

Wieso kann man eigentlich keine Class Const deklarieren, und auch kein Class Type? Ich hab diese geniale Idee mit den Klassenvariablen nämlich gleich mal ausprobiert, um nicht immer alles im Datenmodul deklarieren zu müssen.

[Sir Rufo]

Zitat:

Zitat von Perlsau (Beitrag 1245704)

Wieso kann man eigentlich keine Class Const deklarieren, und auch kein Class Type? Ich hab diese geniale Idee mit den Klassenvariablen nämlich gleich mal ausprobiert, um nicht immer alles im Datenmodul deklarieren zu müssen.

Weil es unnötig ist ;)

Die Konstanten sind immer da und erreichbar und die Types auch

[Perlsau]

Hab Dank, Sir Rufo, genau das hatte ich vermutet, denn es hat bei Const und Type auch ohne vorangestelltes Class funktioniert :thumb:

[himitsu]

Es gibt

Delphi-Quellcode:

class abstract

, wo der Compiler und auch zur Laufzeit eine Exception werfen sollte, wenn man versucht davon eine Instanz zu createn. (die weitere Vererbung könnte man auch noch abschalten)
Und du kannst es auch gerne als Record deklarieren.

In die Klasse rein, kann man auch noch abhängige/private Typen und Konstanten aufnehmen, welche dann nicht im Kontext der Unit "öffentlich" rumschwirren.

[Kralle]

Hallo,

erstmal Entschuldigung das ich erst jetzt antworte.

Ich habe gerade versucht das jetzt umzusetzen - leider ohne Erfolg.
Ich habe eine neue Unit angelegt und so gefüllt:

Delphi-Quellcode:

unit datenmodul;

interface
 type
   Global = class
     private
       class var FSymboltyp : Integer;
       class procedure SetSymboltyp (const Value : Integer);
     public
       class property Symboltyp : Integer read FSymboltyp write SetSymboltyp;
   end;

implementation

procedure Global.SetSymboltyp(const Value : Integer);
 begin
   FSymboltyp:=Value;
 end;

end.

Wenn das Projekt erstellen will bekomme ich diese Fehlermeldungen:

Zitat:

[dcc32 Fehler] datenmodul.pas(10): E2355 Für den Zugriff auf Klasseneigenschaften muss ein Klassenfeld oder eine statische Klassenmethode verwendet werden
[dcc32 Fehler] datenmodul.pas(15): E2037 Deklaration von 'SetSymboltyp' unterscheidet sich von vorheriger Deklaration
[dcc32 Fehler] datenmodul.pas(17): E2003 Undeklarierter Bezeichner: 'FSymboltyp'
[dcc32 Fehler] datenmodul.pas(8): E2065 Ungenügende Forward- oder External-Deklaration: 'Global.SetSymboltyp'
[dcc32 Fataler Fehler] main.pas(8): F2063 Verwendete Unit 'datenmodul.pas' kann nicht compiliert werden

Und die Eingabemarke steht auf dem "SetSymboltyp" nach dem "write".
Wenn es sich um eine Tippfehler handelt, finde ich ihn nicht.

Könnt Ihr noch mal schauen?

Gruß Heiko

[DeddyH]

Delphi-Quellcode:

class procedure Global.SetSymboltyp(const Value : Integer);
 begin
   FSymboltyp:=Value;
 end;

Es ist ja als Klassenmethode deklariert, deshalb muss es auch so implementiert werden.

[Kralle]

Hallo Detlef,

Zitat:

Zitat von DeddyH (Beitrag 1246073)

Delphi-Quellcode:

class procedure Global.SetSymboltyp(const Value : Integer);
 begin
   FSymboltyp:=Value;
 end;

Es ist ja als Klassenmethode deklariert, deshalb muss es auch so implementiert werden.

Jetzt gibt es nur noch eine Fehlermeldung:

Zitat:

[dcc32 Fehler] datenmodul.pas(10): E2355 Für den Zugriff auf Klasseneigenschaften muss ein Klassenfeld oder eine statische Klassenmethode verwendet werden

Gruß Heiko

[mkinzler]

Zitat:

Zitat von Kralle (Beitrag 1246075)

Jetzt gibt es nur noch eine Fehlermeldung:

Zitat:

[dcc32 Fehler] datenmodul.pas(10): E2355 Für den Zugriff auf Klasseneigenschaften muss ein Klassenfeld oder eine statische Klassenmethode verwendet werden

Gruß Heiko

Wie ist FSymbolTyp deklariert als

Delphi-Quellcode:

class var

?

[DeddyH]

Es steht ja da: die Setter-Methode muss statisch sein.

Delphi-Quellcode:

   Global = class
     private
       class var FSymboltyp : Integer;
       class procedure SetSymboltyp (const Value : Integer); static; //hier
     public
       class property Symboltyp : Integer read FSymboltyp write SetSymboltyp;
   end;

Allerdings würde ich persönlich bei der üblichen Nomenklatur bleiben und dem Klassennamen noch ein "T" voranstellen.

[Sir Rufo]

Zitat:

Zitat von DeddyH (Beitrag 1246078)

Es steht ja da: die Setter-Methode muss statisch sein.

Delphi-Quellcode:

   Global = class
     private
       class var FSymboltyp : Integer;
       class procedure SetSymboltyp (const Value : Integer); static; //hier
     public
       class property Symboltyp : Integer read FSymboltyp write SetSymboltyp;
   end;

Allerdings würde ich persönlich bei der üblichen Nomenklatur bleiben und dem Klassennamen noch ein "T" voranstellen.

Dies hier ist die Ausnahme von der Regel, da diese Klasse kein Type im Sinne von Instanzvorlage werden soll.
Von daher würde ich dieser Klasse eben kein T voranstellen :)

[DeddyH]

Dann sag mal bei Emba Bescheid, dass sie z.B. TEncoding falsch benannt haben.

[Sir Rufo]

Zitat:

Zitat von DeddyH (Beitrag 1246081)

Dann sag mal bei Emba Bescheid, dass sie z.B. TEncoding falsch benannt haben.

Haben sie nicht, denn das ist ein Type.
Oder welchen Typ hat die Instanz

Delphi-Quellcode:

UTF8

?

Hier kann man es sehen
http://docwiki.embarcadero.com/Libra...TEncoding.UTF8

[DeddyH]

http://docwiki.embarcadero.com/Libra...tils.TEncoding

Zitat:

TEncoding = class

Und so steht es auc in meiner SysUtils.

[Kralle]

Moin,

es gibt jetzt zwar beim Compilieren keine Fehlermeldung mehr, aber der Variableninhalt wird nicht übertragen.

Setzen:

Delphi-Quellcode:

unit allgemein;

...

implementation

{$R *.dfm}
uses datenablage;

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

Auslesen:

Delphi-Quellcode:

unit anschluesse;

...

implementation

{$R *.dfm}
uses datenablage;

procedure TForm_Anschluesse.FormShow(Sender: TObject);
begin
 lbledt_AnzAnschluesse.EditLabel.Caption:=IntToStr(Global.Symboltyp);
 if  Global.Symboltyp in [7,8,9,10,11,12,13,14] then

Hier kommt nichts an.
Warum?

Gruss Heiko

[Sir Rufo]

Das können wir dir nicht sagen, weil wir nicht wissen, in welcher Reihenfolge das aufgerufen wird.

Wenn die Form Anschlüsse schon angezeigt wird und du dann erst die Änderung machst, dann "kommt" der Wert da nicht an, weil der Wert ja nicht durch Magie die Methode aufruft.

[DeddyH]

Wo landest Du, wenn Du in beiden Units einmal mit STRG-Linksklick auf "Global" abspringst? Ist das auch dieselbe Stelle?

[Kralle]

Hallo Rufo;

Zitat:

Zitat von Sir Rufo (Beitrag 1246087)

Das können wir dir nicht sagen, weil wir nicht wissen, in welcher Reihenfolge das aufgerufen wird.

Wenn die Form Anschlüsse schon angezeigt wird und du dann erst die Änderung machst, dann "kommt" der Wert da nicht an, weil der Wert ja nicht durch Magie die Methode aufruft.

Also, das erstmal werden alle Units so aufgerufen:

Delphi-Quellcode:

procedure TMainForm.FormCreate(Sender: TObject);

begin
// Die Einzelnen Units an die TABs binden
 Form_Allgemein:= TForm_Allgemein.Create(Self);
 Form_Allgemein.Parent:=Tab01_Allgemein;
 Form_Allgemein.Show;
 //
  //
 Form_Anschluesse:= TForm_Anschluesse.Create(Self);
 Form_Anschluesse.Parent:=Tab05_Anschluesse;
 Form_Anschluesse.Show;
end;

Beim laufenden Programm wähle ich erst auf dem TAB "Allgemein" den Symboltyp aus und Wechsel dann auf den TAB "Anschluesse".

Was mir gerade noch auffiel: Ich habe kein "Blauen Punkte" vor den Codezeilen und Breakpoints nutzen auch nichts.
Unter XE2 hat damals das geholfen:

Zitat:

Nachdem ich in den Projekteinstellungen beim Linker den Punkt "Mit
Laufzeit-Packages linken" aktiviert habe, klappt das auch mit den debuggen.

Unter XE5 klapt das nicht.

Gruß Heiko

[Kralle]

Moin,

Zitat:

Zitat von DeddyH (Beitrag 1246088)

Wo landest Du, wenn Du in beiden Units einmal mit STRG-Linksklick auf "Global" abspringst? Ist das auch dieselbe Stelle?

Beides mal auf dem "G" von Global:

Delphi-Quellcode:

unit datenablage;

interface
 type
   Global = class

Gruß HEiko

[Sir Rufo]

Aber dann ist es doch logisch, dass du die Änderung nicht in der Form siehst.

Du holst die Werte beim OnShow Event ab und der ist doch schon lange durch :roll:

[Kralle]

Hallo Rufo,

Zitat:

Zitat von Sir Rufo (Beitrag 1246093)

Aber dann ist es doch logisch, dass du die Änderung nicht in der Form siehst.

Du holst die Werte beim OnShow Event ab und der ist doch schon lange durch :roll:

http://smilies.rompel.cc/danke2.gif
Da stand ich mir mal wieder selber im Weg.

Welches Ereignis wird denn ausgeführt, wenn ich von einem TAB auf den anderen Wechsel?
Okay, ich muß mein Konzept wohl überdenken, das ich alles in den jeweiligen Units lösen will und eine Teil in das "OnChange" des "PageControls" verlegen.
Oder ich definiere eine "Globale"-Variable im "OnChange" die mir anzeigt, das ein TAB gewechselt wurde.


Gruß Heiko