Event Bus

A powerful, type-safe event system for Unity with fluent interface design.

Overview

EventBus provides a robust, decoupled communication system for your Unity projects. Built with type safety and ease of use in mind, it offers a fluent interface for raising and listening to events, with or without payload data.

Key Features

Type-Safe Events: Uses interfaces for event definitions, ensuring compile-time type checking
Fluent Interface: Intuitive builder pattern for clear and concise event handling
Payload Support: Handle events with or without custom data payloads
Event Caching: Optional kick-start feature to receive the last event upon subscription
Zero Dependencies: Works right out of the box with no external dependencies

Why Use It?

Type-Safe Communication

No more string-based events or manual delegate management. Our EventBus ensures all event communications are type-safe and verified at compile time, eliminating runtime errors from typos or wrong event types.

Clean Architecture

Decoupled Systems: Services and components can communicate without direct references
Modular Design: Add or remove features without changing existing code
Easy Maintenance: Change internal logic without affecting other systems
Clear Dependencies: Easily track event flows through your application

Developer Experience

Intuitive API: Simple, fluent interface that's easy to understand and use
IDE Friendly: Full auto-completion support for better productivity
Reduced Boilerplate: No need to write custom event systems or manager classes
Quick Integration: Start using in minutes with minimal setup

Powerful Features

Event Caching: New subscribers can automatically receive the most recent event
Payload Support: Send any type of data with your events
Sender Tracking: Always know which component triggered an event
Flexible Subscription: Subscribe and unsubscribe at any time

Perfect For

Service Architecture: Connect independent services without tight coupling
UI Updates: Keep UI in sync with game state changes
Cross-Scene Communication: Share data between different scenes
State Management: Handle game state changes efficiently
Analytics Integration: Track game events without modifying core systems

Production Ready

Performance Optimized: Efficient event dispatching with minimal overhead
Memory Conscious: Small memory footprint with proper cleanup
Battle Tested: Reliable in production environments
Unity Friendly: Designed specifically for Unity projects

This lightweight yet powerful event system will help you build more maintainable and scalable Unity applications while reducing development time and potential bugs.

API

// base API
EventBus

// defining an Event for actions
EventBus.Event().ActionsChain();
EventBus.Event<IEvent>().ActionsChain();

// other functions
EventBus.Functions();

Quick Start

Events are defined as interface with single Listener method.

using AceLand.EventDriven.Bus;

public interface IGameStartEvent : IEvent
{
    void OnGameStarted(object sender);
}

public interface IScoreUpdateEvent : IEvent
{
    void OnScoreUpdated(object sender, int newScore);
}

Listeners should be inheritted with Event(s).

using AceLand.EventDriven.Bus;
using UnityEngine;

public class GameControl : MonoBehaviour, IGameStartEvent, IScoreUpdateEvent
{
    private void Start()
    {
        EventBus.Event(this)    // Define Event Target
            .Listen()           // Action: Listen
            .KickStart();       // optional: get raised event
    }
    
    private void OnDestroy()
    {
        EventBus.Event(this)    // Define Event Target
            .Unlisten();        // Action: Unlisten
    }

    public void OnGameStarted(object sender)
    {
        Debug.Log($"Event >> {sender?.GetType().Name ?? "Unknown"}");
    }
    
    public void OnScoreUpdated(object sender, int newScore)
    {
        Debug.Log($"Data Event 1 >> {sender?.GetType().Name ?? "Unknown"} | {newScore}");
    }
}

Raise an event, all listeners will receive this event call. EventBus will also cache the last raised event for listeners with kickstart.

using AceLand.EventDriven.Bus;
using UnityEngine;

public class GameMaster : Monobehaviour
{
    private int score = 10;

    private void StartGame()
    {
        EventBus.Event<IGameStartEvent>()
            .WithSender(this)
            .Raise();
    }
    
    private void RaiseScore()
    {
        score++;
        EventBus.Event<IScoreUpdateEvent>()
            .WithSender(this)
            .WithData(score)
            .Raise();
    }
    
    private void ReduceScore()
    {
        score--;
        if (score < 0) score = 0;
        EventBus.Event<IScoreUpdateEvent>()
            .WithSender(this)
            .WithData(score)
            .Raise();
    }
}

Event Caching

Use KickStart() after Listen() when subscribing to automatically receive last raised event.

EventBus.Event<IScoreUpdateEvent>(this)
    .Listen()
    .KickStart(); // Will immediately receive last score update

Clear Cache

// clear cache of specified event
EventBus.ClearCache<IScoreUpdateEvent>();

// clear all cache
EventBus.ClearAllCache();

Multiple Events Handling

Listening and Unlistening multiple events become easier.

An example with events in Quick Start. GameControl will listen all events, but not listen ScoreUpdateEvent when disabled.

using AceLand.EventDriven.Bus;
using UnityEngine;

public class GameControl : MonoBehaviour, IGameStartEvent, IScoreUpdateEvent
{
    // save event state
    private bool _eventReady;

    // listen all events on awake
    private void Awake()
    {
        EventBus.Event(this).Listen().KickStart();
        _eventReady = true;
    }
    
