Sollte C# haben Mehrfachvererbung?

Lieber aggregation über Vererbung!

class foo : bar, baz

ist oft besser behandelt werden mit

class foo : Ibarrable, Ibazzable
{
  ... 
  public Bar TheBar{ set }
  public Baz TheBaz{ set }

  public void BarFunction()
  {
     TheBar.doSomething();
  }
  public Thing BazFunction( object param )
  {
    return TheBaz.doSomethingComplex(param);
  }
}

Diese Weise können Sie den swap in und aus verschiedenen Implementierungen des IBarrable und IBazzable zu erstellen Sie mehrere Versionen der App, ohne zu schreiben, noch eine andere Klasse.

Dependency injection kann mit Hilfe dieser eine Menge.

Hier ist eine sehr nützliche Fall für die mehrfache Vererbung, dass ich in all der Zeit.

Als ein toolkit Hersteller, die ich nicht ändern kann veröffentlichte API ' s oder ich werde brechen die Abwärtskompatibilität. Eine Sache, die Ergebnisse aus, dass ist, dass ich nicht immer hinzufügen, um eine Schnittstelle einmal habe ich freigegeben, weil es brechen würde compilation für jemand, es umzusetzen -- die einzige option ist die Erweiterung der Schnittstelle.

Dies ist in Ordnung für bestehende Kunden, sondern neue sehen würde, diese Hierarchie als unnötig Komplex, und wenn ich es entwerfen, von Anfang an, ich würde nicht ablehnen, um es zu implementieren auf diese Weise -- ich, oder ich will verlieren rückwärts-Kompatibilität. Wenn die Schnittstelle ist intern, ich habe dann einfach fügen Sie es und fixieren Sie die implementors.

In vielen Fällen die neue Methode, die Oberfläche hat eine offensichtliche und kleine Standard-Implementierung, aber ich kann mich nicht zur Verfügung stellen.

Ich würde es vorziehen, zu verwenden, abstrakte Klassen und dann, wenn ich eine Methode hinzufügen, fügen Sie einen virtuellen, mit einer default-Implementierung, und manchmal tun wir dies.

Das Problem ist natürlich, wenn diese Klasse würde wahrscheinlich vermischt werden, etwas, das ist schon etwas erweitern-dann haben wir keine Wahl, sondern eine Schnittstelle und befassen sich mit der Erweiterung Schnittstellen.

Wenn wir denken, wir haben dieses problem in einem großen Weg, entscheiden wir uns für ein reichhaltiges event-Modell statt-ich denke, das ist wahrscheinlich die richtige Antwort in C#, aber nicht jedes problem auf diese Weise gelöst-manchmal möchten Sie eine einfache öffentliche Schnittstelle, und ein reicher, für die Extender.

Mehrfachvererbung nicht unterstützt wird von der CLR in keiner Weise bewusst bin, so bezweifle ich, es könnte unterstützt werden, in einer effizienten Art und Weise, wie es in C++ oder Eiffel, die können es besser machen, gegeben, dass die Sprache ist speziell für die MI).

Eine schöne alternative zur Mehrfachvererbung ist die Traits genannt. Es ermöglicht Ihnen, mischen Sie die verschiedenen Einheiten des Verhaltens in einer einzigen Klasse. Ein compiler unterstützen können Merkmale wie eine compile-time-Erweiterung der einfachen Vererbung Typ-system. Sie einfach erklären, dass Klasse X enthält Merkmale A, B und C, und der compiler legt die Merkmale, Fragen Sie nach, bilden gemeinsam die Umsetzung von X.

Angenommen, Sie versuchen, zu implementieren, die IList(of T). Wenn Sie einen Blick auf die verschiedenen Implementierungen der IList(of T), Sie teilen oft einige der exakt gleiche code. Das waren Eigenschaften kommen. Sie einfach erklären, ein Merkmal, mit dem gemeinsamen code, und Sie können verwenden, dass der gemeinsame code in die Implementierung der IList(of T) - auch wenn die Umsetzung hat bereits einige weitere Basis-Klasse. Hier ist, was die syntax könnte so Aussehen:

