EventsHelper c# .NET -- FireAsync help

[slikrik98]

Greetings,

I have an application that subscribes to an intensive data feed, constantly receiving messages, and then routes those messages to various "listeners." My first attempt was to just create an Event for the messages, and listeners would simply subscribe to the event in standard C# syntax:

EventName += new EventHandler(handlerFunction);

This worked well with one limitation: if one of the "listeners" handling the event took any substantial amount of time to process the event, the calling (main) thread's performance would suffer because the event is handled on the same thread as it's triggered.

I next tried using a delegate in my event handler:

void handlerFunction(object sender, EventArgs e)
{
    ThreadStart threadMethod = delegate
    {
        PerformTimeIntensiveProcedure();
    };
 
    Thread thread = new Thread(threadMethod);
    thread.Start();
}
 

Thinking that this would perform the time-intensive app on a separate thread, and allow the calling thread (the one that triggered the event) to move on, however this also didn't work as I expected.

After some searching on the internet, I came across EventsHelper -- it's actually referenced a lot in these forums. I thought I could use EventsHelper.FireAsync() to get around my problem, however what I'm seeing is there is no way to ensure that the events are received/processed in order. For instance, if each event contains a letter of the alphabet, sequentially, and my "listener" -- event handler -- prints out the letter in the event, it could possibly output: 'A', 'B', 'D', 'C', 'F', ...

I'm wondering what advice you have for handling this situation. I need my main thread to be able to hand off events with minimal time delay (even if the listeners take a while to process the event). I'm thinking each listener is going to need to maintain a queue of incoming events, and asynchronously add incoming events (from the main thread) to each listener's queue, however I'm worried that with FireAsync, the items won't be placed in order in each of the listeners' queues. Any help is greatly appreciated!

RBL

[Plater]

You could try implementing a Queue (there's already a class for it)?
When your application generates an "event" it pushes the relevent data onto the Queue object.
Meanwhile a seperate thread(timer? whatever) is looking at the queue and will pull off the oldest "event data" and process it in the correct order.

Your main thread keeps pushing them on and the other thread keeps taking the oldest one off.


Main (Queue) Other Thread
F -> EDCB -> A

[slikrik98]

Thanks Plater. Yes, I could implement a producer/consumer model that would have one thread (the main thread) adding to the master queue of events, and have another thread -- the consumer thread -- pulling off the queue and triggering events. however, this approach will still suffer in that if I have 10 listeners all subscribed to the same event, listener10 won't learn of the event until listeners 1-9 process the event (yes, the main/producer thread will continue on just fine adding to the queue, but ultimately I need the listeners to be able to receive events when they happen. Does this make sense? It's almost like I need to broadcast the event to each listener simultaneously, so they can each do their own thing with the event -- I figured the FireAsync would do this for me, however it also introduces the possibility that the events will be received out of order. How can I achieve this broadcast effect, but have each listener receive the events in order?

[Plater]

Can you get all your listeners running on seperate threads?

[slikrik98]

Can you get all your listeners running on seperate threads?

Yes, they are all on separate threads. It's almost like I need to be able to designate a separate queue for EACH listener, and then the main thread simply places each event in each listener's queue, that they can handle at their own pace. I'd like to not have to do that explicitly, however, which is why I was hoping there was some mechanism (like FireAsynch) that could accomplish precisely this.