web-dev-qa-db-fra.com

Est-ce que C # supporte l'héritage multiple?

Un collègue et moi nous disputons un peu au sujet de l'héritage multiple. Je dis que ce n'est pas pris en charge et il le dit. Alors, j'ai pensé que je demanderais au groupe intelligent sur le net.

c#multiple-inheritance
48
Neil Knight

Non, utilisez plutôt des interfaces! ^. ^

39
Barrie Reader

Désolé, vous ne pouvez pas hériter de multiple classes. Vous pouvez utiliser des interfaces ou une combinaison de one class and interface(s), les interfaces devant être suivies du nom de classe dans la signature.

interface A { }
interface B { }
class Base { }
class AnotherClass { }

Moyens possibles pour hériter:

class SomeClass : A, B { } // from multiple Interface(s)
class SomeClass : Base, B { } // from one Class and Interface(s)

Ce n'est pas légal:

class SomeClass : Base, AnotherClass { }
83
Asad Butt

L'héritage multiple n'est pas pris en charge en C #.

Mais si vous voulez "hériter" du comportement de deux sources, pourquoi ne pas utiliser le combo: 

  • Composition

    et 

  • Injection de dépendance

Il existe un principe de base OOP, mais important, qui dit: "Privilégiez la composition à la succession".

Vous pouvez créer une classe comme ceci:

public class MySuperClass
{
    private IDependencyClass1 mDependency1;
    private IDependencyClass2 mDependency2;

    public MySuperClass(IDependencyClass1 dep1, IDependencyClass2 dep2)
    {
        mDependency1 = dep1;
        mDependency2 = dep2;
    }

    private void MySuperMethodThatDoesSomethingComplex()
    {
        string s = mDependency1.GetMessage();
        mDependency2.PrintMessage(s);
    }
}

Comme vous pouvez le voir, les dépendances (implémentations réelles des interfaces) sont injectées via le constructeur. Votre classe ne sait pas comment chaque classe est implémentée mais elle sait comment les utiliser. D'où un couplage lâche entre les classes concernées ici, mais le même pouvoir d'utilisation.

Les tendances actuelles montrent que l'héritage est en quelque sorte "démodé".

18
Liviu M.

C # 3.5 ou inférieur ne supporte pas l'héritage multiple, mais C # 4.0 pourrait le faire en utilisant, si je me souviens bien, Dynamics.

13
Gnought

Vous ne pouvez pas faire d'héritage multiple en C # jusqu'à la 3.5. Je ne sais pas comment ça marche avec la version 4.0 puisque je ne l'ai pas regardée, mais @tbischel a posté un lien que j'ai besoin de lire.

C # vous permet de faire des "implémentations multiples" via des interfaces, ce qui est assez différent de "l'héritage multiple"

Donc, vous ne pouvez pas faire:

class A{}

class B{}

class C : A, B{}

Mais vous pouvez faire:

interface IA{}
interface IB{}

class C : IA, IB{}

HTH

7
Sunny

C # ne prend pas en charge l'héritage multiple de classes, mais vous êtes autorisé à hériter/implémenter un nombre illimité d'interfaces.

C'est illégal(B, C, D et E sont toutes les classes)}

class A : B, C, D, E
{
}

Ceci est légal(IB, IC, ID et IE sont toutes des interfaces)}

class A : IB, IC, ID, IE
{
}

Ceci est légal(B est une classe, IC, ID & IE sont des interfaces)}

class A : B, IC, ID, IE
{
}

Composition sur héritage est un modèle de conception qui semble être favorable, même dans les langues prenant en charge l'héritage multiple.

4
series0ne

