auf Klassen-Variable innerhalb einer anderen Klasse zugreifen

[juergen]

Hallo,

schwierig zu beschreiben, ich versuch es mal (ganz rudimentär runtergebrochen).

Ich habe Unit1 und Unit2.
In der Unit1 habe ich eine Klasse definiert.
In der Unit2 habe ich eine andere Klasse definiert.

Nun erstelle ich zur globalen Verfügbarkeit in der Unit1 eine Instanz (Variable) für die Klasse aus Unit2.

Delphi-Quellcode:

   
VAR
  frm_Main: Tfrm_Main;
  JsonDatabaseParam: TDataBase; //meine Klassenvariable auf TDataBase aus Unit2

Ich muss nun von allen anderen Units auf diese Klasseninstanz "JsonDatabaseParam" zugreifen können.
Bis hierhin alles gut.

Ich muss aber auch innerhalb meiner anderen Klasse aus Unit1 in deren Proceduren auf "JsonDatabaseParam" zugreifen können.

Ich hoffe, dass das halbwegs verständlich ist.

Wie setzt man sowas um?

Vielen Dank schon mal vorab.

[Uwe Raabe]

Zitat von juergen:

Ich hoffe, dass das halbwegs verständlich ist.

Nicht wirklich.

[Delphi.Narium]

Als Prozedur- bzw. Funktionsparamter übergeben.

In der Klasse aus Unit1 ein Attribut vom Typ der Klasse aus Unit2 definieren und diesem Attribut der Klasse aus Unit1 dann eine Instanz der Klasse aus Unit2 zuweisen. Analog zu z. B. TDataSource und dem Attribut DataSet, dem man eine Komponente vom Type TDataSet (oder deren Nachfahren) zuweist. Dann kommt man sogar ohne globale Variabeln aus.

[himitsu]

Unit2 ins USES der Unit1,

ABER besser gibt man (DU) den Funktionen/KlassenMethoden im Unit1, beim Erstellen oder Aufrufen, die gewünschte Instanz "JsonDatabaseParam" als Parameter/Property, anstatt sie sich das selbst holt.

[bernau]

Juergen, wenn du die Möglichkeit hast, beide Units in eine Unit zusammenzuführen, dann hast du mittels Forward Declarations die Möglichkeit beide Klassen miteinander bekannt zu machen. Geht aber nur in der gleichen Unit.

Damit kann eine Klasse jeweils auf die anderen Klasse zugreifen.

[kretabiker]

Ich wuerde den Vorschlaegen von himitsu und delphi.narium Vorschlag folgen, Stichwort Dependency Injection, lose Koppung usw. Damit waere evtl auch die globale Variable nicht mehr notwendig, aber das haengt von der grundsaetzlichen Anwendungsarchitektur ab

[Uwe Raabe]

Tut mir leid, aber ich habe das Problem offenbar immer noch nicht verstanden.
Das hier lese ich aus deinen Ausführungen:

JsonDatabaseParam ist eine Variable im Interface-Teil (weil von anderen Units verwendet) von Unit1.
JsonDatabaseParam ist vom Typ TDataBase, der als Klasse in Unit2 definiert ist.

Damit das compiliert muss Unit2 in der Uses-Anwendung von Unit1 stehen.
Folglich sollte es für Prozedur-Implementationen in Unit1 auch kein Problem darstellen, auf JsonDatabaseParam und deren Methoden zuzugreifen.

Wo liegt also das Problem hiermit?

Zitat von juergen:

Ich muss aber auch innerhalb meiner anderen Klasse aus Unit1 in deren Proceduren auf "JsonDatabaseParam" zugreifen können.

[juergen]

Vielen lieben Dank für die Tipps!!

Das Problem saß aber vor dem Bildschirm!
Soeben fiel es mir sofort auf. Ich hatte JsonDatabaseParam: TDataBase; statt global zu definieren in der frm_main-Klasse definiert!
Komisch dass ich es gestern Nacht nicht gesehen hatte.
Manchmal ist es aber auch zum Haare raufen.

[jus]

Zitat von bernau:

Juergen, wenn du die Möglichkeit hast, beide Units in eine Unit zusammenzuführen, dann hast du mittels Forward Declarations die Möglichkeit beide Klassen miteinander bekannt zu machen. Geht aber nur in der gleichen Unit.

Damit kann eine Klasse jeweils auf die anderen Klasse zugreifen.

Ich bin öfters mal auf die Forward Deklaration gestossen, nur für welchen Anwendungszweck ist diese Forward Deklaration eigentlich gut?

[Uwe Raabe]

Zitat von jus:

Ich bin öfters mal auf die Forward Deklaration gestossen, nur für welchen Anwendungszweck ist diese Forward Deklaration eigentlich gut?

Neben dem Beispiel in der Doku kommt z.B. folgender Beispiel-Fall zur Anwendung:

Delphi-Quellcode:

type
  TContainer = class;

  TContainerItem = class
  private
    FContainer: TContainer;
  protected
    procedure RecalcAll;
  public
    procedure Recalc;
  end;

  TContainer = class
  private
    FItems: TArray<TContainerItem>;
  public
    procedure RecalcAll;
  end;

procedure TContainerItem.RecalcAll;
begin
  FContainer.RecalcAll;
end;

procedure TContainer.RecalcAll;
begin
  for var item in FItems do
    item.Recalc;
end;

Hier wissen die Items, zu wem sie gehören und können was auch immer damit tun.