Étant donné que l'héritage multiple est mauvais (cela rend la source plus compliquée), C # ne fournit pas directement un tel modèle. Mais parfois, il serait utile d'avoir cette capacité.
Par exemple, je suis capable d'implémenter le modèle d'héritage multiple manquant en utilisant des interfaces et trois classes comme ça:
public interface IFirst { void FirstMethod(); }
public interface ISecond { void SecondMethod(); }
public class First:IFirst
{
public void FirstMethod() { Console.WriteLine("First"); }
}
public class Second:ISecond
{
public void SecondMethod() { Console.WriteLine("Second"); }
}
public class FirstAndSecond: IFirst, ISecond
{
First first = new First();
Second second = new Second();
public void FirstMethod() { first.FirstMethod(); }
public void SecondMethod() { second.SecondMethod(); }
}
Chaque fois que j'ajoute une méthode à l'une des interfaces, je dois également changer la classe FirstAndSecond .
Existe-t-il un moyen d'injecter plusieurs classes existantes dans une nouvelle classe comme c'est possible en C ++?
Peut-être existe-t-il une solution utilisant une sorte de génération de code?
Ou cela peut ressembler à ceci (syntaxe c # imaginaire):
public class FirstAndSecond: IFirst from First, ISecond from Second
{ }
Pour qu'il n'y ait pas besoin de mettre à jour la classe FirstAndSecond lorsque je modifie l'une des interfaces.
ÉDITER
Il serait peut-être préférable de considérer un exemple pratique:
Vous avez une classe existante (par exemple, un client TCP basé sur du texte basé sur ITextTcpClient) que vous utilisez déjà à différents endroits dans votre projet. Vous ressentez maintenant le besoin de créer un composant de votre classe pour être facilement accessible aux développeurs de formulaires Windows.
Autant que je sache, vous avez actuellement deux façons de procéder:
Écrivez une nouvelle classe héritée des composants et implémente l'interface de la classe TextTcpClient à l'aide d'une instance de la classe elle-même, comme illustré avec FirstAndSecond.
Écrivez une nouvelle classe qui hérite de TextTcpClient et implémente en quelque sorte IComponent (ne l'ont pas encore essayé).
Dans les deux cas, vous devez travailler par méthode et non par classe. Puisque vous savez que nous aurons besoin de toutes les méthodes de TextTcpClient et Component, ce serait la solution la plus simple pour simplement combiner ces deux en une seule classe.
Pour éviter les conflits, cela peut être fait par génération de code où le résultat pourrait être modifié par la suite, mais le taper à la main est une pure douleur dans le cul.