C# async/await for external event handler to fire

Question

I am building an API to communicate with a Sony PTZ camera over UDP. In order to "query" the device (get data from the camera), you have to send a specific UDP packet, then wait for the response to come back. I have a MessageRecieved handler that responds to ANY incoming UDP packet from my camera. The way that I will know it is the "current" response, because the camera sends back the same sequence number I sent it in my request. I am trying to figure out how to do this in an async/await fashion so I can create a single method like GetCurrentAperatureValue

I thought about using something like a concurrent bag to store each command & sequence number that I send, then wait for the server to respond with the same sequence number, and do a lookup in the bag. Maybe poll the bag for the presence of the value? But this doesn't feel right to me.

Here is some abbreviated code to demonstrate what I'm trying to do.

public class SonyAPI {

        public SonyAPI() {
            server = new UDPServer();
            server.MessageReceived += Server_MessageReceived;
            server.Start();
            sequenceNum = 0;
        }

        public async Task<AperatureValue> void GetCurrentAperatureValue(){
             //build the buffer here and send payload;
             server.send("192.168.1.28", 5321, buf);
             
             //STUCK HERE: somehow I need to wait for the MessageRecieved event handler (Below) to fire with my same sequence number that I just sent and then return the result after I process it here. 
             //Becuase this is UDP, there can be lots of messages coming in together. I need to filter out this one that I need. All of this happens in less than 2 ms.
        }


        private void Server_MessageReceived(object sender, UDPMessageEventArgs e) {
              
            var newSequenceNum = BitConverter.ToInt32(e.sequenceNum);                
            Console.WriteLine("message received" + newSequenceNum + " "+ e.RemoteEndPoint);

             //TODO: When the sequence number from the above method call comes back in, send it to the method above so it can return its value.
        }
}

More specifically, a priority queue. The sequence number would be the priority, and you could pull them out in order. — Robert Harvey, Sep 14 '21 at 03:05
Is your question "Maybe poll the bag for the presence of the value?"? Or are you asking something else? — Enigmativity, Sep 14 '21 at 03:13

Andrew Shepherd · Accepted Answer · 2021-09-14T23:31:49.313

You would create a TaskCompletionSource for each waiting call, and then store this TaskCompletionSource in a lookup.

private readonly ConcurrentDictionary<long, TaskCompletionSource<AperatureValue>> _taskLookup = new ConcurrentDictionary<long, TaskCompletionSource<AperatureValue>>();

public Task<AperatureValue> GetCurrentAperatureValue()
{
    long id = GenerateMessageId();

    var taskCompletionSource = new TaskCompletionSource<AperatureValue>();
    _taskLookup.TryAdd(id, taskCompletionSource);

    //build the buffer here and send payload;
    server.send("192.168.1.28", id, buf);

    return taskCompletionSource.Task;             
}

private void Server_MessageReceived(object sender, UDPMessageEventArgs e) 
{
    var newSequenceNum = BitConverter.ToInt32(e.sequenceNum);               
    if (this._taskLookup.TryRemove(
           newSequenceNum, 
           out TaskCompletionSource<AperatureValue> taskCompletionSource
         )
     )
    {
        taskCompletionSource.SetResult(e.Value);
    }
}

This gives you the basic approach. You would then need to deal with other factors like what happens if a corresponding server message doesn't come back in a reasonable time, and how do you log an error if the received server message does not have a corresponding call.

thanks so much, this is perfect. Can you shed any light on timeouts like you discussed above? How would I expire the task after say 10ms if no response comes? — Chris Kooken, Sep 14 '21 at 11:46
@ChrisKooken In the solution I implemented, I created a separate timer for each task. Instead of a lookup of `TaskCompletionSource`, it would be a look up of `TaskCompletionSource/Timer` tuples. My solution didn't need to handle more than one call per second, and the timeout was 30 seconds. If you have many calls per second or a really short timeout then you have a different problem to me. Good luck :-) — Andrew Shepherd, Sep 16 '21 at 03:12

C# async/await for external event handler to fire

1 Answers1