public void OnUnhandledException(UnhandledExceptionAsyncData data)
            {
                Fx.Assert(data != null, "data must not be null!");
                Fx.Assert(data.Exception != null, "data.Exception must not be null!");

                FxTrace.Exception.AsWarning(data.Exception);

                try
                {                   
                    IAsyncResult result;
                    if (this.action == WorkflowUnhandledExceptionAction.Cancel)
                    {
                        result = this.instance.BeginCancel(null, TimeSpan.MaxValue, operationCallback, data);
                    }
                    else if (this.action == WorkflowUnhandledExceptionAction.Terminate)
                    {
                        result = this.instance.BeginTerminate(data.Exception, null, TimeSpan.MaxValue, operationCallback, data);
                    }
                    else if (this.action == WorkflowUnhandledExceptionAction.AbandonAndSuspend)
                    {
                        this.instance.isRunnable = false;
                        // For non-durable WF, simply abandon.
                        if (this.instance.persistenceContext.CanPersist)
                        {
                            result = this.instance.BeginAbandonAndSuspend(data.Exception, TimeSpan.MaxValue, operationCallback, data);
                        }
                        else
                        {
                            result = this.instance.BeginAbandon(data.Exception, TimeSpan.MaxValue, operationCallback, data);
                        }
                    }
                    else
                    {
                        this.instance.isRunnable = false;
                        result = this.instance.BeginAbandon(data.Exception, TimeSpan.MaxValue, operationCallback, data);
                    }

                    if (result.CompletedSynchronously)
                    {
                        HandleEndOperation(result);
                    }
                }
                catch (Exception ex)
                {
                    if (Fx.IsFatal(ex))
                    {
                        throw;
                    }
                    this.instance.AbortInstance(ex, true);
                }
            }
        protected override void OnNotifyUnhandledException(Exception exception, Activity exceptionSource, 
            string exceptionSourceInstanceId)
        {
            bool ownsLock = true;
            bool keepLock = false;
            UnhandledExceptionAsyncData data = new UnhandledExceptionAsyncData(this, exception, exceptionSource);

            try
            {
                if (this.Controller.HasPendingTrackingRecords)
                {
                    IAsyncResult result = this.Controller.BeginFlushTrackingRecords(this.trackTimeout, TrackUnhandledExceptionDoneCallback, data);

                    if (result.CompletedSynchronously)
                    {
                        this.Controller.EndFlushTrackingRecords(result);
                    }
                    else
                    {
                        keepLock = true;
                        return;
                    }
                }

                this.handlerThreadId = Thread.CurrentThread.ManagedThreadId;

                try
                {
                    this.isInHandler = true;
                    OnUnhandledException(data);
                }
                finally
                {
                    this.isInHandler = false;
                }
            }
            finally
            {
                if (!keepLock)
                {
                    ReleaseLock(ref ownsLock);
                }
            }
        }
        void OnUnhandledException(UnhandledExceptionAsyncData data)
        {
            Fx.Assert(data != null, "data must not be null!");
            Fx.Assert(data.Exception != null, "data.Exception must not be null!");

            FaultPendingRequests(data.Exception);
            this.UnhandledExceptionPolicy.OnUnhandledException(data);
        }
 private void OnUnhandledException(UnhandledExceptionAsyncData data)
 {
     this.FaultPendingRequests(data.Exception);
     this.UnhandledExceptionPolicy.OnUnhandledException(data);
 }