English
Español
Català
Event Dispatcher per a Unity
Senyals tipades despatxades a través d'un servei, amb suport per a autoregistre i sense singletons estàtics.
Per a què serveix aquest sistema
El baix acoblament a Unity sol començar amb esdeveniments de C#. Després apareixen UnityEvents a l'Inspector. Després sorgeix un bus de missatges a mida perquè ningú vol cablejar UnityEvents un a un entre escenes. Cada projecte acaba amb la seva pròpia variant de la mateixa idea, i el codi resultant segueix filtrant referències entre sistemes que no s'haurien de conèixer.
L'Event Dispatcher de Serenity és la manera estàndard de despatxar senyals dins de la foundation. És basat en servei, les senyals són tipades i les accions poden autoregistrar-se mitjançant un atribut. Tots els altres sistemes de la foundation el fan servir, així que les senyals no són un afegit posterior, són la manera en què els sistemes parlen entre si.
El problema a Unity
Els esdeveniments de Unity vénen en massa sabors i cap no és del tot adequat per a la comunicació entre sistemes. Els esdeveniments de C# són simples però fàcils de filtrar. Els UnityEvents són visibles a l'Inspector però es resisteixen al refactor. Els busos d'esdeveniments estàtics són còmodes però barallen amb els tests unitaris. Cap no anima a fer servir payloads tipats i tots tendeixen a créixer orgànicament fins que el graf de dependències entre sistemes és impossible de dibuixar.
A sobre, el registre és la part que tothom oblida. Les subscripcions són fàcils d'afegir i fàcils de filtrar. Quan un sistema necessita escoltar una senyal, trobar el moment adequat per registrar-se i el moment adequat per desregistrar-se sol ser prou pesat com perquè la gent s'ho salti.
Com ho aborda Serenity
Serenity exposa la capa d'esdeveniments a través d'IEventDispatcherService, amb IEventDispatcherAction per als gestors i EventDispatcherSignal com a contracte de senyal tipada. L'autoregistre està suportat mitjançant AutoRegisterEventActionAttribute, així que les accions es poden descobrir i registrar des de l'instal·lador en lloc de fer-ho a mà.
La implementació Unity és UnityEventDispatcherService, registrada via UnityEventDispatcherInstaller. El dispatcher és un servei, no un singleton estàtic. Els tests el poden reemplaçar. Els altres sistemes el resolen a través de la interfície i mai no toquen un global.
El diagnòstic és de primer nivell. La capa d'Infraestructura inclou UnityFileLogService i UnityFileLogSettings, registrats mitjançant UnityFileLogInstaller, així que el flux de senyals es pot abocar a un fitxer de log durant el desenvolupament. Quan alguna cosa va malament pots veure les senyals reals que es van disparar i l'ordre en què es van gestionar.
Com encaixa a Serenity
Event Dispatcher viu al namespace Serenity.EventDispatcher. Entitats de Domini com EventDispatcherSignal i EventDispatcherSignalDelegate descriuen el contracte. La capa d'Aplicació exposa les interfícies de servei i acció. La capa d'Infraestructura aporta UnityEventDispatcherService juntament amb el servei de log a fitxer fet servir per a diagnòstic mitjançant UnityFileLogService i UnityFileLogSettings.
Tots els altres sistemes de la foundation fan servir el dispatcher per comunicar-se. Els menús emeten OnMenuSubmitOptionSignal. Els modals emeten OnShowModalSignal, OnCloseModalSignal i OnModalSubmitOptionSignal. Game Mode emet StartGameSignal, EnterMenuSignal i GameModeChangedSignal. Els reproductors d'àudio i música emeten PlayAudioClipSignal i PlayMusicTrackSignal. Game Settings emet OnGameSettingsOnValueUpdatedSignal. El dispatcher és el teixit connectiu que manté desacoblats aquests sistemes.
Flux de treball pràctic
- Defineix el teu tipus de senyal com una classe que estén EventDispatcherSignal.
- Defineix una acció que implementi IEventDispatcherAction per a aquesta senyal.
- Decora l'acció amb AutoRegisterEventActionAttribute si vols que l'instal·lador la descobreixi.
- Llança la senyal a través d'IEventDispatcherService des del codi que vulgui notificar.
- Subscriu-te amb accions o delegats registrats des del codi que vulgui reaccionar.
- Reemplaça el servei en tests si necessites afirmar que es va llançar una senyal.
Què inclou
- Dispatcher basat en servei IEventDispatcherService sense singletons estàtics
- Contracte de senyal tipada a través d'EventDispatcherSignal i EventDispatcherSignalDelegate
- Interfície d'acció IEventDispatcherAction per a gestors reactius
- Suport d'autoregistre via AutoRegisterEventActionAttribute
- Implementació Unity UnityEventDispatcherService amb registre a través d'instal·lador
- Diagnòstic mitjançant UnityFileLogService i UnityFileLogSettings
- Fet servir com a capa connectiva entre tots els altres sistemes de Serenity
- Testejable de manera aïllada perquè el servei es resol a través d'una interfície
Quan fer-lo servir
- Projectes que volen que els sistemes de gameplay es comuniquin sense referenciar-se entre ells.
- Equips que prefereixen senyals tipades davant d'UnityEvents o esdeveniments crus de C# per a la comunicació entre sistemes.
- Bases de codi que es mouen de busos d'esdeveniments estàtics cap a un servei resoluble.
- Jocs que necessiten diagnòstic o replay del flux d'esdeveniments durant el desenvolupament.
Sistemes relacionats
Utilitza Serenity quan vulguis una capa d'esdeveniments tipada que la resta de la foundation ja parla, però que et segueix deixant definir les teves pròpies senyals i accions per al teu joc.