///This trait declares default methods of IList<T>
public trait DefaultListMethods<T> : IList<T>
{
    //Methods without bodies must be implemented by another 
    //trait or by the class
    public void Insert(int index, T item);
    public void RemoveAt(int index);
    public T this[int index] { get; set; }
    public int Count { get; }

    public int IndexOf(T item)
    {
        EqualityComparer<T> comparer = EqualityComparer<T>.Default;
        for (int i = 0; i < Count; i++)
            if (comparer.Equals(this[i], item))
                return i;
        return -1;
    }
    public void Add(T item)
    {
        Insert(Count, item);
    }
    public void Clear()
    {   //Note: the class would be allowed to override the trait 
        //with a better implementation, or select an 
        //implementation from a different trait.
        for (int i = Count - 1; i >= 0; i--)
            RemoveAt(i);
    }
    public bool Contains(T item)
    {
        return IndexOf(item) != -1;
    }
    public void CopyTo(T[] array, int arrayIndex)
    {
        foreach (T item in this)
            array[arrayIndex++] = item;
    }
    public bool IsReadOnly
    {
        get { return false; }
    }
    public bool Remove(T item)
    {
        int i = IndexOf(item);
        if (i == -1)
            return false;
        RemoveAt(i);
        return true;
    }
    System.Collections.IEnumerator 
        System.Collections.IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
    IEnumerator<T> GetEnumerator()
    {
        for (int i = 0; i < Count; i++)
            yield return this[i];
    }
}

Sind und Sie die Eigenschaft wie diese:

class MyList<T> : MyBaseClass, DefaultListMethods<T>
{
    public void Insert(int index, T item) { ... }
    public void RemoveAt(int index)       { ... }
    public T this[int index] {
        get { ... }
        set { ... }
    }
    public int Count {
        get { ... }
    }
}

Natürlich bin ich nur an der Oberfläche gekratzt hier. Für eine vollständige Beschreibung finden Sie unter das Papier Merkmale: Composable Units of Behavior (PDF).

Den Rost Sprache (von Mozilla) umgesetzt hat, die Merkmale in einer interessanten Art und Weise: Sie bemerkt, dass die Merkmale sind ähnlich wie Standard-interface-Implementierungen, so dass Sie einheitliche Schnittstellen und Eigenschaften in einer einzigen Funktion, die Sie aufrufen, Eigenschaften). Der wesentliche Unterschied zwischen Eigenschaften und die Standard-interface-Implementierungen (Java jetzt hat) ist, dass Merkmale enthalten kann, die private oder protected-Methoden, im Gegensatz zu herkömmlichen interface-Methoden müssen öffentlich sein. Wenn die Eigenschaften und Schnittstellen sind nicht einheitlich in einer einzigen Funktion, dann ein weiterer Unterschied ist, dass Sie einen Verweis auf eine Schnittstelle, aber Sie können nicht einen Verweis auf eine Eigenschaft; eine Eigenschaft ist, die nicht selbst eine Art.

Ich würde behaupten, gegen Mehrfachvererbung einfach aus dem Grund Stand. Entwickler missbrauchen. Ich habe genug gesehen, um Probleme mit jeder Klasse erbt, die von einer utility-Klasse, nur so können Sie eine Funktion aufrufen, die aus jeder Klasse, ohne zu geben, so viel, zu wissen, dass Mehrfachvererbung würde führen zu schlechten code in vielen Situationen. Das gleiche kann gesagt werden über "GoTo", das ist einer der Gründe, es ist so verpönt. Ich denke, dass Mehrfachvererbung einige gute verwendet, genauso wie Springen, In einer idealen Welt, wo Sie beide wurden nur verwendet, wenn angemessen, gäbe es keine Probleme. Doch die Welt ist nicht ideal, und deshalb müssen wir uns schützen, schlechte Programmierer vor sich selbst.

Ich bin froh, dass C# keine Mehrfachvererbung, auch wenn es manchmal bequem sein. Was ich möchte, um zu sehen, stattdessen ist die Fähigkeit, eine Standard-Implementierung einer interface-Methode. Das heißt:

interface I
{
    void F();
    void G();
}


class DefaultI : I
{
    void F() { ... }
    void G() { ... }
}

