在同步结构（例如ManualResetEvent）上等待的可更新（可重置）超时

Question

Here is the description of the problem:

I need to make an API call synchronized. In order to make this call synchronized, I defined a ManualResetEvent and called WaitOne on it. WaitOne is called after the call to external COM object. In some circumstances it never returns. That's why I must define a timeout for that Wait call. But, I can't pass a constant into Wait method, because if the call was successfull than this API receives events from the COM object and in each handler of an event, timeout passed into WaitOne should be reset.

Consider the example:

private ManualResetEvent operationIsInProcess;
private static readonly IComObject sender;
private int timeout = 30000;

public void Start() {                           
    sender.OnExchange += SenderOnOnExchange;            
}
private void StartOperation(){
    sender.StartAsyncExchange();
    operationIsInProcess.WaitOne(timeout);
}

private void SenderOnOnExchange(){
    //somehow we need to reset or update that timeout on WaitOne
    //operationInProcess.Update(timeout);
}

I'm just wondering whether anybody faced this problem or not. I'm sure this should be a common situation. As I understand there is no "out of the box" solution. So I have to build my own syncronization primitive, or maybe someone have already done it?

Update. I wanted something like this (implemented by myself):

public class UpdateableSpin {
        private readonly object lockObj = new object();
        private bool shouldWait;
        private long taskExecutionStartingTime;

        public UpdateableSpin(bool initialState) {
            shouldWait = initialState;
        }

        public void Wait(TimeSpan executionTimeout, int spinDuration = 0) {
            UpdateTimeout();
            while (shouldWait && DateTime.UtcNow.Ticks - taskExecutionStartingTime < executionTimeout.Ticks) {
                lock (lockObj) {
                    Thread.Sleep(spinDuration);
                }
            }
        }

        public void UpdateTimeout() {
            lock (lockObj) {
                taskExecutionStartingTime = DateTime.UtcNow.Ticks;
            }
        }

        public void Reset() {
            lock (lockObj) {
                shouldWait = true;
            }
        }

        public void Set() {
            lock (lockObj) {
                shouldWait = false;
            }
        }
    }

Answer 1

You could enter a loop and restart the wait:

while (true)
{
    if (!operationIsInProcess.WaitOne(timeout))
    {
        // timed out 
        break;
    }
    else
    {
        // Reset the signal.
        operationIsInProcess.Reset();
    }
}

Then set your event in the event handler.

private void SenderOnOnExchange () 
{
    operationInProcess.Set();
}