Dfyjkt

I've been searching quite a bit on this topic, but I think I'm not using the right words for searching any of this stuff, because I've not found an answer yet.

I'm looking for a way to make a process wait for a (specific) response of an external source.

In more detail, in a standard socket connection, I ask my remote endpoint for a certain value via a socket.send, how can I "catch" their reply? The idea that I already had was to send some sort of identifier along to determine what request this belongs to.

Is there a way to efficiently achieve this? (Performance is rather important). I'm currently using .NET2.0 if that's relevant information.

Some example code:

 public void AskForReply()
 
 //Send to connected endpoint
 

 public void ReceiveReply(IAsyncResult response)
 
 //Do stuff with the response
 

I've been working out several ideas in my head. But they all feel really messy and not very efficient. Is there a design pattern for this? Are there standards for this behavior?

And help is greatly appreciated!

For anyone who runs into a similar problem, I have found a way to make an asynchronous call synchronous (which is essentially what you are trying to achieve).

 EventWaitHandle waitHandler;
 string replyMessage;

 void string AskForReply()
 
 //Already requesting something...
 if(waitHandler != null) return; 
 waitHandler = new EventWaitHandle(false, EventResetMode.AutoReset);

 //Send a request to a remote service

 waitHandler.WaitOne(timeout);

 //Will reply null (or the default value) if the timeout passes.
 return replyMessage;
 

 void ReceiveReply(string message)
 
 //We never asked for a reply? (Optional)
 if (waitHandler != null) return; 
 replyMessage = message;
 //Process your reply

 waitHandler.Set();
 waitHandler = null;
 

It's probably a good idea to put the EventWaitHandle and the reply message in a class for better and cleaner management. You can then even put this object in a dictionary along with a key that you can use handle multiple requests at once (do keep in mind they are synchronous and will block your thread until the timeout or the waithandle is set).