class C : I = DefaultI
{
    public void F() { ... } //implements I.F
}

In diesem Fall ((I)new C()).F() rufen C's Umsetzung von I.F(), während ((I)new C()).G() rufen DefaultI's Umsetzung von I.G().

Gibt es eine Reihe von Problemen auf, die die Sprache der Designer arbeiten, bevor diese Hinzugefügt werden könnten, um die Sprache, aber keine, die sind sehr schwer und das Ergebnis würde für viele der Bedürfnisse, die Mehrfache Vererbung wünschenswert.

Mehrfache Vererbung im Allgemeinen kann nützlich sein, und viele OO-Sprachen implementiert es die eine oder andere Weise (C++, Eiffel, CLOS, Python...). Ist es so wichtig? Nein. Ist es schön zu haben? Ja.

Keine.

(für die Abstimmung)

Statt der Mehrfachvererbung, die Sie verwenden können,Mixins in Verbindung, das ist eine bessere Lösung.

Während es gibt sicherlich Fälle, in denen es nützlich sein kann, habe ich festgestellt, dass die meisten der Zeit, wenn ich glaube, ich brauche es, ich weiß es wirklich nicht.

Ich denke seine wirklich einfach. Genau wie jede andere komplexe Programmier-Paradigma, können Sie missbraucht und dich verletzt. Können Sie Missbrauch Objekte (oh ja!), aber das bedeutet nicht, dass OO ist schlecht in sich selbst.

Ähnlich verhält es sich mit MI. Wenn Sie nicht über einen großen "Baum" von vererbten Klassen, oder eine Menge von Klassen, die gleich benannte Methoden sind, dann werden Sie völlig in Ordnung, mit MI. In der Tat, wie MI bietet die Umsetzung, Sie werden oft besser aus als eine SI-Umsetzung, wo haben Sie zu re-code, oder cut&paste-Methoden an Objekte delegiert. Weniger code ist besser in diesen Fällen.. Sie können eine allmächtige Chaos-sharing-code, indem Sie versuchen, die Wiederverwendung von Objekten durch interface-Vererbung. Und solche workarounds nicht riechen Recht.

Ich denke, dass die single-Vererbung-Modell .NET ist falsch: Sie hätten mit Schnittstellen, oder MI nur. Mit "halb und halb" (dh einzelne Implementierung Vererbung plus multiple interface inheritance) ist mehr verwirrend als es sein sollte, und auch nicht elegant auf allen.

Ich komme aus einer MI-hintergrund, und ich bin nicht erschrocken, oder verbrannt durch es.

Ich habe multiple inheritence in C++ auch selbst an, aber Sie haben wirklich zu wissen, was Sie tun, um nicht selbst in Schwierigkeiten, vor allem, wenn Sie zwei Basis-Klassen, die eine gemeinsame Großeltern. Dann können Sie in Probleme mit virtuellen inheritence, zu erklären, jeder Konstruktor du gehst zu nennen, die die Kette (was macht binäre Wiederverwendung viel schwerer)... es kann ein Durcheinander.

Mehr wichtiger ist, die Art und Weise der CLI ist derzeit errichtet verhindert, MI von umgesetzt leicht. Ich bin mir sicher, dass Sie es tun könnte, wenn Sie wollte, aber ich habe andere Dinge, die ich lieber sehen in der CLI als multiple inheritence.

Dinge, die ich möchte, um zu sehen, gehören einige der Funktionen der Spec#, wie null-Referenz-Typen. Ich würde auch gerne mehr sehen, Objekt-Sicherheit, indem Sie in der Lage, Parameter zu deklarieren, die als const, und die Möglichkeit zum deklarieren einer Funktion const (was bedeutet, dass Sie garantieren, dass der interne Zustand eines Objekts nicht geändert werden, von der Methode und der compiler überprüft werden).

