Eigenschaft einem Interface aus anderer Programmiersprache hinzufügen
Bei den Antworten handelt es sich teilweise um ein Missverständnis zwischen Fragesteller und den Antwortenden. Dieses wurde eben per PM geklärt.
Hallo,
ich habe eine Bibliothek aus einer anderen Programmiersprache aus der ich ein Interface benutze. Diesem Interface möchte ich eine weitere Eigenschaft hinzufügen.
Meine Idee ist folgende: Ich erstelle eine Klasse, in der eine Instanz dieses Interfaces vorhanden ist und füge der Klasse die zusätzliche Eigenschaft hinzu. Durch eine Vererbung der Klasse aus dem Interface, zwinge ich diese Klasse dazu jede Methode des Interface überschreiben zu müssen.
Nun kann ich jede zu überschreibene Methode direkt "weiterleiten" an die Instanz des Interface.
Zum Beispiel:
public IEnumerator GetEnumerator()
{
return interfaceInstance.GetEnumerator();
}
Meine Frage lautet, ob dies nun sauberer Programmierstil ist, oder ob das irgendwie auch eleganter geht. Unsinnig finde ich jetzt zum Beispiel die Methoden an die Interfacemethoden "per Hand" weiterzuleiten.
Danke!
dahaack
So, wie ich deine Ausführungen verstanden habe, setzt du da das Decorator-Pattern um.
Und da es sich um ein Entwurfsmuster ist, kann man nicht unbedingt von schlechtem Programmierstil reden 😉
Hängt aber auch vom konkreten Problem ab. Willst du uns etwas mehr darüber verraten?
Hallo dN!3L,
du hast es denke ich (fast) richtig verstanden. Der Unterschied, den ich zum Decorator erkenne ist, dass beim Decorator noch eine "Zwischenklasse" erstellt wird, den Dekorierer.
In meinem Beispiel habe ich bisher nur den KonkretenDekorierer der von dem Interface direkt erbt und eine Instanz dieses Interfaces selbst beinhaltet.
Mit elegant meine ich hier, dass ich nicht jede Methode per Hand an die Instanz innerhalb der Klasse weiterleiten möchte, sondern dass dies - wie auch immer (zum Beispiel mit nem anderen Entwurfsmuster) - automatisch passiert.
Als Ansatz fällt mir sowas wie eine überschreibende Methode ein. Das heißt eine Methode bei deren Aufruf immer die übergeordnete Methode aufgerufen wird, solange diese in der Klasse selbst nicht überschrieben wird. Soweit ich das Thema überblicke ist diese "Eleganz" wohl nicht mit meinem aktuellen Problem vereinbar.
Da ich ein Interface habe, müssen soweit ich weiß alle Methoden tatsächlich geschrieben werden, ohne an dem aktuellen Problem irgendwas "automatisieren" zu können, sehe ich das richtig?
Vielen Dank!
dahaack
Nein, mach dir da keine Gedanken. Den Fall hättest du, wenn du nicht von dem Interface, sondern von der konkreten Klasse ableiten würdest. Aber das ist ja nicht Sinn der Sache, wenn man Interfaces verwendet. So bleibt deine Implementierung flexibel.
Hallo dahaack,
ich habe eine Bibliothek aus einer anderen Programmiersprache aus der ich ein Interface benutze. Diesem Interface möchte ich eine weitere Eigenschaft hinzufügen.
du willst die Eigenschaft doch nicht dem Interface hinzufügen, bzw. kannst das nicht, weil das Interface von der Bibliothek vorgegeben ist. Du willst die Eigenschaft der Klasse - ebenfalls aus der Bibliothek - hinzufügen, die das Interface implementiert. Sehe ich das alles richtig?
Wenn ja, wäre es doch am einfachsten eine Unterklasse der Klasse zu erstellen. Die Unterklasse hätte dann die zusätzliche Eigenschaft. Sofern es sich bei der anderen Sprache auch um eine .NET-basierte handelt und die Klasse nicht sealed ist, sollte das ohne Weiteres gehen.
herbivore
Hallo herbivore,
du willst die Eigenschaft doch nicht dem Interface hinzufügen, bzw. kannst das nicht, weil das Interface von der Bibliothek vorgegeben ist.
Richtig.
Du willst die Eigenschaft der Klasse - ebenfalls aus der Bibliothek - hinzufügen, die das Interface implementiert. Sehe ich das alles richtig?
Die zusätzliche Eigenschaft hat mit der Bibliothek nichts zu tun. Dem Interface soll einfach eine bool'sche Variable hinzugefügt werden. Da ein Interface keine Variablen beinhalten kann, muss meine zu erstellende Klasse also eine "echte" Klasse sein.
Wenn ja, wäre es doch am einfachsten eine Unterklasse der Klasse zu erstellen. Die Unterklasse hätte dann die zusätzliche Eigenschaft. Sofern es sich bei der anderen Sprache auch um eine .NET-basierte handelt und die Klasse nicht sealed ist, sollte das ohne Weiteres gehen.
Genau das ist auch mein Plan. Wie gesagt, finde ich es aber nicht so schön, dass ich jede Methode und jede Propertie an die Interface-Instanz "per Hand" weiterleiten muss.
Aber solange das Endergebnis funktioniert, kann ich mich damit abfinden.
Vielen Dank nochmal.
Genau das ist auch mein Plan. Wie gesagt, finde ich es aber nicht so schön, dass ich jede Methode und jede Propertie an die Interface-Instanz "per Hand" weiterleiten muss.
Nein, was herbivore meint ist, dass du von der Klasse ableitest, und nicht von der Schnittstelle. Wenn du von der Klasse ableitest, brauchst du die Methoden ja nicht überschreiben oder weiterleiten.
Oh, dann kann ich Euch nicht ganz folgen.
Sobald ich von dem Interface ableite, müsste ich ja alle Methoden und Properties implementieren. Wenn ich also laut deiner Aussage nichts überschreiben oder weiterleiten muss, so darf ich von dem Interface also nicht ableiten.
Dein Vorlschlag ist also eine Klasse (ich nenne sie Klasse1) zu erzeugen und von dieser Klasse eine Klasse (ich nenne sie Klasse2) abzuleiten.
Wenn ich dich richtig verstehe, beihnaltet Klasse1 eine Instanz des Interface, Klasse2 beinhaltet die zusätzliche Eigenschaft.
Wenn ich nun in meinem Programm eine Instanz der Klasse2 erstelle, so kann ich auf die Methoden ja nur indirekt zugreifen, indem ich mir über ein Propertie das Interface zunächst raushole, und dann die Methoden aufrufe.
Mein Ziel wäre jedoch eine Klasse zu erstellen, die diese Methoden direkt aufrufen kann, ohne dass man sich das Interface aus der Klasse1 "rausholen" muss.
Also statt
K2Inst.InterfaceInst.Methode1();
K2Inst.Methode1();
Hallo,
Klasse1 implementiert das Interface und Klasse2 erweitert Klasse1 indem es davon erbt und die zusätzlcihe Eigenschaft hat.
Deine wiederholten Nachfragen verwundern mich. Es geht hier nur im einfache Vererbung. Dazu sollten sich keine Fragen stellen. Zumindest wären sie nach [Hinweis] Wie poste ich richtig? Punkt 1.1.1 nicht zulässig.
mfG Gü
Stellt fachliche Fragen bitte im Forum, damit von den Antworten alle profitieren. Daher beantworte ich solche Fragen nicht per PM.
"Alle sagten, das geht nicht! Dann kam einer, der wusste das nicht - und hat's gemacht!"
Der Thread wurde wegen einem Missverständnis geschlossen und ist nun wieder geöffnet.
Programmierhans schrieb vor einem Monat per PM an die Mods:
Ich verstehe das Problem eher so:
Er verwendet eine fremdes Dll.
Darin gibt es das InterfaceA.
Innerhalb des Dll gibt es mehrere Klassen die das Interface implementieren.
LibClassA:InterfaceA
LibClassB:InterfaceA
LibClassC:InterfaceAEr hat nun das Problem, dass er eine zusätzliche Funktionalität braucht die dann aber in allen Ableitungen von InterfaceA (also in LibClassA/LibClassB/LibClassC) verfügbar sein soll. (dies würde erkären wieso er immer von der Instanz des Interfaces redet... eine Instanz des Interfaces kann ja nur eine Instanz einer konkreten Klasse sein welche das Interface implementiert)
Deshalb hat er eine Klasse SeineClass:InterfaceA erstellt.
z.B: über eine Factory erhält er dann eine Konkrete Instanz (LibClassA/B/C)... und muss dann natürlich aus SeineClass auf die effektive Instanz wrappen. (oder die Instanz rausstellen).Dies jedefalls würde erklären, wiese er nicht direkt von der konkreten Klasse ableiten kann (also er kann nicht von LibClassA/B/C ableiten... sonst müsste er seinen neuen Code 3 mal implementieren.
Könnt Ihr den Thread nochmal aufmachen und meinen Post da reinhängen ?
Danke und Gruss
Programmierhans
So habe ich das auch gemeint. Ich habe das Problem "per Hand" gelöst. Rein aus Interesse kann der Thread - falls jemand will - ja trotzdem noch beantwortet werden, falls es eine elegantere Lösung für das Problem gibt.
Grüße
dahaack
Hallo dahaack,
möglicherweise könnte man mit einem AOP-Tool wie PostSharp die zusätzliche Funktionalität in die bestehenden Klassen bekommen. Ist aber die Frage, ob es wirklich geht und ob das den Aufwand lohnt.
herbivore
Ich bin mir nicht ganz sicher, ob ich das ganze inzwischen auch richtig verstanden habe, aber könnten dir Extension Methoden hier weiterhelfen?
Nachdem sowohl das Interface als auch die 3 Implementierungen nicht von dir sind (in der anderen Programmiersprache innerhalb der Library?), kannst du so oder so nicht auf Implementierungsdetails eingehen - und damit sollte auch eine Extension Methode reichen, die sogesehen ja auch nur Zugriff auf die public Member des erweiternden Interface/Klasse hat.
Nachteil, funktioniert natürlich nur mit Methoden - Extension Properties gibts ja nicht.