/// <summary>Initiates an asynchronous receive operation that has a specified time-out and a specified state object. The state object provides associated information throughout the lifetime of the operation. This overload receives notification, through a callback, of the identity of the event handler for the operation. The operation is not complete until either a message becomes available in the queue or the time-out occurs.</summary>
/// <param name="callback">The <see cref="T:System.AsyncCallback"></see> that receives the notification of the asynchronous operation completion. </param>
/// <param name="state">A state object, specified by the application, that contains information associated with the asynchronous operation. </param>
/// <param name="timeout">A <see cref="T:System.TimeSpan"></see> that indicates the interval of time to wait for a message to become available. </param>
/// <returns>The <see cref="T:System.IAsyncResult"></see> that identifies the posted asynchronous request.</returns>
public IAsyncResult BeginReceive(TimeSpan timeout, object state, AsyncCallback callback)
{
long totalMilliseconds = (long)timeout.TotalMilliseconds;
if ((totalMilliseconds < 0L) || (totalMilliseconds > 4294967295L))
{
throw new ArgumentException("InvalidParameter", "timeout");
}
ReceiveItemCallback caller = new ReceiveItemCallback(ReceiveItemWorker);
if (callback == null)
{
callback = CreateCallBack();
}
if (state == null)
{
state = new object();
}
// Initiate the asychronous call. Include an AsyncCallback
// delegate representing the callback method, and the data
// needed to call EndInvoke.
IAsyncResult result = caller.BeginInvoke(timeout, state, callback, caller);
this.resetEvent.Set();
return(result);
}
/// <summary>Completes the specified asynchronous receive operation.</summary>
/// <param name="asyncResult"></param>
/// <returns></returns>
public IQueueItem EndReceive(IAsyncResult asyncResult)
{
// Retrieve the delegate.
ReceiveItemCallback caller = (ReceiveItemCallback)asyncResult.AsyncState;
// Call EndInvoke to retrieve the results.
IQueueItem item = (IQueueItem)caller.EndInvoke(asyncResult);
AsyncCompleted(item);
this.resetEvent.WaitOne();
return(item);
}
/// <summary>
/// AsyncReceive
/// </summary>
/// <returns></returns>
public IQueueItem AsyncReceive()
{
object state = new object();
TimeSpan ts = TimeSpan.FromSeconds(QueueDefaults.DefaultRecieveTimeOutInSecond);
ReceiveItemCallback caller = new ReceiveItemCallback(ReceiveItemWorker);
// Initiate the asychronous call.
IAsyncResult result = caller.BeginInvoke(ts, state, CreateCallBack(), caller);
Thread.Sleep(10);
result.AsyncWaitHandle.WaitOne();
// Call EndInvoke to wait for the asynchronous call to complete,
// and to retrieve the results.
IQueueItem item = caller.EndInvoke(result);
AsyncCompleted(item);
return(item);
}
