Originating from#970 the discussion is about how we deal with the currently public events.

Starter was the post from@stebet

I'm wondering if a better implementation than having the events is to have a "handler" interface that can be registered in the channels, so instead of events likeFlowControlChanged etc. there would be an interface called IChannelHandler, that could be registered like consumers. These handlers would exposes the standard methods:

publicinterfaceIChannelHandler{ValueTaskOnFlowControl(IChannelchannel,boolactive);ValueTaskOnPublicAckReceived(IChannelchannel);  ...}

That way it's easy to override whatever logic to take care of in a class (logging, waiting for publish confirms etc.) and then register it with the channel interfacechannel.RegisterHandler(myCustomHandler);.

The channel can maintain those handlers in a list and execute them (in parallel if needed) as events happen. That way those implementing the handlers can also do things asynchronously with minimal effort and the channel code would be free of all the async event workarounds we currently have. Logging and all sorts of instrumentation or special logic can then be added to augment the channel interface, especially if the handlers can have a reference to the Channel objects themselves and access other things.

I've done some measurements today regarding performance of various ways of invoking actions To have also an idea about what this means.

Where

• GetInvocationList is the "current way" of getting the individual delegates
• Direct is just calling delegate.Invoke() (no individual control over invocation)
• Reflection.Emit is retrieving the _invocationList field of a delegate via Reflection.Emit (+- what is returned by GetInvocationList)
• Interface is a single method interface stored in a list
• List_Action is all induvidual delegates stored within a list and iterated over

And the first entry always being for one attached event handler and the 2nd one for two handlers (action += handler) (Or entries in the list)

I think the relevant notes are:

• GetInvocationList is kind of slow and allocates
• Direct is obviously unbeatable, but won't allow us to do what we want
• Emit is nice, a but not fast enough while also having additional dependency
• Interface / List_Action are reasonably fast while not allocating. (Downside though is the increased complexity to store them in the list + the allocation will take place there)

This issue should be taken as the place to dicuss where we want to move to with the events in our public API.