Comme Java (dont C # a été dérivé indirectement), C # ne prend pas en charge l'héritage multiple.

Autrement dit, la classe data (variables et propriétés membres) ne peut être héritée que d’une base parent unique class. La classe comportement (méthodes membres), d'autre part, peut être héritée de plusieurs bases parent interfaces.

Certains experts, notamment Bertrand Meyer (considéré par certains comme l’un des pères de la programmation orientée objet), pensent que cela disqualifie C # (et Java, et le reste) d’être un "vrai" orienté objet la langue.

4
David R Tribble

En fait, cela dépend de votre définition de l'héritage:

  • vous pouvez hériter de implementation (membres, c'est-à-dire données et comportement) d'une classe single 
  • vous pouvez hériter de interfaces de multiple, ainsi des interfaces.

Ce n’est pas ce que l’on entend habituellement par le terme "héritage", mais il n’est pas non plus totalement déraisonnable de le définir de cette façon.

3
Jörg W Mittag

L'héritage multiple permet aux programmeurs de créer des classes combinant les aspects de plusieurs classes et de leurs hiérarchies correspondantes. Par ex. le C++ vous permet d'hériter de plus d'une classe

En C #, les classes ne peuvent hériter que d'une classe parent unique, appelée héritage unique. Mais vous pouvez utiliser des interfaces ou une combinaison d'une classe et d'une ou plusieurs interfaces, interface (s) devant être suivie (s) par le nom de la classe dans la signature.

Ex:

Class FirstClass { }
Class SecondClass { }

interface X { }
interface Y { }

Vous pouvez hériter comme suit:

classe NewClass: X, Y {} Dans le code ci-dessus, la classe "NewClass" est créée à partir de plusieurs interfaces.

classe NewClass: FirstClass, X {} Dans le code ci-dessus, la classe "NewClass" est créée à partir de l'interface X et de la classe "FirstClass".

2
Sandeep Verma

Modèle d'héritage multiple simulé
http://www.codeproject.com/KB/architecture/smip.aspxenter image description here

2
Donny V.

Vous ne pouvez pas hériter de plusieurs classes à la fois. Mais il existe une option pour le faire à l'aide de l'interface. Voir ci-dessous le code 

interface IA
{
    void PrintIA();
}

class  A:IA
{
    public void PrintIA()
    {
        Console.WriteLine("PrintA method in Base Class A");
    }
}

interface IB
{
    void PrintIB();
}

class B : IB
{
    public void PrintIB()
    {
        Console.WriteLine("PrintB method in Base Class B");
    }
}

public class AB: IA, IB
{
    A a = new A();
    B b = new B();

    public void PrintIA()
    {
       a.PrintIA();
    }

    public void PrintIB()
    {
        b.PrintIB();
    }
}

vous pouvez les appeler comme ci-dessous

AB ab = new AB();
ab.PrintIA();
ab.PrintIB();
2
reza.cse08

Vous voudrez peut-être pousser plus loin votre argument et parler de modèles de conception - et vous pourrez comprendre pourquoi il voudrait s'embêter à essayer d'hériter de plusieurs classes en c # s'il le peut

2
Jason M

En général, vous ne pouvez pas le faire.

Considérez ces interfaces et classes:

public class A { }    
public class B { }
public class C { }

public interface IA { }
public interface IB { }

Vous pouvez hériter de plusieurs interfaces:

class A : B, IA, IB {
  // Inherits any single base class, plus multiple interfaces.
}

Mais vous ne pouvez pas hériter de plusieurs classes:

class A : B, C, IA, IB {
    // Inherits multiple base classes, plus multiple interfaces.
}
1
Elshan

Il ne le permet pas, utilisez l'interface pour y parvenir.

Pourquoi c'est comme ça?

Voici la réponse: il a permis au compilateur de prendre une décision très raisonnée et rationnelle, qui consistait toujours à consigner de manière cohérente ce qui était hérité et d'où il était hérité. .

1
Awais Ahmad

C # ne prend pas en charge l'héritage multiple intégré.

Pour ajouter plusieurs héritages à des langues qui ne le prennent pas en charge, vous pouvez utiliser modèle de conception double

1
Mohsen Kashi

En guise de suggestion supplémentaire, un autre moyen astucieux de fournir une fonctionnalité similaire à l'héritage multiple consiste à implémenter plusieurs interfaces MAIS à fournir des méthodes d'extension sur ces interfaces. Ceci s'appelle mixins . Ce n'est pas une vraie solution, mais il résout parfois les problèmes qui pourraient vous inciter à vouloir effectuer un héritage multiple.

0
Jaxidian

Je suis récemment tombé dans le même état d'esprit, héritant de deux classes en une classe et je me suis retrouvé sur cette page (même si je connais mieux) et j'aimerais garder la référence à la solution que j'ai trouvée parfaite dans ce scénario, sans imposer l'implémentation d'interfaces

Ma solution à ce problème serait de scinder vos données en classes qui ont du sens:

public class PersonAddressSuper
{
    public PersonBase Person { get; set; }
    public PersonAddress Address { get; set; }

    public class PersonBase
    {
        public int ID { get; set; }
        public string Name { get; set; }
    }
    public class PersonAddress
    {
        public string StreetAddress { get; set; }
        public string City { get; set; }
    }
}

Plus tard dans votre code, vous pourrez l'utiliser comme ceci:

Inclure les deux parties, base et adresse

PersonAddressSuper PersonSuper = new PersonAddressSuper();
PersonSuper.PersonAddress.StreetAddress = "PigBenis Road 16";

Base seulement:

PersonAddressSuper.PersonBase PersonBase = new PersonAddressSuper.PersonBase();
PersonBase.Name = "Joe Shmoe";

Adresse seulement:

PersonAddressSuper.PersonAddress PersonAddress = new PersonAddressSuper.PersonAddress();
PersonAddress.StreetAddress = "PigBenis Road 16";
0
Dementic