How to Sleep a thread until callback for asynchron

问题:

I have a function that needs to be executed only when a callback is received from asynchronous function.

Like

I call asynchronous function Stop() and soon after that I call asynchronous function Start().

The Issue before Stop CallBack is received Start() is called and thus I am getting issues. Also I can not separate the calling of two functions Like I can not do this.:

public void SomeFunction()
{
    Stop();
}  

public void Stop_CallBack(eventargs e)
{
    Start();
}

I have to do this:

public void SomeFunction()
{

  Stop();
  //Do something;

  Start();
}

but before I receive Stop call back my start() function is executed thus creating the problems for me.

Can anyone help me out how can I solve this issue.

回答1:

This is when you want to use wait handles. Here is a short code sample to show one approach:

class AsyncDemo
{
    AutoResetEvent stopWaitHandle = new AutoResetEvent(false);
    public void SomeFunction()
    {    
        Stop();
        stopWaitHandle.WaitOne(); // wait for callback    
        Start();
    }
    private void Start()
    {
        // do something
    }
    private void Stop()
    {
        // This task simulates an asynchronous call that will invoke
        // Stop_Callback upon completion. In real code you will probably
        // have something like this instead:
        //
        //     someObject.DoSomethingAsync("input", Stop_Callback);
        //
        new Task(() =>
            {
                Thread.Sleep(500);
                Stop_Callback(); // invoke the callback
            }).Start();
    }

    private void Stop_Callback()
    {
        // signal the wait handle
        stopWaitHandle.Set();
    }

}

回答2:

Since these look like member functions, you can add an event member variable (either a ManualResetEvent or an AutoResetEvent. Then in the Stop() method you set the event to signaled. In between the calls to Stop() and Start() you wait for the event.

private AutoResetEvent _stopped = new AutoResetEvent(false);

public void SomeFunction()
{
     Stop();
     _stopped.WaitOne();
     Start();
}

In the stop function you would do

private void Stop()
{
    try
    {
         // Your code that does something to stop
    }
    finally
    {
         _stopped.Set();  // This signals the event
    }
}

If using a ManualResetEvent -

private ManualResetEvent _stopped = new ManualResetEvent(false);

public void SomeFunction()
{
     Stop();
     _stopped.WaitOne();
     Start();
}

private void Stop()
{
    try
    {
         // Your code that does something to stop
    }
    finally
    {
         _stopped.Set();  // This signals the event
    }
}

private void Start()
{
    _stopped.Reset();

    // Your other start code here
}