internal bool TryReceive(MsmqInputMessage msmqMessage, TimeSpan timeout, MsmqTransactionMode transactionMode, out MsmqMessageProperty property)
{
property = null;
MsmqQueue.ReceiveResult receiveResult = this.Queue.TryReceive(msmqMessage, timeout, transactionMode);
if (MsmqQueue.ReceiveResult.OperationCancelled == receiveResult)
{
return(true);
}
if (MsmqQueue.ReceiveResult.Timeout == receiveResult)
{
return(false);
}
else
{
property = new MsmqMessageProperty(msmqMessage);
if (this.Transactional)
{
if (this.PoisonHandler.CheckAndHandlePoisonMessage(property))
{
long lookupId = property.LookupId;
property = null;
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCritical(new MsmqPoisonMessageException(lookupId));
}
}
return(true);
}
}
private static void OnPeekCompleted(IAsyncResult result)
{
Msmq4PoisonHandler asyncState = result.AsyncState as Msmq4PoisonHandler;
MsmqQueue.ReceiveResult unknown = MsmqQueue.ReceiveResult.Unknown;
try
{
unknown = asyncState.retryQueueForPeek.EndPeek(result);
}
catch (MsmqException exception)
{
MsmqDiagnostics.ExpectedException(exception);
}
if (MsmqQueue.ReceiveResult.MessageReceived == unknown)
{
lock (asyncState)
{
if (!asyncState.disposed)
{
TimeSpan timeFromNow = (TimeSpan)((MsmqDateTime.ToDateTime(asyncState.retryQueueMessage.LastMoveTime.Value) + asyncState.ReceiveParameters.RetryCycleDelay) - DateTime.UtcNow);
if (timeFromNow < TimeSpan.Zero)
{
asyncState.OnTimer(asyncState);
}
else
{
asyncState.timer.Set(timeFromNow);
}
}
}
}
}
public override MsmqQueue.ReceiveResult TryReceive(NativeMsmqMessage message, TimeSpan timeout, MsmqTransactionMode transactionMode)
{
MsmqQueue.MoveReceiveResult result3;
TimeoutHelper helper = new TimeoutHelper(timeout);
bool flag = false;
long lookupId = 0L;
while (!flag)
{
using (MsmqMessageLookupId id = new MsmqMessageLookupId())
{
MsmqQueue.ReceiveResult result = base.TryPeek(id, helper.RemainingTime());
if (result != MsmqQueue.ReceiveResult.MessageReceived)
{
return(result);
}
lookupId = id.lookupId.Value;
}
try
{
if (base.TryMoveMessage(lookupId, this.lockQueueForMove, MsmqTransactionMode.None) == MsmqQueue.MoveReceiveResult.Succeeded)
{
flag = true;
}
continue;
}
catch (MsmqException exception)
{
MsmqDiagnostics.ExpectedException(exception);
continue;
}
}
try
{
result3 = this.lockQueueForReceive.TryReceiveByLookupId(lookupId, message, MsmqTransactionMode.None, 0x40000010);
}
catch (MsmqException exception2)
{
this.UnlockMessage(lookupId, TimeSpan.Zero);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(exception2);
}
if (result3 == MsmqQueue.MoveReceiveResult.Succeeded)
{
return(MsmqQueue.ReceiveResult.MessageReceived);
}
this.UnlockMessage(lookupId, TimeSpan.Zero);
return(MsmqQueue.ReceiveResult.OperationCancelled);
}
private void OnCompletion(int error, bool completedSynchronously)
{
Exception exception = null;
this.receiveResult = MsmqQueue.ReceiveResult.MessageReceived;
try
{
if (error != 0)
{
if (error != -1072824293)
{
if (error != -1072824312)
{
if (!MsmqQueue.IsReceiveErrorDueToInsufficientBuffer(error))
{
if (MsmqQueue.IsErrorDueToStaleHandle(error))
{
this.msmqQueue.HandleIsStale(this.handle);
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(System.ServiceModel.SR.GetString("MsmqReceiveError", new object[] { MsmqError.GetErrorString(error) }), error));
}
this.message.Unpin();
this.message.GrowBuffers();
this.StartReceive(completedSynchronously);
return;
}
this.receiveResult = MsmqQueue.ReceiveResult.OperationCancelled;
}
else
{
this.receiveResult = MsmqQueue.ReceiveResult.Timeout;
}
}
}
catch (Exception exception2)
{
if ((exception2 is NullReferenceException) || (exception2 is SEHException))
{
throw;
}
exception = exception2;
}
this.message.Unpin();
base.Complete(completedSynchronously, exception);
}
void OnComplete(IAsyncResult result)
{
Exception ex = null;
try
{
receiveResult = receiver.Queue.EndTryReceive(result);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
ex = e;
}
Complete(result.CompletedSynchronously, ex);
}
private void OnComplete(IAsyncResult result)
{
Exception exception = null;
try
{
this.receiveResult = this.receiver.Queue.EndTryReceive(result);
}
catch (Exception exception2)
{
if (Fx.IsFatal(exception2))
{
throw;
}
exception = exception2;
}
base.Complete(result.CompletedSynchronously, exception);
}
private void OnComplete(IAsyncResult result)
{
this.msmqMessage.Dispose();
MsmqQueue.ReceiveResult unknown = MsmqQueue.ReceiveResult.Unknown;
Exception exception = null;
try
{
unknown = this.msmqQueue.EndPeek(result);
}
catch (Exception exception2)
{
if (Fx.IsFatal(exception2))
{
throw;
}
exception = exception2;
}
this.successResult = unknown != MsmqQueue.ReceiveResult.Timeout;
base.Complete(result.CompletedSynchronously, exception);
}
void OnComplete(IAsyncResult result)
{
this.msmqMessage.Dispose();
MsmqQueue.ReceiveResult receiveResult = MsmqQueue.ReceiveResult.Unknown;
Exception completionException = null;
try
{
receiveResult = this.msmqQueue.EndPeek(result);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
completionException = e;
}
this.successResult = receiveResult != MsmqQueue.ReceiveResult.Timeout;
base.Complete(result.CompletedSynchronously, completionException);
}
static void OnPeekCompleted(IAsyncResult result)
{
Msmq4PoisonHandler handler = result.AsyncState as Msmq4PoisonHandler;
MsmqQueue.ReceiveResult receiveResult = MsmqQueue.ReceiveResult.Unknown;
try
{
receiveResult = handler.retryQueueForPeek.EndPeek(result);
}
catch (MsmqException ex)
{
MsmqDiagnostics.ExpectedException(ex);
}
if (MsmqQueue.ReceiveResult.MessageReceived == receiveResult)
{
lock (handler)
{
if (!handler.disposed)
{
// Check the time - move it, and begin peeking again
// if necessary, or wait for the timeout.
DateTime lastMoveTime = MsmqDateTime.ToDateTime(handler.retryQueueMessage.LastMoveTime.Value);
TimeSpan waitTime = lastMoveTime + handler.ReceiveParameters.RetryCycleDelay - DateTime.UtcNow;
if (waitTime < TimeSpan.Zero)
{
handler.OnTimer(handler);
}
else
{
handler.timer.Set(waitTime);
}
}
}
}
}
private void CollectLocks(MsmqQueue lockQueue)
{
MsmqQueue.ReceiveResult messageReceived = MsmqQueue.ReceiveResult.MessageReceived;
while (messageReceived == MsmqQueue.ReceiveResult.MessageReceived)
{
using (MsmqMessageLookupId id = new MsmqMessageLookupId())
{
try
{
messageReceived = lockQueue.TryPeek(id, TimeSpan.FromSeconds(0.0));
if (messageReceived == MsmqQueue.ReceiveResult.MessageReceived)
{
lockQueue.TryMoveMessage(id.lookupId.Value, this.mainQueueForMove, MsmqTransactionMode.None);
}
}
catch (MsmqException exception)
{
MsmqDiagnostics.ExpectedException(exception);
messageReceived = MsmqQueue.ReceiveResult.Unknown;
}
continue;
}
}
}
void OnComplete(IAsyncResult result)
{
Exception ex = null;
try
{
receiveResult = receiver.Queue.EndTryReceive(result);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
ex = e;
}
Complete(result.CompletedSynchronously, ex);
}
private void OnComplete(IAsyncResult result)
{
Exception exception = null;
try
{
this.receiveResult = this.receiver.Queue.EndTryReceive(result);
}
catch (Exception exception2)
{
if (Fx.IsFatal(exception2))
{
throw;
}
exception = exception2;
}
base.Complete(result.CompletedSynchronously, exception);
}
