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＃中进行多重继承，但可以实现多个接口：

使用与A
使用与B
在C。
从A和C实现A接口（C的实现只调用其类型A的成员变量）
从B和C实现B接口（C的实现只调用其B类型的成员变量）

Answer 3

你不能，C＃不支持多重继承类。

如果你提供一个更具体的例子来表明你想要做的事情，也许我们可以给你一个更好的解决方案（例如，也许你的成分是你所追求的，而不是继承 - 当然，我可以'从这个简单的例子中得知）。

Answer 4

无论好坏，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 5

除非其中一个继承自另一个，否则C和A不能同时为B。

但是，如果您希望C拥有来自A和B的行为并非两者共有，请使用界面。

Answer 6

另一种不使用合成的方法使用扩展方法。使用无方法定义接口，并使用C类实现它们。然后，编写一个带有扩展方法的静态类，为您的接口提供实现。

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

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

Answer 7

您可以通过多级继承实现此目的......

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

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

Answer 8

所以我想它不能这样做......

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

如何在C＃中模拟多重继承

8 个答案: