Devo preferir composição ou herança neste cenário?

Considere uma interface:

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

Essa interface é implementada por várias classes que geram ondas de diferentes formas (por exemplo, SineWaveGeneratore SquareWaveGenerator).

Quero implementar uma classe que gere uma SoundWavebase em dados musicais, não em dados brutos de som. Ele receberia o nome de uma nota e um comprimento em termos de batidas (não segundos) e usaria internamente a IWaveGeneratorfuncionalidade para criar uma SoundWaveconformidade.

A questão é: deve NoteGeneratorconter IWaveGeneratorou deve herdar de uma IWaveGeneratorimplementação?

Estou me inclinando para a composição por dois motivos:

1- Ele me permite injetar qualquer IWaveGeneratorà NoteGeneratordinamicamente. Além disso, eu só preciso de uma NoteGeneratorclasse, em vez de SineNoteGenerator, SquareNoteGenerator, etc.

2- Não há necessidade de NoteGeneratorexpor a interface de nível inferior definida por IWaveGenerator.

No entanto, estou postando esta pergunta para ouvir outras opiniões sobre isso, talvez pontos em que não pensei.

BTW: Eu diria que NoteGenerator é conceitualmente um IWaveGeneratorporque gera SoundWaves.

Ele permite injetar qualquer IWaveGenerator no NoteGenerator dinamicamente. Além disso, eu só preciso de uma classe NoteGenerator, em vez de SineNoteGenerator , SquareNoteGenerator , etc.

Isso é um sinal claro que seria melhor para composição uso aqui, e não herdam SineGeneratorou SquareGeneratorou (pior) ambos. No entanto, fará sentido herdar um NoteGenerator diretamente de um IWaveGeneratorse você o alterar um pouco.

O verdadeiro problema aqui é que provavelmente é significativo ter NoteGeneratorum método como

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

mas não com um método

SoundWave GenerateWave(double frequency, double lengthInSeconds);

porque essa interface é muito específica. Você quer que IWaveGenerators sejam objetos que geram SoundWaves, mas atualmente sua interface expressa IWaveGenerators são objetos que geram SoundWaves exclusivamente de frequência e comprimento . Então, crie melhor essa interface dessa maneira

interface IWaveGenerator
{
    SoundWave GenerateWave();
}

e passar parâmetros como frequencyou lengthInSeconds, ou um conjunto de parâmetros completamente diferente, pelos construtores de a SineWaveGenerator, a SquareGeneratorou qualquer outro gerador que você tenha em mente. Isso permitirá que você crie outro tipo de IWaveGenerators com parâmetros de construção completamente diferentes. Talvez você queira adicionar um gerador de ondas retangulares que precise de uma frequência e dois parâmetros de comprimento, ou algo assim, talvez queira adicionar um gerador de ondas triangulares a seguir, também com pelo menos três parâmetros. Ou, uma NoteGenerator, com parâmetros do construtor noteName, noOfBeats, e waveGenerator.

Portanto, a solução geral aqui é separar os parâmetros de entrada da função de saída e tornar apenas a função de saída parte da interface.

Se o NoteGenerator é ou não "conceitualmente" um IWaveGenerator não importa.

Você só deve herdar de uma interface se planeja implementar essa interface exata de acordo com o Princípio de Substituição de Liskov, ou seja, com a semântica correta e com a sintaxe correta.

Parece que seu NoteGenerator pode ter sintaticamente a mesma interface, mas sua semântica (neste caso, o significado dos parâmetros necessários) será muito diferente, portanto, usar herança neste caso seria altamente enganoso e potencialmente propenso a erros. Você está certo em preferir composição aqui.

2- Não é necessário que o NoteGenerator exponha a interface de nível inferior definida pelo IWaveGenerator.

Parece que NoteGeneratornão é um WaveGenerator, portanto, não deve implementar a interface.

Composição é a escolha correta.

Você tem um argumento sólido para composição. Você pode ter um caso para adicionar também herança. A maneira de saber é observando o código de chamada. Se você quiser usar um NoteGeneratorno código de chamada existente que espera um IWaveGenerator, precisará implementar a interface. Você está procurando uma necessidade de substituibilidade. Se conceitualmente "é um gerador de ondas" está fora de questão.

É bom NoteGeneratorimplementar a interface e também NoteGeneratorter uma implementação interna que faça referência (por composição) a outra IWaveGenerator.

Geralmente, a composição resulta em um código mais sustentável (ou seja, legível), porque você não tem complexidades de substituições para raciocinar. Sua observação sobre a matriz de classes que você teria ao usar herança também é relevante e provavelmente pode ser pensada como um cheiro de código apontando para a composição.

A herança é melhor usada quando você tem uma implementação que deseja especializar ou personalizar, o que não parece ser o caso aqui: você só precisa usar a interface.