Objektorientierung / Bestehende Komponente erweitern

[MarioM.]

Hallo,

ich habe eine Komponente, die ich gerne erweitern möchte.
Ich verfüge über den Quelltext der Komponente.

Damit ich nicht jedesmal alles neu machen muss, wenn die Fremdkomponente aktualisiert wird, möchte ich das nicht direkt im Code der Komponente machen, sondern eine eigene davon ableiten.

Dazu benötigt meine neue Klasse ein zusätzliches Feld.
Das Problem ist nun, dass ich eine Funktion (keine Methode!) ändern muss, die sich außerhalb der Klasse befindet.
Diese Funktion soll auf das neue Feld zugreifen.

Mit einer einfachen Ableitung ist ja nun nicht, da die Funktion nicht zu der Basisklasse gehört.

Wie macht man das nun?

[Teekeks]

Wie meinst du das?
Einfach ableiten mittels:

Delphi-Quellcode:

type
  TMeineKlasse=class(TAbleitung)
  {...}
  end;

geht nicht?
Warum?

Gruß Teekeks
OMG! Ich habs tatsächlich mal geschafft als erster zu antworten!

[DeddyH]

Kannst Du mal ein Beispiel posten? Im Moment steig ich noch nicht ganz durch.

[MarioM.]

Also,

Ausgangssituation ist eine von mir lizenzierte Komponentensammlung.
Alle Klassen stehen in einer Unit.
Mehrere Klassen greifen nun auf eine bestimmte Funktion zu. Diese gehört aber nicht zu einer Klasse, sondern steht 'global' in der Unit.

Von einer dieser Klassen möchte ich nun eine Ableitung erstellen.
Der Grund für die Ableitung ist das Hinzufügen einer zusätzlichen Eigenschaft zu der neuen Klasse.
Diese Eigenschaft soll dann in der oben genannten ('globalen') Funktion benutzt werden.

Durch eine Ableitung der Klasse kann ich der neuen nun eine neue Eigenschaft verpassen.

Aber wie mache ich es denn mit der 'globalen' Funktion? Die muss ich ja auch ändern - ableiten geht aber nicht, da sie ja nicht zu der Klasse gehört. Genügt es da, diese Funktion 'global' in der Unit der abgeleiteten Klasse zu deklarieren?

Delphi-Quellcode:

unit Unit2;

interface

type
   //Klasse nutzt GlobaleFunktion
   TKlasse_Alt_1 = class

   end;

   //Klasse nutzt GlobaleFunktion
   TKlasse_Alt_2 = class

   end;

   //Klasse nutzt GlobaleFunktion
   TKlasse_Alt_3 = class

   end;

   //Wird von Klasse 1 abgeleitet
   TKlasse_Neu = class(TKlasse_Alt_1)
   private
      fNewProperty: string;
      procedure SetNewProperty(const Value: string);
   protected
      property NewProperty: string read FNewProperty write SetNewProperty;
   end;

//Besagte Funktion, die von allen Klassen benutzt wird
//Da sie auch die neue Eigenschaft aus Klasse_Neu benutzten soll, muss ich sie verändern; aber nicht in der Originalunit
function GlobaleFunktion: string; 

implementation

function GlobaleFunktion: string;
begin

end;

{ TKlasse_Neu }

procedure TKlasse_Neu.SetNewProperty(const Value: string);
begin
   FNewProperty := Value;
end;

end.

Wichtig:
Die Ableitung muss in einer anderen Unit stehen!

[DeddyH]

Du könntest die Funktion ja in der Ableitungsunit erneut implementieren und darin dann das Original ausführen.

Delphi-Quellcode:

unit NeueUnit;

uses OriginalUnit,...;

function GlobaleFunktion: string;
begin
  Result := OriginalUnit.GlobaleFunktion + 'Neu';
end;

Aber ohne Insiderwissen kann ich da nicht mehr dazu sagen.

[MarioM.]

Ja, ist ein bissel schwierig mit dem Beispiel, da ich den Code aus lizenztechnischen Gründen nicht veröffentlichen darf.
Ich probiere Deinen Vorschlag mal aus - schonmal vielen Dank

[Blup]

Für das beschriebene Problem hat nichts mit Klassen zu tun.
Es geht schlicht darum eine Funktion zu anzupassen, ohne deren Quelltext zu verändern.
Dafür gibt es keine saubere Lösung.
Man könnte die Funktion aber zu Laufzeit patchen:
- Adresse der alten Funktion ermitteln
- Zugriffsrechte zum verändern des entsprechenden Speicherbereichs setzen
- an der Adresse der alten Funktion einen Sprung direkt zu der Adresse der neuen Funktion schreiben

[himitsu]

Zitat von Blup:

- an der Adresse der alten Funktion einen Sprung direkt zu der Adresse der neuen Funktion schreiben

Wenn er die alte Funktion aber dennoch ausführen will (nur halt mit 'ner kleinen Erweiterung der Parameter, bzw. des Rückgabewertes), dann gibt es hier ein kleines Problem.

Denn es wird dann vermutlich diese Funktion direkt angesprungen und nicht über 'ne "Adresstabelle", so wie z.B. bei den WinAPIs.
Wenn er dort also eine Umleitung zu seiner eigenen Funktion einfügen würde, dann würden wohl die ersten Bytes der Funktion überschrieben.


Aber um das abzuklären, wären mal ein paar mehr und vorallem genauere/detailiertere Informationen nötig.