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); } }
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) { 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)); }