Hallo zusammen,
ich habe mal eine konzeptionelle Frage.

Ich habe eine Klasse, die alle Datenbankzugriffe abwickelt (SQL). Davon gibt es 3 Instanzen (Crawler,URL,Document), die davon abgeleitet sind. Diese sind in einer 4 Instanz enthalten (Master).

ungefähr so...

markieren

Delphi-Quellcode:

master = class (SQL)
Crawler: SQL;
URL: SQL;
Document; SQL

Wie kann ich die ganzen Zugriffsdaten (User,pWD...) an alle vier übergeben bzw das diese die gleichen Daten verwenden. Oder ist der Ansatz zu ändern?


Danke!

du könntest dir einen globalen master bauen der unterhalb von implementation declariert ist. Somit ist er außerhalb der Unit nicht sichtbar. Wenn du bei irgend einer Instanz die Zugangsdaten änderst werden diese an den Master übermittelt und der leitet diese weiter an die instanzen. Das würde bedeuten du müsstest einen "initialization" abschnitt anlegen und dort den master erzeugen und dazu natürlich einen "finalization" abschnitt und dort den master wieder freigeben. Wenn eine Instanz deiner klasse erzeugt wird muss diese sich beim master eintragen (damit dieser später der klasse bescheid sagen kann) und im Destroy muss deine Klasse sich wieder beim master austragen.

Danke SirThornberry! Klingt nach der Lösung meines Problems. Leider habe ich so etwas noch nicht gemacht. Hast du evtl ein Beispiel oder ein gutes Tutorial?
Ich konnte leider noch nichts finden..
Danke!

ein kleines Beispiel (mit 2 varianten wies geht)
TExample stellt deine Klasse dar wo jede Instanz die gleichen Daten haben soll.

property Msg1 ist die erste Variante. Die Instanz von TExample behält sich diese Message nirgends. Wird Msg1 gesetzt wird dieser wert beim TExampleLeader verändert. Und wenn diese Message abgefragt wird so wird diese vom Globalen TExampleLeader abgefragt.

Variante2 ist etwas komplizierter ist aber manchmal recht nützlich wenn die instanzen mitbekommen müssen das sich was geändert hat (um sich zum Beispiel neu zu malen (was in diesem Beispiel aber nicth der fall ist)).
Das Property Msg2 wird in der Instanz von TExample gehalten. Im Constructor wird jedoch von der Globalen Instanz GExampleLeader der aktuelle Wert abgefragt. Zusätzlich trägt sich die Instanz von TExample beim TExampleLeader ein damit dieser später über Änderungen benachrichtigen kann (im Destroy von TExample trägt sich die Instanz von TExample logicher Weise auch wieder beim globalen TExampleLeader aus).
Wird also Msg2 abgefragt wird einfach der Wert aus dem Private gelesen.
Wird jedoch Msg2 gesetzt so wird Msg2 beim globalen TExampleLeader gesetzt und dieser ändert dies bei allen Clients (im Beispiel greift der TExampleLeader auf ein Private-Property zu, es ist aber natürlich auch möglich das eine Methode aufgerufen wird die zum Beispiel ein neu zeichnen erzwingt etc.).

Da die globale Instanz von TExampleLeader (GMasterLeader) unter Implementation declariert wird ist diese Instanz außerhalb der Unit nicht sichtbar.

zusammenfalten · markieren

Delphi-Quellcode:

unit uexample;

interface

uses
  classes;

type
  TExample = class(TObject)
  private
    fMsg2: String;
    function FGetMessage1: String;
    procedure FSetMessage1(AMsg: String);
    procedure FSetMessage2(AMsg: String);
  public
    constructor Create;
    destructor Destroy; override;

    //Msg1 wird direkt von Leader abgefragt und gesetzt
    property Msg1: String read FGetMessage1 write FSetMessage1;
    //Msg2 wird intern behalten und nur beim leader gesetzt (dieser änderts dann bei den instanzen)
    property Msg2: String read fMsg2 write FSetMessage2;
  end;

  TExampleLeader = class(TObject)
  private
    fClients: TList;
    fMsg1: String;
    fMsg2: String;
    procedure FSetMsg2(AMsg: String);
  public
    constructor Create;
    destructor Destroy; override;

    property Msg1: String read fMsg1 write fMsg1;
    property Msg2: String read fMsg2 write FSetMsg2;

    procedure ClientAdd(AClient: TExample);
    procedure ClientRemove(AClient: TExample);
  end;

implementation

var
  GMasterLeader: TExampleLeader;

constructor TExampleLeader.Create;
begin
  fMsg1 := 'StdMessage1';
  fMsg2 := 'StdMessage2';
  fClients := TList.Create;
end;

destructor TExampleLeader.Destroy;
var LCount: Integer;
begin
  for LCount := fClients.Count - 1 downto 0 do
    TObject(fClients.Items[LCount]).Free;
  fClients.Free;
end;

procedure TExampleLeader.ClientAdd(AClient: TExample);
begin
  if fClients.IndexOf(AClient) < 0 then
    fClients.Add(AClient);
end;

procedure TExampleLeader.ClientRemove(AClient: TExample);
begin
  fClients.Remove(AClient);
end;

procedure TExampleLeader.FSetMsg2(AMsg: String);
var LCount: Integer;
begin
  fMsg2 := AMsg;
  for LCount := 0 to fClients.Count - 1 do
    TExample(fClients.Items[LCount]).fMsg2 := fMsg2;
end;

{==============================================================================}

constructor TExample.Create;
begin
  inherited Create;
  GMasterLeader.ClientAdd(Self);
  fMsg2 := GMasterLeader.Msg2;
end;

destructor TExample.Destroy;
begin
  GMasterLeader.ClientRemove(Self);
  inherited Destroy;
end;

function TExample.FGetMessage1: String;
begin
  result := GMasterLeader.Msg1;
end;

procedure TExample.FSetMessage1(AMsg: String);
begin
  GMasterLeader.Msg1 := AMsg;
end;

procedure TExample.FSetMessage2(AMsg: String);
begin
  GMasterLeader.Msg2 := AMsg;
end;

initialization
  GMasterLeader := TExampleLeader.Create;

finalization
  GMasterLeader.Free;


end.

Vielen Dank SirThornberry!
Das ist genau was ich brauche.