Как моделировать множественное наследование в 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. Реализовать Интерфейс с обеих А и С (реализация C просто вызывает его переменную-член типа А)
5. реализует интерфейс B от обоих В и С (реализация C просто вызывает его переменную-член типа B)

Answer 5

другой путь, который не использует композицию, использует методы расширения. Определите интерфейсы без методов и реализуйте их с помощью класса 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 
    } 
} 

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