如何模擬多重繼承在C＃

Question

我怎麼可以這樣做：

Class A : DependencyObject {} 

Class B : DependencyObject {} 

Class C : A , B {} 

Answer 1

C＃不具有多重繼承，太行

Class C : A , B {} 

不會有任何效果。你可以做類似的事情與接口雖然，沿

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

你不能，C＃不支持類的多重繼承。

如果您提供了一個更具體的例子，說明您正在嘗試做什麼，也許我們可以給您一個更好的解決方案（例如，也許組合是您所追求的，而不是繼承 - 當然，我可以從這個簡單的例子中可以看出）。

Answer 3

您不能讓C成爲A和B，除非其中一個從另一個繼承。

但是，如果您想讓C具有A和B的行爲，但這些行爲對於它們都不常見，請使用接口。

Answer 4

行你不能做多重繼承在C＃中，但可以實現多個接口：

1. 創建具有相同的方法接口的
2. 公衆成員相同的方法B的公共成員
3. C.
的內部
4. 實現創建一個成員變量和B創建的接口從A和C兩者的A接口（C的實現調用類型A的其成員變量）
5. 實現從B和C（C的實現調用類型B的其成員變量）

Answer 5

另一個B界面不使用組合的方式，使用擴展方法。定義沒有方法的接口，並用C類實現它們。然後，用擴展方法編寫一個靜態類，以提供針對您的界面的實現。

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

這樣做的缺點是，您只能使用界面中定義的對象的屬性。這基本上限制了你自動實現的屬性和方法調用。

Answer 6

對於更好或更差的C＃不支持多繼承。但是，我通過使用extension methods來模擬它的成功有限。擴展方法的方法可能如下所示。

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

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

public class C : A 
{ 
} 

這裏的明顯的問題是C絕對不是B。所以唯一有用的是在某些情況下避免重複代碼。

另一方面，C＃支持實現多個接口。它看起來像這樣。

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(); } 
} 

這裏的一個明顯的問題是，當你繼承接口時，你並沒有繼承實現。這對多態性很好，但對於避免重複代碼很不利。

有時候你可以同時使用這兩種策略來整合類似於多重繼承的東西，但它可能會難以理解和維護。如果你的情況確實需要多重繼承，那麼你的選擇將會受到限制，當然不是理想的，但是它們確實存在。

Answer 7

所以我想，不能被這樣做......

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

您可以通過多級繼承實現這個...

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 
    } 
} 

通過這一點，你可以訪問所有的方法和這些類的屬性。