Dois-je préférer la composition ou l'héritage dans ce scénario?

Considérez une interface:

interface IWaveGenerator
{
    SoundWave GenerateWave(double frequency, double lengthInSeconds);
}

Cette interface est implémentée par un certain nombre de classes qui génèrent des vagues de formes différentes (par exemple, SineWaveGeneratoret SquareWaveGenerator).

Je veux implémenter une classe qui génère un SoundWavebasé sur des données musicales, pas des données sonores brutes. Il recevrait le nom d'une note et une longueur en termes de battements (pas de secondes), et utiliserait en interne la IWaveGeneratorfonctionnalité pour créer un en SoundWaveconséquence.

La question est de savoir si le doit NoteGeneratorcontenir IWaveGeneratorou doit-il hériter d'une IWaveGeneratorimplémentation?

Je penche vers la composition pour deux raisons:

1- Il me permet d'injecter tout IWaveGeneratorle NoteGeneratordynamique. En outre, je ne ai besoin d' une NoteGeneratorclasse, au lieu de SineNoteGenerator, SquareNoteGeneratoretc.

2- Il n'est pas nécessaire NoteGeneratord'exposer l'interface de niveau inférieur définie par IWaveGenerator.

Cependant, je poste cette question pour entendre d'autres opinions à ce sujet, peut-être des points auxquels je n'ai pas pensé.

BTW: Je dirais que NoteGenerator c'est conceptuellement un IWaveGeneratorparce qu'il génère l' SoundWaveart.

Cela me permet d'injecter n'importe quel IWaveGenerator au NoteGenerator dynamiquement. De plus, je n'ai besoin que d'une seule classe NoteGenerator, au lieu de SineNoteGenerator , SquareNoteGenerator , etc.

C'est un signe clair qu'il serait préférable d'utiliser la composition ici, et de ne pas hériter des SineGeneratorou SquareGeneratorou (pire) des deux. Néanmoins, il sera logique d'hériter directement d'un NoteGenerator d'un IWaveGeneratorsi vous changez un peu ce dernier.

Le vrai problème ici est qu'il est probablement significatif d'avoir NoteGeneratorune méthode comme

SoundWave GenerateWave(string noteName, double noOfBeats, IWaveGenerator waveGenerator);

mais pas avec une méthode

SoundWave GenerateWave(double frequency, double lengthInSeconds);

car cette interface est trop spécifique. Vous voulez que IWaveGenerators soit des objets qui génèrent SoundWaves, mais actuellement votre interface exprime IWaveGenerators sont des objets qui génèrent SoundWaves uniquement à partir de la fréquence et de la longueur . Donc, mieux concevoir une telle interface de cette façon

interface IWaveGenerator
{
    SoundWave GenerateWave();
}

et passez des paramètres comme frequencyou lengthInSeconds, ou un ensemble de paramètres complètement différent via les constructeurs de a SineWaveGenerator, a SquareGeneratorou tout autre générateur que vous avez en tête. Cela vous permettra de créer d'autres types de IWaveGenerators avec des paramètres de construction complètement différents. Peut-être que vous voulez ajouter un générateur d'onde rectangulaire qui a besoin d'une fréquence et de deux paramètres de longueur, ou quelque chose comme ça, peut-être que vous voulez ajouter un générateur d'onde triangulaire à côté, également avec au moins trois paramètres. Ou, un NoteGenerator, avec des paramètres du constructeur noteName, noOfBeats, et waveGenerator.

La solution générale consiste donc à découpler les paramètres d'entrée de la fonction de sortie et à n'intégrer que la fonction de sortie à l'interface.

Que NoteGenerator soit ou non "conceptuellement" un IWaveGenerator n'a pas d'importance.

Vous ne devez hériter d'une interface que si vous prévoyez d'implémenter cette interface exacte selon le principe de substitution Liskov, c'est-à-dire avec la sémantique correcte ainsi que la syntaxe correcte.

Il semble que votre NoteGenerator puisse avoir syntaxiquement la même interface, mais sa sémantique (dans ce cas, la signification des paramètres qu'il prend) sera très différente, donc l'utilisation de l'héritage dans ce cas serait très trompeuse et potentiellement sujette aux erreurs. Vous avez raison de préférer la composition ici.

2- Il n'est pas nécessaire que NoteGenerator expose l'interface de niveau inférieur définie par IWaveGenerator.

Il semble que ce NoteGeneratorne soit pas un WaveGenerator, il ne faut donc pas implémenter l'interface.

La composition est le bon choix.

Vous avez un solide dossier de composition. Vous pouvez avoir un cas pour ajouter également l' héritage. La façon de le dire est de regarder le code appelant. Si vous voulez pouvoir utiliser un NoteGeneratordans un code d'appel existant qui attend un IWaveGenerator, vous devez implémenter l'interface. Vous recherchez un besoin de substituabilité. Qu'il soit conceptuellement «générateur de vagues» n'est pas la question.

C'est bien pour NoteGeneratorimplémenter l'interface, et aussi, pour NoteGeneratoravoir une implémentation interne qui référence (par composition) une autre IWaveGenerator.

Généralement, la composition se traduit par un code plus facile à gérer (c'est-à-dire lisible), car vous n'avez pas de complexités de remplacements à raisonner. Votre observation sur la matrice des classes que vous auriez lors de l'utilisation de l'héritage est également pertinente, et peut probablement être considérée comme une odeur de code pointant vers la composition.

L'héritage est mieux utilisé lorsque vous avez une implémentation que vous souhaitez spécialiser ou personnaliser, ce qui ne semble pas être le cas ici: il vous suffit d'utiliser l'interface.