Comment simuler l'héritage multiple en C#

Question

Comment puis-je faire:

Class A : DependencyObject {} 

Class B : DependencyObject {} 

Class C : A , B {} 

Answer 1

C# ne pas l'héritage multiple, donc la ligne

Class C : A , B {} 

ne marchera jamais. Vous pouvez faire des choses semblables avec des interfaces bien, le long des lignes de

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

Vous ne pouvez pas, C# ne prend pas en charge l'héritage multiple de classes. Si vous fournissez un exemple plus concret de ce que vous essayez de faire, nous pouvons peut-être vous donner une meilleure solution (par exemple, peut-être que la composition est ce que vous recherchez, plutôt que l'héritage - bien sûr, je peux ne dites pas de cet exemple simple).

Answer 3

Vous ne pouvez pas avoir C être à la fois un A et un B sauf si l'un de ceux-ci hérite de l'autre. Cependant, si vous voulez que C ait des comportements de A et B qui ne sont pas communs aux deux, utilisez une interface.

Answer 4

Vous ne pouvez pas faire de l'héritage multiple en C# mais vous pouvez implémenter plusieurs interfaces:

1. créer une interface avec les mêmes méthodes que les membres du public de A
2. créer une interface avec les mêmes méthodes que les membres publics de B
3. créer des variables membres pour A et B à l'intérieur de C.
4. Mettre en œuvre la Une interface à la fois A et C (la mise en œuvre de C appelle simplement sa variable membre de type A)
5. implémentent l'interface B à la fois B et C (la mise en œuvre de C appelle simplement sa variable membre de type B)

Answer 5

Une autre manière, qui n'utilise pas la composition, utilise des méthodes d'extension. Définissez des interfaces sans méthodes et implémentez-les avec votre classe C. Ensuite, écrivez une classe statique avec des méthodes d'extension qui fournissent des implémentations sur votre interface. En revanche, vous ne pouvez travailler qu'avec les propriétés de l'objet définies dans l'interface. Cela vous limite essentiellement aux propriétés implémentées automatiquement et aux appels de méthode.

Answer 6

Pour le meilleur ou pour le pire C# ne prend pas en charge l'héritage multiple. Cependant, j'ai eu un succès limité dans la simulation en utilisant extension methods. L'approche de la méthode d'extension pourrait ressembler à ceci.

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

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

public class C : A 
{ 
} 

Le problème évident est ici que C est certainement pas un B. Donc, la seule chose pour laquelle il est bon est d'éviter le code en double dans certaines situations. D'autre part, C# prend en charge la mise en œuvre de plusieurs interfaces. Cela ressemblerait à ceci.

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

Le problème évident ici est que lorsque vous héritez de l'interface, vous n'héritez pas de l'implémentation. C'est bon pour le polymorphisme, mais mauvais pour éviter le code en double. Parfois, vous pouvez utiliser ensemble les deux stratégies pour regrouper quelque chose ressemblant à l'héritage multiple, mais il sera probablement difficile à comprendre et à maintenir. Si votre situation nécessite vraiment l'héritage multiple, alors vos options vont être limitées et certainement pas idéales, mais elles existent quand même.

Answer 7

donc je suppose qu'il ne peut pas être fait si ...

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

Vous pouvez y parvenir en héritage ... multiniveau

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

En cela, vous pouvez avoir accès à toutes les méthodes et propriétés de ces classes.