Wie nennt man es, wenn eine Schnittstelle „erbt“ von einem anderen?

StackOverflow https://stackoverflow.com/questions/807217

  •  03-07-2019
  •  | 
  •  

Frage

Wenn ich       Klasse B: A {}

ich sagen, dass "Klasse B geerbt Klasse A" oder "B-Klasse leitet sich von Klasse A".

Wenn ich aber stattdessen haben: 

  class B : ISomeInterface   {}

Es ist falsch zu sagen, "B erbt ISomeInterface." - der richtige Begriff ist zu sagen, "B Geräte ISomeInterface"

Aber, sagen, ich habe 

  interface ISomeInterface : ISomeOtherInterface   {}

Nun, es ist immer noch falsch „erbt“ zu sagen, aber es ist jetzt genauso falsch „Geräte“ zu sagen, da ISomeInterface etwas nicht implementiert.

So, wie nennt man diese Beziehung?

War es hilfreich?

Lösung

ich persönlich sagen „erweitert“ und I dachte das C # spec verwendet dieses Wort auch irgendwo (ich es jetzt nicht finden kann, leider) - aber ich erinnere mich Eric Lippert sagte, er wäre nicht scharf auf sie, und wollte es für 4.0 ändern.

Ich denke, es ist gut, weil es zeigt, dass Sie den Vertrag durch die ursprüngliche Schnittstelle angegeben sind erstrecken.

EDIT: Nachdem auf der 3.0-Spezifikation sieht ...

Die Spezifikation Art von Neben Schritte das Problem in Abschnitt 13.2. Er spricht über die Mitglieder von der Basis Schnittstellen vererbt werden. Er spricht über eine Klasse extending eine andere, aber nicht Schnittstellen

EDIT: In der C # 5 spec, Abschnitt 13.1.4, verwendet es erbt:

  

Eine Schnittstelle von Null oder mehrere Schnittstellentypen erben

Also das ist wahrscheinlich der beste Begriff zu verwenden.

Andere Tipps

Ich nenne es "erweitert".

In der Regel, ich nenne es Overengineering.

Als maßgebliche Quelle und falls Sie ein hilfreiches Angebot benötigen, stieß ich auf Informationen über MSDN , die beschreibt, " Schnittstelle Vererbung " mit einem praktischen Beispiel der Schnittstelle Vererbungsstruktur für die ComboBox , Kontrolle, Listbox und TextBox:

Und mit Angabe eines expliziten Basis-Interface

  

Eine Schnittstelle kann von Null oder mehr Schnittstellen , erben die sind   rief die explizite Basis-Interfaces der Schnittstelle.

Beispiel: 

interface IControl
{
   void Paint();
}
interface ITextBox: IControl
{
   void SetText(string text);
}
interface IListBox: IControl
{
   void SetItems(string[] items);
}
interface IComboBox: ITextBox, IListBox {}

Quelle:

http://msdn.microsoft.com/ en-us / library / aa664578% 28VS.71% 29.aspx

Warum wäre es falsch, InterfaceB „erbt“ zu sagen oder „leitet sich von“ InterfaceA? „Implementiert“ wäre falsch, weil InterfaceB keine Implementierung zur Verfügung stellen. Semantisch ist Schnittstellen Ableiten Ableitung Klassen sehr ähnlich. C ++, zum Beispiel unterscheidet nicht zwischen Schnittstellen und Klassen überhaupt.

Sie haben die Definition falsch.

. B: A bedeutet "B von A erbt"

, wenn wir sagen „B implementiert InterfaceA“, das bedeutet in der Regel InterfaceA nicht die Definition muss funktionieren - es nur Prototypen sind (oder, PURE in C ++). Jedoch in C ++ und die meisten OOPL, die erben und implementieren Aktien gleiche Syntax.

So, InterfaceB: InterfaceA bedeutet noch "InterfaceB erbt InterfaceA"

.
Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top