Kotlin equivalent of C# events

Question

I am new in Kotlin and was trying to find any equivalent in Kotlin for C# events. I couldn't find any examples so I suppose there aren't any events in Kotlin. Am I right? And also how this functionality in C# can be done in Kotlin?

class A
{
    public event Action<int> NormalEvent;
    public static event Action<int> StaticEvent;

    public void FunA(int x)
    {
        NormalEvent?.Invoke(x);
        StaticEvent?.Invoke(x);

    }
}

class B
{
    private readonly A aInstance;

    public void FunBNormal(int x)
    {
        Console.WriteLine($"Normal event {x}");
    }

    public void FunBStatic(int x)
    {
        Console.WriteLine($"Static event {x}");
    }

    public B(A a)
    {
        aInstance = a;
        aInstance.NormalEvent += FunBNormal;
        A.StaticEvent += FunBStatic;
    }
}

Answer 1

There isn't a built-in language construct for this, but it would be rather trivial to create a class for it. Maybe it would take a little more work to make it thread-safe and avoid leaking listeners. It depends on your needs.

class Event<T> {
    private val observers = mutableSetOf<(T) -> Unit>()

    operator fun plusAssign(observer: (T) -> Unit) {
        observers.add(observer)
    }

    operator fun minusAssign(observer: (T) -> Unit) {
        observers.remove(observer)
    }

    operator fun invoke(value: T) {
        for (observer in observers)
            observer(value)
    }
}

class A {
    companion object {
        val staticEvent = Event<Int>()
    }
    val normalEvent = Event<Int>()

    fun funA(x: Int) {
        normalEvent(x)
        staticEvent(x)
    }
}

class B(private val aInstance: A) {
    init {
        aInstance.normalEvent += ::funBNormal
        A.staticEvent += ::funBStatic
    }

    fun funBNormal(x: Int) {
        println("Normal event $x")
    }


    fun funBStatic(x: Int) {
        println("Static event $x")
    }
}

Answer 2

You can use Signals for this. It uses a proxy magic to turn an interface into a Signal object. It holds on listeners and fire events.

fun interface Chat{
    fun onNewMessage(s:String)    
}

class Foo{
    val chatSignal = Signals.signal(Chat::class)
    
    fun bar(){
        chatSignal.addListener { s-> Log.d("chat", s) } // logs all the messaged to Logcat
    }
}

class Foo2{
    val chatSignal = Signals.signal(Chat::class)
    
    fun bar2(){
        chatSignal.dispatcher.onNewMessage("Hello from Foo2") // dispatches "Hello from Foo2" message to all the listeners
    }
}

The equivalent for static and normal events in your example will be

• Signal.signal() - creates a singleton Signal object
• Signal.localSignal() - creates a new instance of a Signal object

Disclaimer: I am the author of Signals.