Using Native C# Events in Unity



It contains a framework to use C# event system (not UnityEvents). C# event system is more optimized in most cases than Unity Event System. Unless you want to drag and drop references in Unity Editor as a listeners, this is the better way to implement Events


This is the class where events are declared. It is a static class so it doesn’t have to be attached with a Gameobject and it doesn’t inherit Monobehaviour. It can persist among scenes. It’s content will be different based on project

There are 3 steps to this

  1. Declare an event
  2. Invoke it from somewhere
  3. Add listener for this event

1. Declare an event

A simple event declaration looks like this

public static event Action NoArgumentEvent;

As this is a delegate we can’t invoke it from outside this class. To resolve this we create a static function that will Invoke this event and we will call this new method from outside class to invoke the event. The function looks like this

public static void OnNoArgumentEvent() 

2. Invoke it from somewhere

We invoke this event from anywhere using


3. Add listener for this event

We add listener for this event on as many classes as we want. This essentially creates response of different scripts due to something happening

First, We create a function with the response on any class we want. The signature of the event must match with the response function. As this event doesn’t have any parameter, the response function won’t have any

private void OnNoArgumentEventListener()

Debug.Log("NoArgument Event Received from class " + + " . Data received: No data");


Last thing to do is Register this function to the event on Enable and Unregister on disable


GameEvents.NoArgumentEvent += OnNoArgumentEventListener;


GameEvents.NoArgumentEvent -= OnNoArgumentEventListener;

Don’t forget to Unregister to avoid memory leaks


In the GameEvents.cs script there are examples on how to create Events with parameters. The main process is same with minor alterations.


C# events beat UnityEvent for each number of arguments. The gap widens as more args are dispatched to the listeners. In the best case, UnityEvent takes 2.25x longer than C# events but in the worst case it takes almost 40x longer!

In conclusion, UnityEvent creates less garbage than C# events if you add more than two listeners to it, but creates more garbage otherwise. It creates garbage when dispatched (Update: the first time) where C# events do not. And it’s at least twice as slow as C# events. There doesn’t seem to be a compelling case to use it

Check this link for further study

Newsletter Updates

Enter your email address below to subscribe to our newsletter

Leave a Reply

Your email address will not be published. Required fields are marked *