异常后的WaitOne(超时)

Question

我目前正在开发一个从套接字读取数据的应用程序。

我很好奇，如果我有一个比正常超时更大的readDone.WaitOne(600000)，如果由于回调方法中的异常，readDone.Set()从未在我的ReadCallBack方法中被调用，会发生什么？

它是等待整个超时的持续时间，还是继续通过处理在ReadcallBack之外定义的异常来超出主线程？

编辑

这里有一个例子来解释我的意思：

        public void SendAndReceive(Message message)
    {
        try
        {
            IPAddress ipAddress = IPAddress.Parse(this.host.Address);
            IPEndPoint remoteEP = new IPEndPoint(ipAddress, this.host.Port);

            using (Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
            {
                client.BeginConnect(remoteEP, new AsyncCallback(ConnectCallback), client);
                connectDone.WaitOne(host.Timeout);

                message.State = MessageState.SENDING;
                Send(client, message.Request);

                if (sendDone.WaitOne(120000)) // TIMEOUT SET TO 2 MINUTE
                {
                    // Request sent successful. Now attempt to retrieve response.
                    message.State = MessageState.READING;
                    Receive(client);
                }
                else
                {
                    message.State = MessageState.SEND_ERROR;
                    message.ErrorMessage = "Timeout while sending request to socket.";
                }                    

                // Release the socket.
                client.Shutdown(SocketShutdown.Both);
                client.Close();
            }
        }
        catch (Exception ex)
        {
            LogManager.ExceptionHandler(ex);
            message.ErrorMessage = ex.Message;
            message.State = MessageState.EXCEPTION;
        }
    }


    private void Send(Socket client, String data)
    {
        byte[] byteData = Encoding.ASCII.GetBytes(data);
        System.IO.MemoryStream dataStream = new System.IO.MemoryStream();
        dataStream.WriteByte(1);
        dataStream.Write(byteData, 0, byteData.Length);
        dataStream.WriteByte(3);

        client.BeginSend(dataStream.GetBuffer(), 0, dataStream.GetBuffer().Length, 0, new AsyncCallback(SendCallback), client);
    }

    private void SendCallback(IAsyncResult ar)
    {
        try
        {
            var client = (Socket)ar.AsyncState;
            client.EndSend(ar);

            // Throw exception before .Set can is called
            throw new Exception("test");

            sendDone.Set();
        }
        catch (Exception ex)
        {
        }
    }

因此，澄清：

sendDone.WaitOne(120000)设置为2分钟后超时，这意味着在2分钟内没有调用.Set()，主线程将继续执行。我的问题是，如果SendCallBack在调用.Set()之前存在和异常，那么sendDone仍然会将主线程挂起2分钟，还是会自动跳转到SendAndReceive方法中的try catch？

Answer 1

因此，我对此进行了测试，如果抛出异常，WaitOne()将被取消。