Wie die Mehrfachvererbung in C#

Question

simulieren Wie kann ich dies tun:

Class A : DependencyObject {} 

Class B : DependencyObject {} 

Class C : A , B {} 

Answer 1

C# hat keine Mehrfachvererbung, so die Linie

Class C : A , B {} 

wird nie funktionieren. Sie können jedoch mit Schnittstellen ähnliche Dinge tun, nach dem Vorbild der

interface InterfaceA { void doA(); } 
class A : InterfaceA { public void doA() {} } 

interface InterfaceB { void doB(); } 
class B : InterfaceB { public void doB() {}} 

class C : InterfaceA, InterfaceB 
{ 
    m_A = new A(); 
    m_B = new B(); 

    public void doA() { m_A.doA(); } 
    public void doB() { m_B.doB(); } 
} 

Answer 2

Sie können nicht, C# keine Mehrfachvererbung von Klassen unterstützt.

Wenn Sie ein konkreteres Beispiel dafür liefern, was Sie zu tun versuchen, können wir Ihnen vielleicht eine bessere Lösung geben (zum Beispiel, vielleicht ist Komposition das, was Sie suchen, und nicht Vererbung - natürlich kann ich das.) erzähle nicht von diesem einfachen Beispiel).

Answer 3

Sie können C nicht sowohl A als auch B haben, es sei denn, eine dieser Komponenten erbt von der anderen.

Wenn Sie jedoch möchten, dass C Verhaltensweisen von A und B haben, die beiden nicht gemeinsam sind, verwenden Sie eine Schnittstelle.

Answer 4

Sie keine Mehrfachvererbung in C# tun können, aber Sie mehrere Schnittstellen implementieren können:

1. eine Schnittstelle mit den gleichen Methoden erstellen wie die öffentlichen Mitglieder einer
2. erstellen einer Schnittstelle mit den gleichen Methoden, wie die öffentlichen Mitglieder B
3. Elementvariablen für A und B erstellen innerhalb von C.
4. Umsetzung der Eine Schnittstelle von sowohl A als auch C (C Implementierung fordert einfach seine Member-Variable vom Typ A)
5. die B-Schnittstelle sowohl Implementieren von B und C (C-Implementierung ruft einfach seine Member-Variable vom Typ B)

Answer 5

Another Weg, der keine Komposition verwendet, verwendet Erweiterungsmethoden. Definieren Sie Schnittstellen ohne Methoden und implementieren Sie sie mit Ihrer C-Klasse. Schreiben Sie dann eine statische Klasse mit Erweiterungsmethoden, die Implementierungen für Ihre Schnittstelle bereitstellen.

public static void MyMethod(this InterfaceA a) 
{ 
    // do stuff with a 
} 

Nachteil davon ist, dass Sie nur mit den Eigenschaften des Objekts arbeiten können, die in der Schnittstelle definiert sind. Dies beschränkt Sie im Grunde auf automatisch implementierte Eigenschaften und Methodenaufrufe.

Answer 6

Für besser oder schlechter C# unterstützt keine Mehrfachvererbung. Ich hatte jedoch begrenzten Erfolg bei der Simulation mit extension methods. Der Ansatz der Erweiterungsmethode könnte so aussehen.

public class A 
{ 
    public void DoSomething() { } 
} 

public static class B 
{ 
    public static void DoSomethingElse(this A target) { } 
} 

public class C : A 
{ 
} 

Das offensichtliche Problem hier ist, dass C definitiv kein B ist. Das einzige, wofür es gut ist, ist die Vermeidung von doppeltem Code in einigen Situationen.

Auf der anderen Seite unterstützt C# die Implementierung mehrerer Schnittstellen. Es würde so aussehen.

public interface IA 
{ 
    void DoSomething(); 
} 

public interface IB 
{ 
    void DoSomethingElse(); 
} 

public class A : IA 
{ 
    void DoSomething() { } 
} 

public class B : IB 
{ 
    void DoSomethingElse() { } 
} 

public class C : IA, IB 
{ 
    private A m_A = new A(); 
    private B m_B = new B(); 

    public void DoSomething() { m_A.DoSomething(); } 

    public void DoSomethingElse() { m_B.DoSomethingElse(); } 
} 

Das offensichtliche Problem hier ist, dass, während Sie die Schnittstelle erben Sie die Implementierung nicht erben. Dies ist gut für Polymorphie, aber schlecht für die Vermeidung von doppeltem Code.

Manchmal können Sie beide Strategien zusammen verwenden, um etwas zusammenzuhalten, das der Mehrfachvererbung ähnelt, aber es wird wahrscheinlich schwierig zu verstehen und zu pflegen sein. Wenn Ihre Situation wirklich mehrere Vererbung erfordert, dann sind Ihre Möglichkeiten begrenzt und sicherlich nicht ideal, aber sie existieren dennoch.

Answer 7

Also ich denke, es kann nicht so getan werden ...

class A : DependencyObject 
    { 
     public int X 
     { 
      get { return (int)GetValue(XProperty); } 
      set { SetValue(XProperty, value); } 
     } 
     public static readonly DependencyProperty XProperty = DependencyProperty.Register("X", typeof(int), typeof(A), new UIPropertyMetadata(0)); 
    } 

    class B : DependencyObject 
    { 
     public int X 
     { 
      get { return (int)GetValue(XProperty); } 
      set { SetValue(XProperty, value); } 
     } 
     public static readonly DependencyProperty XProperty = DependencyProperty.Register("X", typeof(int), typeof(B), new UIPropertyMetadata(0)); 
    } 

    class C : DependencyObject 
    { 
     A a = new A(); 
     B b = new B(); 
     public int X 
     { 
      get { return a.X; } 
      set { a.X = value; } 
     } 
     public int Y 
     { 
      get { return b.X; } 
      set { b.X = value; } 
     } 
    } 

Answer 8

Sie können dies erreichen, indem Multi-Level-Vererbung ...

public class DependencyObject 
{ 
    public void DependencyObjectMethod() { } 
} 

public class A : DependencyObject 
{ 
    public void MethodA() { } 
} 

public class B : A 
{ 
    public void MethodB() { } 
} 

public class C : B 
{ 
    public void MethodC() 
    { 
     //Do Something 
    } 
} 

Damit können Sie den Zugriff auf alle Methoden erhalten und Eigenschaften dieser Klassen.