internal async Task <TryAsyncResult <RequestContext> > TryReceiveAsync(CancellationToken token)
{
try
{
return(await binder.TryReceiveAsync(token));
}
catch (CommunicationObjectAbortedException)
{
return(TryAsyncResult.FromResult((RequestContext)null));
}
catch (CommunicationObjectFaultedException)
{
return(TryAsyncResult.FromResult((RequestContext)null));
}
catch (CommunicationException e)
{
HandleError(e);
return(TryAsyncResult <RequestContext> .FailedResult);
}
catch (TimeoutException e)
{
HandleError(e);
return(TryAsyncResult <RequestContext> .FailedResult);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
HandleErrorOrAbort(e);
return(TryAsyncResult <RequestContext> .FailedResult);
}
}
public async Task <TryAsyncResult <RequestContext> > TryReceiveAsync(CancellationToken token)
{
if (channel.State == CommunicationState.Faulted)
{
AbortRequests();
return(TryAsyncResult.FromResult((RequestContext)null));
}
var result = await channel.TryReceiveAsync(token);
if (result.Success)
{
if (result.Result != null)
{
return(TryAsyncResult.FromResult((RequestContext) new DuplexRequestContext(channel, result.Result, this)));
}
else
{
AbortRequests();
return(TryAsyncResult.FromResult((RequestContext)null));
}
}
else
{
return(TryAsyncResult <RequestContext> .FailedResult);
}
}
public async Task <T> DequeueAsync(CancellationToken token)
{
TryAsyncResult <T> result = await TryDequeueAsync(token);
if (!result.Success)
{
// TODO: Create derived CancellationToken which carries original timeout with it
throw Fx.Exception.AsError(new TimeoutException(SR.Format(SR.TimeoutInputQueueDequeue, null)));
}
return(result.Result);
}
public async Task <TryAsyncResult <RequestContext> > TryReceiveAsync(CancellationToken token)
{
var result = await channel.TryReceiveAsync(token);
if (result.Success)
{
return(TryAsyncResult.FromResult(WrapMessage(result.Result)));
}
else
{
return(TryAsyncResult <RequestContext> .FailedResult);
}
}
public async Task <TryAsyncResult <T> > TryDequeueAsync(CancellationToken token)
{
WaitQueueReader reader = null;
Item item = new Item();
lock (ThisLock)
{
if (queueState == QueueState.Open)
{
if (itemQueue.HasAvailableItem)
{
item = itemQueue.DequeueAvailableItem();
}
else
{
reader = new WaitQueueReader(this);
readerQueue.Enqueue(reader);
}
}
else if (queueState == QueueState.Shutdown)
{
if (itemQueue.HasAvailableItem)
{
item = itemQueue.DequeueAvailableItem();
}
else if (itemQueue.HasAnyItem)
{
reader = new WaitQueueReader(this);
readerQueue.Enqueue(reader);
}
else
{
return(TryAsyncResult.FromResult(default(T)));
}
}
else // queueState == QueueState.Closed
{
return(TryAsyncResult.FromResult(default(T)));
}
}
if (reader != null)
{
return(await reader.WaitAsync(token));
}
else
{
InvokeDequeuedCallback(item.DequeuedCallback);
return(TryAsyncResult.FromResult(item.GetValue()));
}
}
public async Task <TryAsyncResult <Message> > TryReceiveAsync(CancellationToken token)
{
try
{
var message = await ReceiveAsync(token);
return(TryAsyncResult.FromResult(message));
}
catch (TimeoutException e)
{
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
return(TryAsyncResult <Message> .FailedResult);
}
}
// Locking:
// Only 1 channelBinder operation call should be active at any given time. All future calls
// will wait on the inputQueue. The semaphore is always released right before the Dispatch on the inputQueue.
// This protects a new call racing with an existing operation that is just about to fully complete.
public async Task <TryAsyncResult <RequestContext> > TryReceiveAsync(CancellationToken token)
{
if (Interlocked.CompareExchange(ref pendingOperationSemaphore, 1, 0) == 0)
{
ActionItem.Schedule(tryReceive, this);
}
var result = await inputQueue.TryDequeueAsync(token);
bool success = result.Success;
RequestContextWrapper wrapper = result.Result;
if (success && wrapper != null)
{
return(TryAsyncResult.FromResult(wrapper.RequestContext));
}
return(TryAsyncResult <RequestContext> .FailedResult);
}
internal async Task <TryAsyncResult <IChannelBinder> > TryAcceptAsync(CancellationToken token)
{
IChannelBinder channelBinder;
try
{
channelBinder = await binder.AcceptAsync(token);
if (channelBinder != null)
{
//dispatcher.PendingChannels.Add(channelBinder.Channel);
}
return(TryAsyncResult.FromResult(channelBinder));
}
catch (CommunicationObjectAbortedException)
{
channelBinder = null;
return(TryAsyncResult.FromResult(channelBinder));
}
catch (CommunicationObjectFaultedException)
{
channelBinder = null;
return(TryAsyncResult.FromResult(channelBinder));
}
catch (OperationCanceledException)
{
return(TryAsyncResult <IChannelBinder> .FailedResult);
}
catch (CommunicationException e)
{
HandleError(e);
return(TryAsyncResult <IChannelBinder> .FailedResult);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
HandleErrorOrAbort(e);
return(TryAsyncResult <IChannelBinder> .FailedResult);
}
}
public async Task <TryAsyncResult <T> > WaitAsync(CancellationToken token)
{
bool isSafeToClose = false;
try
{
if (!await waitEvent.WaitAsync(token))
{
if (inputQueue.RemoveReader(this))
{
isSafeToClose = true;
return(TryAsyncResult <T> .FailedResult);
}
else
{
await waitEvent.WaitAsync();
}
}
isSafeToClose = true;
}
finally
{
if (isSafeToClose)
{
waitEvent.Dispose();
}
}
if (exception != null)
{
throw Fx.Exception.AsError(exception);
}
return(TryAsyncResult.FromResult(item));
}
