Как симулировать множественное наследование в 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 #, но вы можете реализовать несколько интерфейсов:

1. Создать интерфейс теми же методами, что и открытые члены A
2. Создать интерфейсс теми же методами, что и у открытых членов B
3. Создание переменных-членов для A и B внутри C.
4. Реализация интерфейса A из A и C (реализация C просто вызывает свою переменную-члентипа A)
5. Реализация интерфейса B как из B, так и из C (реализация C просто вызывает свою переменную-член типа B)

Answer 3

Вы не можете, C # не поддерживает множественное наследование классов.

Если вы предоставите более конкретный пример того, что вы пытаетесь сделать, возможно, мы можем дать вам лучшее решение (например,возможно, вам нужна композиция, а не наследование - конечно, я не могу сказать из этого простого примера).

Answer 4

К лучшему или худшему, C # не поддерживает множественное наследование. Тем не менее, я имел ограниченный успех в моделировании его с помощью методов расширения . Подход метода расширения может выглядеть следующим образом.

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

Этого можно добиться с помощью многоуровневого наследования ...

 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 6

Другой способ, который не использует композицию, использует методы расширения. Определите интерфейсы без методов и реализуйте их с вашим классом C. Затем напишите статический класс с методами расширения, которые предоставляют реализации для вашего интерфейса.

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

Недостатком этого является то, что вы можете работать только с теми свойствами объекта, которые определены в интерфейсе. Это ограничивает вас автоматически реализуемыми свойствами и вызовами методов.

Answer 7

Вы не можете иметь C одновременно и A, и B, если только один из них не наследуется от другого.

Однако, если вы хотите, чтобы C имел поведения от Aи B, которые не являются общими для них обоих, используйте интерфейс.

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