Question

I have an API whose interface looks like this:

void SendRequest(Guid id, IRequest request);
event EventHandler<ResponseEventArgs> ResponseReceived;

What’s the best way of implementing this method?

Task<T> GetResponse(IRequest request) where T: IRequest

Note that multiple requests may overlap each other, so when a response comes back I need to look up the parent request. I have a feeling TaskCompletionSource may be of use, but can’t quite piece it together.

Answer 1

EDIT:

If you want to do this without blocking a thread, you can do something like this using TaskCompletionSource<T>:

var completionSource = new TaskCompletionSource<T>();

var requestIdentifier = Guid.NewGuid();

EventHandler<ResponseEventArgs> handler = null;

handler = (sender, args) =>
{
    if(args.RequestIdentifier == requestIdentifier)
    {
        api.ResponseReceived -= handler; 

        // TrySetResult avoids re-entrancy problems in case of an
        // API that sends duplicates, but there other ways of 
        // dealing with this too.
        completionSource.TrySetResult((T)args.Response);
    }      
};


api.ResponseReceived += handler; 

// Make this async if you want.
api.SendRequest(requestIdentifier, request); 

return completionSource.Task;

---

Original Answer:

I think you want something like the following, which uses a ManualResetEvent to block the thread until the event is raised by the API:

return Task.Factory.StartNew<T>(() =>
{
    var waitHandle = new ManualResetEvent(false);

    T result = default(T);

    var requestIdentifier = Guid.NewGuid();

    EventHandler<ResponseEventArgs> handler = (sender, args) =>
    {
         if(args.RequestIdentifier == requestIdentifier)
         {
             result = (T)args.Response; // Not sure how this looks in your API
             waitHandle.Set(); // Unblock the thread running the task     
         }      
    };

    // Attach handler to respond to the response being received.
    api.ResponseReceived += handler; 

    // Send request off.
    api.SendRequest(requestIdentifier, request); 

    // Wait until response is received.
    waitHandle.WaitOne(); 

    // Detach handler to prevent leak.
    api.ResponseReceived -= handler; 

    return result;
});

---

For a cleaner way of doing this, look into Reactive Extensions.