Vererbung: Gemeinsame Methode von unterschiedlichen Klassen

[blackdrake]

Hallo.

Ich habe mal wieder ein Problem mit der Vererbung beim VCL-Entwickeln.

Folgender, verallgemeinerte und sehr vereinfachter Code soll mein Problem (hoffentlich verständlich) beschreiben:

Delphi-Quellcode:

type
  TComponentA = class(TGraphicControl)
  protected
    procedure MeineProzedur;
  end;

  TComponentB = class(TWinControl)
  protected
    procedure MeineProzedur;
  end;

In diesem Beispiel erweitere ich TGraphicControl und TWinControl einfach nur um eine Prozedur. In meinem Code wird jedoch die jeweilige Komponente z.B. TLabel mit diversen Eigenschaften und private/public-Methoden/Feldern erweitert.

Das Problem kommt nun:

Delphi-Quellcode:

type
  THandlerComponent = class(TComponent)
  private
    ComponentToHandle: TComponentA;
  public
    procedure Irgendwas;
  end;

procedure THandlerComponent.Irgendwas;
begin
  if Assigned(ComponentToHandle) then ComponentToHandle.MeineProzedur;
end;

Die Klasse THandlerComponent ist also auf TComponentA fest eingestellt. Ich möchte aber auch TComponentB in die Klasse bei "ComponentToHandle" aufnehmen.

Die Lösung derzeit ist, dass ich für jede TComponentX eine eigene HandlerComponent-Klasse definiere:

Delphi-Quellcode:

type
  THandlerComponentA = class(TComponent)
  private
    ComponentToHandle: TComponentA;
  public
    procedure Irgendwas;
  end;

  THandlerComponentB = class(TComponent)
  private
    ComponentToHandle: TComponentB;
  public
    procedure Irgendwas;
  end;

procedure THandlerComponentA.Irgendwas;
begin
  if Assigned(ComponentToHandle) then ComponentToHandle.MeineProzedur;
end;

procedure THandlerComponentB.Irgendwas;
begin
  if Assigned(ComponentToHandle) then ComponentToHandle.MeineProzedur;
end;

Das geht mir natürlich mächtig auf den Keks, da ich bei 10 TComponentX auch 10 THandlerComponentX bräuchte, obwohl der Code stets der selbe ist, mit Ausnahme, dass ich jeweils den TComponentX-Typ in der private-Deklaration ändere.

Dabei erachte ich es als unnötig, dass ich 10 THandlerComponentX für 10 TComponentX erstelle, da der gemeinsame Nenner ja stets die Prozedur "MeineProzedur" ist, die in allen TComponentX vorhanden ist, egal wie unterschiedlich sie sich sind.

Ich müsse eigentlich für eine Lösung einen gemeinsamen Nenner von TWinControl und TGraphicControl finden. Dieser wäre TControl.

Das private-Symbol "ComponentToHandle" kann jedoch nicht TControl sein, da TControl keine Prozedur "MeineProzedur" besitzt, die bei der public Prozedur "Irgendwas" verwendet wird.

Da TGraphicControl und TWinControl auch sehr große Unterschiede aufweisen, kann ich für TComponentA und TComponentB keinen gemeinsamen Vorfahren herstellen.

Ich hatte mir überlegt, dass Interfaces irgendwas mit der Problemlösung zu tun haben könnten, da sie die bestehenden VCLs einfach mit "MeineProzedur" erweitern könnten. Das Problem ist hier jedoch, dass ich ja nicht nur um Methoden erweitere, sondern die VCLs jeweils divers bearbeite. Ich bin daher auch zu keiner Lösung gekommen.

Weiß jemand eine Lösung?

Gruß
blackdrake

[mkinzler]

Die Verwendung eines Interface mit Implementierung per Subclassing oder ClassHelpers

[blackdrake]

Zitat von mkinzler:

Die Verwendung eines Interface mit Implementierung per Subclassing oder ClassHelpers

Kannst du mir dazu ein kurzes triviales Codebeispiel nennen?

Soweit ich weiß sind Helferklassen aber nur für Delphi .NET - also nicht für meine Win32 Umgebung.

[mkinzler]

ClassHelper gehen sei D10 auch unter Win32

[blackdrake]

Hallo.

Zitat von mkinzler:

ClassHelper gehen sei D10 auch unter Win32

Gut das zu wissen. Dann mach ich eben in Turbo Delphi weiter. (Wollte eigentlich mit D7 Kompatibel bleiben, aber naja...)

Mit dem Begriff subclassing weiß ich nichts richtiges anzufangen. Kann es sein, dass damit lediglich die Vererbung, also die "Unter-Klassen" (Unterklasse ?= Vererbte Klasse) gemeint ist?

Ich habe jetzt folgenden Code mit einem Interface... Und wie geht's weiter? Ich weiß, was Interfaces sind und ich weiß, was Helferklassen sind. Aber wie bringt man sowas zusammen, sodass eine Problemlösung entsteht?

Delphi-Quellcode:

type
  ITest = interface(IInterface)
    procedure MeineProzedur;
  end;

  TComponentA = class(TGraphicControl, ITest)
  protected
    procedure MeineProzedur;
  end;

  TComponentB = class(TWinControl, ITest)
  protected
    procedure MeineProzedur;
  end;

  TGemeinsamerNenner = class(???) // <-- was jetzt?
  end;

  THandlerComponent = class(TComponent)
  private
    ComponentToHandle: TGemeinsamerNenner;
  public
    procedure Irgendwas; // <-- benötigt Zugriff auf ComponentToHandle.MeineProzedur();
  end;

Gruß
blackdrake

[Apollonius]

ComponentToHandle muss dann logischerweise ein ITest sein.

[blackdrake]

Zitat von Apollonius:

ComponentToHandle muss dann logischerweise ein ITest sein.

Hallo mkinzler und Apollonius.

Vielen Dank für eure Hilfe! Ich hätte nicht gedacht, dass es so einfach geht. Und ging jetzt ja sogar nur mit Interfaces und ohne Helferklassen (somit bleibt auch die Code-Kompatibilität)

Delphi-Quellcode:

type
  ITest = interface(IInterface)
    procedure MeineProzedur;
  end;

  TComponentA = class(TGraphicControl, ITest)
  protected
    procedure MeineProzedur;
  end;

  TComponentB = class(TWinControl, ITest)
  protected
    procedure MeineProzedur;
  end;

  THandlerComponent = class(TComponent)
  private
    ComponentToHandle: ITest;
  public
    procedure Irgendwas;
  end;

procedure TComponentA.MeineProzedur;
begin
  showmessage('A');
end;

procedure TComponentB.MeineProzedur;
begin
  showmessage('B');
end;

procedure THandlerComponent.Irgendwas;
begin
  if Assigned(ComponentToHandle) then ComponentToHandle.MeineProzedur;
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  x: THandlerComponent;
  a: TComponentA;
  b: TComponentB;
begin
  x := THandlerComponent.Create(self);
  try
    a := TComponentA.Create(self);
    b := TComponentB.Create(self);
    try
      x.ComponentToHandle := a;
      x.Irgendwas; // ^= Showmessage('A');
      x.ComponentToHandle := b;
      x.Irgendwas; // ^= Showmessage('B');
    finally
      a.Free;
      b.Free;
    end;
  finally
    x.Free;
  end;
end;

Ich werde das ganze jetzt noch auf meinen richtigen Code umsetzen und hoffen, dass es dort auch so gut funktioniert.

Gruß
blackdrake