event-systems

Prevent memory leaks in Unity event subscriptions by enforcing symmetric subscribe and unsubscribe calls. This ensures disabled objects, destroyed GameObjects, and unloaded scenes properly detach listeners, avoiding dangling references and unintended event behavior.

The best way to decouple Unity systems for high-frequency gameplay communication is using zero-allocation event architectures. Typed C# events and static event buses minimize garbage collection overhead compared to heavy abstractions.

Use ScriptableObject event channels when communicating between unrelated systems that should not reference each other directly. Use C# events for efficient communication between closely related classes where slight coupling is acceptable.

Your UnityEvent fires after the target object is disabled because the subscription was not properly managed during the lifecycle. Implementing lifecycle-safe subscription management ensures listeners are detached when objects are disabled or destroyed.

You can use static event buses across unloaded Unity scenes, but it requires strict lifecycle-safe subscription management. If listeners do not unsubscribe symmetrically during scene unloading, static buses will retain dangling references and cause memory leaks.

You need to avoid UnityEvent abstractions for performance-critical event paths because they generate unnecessary allocations. Applying zero-allocation approaches with typed C# events prevents garbage collection spikes during high-frequency gameplay communication.