Beispiel #1
0
        public void CancelAsync(object userState)
        {
            if (userState == null)
            {
                throw Microsoft.CoreWf.Internals.FxTrace.Exception.ArgumentNull("userState");
            }

            AsyncInvokeContext context = this.RemoveFromPendingInvokes(userState);

            if (context != null)
            {
                // cancel does not need a timeout since it's bounded by the invoke timeout
                if (s_cancelCallback == null)
                {
                    s_cancelCallback = Fx.ThunkCallback(new AsyncCallback(CancelCallback));
                }
                // cancel only throws TimeoutException and shouldnt throw at all if timeout is infinite
                // cancel does not need to raise InvokeCompleted since the InvokeAsync invocation would raise it
                IAsyncResult result = context.WorkflowApplication.BeginCancel(TimeSpan.MaxValue, s_cancelCallback, context);
                if (result.CompletedSynchronously)
                {
                    context.WorkflowApplication.EndCancel(result);
                }
            }
        }
Beispiel #2
0
 private void PostInvokeCompletedAndRemove(AsyncInvokeContext context, Exception error)
 {
     if (context.UserState != null)
     {
         RemoveFromPendingInvokes(context.UserState);
     }
     PostInvokeCompleted(context, error);
 }
Beispiel #3
0
        private void CancelCallback(IAsyncResult result)
        {
            if (result.CompletedSynchronously)
            {
                return;
            }
            AsyncInvokeContext context = (AsyncInvokeContext)result.AsyncState;

            // cancel only throws TimeoutException and shouldnt throw at all if timeout is infinite
            context.WorkflowApplication.EndCancel(result);
        }
Beispiel #4
0
 private void AddToPendingInvokes(AsyncInvokeContext context)
 {
     lock (ThisLock)
     {
         if (this.PendingInvokes.ContainsKey(context.UserState))
         {
             throw Microsoft.CoreWf.Internals.FxTrace.Exception.AsError(new InvalidOperationException(SR.SameUserStateUsedForMultipleInvokes));
         }
         this.PendingInvokes.Add(context.UserState, context);
     }
 }
Beispiel #5
0
        private void PostInvokeCompleted(AsyncInvokeContext context, bool cancelled, Exception error)
        {
            InvokeCompletedEventArgs e = new InvokeCompletedEventArgs(error, cancelled, context);

            if (this.InvokeCompleted == null)
            {
                context.Operation.OperationCompleted();
            }
            else
            {
                context.Operation.PostOperationCompleted(this.RaiseInvokeCompletedCallback, e);
            }
        }
Beispiel #6
0
        private void PostInvokeCompleted(AsyncInvokeContext context, Exception error)
        {
            bool cancelled;

            if (error == null)
            {
                context.WorkflowApplication.GetCompletionStatus(out error, out cancelled);
            }
            else
            {
                cancelled = false;
            }
            PostInvokeCompleted(context, cancelled, error);
        }
Beispiel #7
0
        private void InternalInvokeAsync(IDictionary <string, object> inputs, TimeSpan timeout, object userState)
        {
            AsyncInvokeContext context = new AsyncInvokeContext(userState, this);

            if (userState != null)
            {
                AddToPendingInvokes(context);
            }
            Exception error = null;
            bool      completedSynchronously = false;

            try
            {
                if (s_invokeCallback == null)
                {
                    s_invokeCallback = Fx.ThunkCallback(new AsyncCallback(InvokeCallback));
                }
                context.Operation.OperationStarted();
                IAsyncResult result = WorkflowApplication.BeginInvoke(_workflow, inputs, _extensions, timeout, SynchronizationContext.Current, context, s_invokeCallback, context);
                if (result.CompletedSynchronously)
                {
                    context.Outputs        = this.EndInvoke(result);
                    completedSynchronously = true;
                }
            }
            catch (Exception e)
            {
                if (Fx.IsFatal(e))
                {
                    throw;
                }
                error = e;
            }
            if (error != null || completedSynchronously)
            {
                PostInvokeCompletedAndRemove(context, error);
            }
        }
Beispiel #8
0
        private void InvokeCallback(IAsyncResult result)
        {
            if (result.CompletedSynchronously)
            {
                return;
            }
            AsyncInvokeContext context = (AsyncInvokeContext)result.AsyncState;
            WorkflowInvoker    thisPtr = context.Invoker;
            Exception          error   = null;

            try
            {
                context.Outputs = thisPtr.EndInvoke(result);
            }
            catch (Exception e)
            {
                if (Fx.IsFatal(e))
                {
                    throw;
                }
                error = e;
            }
            thisPtr.PostInvokeCompletedAndRemove(context, error);
        }
Beispiel #9
0
 internal InvokeCompletedEventArgs(Exception error, bool cancelled, AsyncInvokeContext context)
     : base(error, cancelled, context.UserState)
 {
     this.Outputs = context.Outputs;
 }