Question

I have a question about events in .NET (C#). I have had to write code for several situations in which I have a background task running and I want to notify a main thread, or controller class, that something has occurred, such as task completed, or finished copying a file, but I don’t want the background task to wait for the main thread’s delegate to process the event.

I want to do something like message passing: Send the message, but who cares what they do with it.

For example:

A class is written to process several processes in sequence, one after the other. Each process needs to run on a background thread. When work is completed, an event fires and tells the controller that it’s done (let’s say using OnCompleted() method)

The problem is that if the controller’s event handler is used to start the subsequent process, the previous processes’ OnComplete method stays on the call stack (never finishes executing) until the all of the processes have completed.

In that situation, how could the background task notify the controller class that the work is done without keeping the event raising method on the stack?

Example 2: A backup program.

A background thread runs to copy each file to the destination. The background needs to notify the UI the last file that was copied, but it doesn’t need to wait for the UI to update. Instead, it just wants to say, “BTW, here’s some info. Now, let me get back to work.” The event listener shouldn’t block the processing of the event raiser.

Answer 1

You could do an async invoke when raising the event (as mentioned), or just raise the event itself on a background thread:

void OnUpdated(EventArgs e) {
   EventHandler h = this.Updated;
   if (h != null) h(e);
}

void DoStuff() {
   BigMethod();
   ThreadPool.QueueUserWorkItem(OnUpdated, EventArgs.Empty);
   BigMethod2();
}

If you raise asynchronously, multiple listeners would be processing your event at the same time. At the very least, that requires a thread-safe EventArg class. If you expect them to interact with your class as well, then you should document very carefully or make it thread-safe as well.

Raising the event on a background thread carries the same caveats for your class methods, but you don’t have to worry about the EventArgs class itself.