Que "odores de código" existem como sintoma de que é necessário um modelo de ouvinte de evento?

Quais são os sintomas em uma base de código que indicam que é necessária uma abordagem de ouvinte de eventos?

Parece-me que, quando há classes que precisam ser chamadas por várias, não definidas no conjunto de outras classes no tempo de design, você precisa de algum tipo de estrutura de sinalização, mas eu gostaria de ouvir que outras situações existem. aprimorada alterando para um modelo baseado em evento.

A abordagem de Evento / Ouvinte tenta evitar um acoplamento rígido ; portanto, todo o código que indica isso indica o apelo.

Com base nisso, sugiro os seguintes sintomas:

• grandes construtores , pois todo objeto precisa conhecer todos os outros objetos e não pode funcionar sem. Talvez disfarçado como muitos obj.set_dependecy(x)imediatamente após a chamada do construtor.

• dependências bidirecionais , porque, sem eventos, em uma linguagem imperativa, o fluxo de informações é basicamente 'push' (chamando o método de alguém)

• 'hierarquia do conhecimento' é difícil de determinar . Essas são as dependências bidirecionais , apenas outro foco: se há A, que ouve B, A conhece B, mas B não sabe A, então há uma 'hierarquia': alguns objetos não sabem nada, outros conhecem outros Por exemplo, ao implementar o MVC assim: http://en.wikipedia.org/wiki/Model_View_Controller , o modelo conhece apenas a si mesmo, a visualização conhece o modelo e o controlador conhece a visualização e o modelo.

Quando você não pode ou não deve saber o que deve reagir a um conjunto de mensagens / sinais / eventos.

Muitas vezes, é quando você deseja que o "mundo" saiba sobre algo que está acontecendo em um módulo (uma classe ou um sistema de classes), mas não deseja se preocupar com o que é chamado.

O cheiro do código associado, para ser específico, é quando você sente que começa a misturar código de módulos independentes, um fazendo algo ao qual o outro deveria reagir. Depois de perceber que é necessário chamar o código do módulo B, dependendo do estado / eventos do módulo A, você precisará de ouvintes de eventos.

Eu mudaria sua pergunta e diria: quando um evento baseado não é a solução certa para um aplicativo orientado a objetos? Eu acho que a maioria dos aplicativos OO pode se beneficiar se eles forem projetados como produtores e consumidores de eventos.

No final, uma "chamada de método" é de fato uma mensagem que chega a um objeto e o objeto é responsável por decidir se fará algo com a mensagem e executar a operação. Isso não é muito claro em linguagens fortemente tipadas como Java, mas se torna mais óbvio em linguagens dinâmicas como Ruby.

Outro ponto interessante ao projetar um aplicativo como baseado em eventos é que geralmente os componentes internos precisam ser adequadamente isolados e coerentes; caso contrário, o código se torna uma bagunça muito, muito rapidamente. Como exemplo, eu realmente gosto do conceito de Arquitetura Hexagonal usado por Alistair Cockburn, pois esse padrão geralmente cria um melhor encapsulamento e força (na minha opinião) componentes mais coesos.

Acho (mas provavelmente estou errado) que isso também esteja relacionado ao conceito de Design Orientado a Domínio de Eventos de Domínio , no qual as classes de domínio emitem eventos que são capturados por outros objetos e esses objetos emitem outros eventos (você vê onde isto está indo: D). O que eu gosto nesse padrão é que diz que as interfaces devem modelar funções, não implementações.

Desculpe se não faço muito sentido, tenho experimentado esses padrões nos últimos meses com resultados surpreendentes, mas ainda estou tentando entender os conceitos e até que ponto eles alcançam.

Pense no que você teria que fazer se os ouvintes de eventos (também conhecido como Padrão do Observador) não existissem.

Se você tem um objeto que tem referências a uma lista de outros objetos e chama um método para eles em um determinado ponto do processo, você definitivamente deveria ter tido um evento lá.

Se você tem um sinalizador em um objeto para dizer que algo foi feito e está observando esse sinalizador de outros objetos, definitivamente deveria ter usado um modelo orientado a eventos.

No entanto, não confunda isso com um retorno de chamada. Se você chamar um método em outro objeto e passá-lo para um método no objeto de origem para retornar em um determinado momento, deixe-o assim, em vez de usar um ouvinte de evento.