Dovrei preferire la composizione o l'eredità in questo scenario?

Prendi in considerazione un'interfaccia:

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

Questa interfaccia è implementata da un numero di classi che generano ondate di forme diverse (ad esempio, SineWaveGeneratore SquareWaveGenerator).

Voglio implementare una classe che genera una SoundWavebasata su dati musicali, non su dati audio grezzi. Riceverà il nome di una nota e una lunghezza in termini di battute (non secondi) e utilizzerà internamente la IWaveGeneratorfunzionalità per creare di SoundWaveconseguenza.

La domanda è: dovrebbe NoteGeneratorcontenere IWaveGeneratoro dovrebbe ereditare da IWaveGeneratorun'implementazione?

Mi sto orientando verso la composizione per due motivi:

1- Mi permette di iniettare qualsiasi IWaveGeneratoral NoteGeneratormodo dinamico. Inoltre, ho solo bisogno di una NoteGeneratorclasse, invece di SineNoteGenerator, SquareNoteGeneratorecc

2- Non è necessario NoteGeneratoresporre l'interfaccia di livello inferiore definita da IWaveGenerator.

Tuttavia sto pubblicando questa domanda per ascoltare altre opinioni in merito, forse punti a cui non ho pensato.

A proposito: direi che NoteGenerator è concettualmente un IWaveGeneratorperché genera SoundWaves.

Mi permette di iniettare dinamicamente qualsiasi IWaveGenerator nel NoteGenerator. Inoltre, ho bisogno solo di una classe NoteGenerator, invece di SineNoteGenerator , SquareNoteGenerator , ecc.

Questo è un chiaro segno che sarebbe stato meglio per la composizione uso qui, e non ereditano da SineGeneratoro SquareGeneratoro (peggio) entrambi. Tuttavia, avrà senso ereditare un NoteGenerator direttamente da un IWaveGeneratorse si modifica un po 'quest'ultimo.

Il vero problema qui è, probabilmente è significativo avere NoteGeneratorcon un metodo simile

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

ma non con un metodo

SoundWave GenerateWave(double frequency, double lengthInSeconds);

perché questa interfaccia è troppo specifica. Vuoi che IWaveGenerators siano oggetti che generano SoundWaves, ma attualmente la tua interfaccia esprime IWaveGenerators sono oggetti che generano SoundWaves esclusivamente in frequenza e lunghezza . Quindi progettare meglio un'interfaccia del genere in questo modo

interface IWaveGenerator
{
    SoundWave GenerateWave();
}

e passa parametri come frequencyo lengthInSeconds, o un insieme completamente diverso di parametri attraverso i costruttori di a SineWaveGenerator, a SquareGeneratoro qualunque altro generatore tu abbia in mente. Ciò ti consentirà di creare altri tipi di IWaveGenerators con parametri di costruzione completamente diversi. Forse vuoi aggiungere un generatore di onde rettangolari che ha bisogno di una frequenza e due parametri di lunghezza, o qualcosa del genere, forse vuoi aggiungere un generatore di onde triangolari, anche con almeno tre parametri. Oppure, una NoteGenerator, con parametri del costruttore noteName, noOfBeatse waveGenerator.

Quindi la soluzione generale qui è di disaccoppiare i parametri di input dalla funzione di output e rendere solo la funzione di output parte dell'interfaccia.

Non importa se NoteGenerator sia "concettualmente" un IWaveGenerator.

Dovresti ereditare da un'interfaccia solo se prevedi di implementare quell'interfaccia esatta secondo il Principio di sostituzione di Liskov, cioè con la semantica corretta e la sintassi corretta.

Sembra che il tuo NoteGenerator potrebbe avere sinteticamente la stessa interfaccia, ma la sua semantica (in questo caso, il significato dei parametri che assume) sarà molto diversa, quindi l'uso dell'ereditarietà in questo caso sarebbe altamente fuorviante e potenzialmente soggetto a errori. Hai ragione a preferire la composizione qui.

2- Non è necessario che NoteGenerator esponga l'interfaccia di livello inferiore definita da IWaveGenerator.

Sembra che NoteGeneratornon sia un WaveGenerator, quindi non dovrebbe implementare l'interfaccia.

La composizione è la scelta corretta.

Hai un solido caso di composizione. Potresti avere un caso per aggiungere anche l' eredità. Il modo di dire è guardando il codice chiamante. Se si desidera poter utilizzare un NoteGeneratorcodice di chiamata esistente che prevede un IWaveGenerator, è necessario implementare l'interfaccia. Stai cercando un bisogno di sostituibilità. Che sia concettualmente un generatore di onde "is-a" non ha senso.

Va bene NoteGeneratorimplementare l'interfaccia e anche NoteGeneratoravere un'implementazione interna che fa riferimento (per composizione) a un'altra IWaveGenerator.

Generalmente, la composizione si traduce in un codice più gestibile (cioè leggibile), perché non hai complessità di sostituzioni su cui ragionare. Anche la tua osservazione sulla matrice delle classi che avresti quando usi l'ereditarietà è importante e probabilmente può essere considerata come un odore di codice che punta verso la composizione.

L'ereditarietà viene utilizzata meglio quando si dispone di un'implementazione che si desidera specializzare o personalizzare, il che non sembra essere il caso qui: è sufficiente utilizzare l'interfaccia.