Basic on Csharp delegates, and more ...

Csharp is crazy powerful, however, I have trouble in understanding its delegate and delegates’s implementation, including Action, EventHandler, Func. Therefore, this post is written to summarized all of these. I would give each the definition and some analysis.

A. Delegate

Delegate is simply a reference to a method. The example that gives the best illustration on the application of delegate is a UI Button. Whatever framework, engine or libraries you use, the UIButton you create must have the ability to trigger callback method.

How to trigger a callback method? Simply create a delegate type for the UIButton, then invoke the delegate once the button is clicked. Then, at startup/setup cycle of the button, assign the delegate to the actual method implementation. Now, you are sure that the callback method is triggered correctly. This simplified a lot of process and make the callback to be very generic, scalable.

Delegate is reference to a method. And each method have return type and parameter lists. Therefore, delegate itself must have the same return type and parameter lists as the method they are assigned to. Otherwise, the two are not compatible. Below is one example:

public delegate int PerformCalculation(int x, int y); // this delegate have `int` return type, and two `int` parameter

Delegate is the most important concept, the ones after are only implementation of delegates, or predefine delegates that are useful and very well-known.

Common mistake

public delegate void TestDelegate();

This line simply declare a delegate type! You must create a delegate instance then trigger it! Check the example below.

public void HelloWorld()
{
    TestDelegate?.Invoke(); // This line cannot be compiled

    TestDelegate myDelegate = null // this works
    myDelegate?.Invoke();
}

Because of this, c# predefines a bunch of generic delegates for us!

B. Predicate

Predicate<T> is a delegate that take a input and return boolean

public delegate bool Predicate<in T>(T obj);

This is used extensively in ICollection, you would see its in Array.FindIndex

public static int FindIndex<T>(T[] array, Predicate<T> match);

C. Action

Action is delegate that return no value (void). They are commonly used in callback in UI or event.

public delegate void Action();
public delegate void Action<in T1>(T1 arg1);
public delegate void Action<in T1, in T2 >(T1 arg1, T2 arg2);
public delegate void Action<in T1, in T2, in T3>(T1 arg1, T2 arg2, T3 arg3);

D. Func

In case you need a delegate that has return type. C# have builtin Func, here are some of them

public delegate TResult Func<out TResult>();
public delegate TResult Func<in T1, out TResult>(T1 arg1);
public delegate TResult Func<in T1, in T2, out TResult>(T1 arg1, T2 arg2);
public delegate TResult Func<in T1, in T2, in T3, out TResult>(
    T1 arg1, T2 arg2, T3 arg3);

E. EventHandler

Again, this delegate is used in event, they represent callback when event triggered.

public delegate void EventHandler<TEventArgs>(object? sender, TEventArgs e);

G. event keyword

This is simply a warper over the Action delegate. An event keyword is simply a Action, but only allow to be triggered from the owner of method only (aka it can only be used inside a class). This still means you can Combine and Remove method from outside class (but CANNOT trigger)

public class Publisher
{
    public Action MyAction;

    public event Action MySecondAction;
}

public class Test
{

    void Method()
    { 
        
        myPublisher.MyAction?.Invoke(); 
        myPublisher.MyAction += () => { };

        myPublisher.MySecondAction += () => { };
        myPublisher.MySecondAction?.Invoke(); // THIS LINE WILL NOT WORK!
    }
}

H. What about … UnityAction and UnityEvent.

This is just another implementation of delegate, the actual implementation is varied from Action. Some said they are developed to be used from the Editor. Some claimed they are used extensively by the UnityEvent. The actual implementation of UnityAction is

public delegate void UnityAction();

Very simple, right? Hold on … so what are UnityEvent? They are just events that are serializable and has more support from engine. Let’s take a look at there docs at: https://docs.unity3d.com/6000.0/Documentation/ScriptReference/Events.UnityEvent.html:

...
UnityEvents

Inherited Members
Public Methods
GetPersistentEventCount	Get the number of registered persistent listeners.
GetPersistentListenerState	Returns the execution state of a persistent listener.
GetPersistentMethodName	Get the target method name of the listener at index index.
GetPersistentTarget	Get the target component of the listener at index index.
RemoveAllListeners	Remove all non-persistent (ie created from script) listeners from the event.
SetPersistentListenerState	Modify the execution state of a persistent listener.
Static Methods
GetValidMethodInfo	Given an object, function name, and a list of argument types; find the method that matches.

The thing is UnityEvent CAN be invoked outside its owner (The same is NOT TRUE for c# event). So the below code is valid!

public class Publisher
{
    public UnityEvent Events;
    public UnityAction actions;
    public void HelloWorld()
    {

    }
}

class A{
    void Method()
    { 
        Publisher myPublisher = new Publisher();
        myPublisher.HelloWorld();

        myPublisher.Events?.Invoke(); // this is valid!
    }
}

UnityEvent is used in Button (UnityEngine.UI)

namespace UnityEngine.UI
{
    /// <summary>
    /// A standard button that sends an event when clicked.
    /// </summary>
    [AddComponentMenu("UI/Button", 30)]
    public class Button : Selectable, IPointerClickHandler, ISubmitHandler
    {
        [Serializable]
        /// <summary>
        /// Function definition for a button click event.
        /// </summary>
        public class ButtonClickedEvent : UnityEvent {}
    ...

So when to use event and UnityEvent? When to use Action and UnityAction. The answer is that it varies. There are tons of article that compare performance between the ones powered by Unity and the ones that is pure C# … I would not discuss further here. I would say that you would choose the one that fit with your scenario. For example: If the delegate you want requires input parameters then UnityAction is not the option.

I hope this quick article would be useful for references in the future! Thanks for reading!

END