C# 如何在C语言中模拟多重继承#

我如何做到这一点：

Class A : DependencyObject {}

Class B : DependencyObject {}

Class C : A , B {}

不能，C#不支持类的多重继承

---

如果你提供一个更具体的例子来说明你正在尝试做什么，也许我们可以给你一个更好的解决方案（例如，也许你所追求的是合成，而不是继承——当然，我不能从这个简单的例子中分辨出来）.

你不能让

C

同时成为

A

和

B

，除非其中一个继承自另一个

但是，如果您希望

C

具有

A

和

B

中的行为，而这两种行为对它们都不常见，请使用一个接口。

C#没有多重继承，因此

Class C : A , B {}

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

这是行不通的。不过，您可以使用接口执行类似的操作，方法如下：

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

---

您不能在C#中执行多重继承，但可以实现多个接口：

使用与的公共成员相同的方法创建接口

使用与B的公共成员相同的方法创建接口

在C中为A和B创建成员变量

从A和C实现A接口（C的实现只是调用其类型为A的成员变量）

从B和C实现B接口（C的实现只是调用其类型为B的成员变量）

---

另一种不使用组合的方法是使用扩展方法。定义没有方法的接口，并用C类实现它们。然后，编写一个带有扩展方法的静态类，这些扩展方法针对您的接口提供实现

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

这样做的缺点是，您只能使用接口中定义的对象属性。这基本上限制了自动实现的属性和方法调用。

无论好坏，C#都不支持多重继承。然而，我在通过使用来模拟它方面取得了有限的成功。扩展方法可能如下所示

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

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

public class C : A
{
}

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

这里明显的问题是

C

绝对不是a

B

。因此，在某些情况下，这唯一有利于避免重复代码

另一方面，C#确实支持实现多个接口。看起来是这样的

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

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

public class C : A
{
}

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

这里明显的问题是，当您继承接口时，您并没有继承实现。这有利于多态性，但不利于避免重复代码

---

有时，您可以同时使用这两种策略来将类似于多重继承的东西组合在一起，但这可能很难理解和维护。如果你的情况真的需要多重继承，那么你的选择将是有限的，当然不是理想的，但它们确实存在。

所以我想这是不可能的

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

---

您可以通过多级继承来实现这一点

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

---

通过它，您可以访问这些类的所有方法和属性。

或者您可以使用composition并开辟自己的道路。：）我碰巧认为C#排除MI的情况更糟。但那是因为我认为复杂性的论点被夸大了。我想我们都有自己的观点，但这是我最直言不讳的一点……当然是好是坏：）