C# NativeActivityContext.RemoveBookmark方法代码示例

 protected override void Cancel(NativeActivityContext context)
 {
     Bookmark bookmark = this.timerBookmark.Get(context);
     this.GetTimerExtension(context).CancelTimer(bookmark);
     context.RemoveBookmark(bookmark);
     context.MarkCanceled();
 }

 protected override void Cancel(NativeActivityContext context)
 {
     Bookmark bookmark = this.bookmark.Get(context);
     if (bookmark != null)
     {
         context.RemoveBookmark(bookmark);
     }
     base.Cancel(context);
 }

 internal void RemoveBookmark(NativeActivityContext context, CompensationBookmarkName bookmarkName)
 {
     Bookmark bookmark = this.BookmarkTable[bookmarkName];
     if (bookmark != null)
     {
         context.RemoveBookmark(bookmark);
         this.BookmarkTable[bookmarkName] = null;
     }
 }

 protected override void Cancel(NativeActivityContext context)
 {
     Bookmark bookmark = timerExpiredBookmark.Get(context);
     if (bookmark != null)
     {
         context.GetTimerExtension().CancelTimer(bookmark);
         context.RemoveBookmark(bookmark);
     }
     context.MarkCanceled();
 }

        private void OnExtensionProgress(NativeActivityContext context, Bookmark bookmark, Object data)
        {
            if (bookmarkProgress.Get(context) != bookmark)
                return;

            if (data is int && !context.IsCancellationRequested)
            {
                Track(context, data);
                if (this.OnProgress != null)
                    context.ScheduleAction<int>(this.OnProgress, (int)data);
            }
            else
            {
                this.noPersistHandle.Get(context).Exit(context);
                context.RemoveBookmark(bookmark);

                if (data is Exception)
                    throw data as Exception;
            }
        }

        protected override void Cancel(NativeActivityContext context)
        {
            context.CancelChildren();
            var bookmark = bookmarkProgress.Get(context);

            var extension = context.GetExtension<Hosting.FileCopyExtension>();
            extension.Cancel(bookmark.Name);

            this.noPersistHandle.Get(context).Exit(context);
            context.RemoveBookmark(bookmark);
            context.MarkCanceled();
        }

        void OnMainRootComplete(NativeActivityContext context, Bookmark bookmark, object value)
        {
            CompensationExtension compensationExtension = context.GetExtension<CompensationExtension>();
            Fx.Assert(compensationExtension != null, "CompensationExtension must be valid");

            CompensationTokenData rootHandle = compensationExtension.Get(CompensationToken.RootCompensationId);
            Fx.Assert(rootHandle != null, "rootToken must be valid");

            ActivityInstanceState completionState = (ActivityInstanceState)value;

            if (completionState == ActivityInstanceState.Closed)
            {
                context.ResumeBookmark(compensationExtension.WorkflowConfirmation, new CompensationToken(rootHandle));
            }
            else if (completionState == ActivityInstanceState.Canceled)
            {
                context.ResumeBookmark(compensationExtension.WorkflowCompensation, new CompensationToken(rootHandle));
            }
            else if (completionState == ActivityInstanceState.Faulted)
            {
                // Do nothing. Neither Compensate nor Confirm.
                // Remove the bookmark to complete the WorkflowCompensationBehavior execution. 
               context.RemoveBookmark(compensationExtension.WorkflowConfirmation); 
               context.RemoveBookmark(compensationExtension.WorkflowCompensation);
            }
        }

        void OnConfirmationComplete(NativeActivityContext context, ActivityInstance completedInstance)
        {
            CompensationExtension compensationExtension = context.GetExtension<CompensationExtension>();
            Fx.Assert(compensationExtension != null, "CompensationExtension must be valid");

            context.RemoveBookmark(compensationExtension.WorkflowCompensation);
        }

 private void OnBookmarkCallback(NativeActivityContext context, Bookmark bookmark, object value)
 {
     if (this.Result != null)
         this.Result.Set(context, value == null ? string.Empty : value.ToString());
     context.RemoveBookmark(bookmark);
 }

        private void OnMainRootComplete(NativeActivityContext context, Bookmark bookmark, object value)
        {
            CompensationExtension extension = context.GetExtension<CompensationExtension>();
            CompensationTokenData tokenData = extension.Get(0L);
            switch (((ActivityInstanceState) value))
            {
                case ActivityInstanceState.Closed:
                    context.ResumeBookmark(extension.WorkflowConfirmation, new CompensationToken(tokenData));
                    return;

                case ActivityInstanceState.Canceled:
                    context.ResumeBookmark(extension.WorkflowCompensation, new CompensationToken(tokenData));
                    return;

                case ActivityInstanceState.Faulted:
                    context.RemoveBookmark(extension.WorkflowConfirmation);
                    context.RemoveBookmark(extension.WorkflowCompensation);
                    break;
            }
        }

 private void OnConfirmationComplete(NativeActivityContext context, System.Activities.ActivityInstance completedInstance)
 {
     CompensationExtension extension = context.GetExtension<CompensationExtension>();
     context.RemoveBookmark(extension.WorkflowCompensation);
 }

 protected override void Cancel(NativeActivityContext context)
 {
     SendReceiveExtension sendReceiveExtension = context.GetExtension<SendReceiveExtension>();
     if (sendReceiveExtension != null)
     {
         Bookmark pendingBookmark = this.extensionReceiveBookmark.Get(context);
         if (pendingBookmark != null)
         {
             sendReceiveExtension.Cancel(pendingBookmark);
             context.RemoveBookmark(pendingBookmark);
         }
     }
     base.Cancel(context);
 }

 //延迟书签回调
 private void OnDelayBookmarkCallback(NativeActivityContext context, Bookmark bookmark, object value)
 {
     context.RemoveBookmark(bookmark);
     //删除延迟书签后直接执行主体
     this.InternalExecuteBody(context);
 }

        private void OnBookmarkCallback(NativeActivityContext context, Bookmark bookmark)
        {
            var log = context.Resolve<ILoggerFactory>() != null
                    ? context.Resolve<ILoggerFactory>().Create(typeof(SubProcess))
                    : null;
            var parser = context.Resolve<IScriptParser>();
            var extension = context.GetExtension<DataFieldExtension>();

            //完成规则解析
            if (this.Result != null
                && parser != null
                && this.FinishRule != null
                && this.FinishRule.Count > 0)
            {
                foreach (var i in this.FinishRule)
                    if (parser.EvaluateRule(i.Value, extension))
                    {
                        this.Result.Set(context, i.Key);
                        if (log != null)
                            log.InfoFormat("SubProcess节点完成规则“{0}”测试通过，将进入节点“{1}”", i.Value, i.Key);
                        break;
                    }
            }
            //所有逻辑完成才可删除，若上述逻辑失败则将此书签用于错误恢复
            context.RemoveBookmark(bookmark);
        }