Async Public Events

Question

Hi,
I'm building a component which serves as mediator between 3rd-party API and the rest of my app.
Basically, my problem is that I need to capture and handle some events sent by the API, do some work, and then trigger an event which will be used by my app. But, I must handle the API's event as fast as possible, and if I trigger a public event as part
of the handler procedure, I may get delayed by the event's consumers.
The code looks something like this
public class Mediator
private ExtApi extApi;
public event StatusChangedEventHandler StatusChanged;
public Mediator()
extApi = new ExtApi();
extApi.StatusChanged += extApi_StatusChanged;
private void extApi_StatusChanged(object sender, StatusChangedEventArgs e)
// do some work ...
// trigger a public event - consumed by the rest of the app
StatusChangedEventHandler handler = StatusChanged;
if (handler != null)
handler(this, e);
I was thinking about triggering my event "handler(this,e);" asynchronously, thus ensuring that my own handler (extApi_StatusChanged) won't be delayed.
How do I do that?
Are there better ways to solve the problem?

Answer 1

You are confusing me!!! Normally in .Net you have synchronous and asynchronous methods.  Synchronous methods are blocking which means they don't return until all the read/writing is completed. Asynchronous methods are non-blocking. they are part of
an event handler and return when the available data is processed. The event handler can be trigger by lots of ways like with timers or when data is available.
Your code below you are not using a public event
extApi.StatusChanged += extApi_StatusChanged;
You are using a standard build in method in the Net library to register an event and to specify the event handler to process the event.  All registered events are handled in the windows operating system.  there is no way of speeding up the event
handling.  Windows has a latency on the events that could be as much as 200msec.  The latency is pretty constant and should effect the performance of the application as long as the amount of data being processed doesn't overload the PC youi are using. 
Executive
client --------------------------|                       |                        |                              
API
client --------------------------|   Server           |      Client          |----------------------- Server
client --------------------------|                       |                        
|
Your architecture should look like the above.  You need an executive that funnels the messages to the API.  The executive will send one command to the API and wait for a response before sending a second command to the API.  The executive can
also periodically send a command to the API to get status.  The executive will have an input queue from the clients and process the messages as they are received from the clients.
jdweng