¿Debo preferir la composición o la herencia en este escenario?

Considere una interfaz:

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

Esta interfaz se implementa mediante una serie de clases que generan ondas de diferentes formas (por ejemplo, SineWaveGeneratory SquareWaveGenerator).

Quiero implementar una clase que genere SoundWavedatos basados ​​en datos musicales, no en sonido sin formato. Recibiría el nombre de una nota y una duración en términos de latidos (no segundos), y utilizaría internamente la IWaveGeneratorfuncionalidad para crear un SoundWaveacorde.

La pregunta es, ¿debería NoteGeneratorcontener IWaveGeneratoro debería heredar de una IWaveGeneratorimplementación?

Me inclino por la composición por dos razones:

1- Me permite inyectar cualquiera IWaveGeneratora la NoteGeneratordinámica. Además, sólo necesito una NoteGeneratorclase, en lugar de SineNoteGenerator, SquareNoteGenerator, etc.

2- No es necesario NoteGeneratorexponer la interfaz de nivel inferior definida por IWaveGenerator.

Sin embargo, estoy publicando esta pregunta para escuchar otras opiniones al respecto, tal vez puntos en los que no he pensado.

Por cierto: diría que NoteGenerator es conceptualmente IWaveGeneratorporque genera SoundWaves.

Me permite inyectar cualquier IWaveGenerator al NoteGenerator dinámicamente. Además, solo necesito una clase NoteGenerator, en lugar de SineNoteGenerator , SquareNoteGenerator , etc.

Esto es una clara señal de que sería mejor composición de uso aquí, y no hereda de SineGeneratoro SquareGeneratoro (peor) a la vez. Sin embargo, tendrá sentido heredar un NoteGenerator directamente de un IWaveGeneratorsi cambia un poco este último.

El verdadero problema aquí es que probablemente sea significativo tener NoteGeneratorun método como

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

pero no con un método

SoundWave GenerateWave(double frequency, double lengthInSeconds);

porque esta interfaz es muy específica Desea que IWaveGenerators sean objetos que generan SoundWaves, pero actualmente su interfaz expresa IWaveGenerators son objetos que generan SoundWaves exclusivamente de frecuencia y longitud . Así que mejor diseño de esta interfaz de esta manera

interface IWaveGenerator
{
    SoundWave GenerateWave();
}

y pasar parámetros como frequencyo lengthInSeconds, o un conjunto de parámetros completamente diferente a través de los constructores de a SineWaveGenerator, a SquareGenerator, o cualquier otro generador que tenga en mente. Esto le permitirá crear otro tipo de IWaveGenerators con parámetros de construcción completamente diferentes. Tal vez desee agregar un generador de onda rectangular que necesite una frecuencia y dos parámetros de longitud, o algo así, tal vez desee agregar un generador de onda triangular a continuación, también con al menos tres parámetros. O bien, una NoteGenerator, con parámetros del constructor noteName, noOfBeats, y waveGenerator.

Entonces, la solución general aquí es desacoplar los parámetros de entrada de la función de salida y hacer que solo la función de salida forme parte de la interfaz.

Si NoteGenerator es o no "conceptualmente" un IWaveGenerator no importa.

Solo debe heredar de una interfaz si planea implementar esa interfaz exacta de acuerdo con el Principio de sustitución de Liskov, es decir, con la semántica correcta y la sintaxis correcta.

Parece que su NoteGenerator podría tener sintácticamente la misma interfaz, pero su semántica (en este caso, el significado de los parámetros que toma) será muy diferente, por lo que el uso de la herencia en este caso sería muy engañoso y potencialmente propenso a errores. Tienes razón al preferir la composición aquí.

2- No es necesario que NoteGenerator exponga la interfaz de nivel inferior definida por IWaveGenerator.

Parece que NoteGeneratorno es un WaveGenerator, por lo tanto, no debe implementar la interfaz.

La composición es la elección correcta.

Tienes un caso sólido para la composición. Es posible que tenga un caso para agregar también herencia. La forma de saberlo es mirando el código de llamada. Si desea poder utilizar un NoteGeneratorcódigo de llamada existente que espera un IWaveGenerator, entonces necesita implementar la interfaz. Estás buscando una necesidad de sustituibilidad. Si conceptualmente es "un generador de onda" no viene al caso.

Está bien NoteGeneratorimplementar la interfaz y también NoteGeneratortener una implementación interna que haga referencia (por composición) a otra IWaveGenerator.

En general, la composición da como resultado un código más fácil de mantener (es decir, legible), porque no tiene complejidades de anulaciones para razonar. Tu observación sobre la matriz de clases que tendrías al usar la herencia también es correcta, y probablemente se pueda considerar como un olor a código que apunta hacia la composición.

La herencia se usa mejor cuando tienes una implementación que deseas especializar o personalizar, lo cual no parece ser el caso aquí: solo necesitas usar la interfaz.