Как моделировать множественное наследование в C#

В C # нельзя выполнять множественное наследование, но можно реализовать несколько интерфейсов:

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

К лучшему или худшему, 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(); }
}

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

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

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

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

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

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

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

Вы можете достичь этого с помощью многоуровневого наследования...

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

С помощью этого вы можете получить доступ ко всем методам и свойствам этих классов.

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

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

Так что я думаю, это не может быть сделано так ...

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