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.
Non, utilisez plutôt des interfaces! ^. ^
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 { }
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é".
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.
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
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.
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.
En fait, cela dépend de votre définition de l'héritage:
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.
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".
Modèle d'héritage multiple simulé
http://www.codeproject.com/KB/architecture/smip.aspx
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();
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
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.
}
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é. .
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
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.
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";