{"id":6135,"date":"2025-11-10T13:45:21","date_gmt":"2025-11-10T12:45:21","guid":{"rendered":"https:\/\/gdksoftware.com\/?post_type=knowledge&p=6135"},"modified":"2025-11-10T13:45:21","modified_gmt":"2025-11-10T12:45:21","slug":"eventbus-pattern","status":"publish","type":"knowledge","link":"https:\/\/gdksoftware.com\/nl\/kennisbank\/eventbus-pattern","title":{"rendered":"EventBus pattern"},"content":{"rendered":"

Introductie<\/h2>\n

Tijdens de ontwikkeling van Codolex merkten we dat het verbinden van verschillende formulieren en componenten via callback events zorgde voor sterk gekoppelde code. Een voorbeeld: wanneer een gebruiker een project opslaat, moeten meerdere onderdelen van de applicatie reageren. De lijst met recente items moet worden bijgewerkt, de backup manager moet in actie komen en de analytics tracker moet de gebeurtenis vastleggen. Met overal callback events werd dit al snel moeilijk onderhoudbaar. Om dit probleem op te lossen, hebben we het EventBus pattern ge\u00efmplementeerd.<\/p>\n

De EventBus biedt een centrale plek om events te distribueren. Wanneer een proces een event naar de EventBus stuurt, distribueert deze het automatisch naar alle componenten die zich hebben geabonneerd op dat eventtype. Dit is een implementatie van het Observer pattern<\/a> gecombineerd met het Mediator pattern<\/a> om code te ontkoppelen.<\/p>\n

Implementation<\/h3>\n

Bij het versturen van events moeten we kunnen identificeren om wat voor soort event het gaat. We gebruiken hiervoor een enumeratie om het eventtype te herkennen. De waarden zijn afhankelijk van je specifieke implementatie.<\/p>\n

\n
{$SCOPEDENUMS ON}<\/span>\r\n\/\/ Indicates which event is fired<\/span>\r\nTEventType =<\/span> (New<\/span>,<\/span> Update,<\/span> Open,<\/span> Close<\/span>,<\/span> Cancel,<\/span> Validation);<\/span>\r\nTEventTypes =<\/span> set<\/span> of<\/span> TEventType;<\/span>\r\n{$SCOPEDENUMS OFF}<\/span>\r\n<\/pre>\n<\/div>\n
Vervolgens defini\u00ebren we de EventBus. We defini\u00ebren deze als generic, zodat we bij het gebruik direct met de juiste types werken. De EventBus heeft een procedure nodig waarmee observers zich kunnen abonneren en een procedure waarmee een event kan worden afgevuurd.<\/p>\n
\n
\/\/ Procedure definition to receive events<\/span>\r\nTEventAction<<\/span>I:<\/span> ISerializableObject><\/span> =<\/span> \r\n       reference to<\/span> procedure<\/span>(const<\/span> EventType:<\/span> TEventType;<\/span> const<\/span> Data:<\/span> I);<\/span>\r\n\r\n\/\/ Procedure to unsubscribe<\/span>\r\nTUnsubscribeEvent =<\/span> reference to<\/span> procedure<\/span>;<\/span>\r\n\r\n\/\/ Base (generic) event bus interface<\/span>\r\nIEventBus<\/span><<\/span>I:<\/span> ISerializableObject><\/span> =<\/span> interface<\/span>\r\n\r\n  function<\/span> Subscribe<\/span>(const<\/span> OnEvent:<\/span> TEventAction<<\/span>I><\/span>):<\/span> TUnsubscribeEvent;<\/span> overload;<\/span>\r\n  \/\/ Overloaded variant to register filtered subscriptions<\/span>\r\n  function<\/span> Subscribe<\/span>(const<\/span> OnEvent:<\/span> TEventAction<<\/span>I>;<\/span> \r\n                     const<\/span> Filter:<\/span> TEventTypes):<\/span> TUnsubscribeEvent;<\/span> overload;<\/span>\r\n\r\n  procedure<\/span> Post<\/span>(const<\/span> EventType:<\/span> TEventType;<\/span> const<\/span> Data:<\/span> I);<\/span>\r\nend<\/span>;<\/span>\r\n<\/pre>\n<\/div>\n
Met de basis van de EventBus gedefinieerd, kunnen we event buses maken voor specifieke types:<\/p>\n
\n
  \/\/ Specific interfaces for different types of event buses<\/span>\r\n  IProjectEventBus =<\/span> interface<\/span>(IEventBus<<\/span>IProject><\/span>)\r\n  end<\/span>;<\/span>\r\n\r\n  IDataEntityEventBus =<\/span> interface<\/span>(IEventBus<<\/span>IDataEntity><\/span>)\r\n  end<\/span>;<\/span>\r\n\r\n  IFlowEventBus =<\/span> interface<\/span>(IEventBus<<\/span>IFlow><\/span>)\r\n  end<\/span>;<\/span>\r\n<\/pre>\n<\/div>\n
De master event bus<\/h3>\n
We willen een eenvoudige en transparante manier om de event bus structuur te gebruiken. Om dit te bereiken, gebruiken we een master event bus die een collectie van event buses bevat. Door deze master bus een singleton te maken in je applicatie, is er een uniforme manier om toegang te krijgen tot alle onderliggende event buses.<\/p>\n
\n
  \/\/ Master event bus to expose the available types of event buses (should be a singleton)<\/span>\r\n  IMasterEventBus =<\/span> interface<\/span>\r\n    function<\/span> Project<\/span>:<\/span> IProjectEventBus;<\/span>\r\n    function<\/span> Flow<\/span>:<\/span> IFlowEventBus;<\/span>\r\n    function<\/span> DataEntity<\/span>:<\/span> IDataEntityEventBus;<\/span>\r\n  end<\/span>;<\/span>\r\n<\/pre>\n<\/div>\n
Abonnementen beheren<\/h3>\n
Wanneer iemand zich abonneert op een event bus, geeft de procedure een TUnsubscribeEvent<\/strong> terug die gebruikt kan worden om het abonnement op te zeggen. Als je je abonneert op meerdere event buses, wil je deze allemaal in \u00e9\u00e9n keer kunnen opruimen. Hiervoor defini\u00ebren we een aparte interface die de unsubscribe events bijhoudt en opruimt via een enkele functie (of wanneer het object automatisch wordt vernietigd).<\/p>\n
\n
  \/\/ Interface to store unsubscribe events and unsubscribe all at once<\/span>\r\n  IUnsubscriber =<\/span> interface<\/span>(IList<<\/span>TUnsubscribeEvent><\/span>)\r\n    procedure<\/span> Unsubscribe<\/span>;<\/span>\r\n  end<\/span>;<\/span>\r\n<\/pre>\n<\/div>\n
Voorbeeld gebruik<\/h3>\n
Nu we alles op zijn plaats hebben, werkt het in de praktijk als volgt:<\/p>\n
\n
\/\/ Somewhere in the constructor: declare the unsubscriber<\/span>\r\nFUnsubscriber :=<\/span> GlobalContainer.<\/span>Resolve<<\/span>IUnsubscriber>;<\/span>\r\n\r\n\/\/ Declare and get the master event bus<\/span>\r\nvar<\/span> EventBus :=<\/span> GlobalContainer.<\/span>Resolve<<\/span>IMasterEventBus>;<\/span>\r\n\r\n\/\/ Subscribe for specific flow events<\/span>\r\nvar<\/span> UnsubscribeFlow :=<\/span> EventBus.<\/span>Flow.<\/span>Subscribe(\r\n                        procedure<\/span>(const<\/span> EventType:<\/span> TEventType;<\/span> const<\/span> Data:<\/span> IFlow)\r\n                        begin<\/span>\r\n                          \/\/ Handle the flow event<\/span>\r\n                        end<\/span>,<\/span>\r\n                        [TEventType.<\/span>Open,<\/span> TEventType.<\/span>Close]);<\/span>\r\n\r\nFUnsubscriber.<\/span>Add(UnsubscribeFlow);<\/span>\r\n\r\n\/\/ Subscribe for all project events<\/span>\r\nFUnsubscriber.<\/span>Add(\r\n  EventBus.<\/span>Project.<\/span>Subscribe(\r\n    procedure<\/span>(const<\/span> EventType:<\/span> TEventType;<\/span> const<\/span> Data:<\/span> IProject)\r\n    begin<\/span>\r\n      \/\/ Handle the project event<\/span>\r\n    end<\/span>));<\/span>\r\n\r\n\/\/ Post an event about a data entity<\/span>\r\nvar<\/span> MyDataEntity:<\/span> IDataEntity;<\/span>\r\nEventBus.<\/span>DataEntity.<\/span>Post(TEventType.<\/span>Update,<\/span> MyDataEntity);<\/span>\r\n\r\n\/\/ Somewhere in the destructor: clean up all subscriptions<\/span>\r\nFUnsubscriber.<\/span>Unsubscribe;<\/span>\r\n<\/pre>\n<\/div>\n
De filter parameter gebruikt de set-syntax van Delphi om aan te geven welke eventtypes je wilt ontvangen. In het bovenstaande voorbeeld abonneren we ons alleen op Open<\/code> en Close<\/code> events voor flows, terwijl we ons voor projecten abonneren op alle eventtypes.<\/p>\n
Voordelen in de praktijk<\/h3>\n
Het EventBus pattern heeft ons geholpen om Codolex onderhoudbaar te houden naarmate het groeit. Voordat we dit pattern implementeerden, hadden we callback events verspreid door de hele codebase. Het toevoegen van een nieuwe feature die moest reageren op projectwijzigingen betekende dat we meerdere bestanden moesten aanpassen en alle verbindingen handmatig moesten bijhouden.<\/p>\n
Met de EventBus is het toevoegen van nieuwe functionaliteit eenvoudig. Toen we bijvoorbeeld analytics tracking toevoegden, abonneerden we ons simpelweg op de relevante events zonder bestaande code aan te raken. Hetzelfde gold toen we de backup manager en de lijst met recente items implementeerden. Elk component registreert zijn interesse in specifieke events en behandelt deze onafhankelijk.<\/p>\n
Deze aanpak maakt testen ook eenvoudiger. We kunnen componenten ge\u00efsoleerd testen en verifi\u00ebren dat ze de juiste events posten, zonder dat de hele applicatiestructuur aanwezig hoeft te zijn.<\/p>\n
Belangrijke overwegingen<\/h3>\n
Hoewel het EventBus pattern krachtig is, zijn er een aantal zaken om rekening mee te houden:<\/p>\n