Ich denke, dass zwischen Single-Inheritence, Mehrere Interface-Inheritence, Generika und Erweiterung-Methoden, die Sie tun können, so ziemlich alles was Sie brauchen. Wenn Sie etwas verbessern könnten, Dinge, die für jemanden in dem Wunsch, MI, ich denke, irgendeine Art von Sprache konstruieren, die würde erlauben würde, einfacher aggregation und Komposition erforderlich ist. So können Sie eine gemeinsame Schnittstelle, aber dann delegieren Sie die Umsetzung an eine private Instanz der Klasse, die Sie normalerweise Erben aus. Jetzt, dass nimmt eine Menge von boiler plate code zu tun. Mit einem automatisierten Sprach-feature für, das würde deutlich helfen.

Ich glaube, dass Sprachen wie C# sollte der Programmierer die Möglichkeit. Nur weil es vielleicht zu kompliziert bedeutet nicht, dass es werden zu kompliziert. Programmiersprachen sollten die Entwickler mit tools zu bauen, die alles, was der Programmierer will.

Wählen Sie zur Nutzung dieser API die Entwickler bereits schrieb, sind Sie nicht zu haben.

Nein, ich nicht. Ich benutze alle anderen OO-features zu entwickeln, was ich will. Ich benutze Schnittstelle und Kapselung Objekt und ich bin nie auf das, was ich tun will.

Nicht, es sei denn, Diamant-problem ist gelöst. und können Sie nutzen Zusammensetzung bis heute nicht gelöst ist.

Wenn wir uns vorstellen, Mehrfachvererbung, dann sind wir wieder vor der alten Diamant-problem von C++...

Jedoch für diejenigen, die denken, es ist unvermeidlich, wir können uns immer noch vorstellen Mehrfachvererbung Effekte durch Komposition (Komponieren, mehrere Objekte in ein Objekt und setzen die öffentlichen Methoden, die Verantwortlichkeiten zu komponiert Objekt und zurück)...

Warum also die Mühe machen, mehrere die erbschaft-und machen den code anfällig für unvermeidbare Ausnahmen...

Ich fast don ' T miss Mehrfachvererbung in C#.

Wenn Sie mehrere inhertance zu definieren, die eine tatsächliche domain-Modell, das dann in meiner Erfahrung, kann man oft ein gleich gutes design mit einfacher Vererbung und einige gute design-patterns.

Meisten der Orte, wo ich zu finden Mehrfachvererbung werden von wirklichem Wert sind die Orte, wo es nicht die domain selbst, aber einige Technologie/framework Einschränkung, die erfordert die Verwendung von MI. Implementierung von COM-Objekten mit ATL ist ein sehr gutes Beispiel für die Verwendung von Mehrfachvererbung zu implementieren alle notwendigen Schnittstellen, die Sie COM-Objekt braucht, und eine elegante Lösung zu einem hässlich (im Vergleich zu .NET) - Technologie. Elegant aus der Sicht, dass es ein C++ - framework!

Habe ich die situation jetzt aber, wo ich verwenden könnte, die mehrfache Vererbung. Ich habe eine Klasse, die Bedürfnisse ableiten von Funktionen aus einer anderen Domäne-Objekt, aber es muss auch zugänglich sein für cross-AppDomain-Anrufe. Dies bedeutet, dass es MUSS von MarshalByRefObject Erben. Also in diesem speziellen Fall, ich möchte wirklich, dass die Ableitung sowohl von MarshalByRefObject abgeleitet und meinem spezifischen Domäne-Objekt. Das ist jedoch nicht möglich, also meine Klasse zu implementieren hat die gleiche Schnittstelle wie meine domain-Objekt, und umleiten der Anrufe auf eine aggregierte Instanz.

Aber das ist, wie gesagt, einen Fall, wo die Technologie/framework stellen eine Einschränkung, und nicht dem domain-Modell.

Interfaces sind Mehrfachvererbung. Als eine Angelegenheit von der Tat, würde ich prüfen, Java/C# - Typ-Schnittstellen die "richtige" Implementierung der Mehrfachvererbung. Zwingen Mehrfachvererbung durch den Einsatz von interfaces, dann eher so dass die Vererbung von mehrere konkrete oder abstrakte Klassen zwingt die Entwickler Zusammensetzung/delegation für die Wiederverwendung von code. Vererbung sollte niemals verwendet werden, für die Wiederverwendung von code, und der Abwesenheit von C++ - Typ Mehrfachvererbung Entwickler zu kommen mit besser entwickelten Klassen.