IAsyncResult BeginReceiveMessages(int messageCount, TimeSpan batchWaitTimeout, TimeSpan timeout, AsyncCallback callback, object state)
{
this.ThrowIfClosed();
List <AmqpMessage> messages = new List <AmqpMessage>();
lock (this.SyncRoot)
{
if (this.messageQueue != null && this.messageQueue.Count > 0)
{
for (int i = 0; i < messageCount && this.messageQueue.Count > 0; i++)
{
messages.Add(this.messageQueue.Dequeue());
}
}
}
if (!messages.Any() && timeout > TimeSpan.Zero)
{
ReceiveAsyncResult waiter = new ReceiveAsyncResult(this, messageCount, batchWaitTimeout, timeout, callback, state);
bool completeWaiter = true;
lock (this.SyncRoot)
{
if (this.messageQueue == null)
{
// closed, so return null message immediately
}
else if (this.messageQueue.Count > 0)
{
for (int i = 0; i < messageCount && this.messageQueue.Count > 0; i++)
{
messages.Add(this.messageQueue.Dequeue());
}
}
else
{
LinkedListNode <ReceiveAsyncResult> node = this.waiterList.AddLast(waiter);
waiter.Initialize(node);
completeWaiter = false;
// If no auto-flow, trigger a flow to get messages.
int creditToIssue = this.Settings.AutoSendFlow ? 0 : this.GetOnDemandReceiveCredit();
if (creditToIssue > 0)
{
// Before the credit is issued, waiters could be completed already. In this case, we will queue the incoming
// messages and wait for the next receive calls.
this.IssueCredit((uint)creditToIssue, false, AmqpConstants.NullBinary);
}
}
}
if (completeWaiter)
{
waiter.Signal(messages, true);
}
return(waiter);
}
return(new CompletedAsyncResult <IEnumerable <AmqpMessage> >(messages, callback, state));
}
public IAsyncResult BeginReceive(TimeSpan timeout, AsyncCallback callback, object state)
{
ReceiveAsyncResult <TChannel> result = new ReceiveAsyncResult <TChannel>(this, timeout, callback, state);
result.Begin();
return(result);
}
public static bool End(IAsyncResult result, out IEnumerable <AmqpMessage> messages)
{
ReceiveAsyncResult thisPtr = AsyncResult.End <ReceiveAsyncResult>(result);
messages = thisPtr.messages;
return(thisPtr.completed == 1);
}
void OnReceiveMessage(AmqpMessage message)
{
if (this.messageListener != null)
{
this.messageListener(message);
}
else
{
ReceiveAsyncResult waiter = null;
lock (this.syncRoot)
{
if (this.waiterList != null && this.waiterList.Count > 0)
{
waiter = this.waiterList.First.Value;
this.waiterList.RemoveFirst();
waiter.OnRemoved();
}
else if (this.messageQueue != null)
{
this.messageQueue.Enqueue(message);
}
}
if (waiter != null)
{
waiter.Signal(message, false);
}
}
this.minTimeout = TimeSpan.Zero;
}
void OnReceiveMessage(AmqpMessage message)
{
if (this.messageListener != null)
{
this.messageListener(message);
}
else
{
ReceiveAsyncResult waiter = null;
int creditToIssue = 0;
bool releaseMessage = false;
lock (this.SyncRoot)
{
if (this.waiterList != null && this.waiterList.Count > 0)
{
waiter = this.waiterList.First.Value;
this.waiterList.RemoveFirst();
waiter.OnRemoved();
creditToIssue = this.Settings.AutoSendFlow ? 0 : this.GetOnDemandReceiveCredit();
}
else if (!this.Settings.AutoSendFlow && this.Settings.SettleType != SettleMode.SettleOnSend)
{
releaseMessage = true;
}
else if (this.messageQueue != null)
{
this.messageQueue.Enqueue(message);
AmqpTrace.Provider.AmqpCacheMessage(
this,
message.DeliveryId.Value,
this.messageQueue.Count,
this.messageQueue.IsPrefetchingBySize,
this.TotalCacheSizeInBytes ?? 0,
this.Settings == null ? 0 : this.Settings.TotalLinkCredit,
this.LinkCredit);
}
}
if (releaseMessage)
{
this.ReleaseMessage(message);
message.Dispose();
}
if (creditToIssue > 0)
{
this.IssueCredit((uint)creditToIssue, false, AmqpConstants.NullBinary);
}
if (waiter != null)
{
// Schedule the completion on another thread so we don't block the I/O thread
ActionItem.Schedule(
o => { var state = (Tuple <ReceiveAsyncResult, IEnumerable <AmqpMessage> >)o; state.Item1.Signal(state.Item2, false); },
new Tuple <ReceiveAsyncResult, IEnumerable <AmqpMessage> >(waiter, new AmqpMessage[] { message }));
}
}
}
public AmqpMessage EndReceiveMessage(IAsyncResult result)
{
if (result is ReceiveAsyncResult)
{
return(ReceiveAsyncResult.End(result));
}
else
{
return(CompletedAsyncResult <AmqpMessage> .End(result));
}
}
public bool EndReceiveMessages(IAsyncResult result, out IEnumerable <AmqpMessage> messages)
{
if (result is ReceiveAsyncResult)
{
return(ReceiveAsyncResult.End(result, out messages));
}
messages = CompletedAsyncResult <IEnumerable <AmqpMessage> > .End(result);
return(true);
}
void OnReceiveComplete(IAsyncResult result)
{
HttpListenerContext context = ReceiveAsyncResult.End(result);
_bufferPool.Return(((ReceiveAsyncResult)result).buffer);
if (!_enqueueOnReceive)
{
this.Enqueue();
}
SendReply(context);
}
public bool EndReceiveMessage(IAsyncResult result, out AmqpMessage message)
{
if (result is ReceiveAsyncResult)
{
IEnumerable <AmqpMessage> messages;
bool retValue = ReceiveAsyncResult.End(result, out messages);
message = messages.FirstOrDefault();
return(retValue);
}
message = CompletedAsyncResult <IEnumerable <AmqpMessage> > .End(result).FirstOrDefault();
return(true);
}
static void OnTimer(object state)
{
ReceiveAsyncResult thisPtr = (ReceiveAsyncResult)state;
lock (thisPtr.parent.SyncRoot)
{
if (thisPtr.parent.waiterList == null || thisPtr.node == null)
{
return;
}
thisPtr.parent.waiterList.Remove(thisPtr.node);
thisPtr.node = null;
}
thisPtr.CompleteInternal(false, thisPtr.MessageCount > 0 ? 1 : 2, null); // 1: signaled, 2: timeout
}
public IAsyncResult BeginReceiveMessage(TimeSpan timeout, AsyncCallback callback, object state)
{
this.ThrowIfNotOpen();
if (timeout < this.minTimeout)
{
timeout = this.minTimeout;
}
AmqpMessage message = null;
lock (this.syncRoot)
{
if (this.messageQueue.Count > 0)
{
message = this.messageQueue.Dequeue();
}
}
if (message == null && timeout > TimeSpan.Zero)
{
ReceiveAsyncResult waiter = new ReceiveAsyncResult(this, timeout, callback, state);
lock (this.syncRoot)
{
if (this.messageQueue.Count > 0)
{
message = this.messageQueue.Dequeue();
}
else
{
LinkedListNode <ReceiveAsyncResult> node = this.waiterList.AddLast(waiter);
waiter.Initialize(node);
}
}
if (message != null)
{
waiter.Signal(message, true);
}
return(waiter);
}
else
{
return(new CompletedAsyncResult <AmqpMessage>(message, callback, state));
}
}
static void OnTimer(object state)
{
ReceiveAsyncResult thisPtr = (ReceiveAsyncResult)state;
lock (thisPtr.parent.SyncRoot)
{
if (thisPtr.parent.waiterList == null || thisPtr.node == null)
{
return;
}
thisPtr.parent.waiterList.Remove(thisPtr.node);
thisPtr.node = null;
}
thisPtr.CompleteInternal(null, false, 2, null);
}
public IAsyncResult BeginReceiveMessage(TimeSpan timeout, AsyncCallback callback, object state)
{
this.ThrowIfNotOpen();
if (timeout < this.minTimeout)
{
timeout = this.minTimeout;
}
AmqpMessage message = null;
lock (this.syncRoot)
{
if (this.messageQueue.Count > 0)
{
message = this.messageQueue.Dequeue();
}
}
if (message == null && timeout > TimeSpan.Zero)
{
ReceiveAsyncResult waiter = new ReceiveAsyncResult(this, timeout, callback, state);
lock (this.syncRoot)
{
if (this.messageQueue.Count > 0)
{
message = this.messageQueue.Dequeue();
}
else
{
LinkedListNode<ReceiveAsyncResult> node = this.waiterList.AddLast(waiter);
waiter.Initialize(node);
}
}
if (message != null)
{
waiter.Signal(message, true);
}
return waiter;
}
else
{
return new CompletedAsyncResult<AmqpMessage>(message, callback, state);
}
}
static void OnReadComplete(IAsyncResult result)
{
if (result.CompletedSynchronously)
{
return;
}
ReceiveAsyncResult thisPtr = result.AsyncState as ReceiveAsyncResult;
Exception completionException = null;
try
{
thisPtr.HandleReadComplete(result);
}
catch (Exception ex)
{
completionException = ex;
}
thisPtr.Complete(false, completionException);
}
static void OnReceiveComplete(object state)
{
ReceiveAsyncResult thisPtr = ((ReceiveAsyncResult)state);
Exception completionException = null;
try
{
thisPtr.SetReturnValue(thisPtr.Source.EndReceive());
}
#pragma warning suppress 56500 // Microsoft, transferring exception to another thread
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
completionException = e;
}
thisPtr.CompleteWithUnlock(false, completionException);
}
static void OnReadData(IAsyncResult result)
{
if (result.CompletedSynchronously)
{
return;
}
ReceiveAsyncResult thisPtr = (ReceiveAsyncResult)result.AsyncState;
Exception completionException = null;
try
{
thisPtr.CompleteReadData(result);
}
catch (Exception e)
{
completionException = e;
}
thisPtr.Complete(false, completionException);
}
public static Message End(IAsyncResult result)
{
ReceiveAsyncResult <TInputChannel> thisPtr = AsyncResult.End <ReceiveAsyncResult <TInputChannel> >(result);
return(thisPtr.Message);
}
public static HttpListenerContext End(IAsyncResult result)
{
ReceiveAsyncResult thisPtr = AsyncResult.End <ReceiveAsyncResult>(result);
return(thisPtr.context);
}
public IMessage EndReceive(IAsyncResult asyncResult)
{
ReceiveAsyncResult result = (ReceiveAsyncResult)asyncResult;
return(result.Message);
}
public static Message End(IAsyncResult result)
{
ReceiveAsyncResult thisPtr = AsyncResult.End <ReceiveAsyncResult>(result);
return(thisPtr.message);
}
public static Message End(IAsyncResult result)
{
ReceiveAsyncResult asyncResult = AsyncResult.End <ReceiveAsyncResult>(result);
return(asyncResult.Message);
}
public virtual Message EndReceive(IAsyncResult result)
{
return(ReceiveAsyncResult.End(result));
}
public Message EndReceive(IAsyncResult result)
{
return(ReceiveAsyncResult <TChannel> .End(result));
}
void OnReceiveMessage(AmqpMessage message)
{
if (this.messageListener != null)
{
this.messageListener(message);
}
else
{
ReceiveAsyncResult waiter = null;
int creditToIssue = 0;
bool releaseMessage = false;
lock (this.SyncRoot)
{
if (this.waiterList != null && this.waiterList.Count > 0)
{
var firstWaiter = this.waiterList.First.Value;
if (this.messageQueue.IsPrefetchingBySize)
{
if (this.messageQueue.UpdateCreditToIssue(message))
{
this.SetTotalLinkCredit(this.messageQueue.BoundedTotalLinkCredit, true);
}
}
firstWaiter.Add(message);
if (firstWaiter.RequestedMessageCount == 1 || firstWaiter.MessageCount >= firstWaiter.RequestedMessageCount)
{
this.waiterList.RemoveFirst();
firstWaiter.OnRemoved();
creditToIssue = this.Settings.AutoSendFlow ? 0 : this.GetOnDemandReceiveCredit();
waiter = firstWaiter;
}
}
else if (!this.Settings.AutoSendFlow && this.Settings.SettleType != SettleMode.SettleOnSend)
{
releaseMessage = true;
}
else if (this.messageQueue != null)
{
this.messageQueue.Enqueue(message);
AmqpTrace.Provider.AmqpCacheMessage(
this,
message.DeliveryId.Value,
this.messageQueue.Count,
this.messageQueue.IsPrefetchingBySize,
this.TotalCacheSizeInBytes ?? 0,
this.Settings == null ? 0 : this.Settings.TotalLinkCredit,
this.LinkCredit);
}
}
if (releaseMessage)
{
this.ReleaseMessage(message);
message.Dispose();
}
if (creditToIssue > 0)
{
this.IssueCredit((uint)creditToIssue, false, AmqpConstants.NullBinary);
}
if (waiter != null)
{
// Schedule the completion on another thread so we don't block the I/O thread
ActionItem.Schedule(o => { var w = (ReceiveAsyncResult)o; w.Signal(false); }, waiter);
}
}
}
