Per Klasse auf übergeordnete Klasse zugreifen?

[Elvis]

Zitat von Pseudemys Nelsoni:

@Elvis: WIeso ist es ein Interface und keine Klasse? (Nie mit solchen gearbeitet)

Deine widerwillige Frage nach den Forward declarations ließ vermuten, dass du keinen Bock hast soviele Klassen in eine Unit zu quetschen.
Mit der Abstraktion über ein Interface kannst du die Verbindung zwischen den 2 Klassen in eine 3. Unit auslagern wodurch dein TServer keine Ahnung von der Hauptklasse haben muss.
So hast du 3 Units, die jeweils auf einen Moni passen im Gegensatz zu ...

Delphi-Quellcode:

type
   IMainDingens = interface
      function getPort : Integer;
      function getHost : string;

      procedure setPort(value : Integer);
      procedure setHost(value : string);

      property Port : Integer read getPort write setPort;
      property Host : string read getHost write setHost;
   end;

Delphi-Quellcode:

uses
   Classes,
   uMainComponentInterface;

type
   TServer = class(TPersistent)
   private
      fMainDingens : IMainDingens;
      function getHost : string;
      procedure setHost(const value : string);
      function getPort : Word;
      procedure setPort(const value : Word);
   published
      property Host : string read getHost write setHost;
      property Port : Word read getPort write setPort;
   public
      constructor Create(const owner : IMainDingens);
   end;
implementation

{ TServer }

constructor TServer.Create(const owner: IMainDingens);
begin
   fMainDingens := owner;
end;

function TServer.getHost: string;
begin
   result := fMainDingens.Host;
end;

function TServer.getPort: Word;
begin
   result := fMainDingens.Port;
end;

procedure TServer.setHost(const value : string);
begin
   fMainDingens.Host := value;
end;

procedure TServer.setPort(const value : Word);
begin
   fMainDingens.Port := value;
end;

Delphi-Quellcode:

uses
   Classes,
   ScktComp,
   uServerAggregate,
   uMainComponentInterface;

type
   TMainClass = class(TComponent, IMainDingens)
   private
      fClientSocket : TClientSocket;
      fServer : TServer;
   protected
      property ClientSocket : TClientSocket read fClientSocket implements IMainDingens;

      // vielen Dank dafür, dass man keine abstrakten Properties in Interfaces packen kann! :wall:
      function getPort : Integer;
      function getHost : string;
   published
      property Server : TServer read fServer write fServer;
   public
      procedure AfterConstruction; override;
    procedure BeforeDestruction; override;
   end;
implementation

{ TMainClass }


function TMainClass.getHost: string;
begin
   Result := fClientSocket.Host;
end;

function TMainClass.getPort: Integer;
begin
   Result := fClientSocket.Port;
end;

procedure TMainClass.AfterConstruction;
begin
   inherited;
   fClientSocket := TClientSocket.Create(self);
   fServer := TServer.Create(self);
end;

procedure TMainClass.BeforeDestruction;
begin
   inherited;
   fServer.Free();
   fClientSocket.Free();
end;

Die beiden getter in der Komponente verdanken wir der zickigen Eigenart von Delphi-Interfaces, Properties nur mit vollen Zugriffsmethoden zuzulassen. (anstatt einfach property X : TType read write
Deshalb können die Getter hier nicht zu TClientSocket delegiert werden.