예제 #1
0
 protected void OnReceiveFirstTransfer(Transfer transfer)
 {
     Fx.Assert(transfer.DeliveryId.HasValue, "The first transfer must have a delivery id.");
     this.nextDeliveryId = transfer.DeliveryId.Value;
 }
예제 #2
0
        protected bool TryComplete(bool didCompleteSynchronously, Exception exception)
        {
            lock (this.ThisLock)
            {
                if (this.isCompleted)
                {
                    return(false);
                }

                this.exception   = exception;
                this.isCompleted = true;
            }

#if DEBUG
            this.marker.AsyncResult = null;
            this.marker             = null;
#endif

            this.completedSynchronously = didCompleteSynchronously;
            if (this.OnCompleting != null)
            {
                // Allow exception replacement, like a catch/throw pattern.
                try
                {
                    this.OnCompleting(this, this.exception);
                }
                catch (Exception e)
                {
                    if (Fx.IsFatal(e))
                    {
                        throw;
                    }
                    this.exception = e;
                }
            }

            if (didCompleteSynchronously)
            {
                // If we completedSynchronously, then there's no chance that the manualResetEvent was created so
                // we don't need to worry about a race
                Fx.Assert(this.manualResetEvent == null, "No ManualResetEvent should be created for a synchronous AsyncResult.");
            }
            else
            {
                lock (this.ThisLock)
                {
                    if (this.manualResetEvent != null)
                    {
                        this.manualResetEvent.Set();
                    }
                }
            }

            if (this.callback != null)
            {
                try
                {
                    if (this.VirtualCallback != null)
                    {
                        this.VirtualCallback(this.callback, this);
                    }
                    else
                    {
                        this.callback(this);
                    }
                }
#pragma warning disable 1634
#pragma warning suppress 56500 // transferring exception to another thread
                catch (Exception e)
                {
                    if (Fx.IsFatal(e))
                    {
                        throw;
                    }

                    throw Fx.Exception.AsError(new CallbackException(CommonResources.AsyncCallbackThrewException, e));
                }
#pragma warning restore 1634
            }

            return(true);
        }
예제 #3
0
            public void DisposeDelivery(Delivery delivery, bool settled, DeliveryState state, bool noFlush)
            {
                if (delivery.Settled)
                {
                    this.OnWindowMoved(1);
                    return;
                }

                bool     scheduleTimer = false;
                Delivery toDispose     = null;

                lock (this.syncRoot)
                {
                    delivery.StateChanged = true;
                    delivery.Settled      = settled;
                    delivery.State        = state;

                    if (!delivery.Batchable)
                    {
                        delivery.StateChanged = false;
                        toDispose             = delivery;
                        if (delivery.Settled)
                        {
                            Delivery.Remove(ref this.firstUnsettled, ref this.lastUnsettled, delivery);
                        }
                    }
                    else if (this.sendingDisposition || noFlush)
                    {
                        return;
                    }
                    else if (this.session.settings.DispositionInterval == TimeSpan.Zero ||
                             ++this.needDispositionCount >= this.session.settings.DispositionThreshold)
                    {
                        this.sendingDisposition   = true;
                        this.needDispositionCount = 0;
                    }
                    else if (!this.timerScheduled)
                    {
                        this.timerScheduled = true;
                        scheduleTimer       = true;
                    }
                }

                if (toDispose != null)
                {
                    this.SendDisposition(new DispositionInfo()
                    {
                        First = toDispose
                    });
                    if (delivery.Settled)
                    {
                        this.OnWindowMoved(1);
                    }
                }
                else if (scheduleTimer)
                {
                    Fx.Assert(this.dispositionTimer != null, "Disposition timer cannot be null");
                    this.dispositionTimer.Change(this.session.settings.DispositionInterval, Timeout.InfiniteTimeSpan);
                }
                else
                {
                    this.SendDisposition();
                }
            }
예제 #4
0
 public DefaultActionItem(WaitCallback callback, object state)
 {
     Fx.Assert(callback != null, "Shouldn't instantiate an object to wrap a null callback");
     this.callback = callback;
     this.state    = state;
 }
예제 #5
0
 public static void End(IAsyncResult result)
 {
     Fx.AssertAndThrowFatal(result.IsCompleted, "CompletedAsyncResult was not completed!");
     AsyncResult.End <CompletedAsyncResult>(result);
 }
예제 #6
0
 public static void Schedule(WaitCallback callback, object state)
 {
     Fx.Assert(callback != null, "A null callback was passed for Schedule!");
     ThreadPool.QueueUserWorkItem(callback, state);
 }
예제 #7
0
 bool CompleteInternal(bool syncComplete, Exception exception)
 {
     Fx.Assert(exception != null || this.setTimerCalled, "Must call SetTimer.");
     return(this.TryComplete(syncComplete, exception));
 }