    // listen IScoreUpdateEvent if not ready
    private void OnEnable()
    {
        if (_eventReady) return;
        
        EventBus.Event<IScoreUpdateEvent>(this).Listen().KickStart();
        _eventReady = true;
    }
    
    // unlisten IScoreUpdateEvent
    private void OnDisable()
    {
        EventBus.Event<IScoreUpdateEvent>(this).Unlisten();
        _eventReady = false;
    }
    
    // unlisten all events
    private void OnDestroy()
    {
        EventBus.Event(this).Unlisten();
    }

    //... other stuffs
}

Advanced Usage

The following example demonstrates how EventBus can elegantly connect services and UI layers without direct references, using a weather monitoring system.

Adding listener method in Event Interface can confirm correct listener method in obsersers.

using System;

public interface IWeatherUpdateEvent : IEvent
{
    // constrait observers to create listener with data type
    void OnWeatherUpdate(object sender, WeatherData data);
}

public struct WeatherData
{
    public float Temperature;
    public float Humidity;
    public DateTime Timestamp;
}

using System;
using System.Collections;
using System.Threading.Tasks;
using AceLand.EventDriven.Bus;
using AceLand.TaskUtils;
using UnityEngine;

public class WeatherService : MonoBehaviour
{
    [SerializeField] private float updateInterval = 300f; // 5 minutes

    private void Start()
    {
        StartCoroutine(WeatherUpdateRoutine());
    }

    private IEnumerator WeatherUpdateRoutine()
    {
        while (enabled)
        {
            yield return new WaitForSeconds(updateInterval);
            yield return FetchAndBroadcastWeather();
        }
    }

    private Task FetchAndBroadcastWeather()
    {
        return Task.Run(async () =>
            {
                // Simulate web service call
                var data = await FetchWeatherData();
                
                // Broadcast to all listeners
                // raise event in main thread
                Promise.Dispatcher.Run(() =>
                    EventBus.Event<IWeatherUpdateEvent>()
                        .WithSender(this)
                        .WithData(data)
                        .Raise()
                );
            },
            Promise.ApplicationAliveToken
        );


    }

    // Simulate web service call
    private Task<WeatherData> FetchWeatherData()
    {
        return Task.Run(() => new WeatherData
            {
                Temperature = 25.5f,
                Humidity = 60f,
                Timestamp = DateTime.Now
            },
            Promise.ApplicationAliveToken
        );
    }
}

using AceLand.EventDriven.Bus;
using AceLand.Test;
using TMPro;
using UnityEngine;

// add the event interface to confirm correct observer listener
public class WeatherUIController : MonoBehaviour, IWeatherUpdateEvent
{
    [SerializeField] private TextMeshProUGUI temperatureText;
    [SerializeField] private TextMeshProUGUI humidityText;
    [SerializeField] private TextMeshProUGUI timestampText;

    private void OnEnable()
    {
        // Subscribe with kick-start to get latest data immediately
        EventBus.Event(this).Listen().KickStart();
    }

    private void OnDisable()
    {
        EventBus.Event(this).Unlisten();
    }

    // promised correct listener
    public void OnWeatherUpdate(object sender, WeatherData data)
    {
        // confirm sender
        if (sender is not WeatherService) return;
    
        // Update UI elements
        temperatureText.text = $"{data.Temperature:F1}°C";
        humidityText.text = $"{data.Humidity:F0}%";
        timestampText.text = data.Timestamp.ToString("HH:mm:ss");
    }
}

using System.Collections.Generic;
using AceLand.EventDriven.Bus;
using AceLand.Test;
using UnityEngine;

// add the event interface to confirm correct observer listener
public class WeatherAnalytics : MonoBehaviour, IWeatherUpdateEven
{
    private List<WeatherData> weatherHistory = new List<WeatherData>();

    private void OnEnable()
    {
        EventBus.Event(this)
            .Listen();
    }

    private void OnDisable()
    {
        EventBus.Event(this)
            .Unlisten();
    }

    // promised correct listener
    public void OnWeatherUpdate(object sender, WeatherData data)
    {
        // Store historical data
        weatherHistory.Add(data);
        
        // Analyze trends
        AnalyzeWeatherTrends();
        
        // Update analysis visualization
        UpdateWeatherGraph();
    }

    private void AnalyzeWeatherTrends()
    {
        // Implement weather trend analysis
    }

    private void UpdateWeatherGraph()
    {
        // Update weather history visualization
    }
}

This example demonstrates several powerful features of EventBus:

Service Decoupling: Services can communicate without direct references
Multiple Listeners: Both UI and Analytics respond to the same event
Automatic Updates: UI receives updates as soon as new data arrives
Clean Architecture: Clear separation between data providers and consumers

Task Utils is using in this example.

Best Practices

Define events as empty interfaces
Use meaningful interface names (e.g., IGameStartEvent, IPlayerDeathEvent)
Keep event payloads simple and serializable
Always unsubscribe when destroying objects to prevent memory leaks
Consider using KickStart() for state-based events
Comfirm correct listener method by adding method in Event interface

PreviousChange Log NextEvent Signal

Last updated 9 days ago