protected override void Execute(NativeActivityContext context) { Bookmark bookmark = context.CreateBookmark(new BookmarkCallback(this.OnMainRootComplete), BookmarkOptions.NonBlocking); context.RegisterMainRootCompleteCallback(bookmark); CompensationExtension extension = context.GetExtension<CompensationExtension>(); extension.WorkflowCompensation = context.CreateBookmark(new BookmarkCallback(this.OnCompensate)); extension.WorkflowConfirmation = context.CreateBookmark(new BookmarkCallback(this.OnConfirm)); context.ResumeBookmark(extension.WorkflowCompensationScheduled, null); }
internal void NotifyMessage(NativeActivityContext context, long compensationId, CompensationBookmarkName compensationBookmark) { Bookmark bookmark = this.FindBookmark(compensationId, compensationBookmark); if (bookmark == null) { throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.BookmarkNotRegistered(compensationBookmark))); } context.ResumeBookmark(bookmark, compensationId); }
internal void NotifyMessage(NativeActivityContext context, long compensationId, CompensationBookmarkName compensationBookmark) { Bookmark bookmark = FindBookmark(compensationId, compensationBookmark); if (bookmark != null) { context.ResumeBookmark(bookmark, compensationId); } else { throw FxTrace.Exception.AsError(new InvalidOperationException(SR.BookmarkNotRegistered(compensationBookmark))); } }
private void OnTriggerCompleted(NativeActivityContext context, System.Activities.ActivityInstance completedInstance) { Pick.PickState state = (Pick.PickState)context.Properties.Find("System.Activities.Statements.Pick.PickState"); if ((completedInstance.State == ActivityInstanceState.Closed) && (state.TriggerCompletionBookmark != null)) { context.ResumeBookmark(state.TriggerCompletionBookmark, context.ActivityInstanceId); state.TriggerCompletionBookmark = null; state.ExecuteActionBookmark = context.CreateBookmark(new BookmarkCallback(this.OnExecuteAction)); } else if (!context.IsCancellationRequested) { context.CreateBookmark(); } }
protected override void Execute(NativeActivityContext context) { Bookmark mainRootCompleteBookmark = context.CreateBookmark(OnMainRootComplete, BookmarkOptions.NonBlocking); context.RegisterMainRootCompleteCallback(mainRootCompleteBookmark); CompensationExtension compensationExtension = context.GetExtension<CompensationExtension>(); Fx.Assert(compensationExtension != null, "CompensationExtension must be valid"); compensationExtension.WorkflowCompensation = context.CreateBookmark(new BookmarkCallback(OnCompensate)); compensationExtension.WorkflowConfirmation = context.CreateBookmark(new BookmarkCallback(OnConfirm)); Fx.Assert(compensationExtension.WorkflowCompensationScheduled != null, "compensationExtension.WorkflowCompensationScheduled bookmark must be setup by now"); context.ResumeBookmark(compensationExtension.WorkflowCompensationScheduled, null); }
protected override void Execute(NativeActivityContext context) { if (Condition.Expression != null && !Condition.Get(context)) { return; } var bookmark = (Bookmark)context.Properties.Find(BOOKMARK_NAME); if (bookmark != null) { var value = context.CreateBookmark(); _ = context.ResumeBookmark(bookmark, value); } }
protected override void Execute(NativeActivityContext context) { Bookmark mainRootCompleteBookmark = context.CreateBookmark(OnMainRootComplete, BookmarkOptions.NonBlocking); context.RegisterMainRootCompleteCallback(mainRootCompleteBookmark); CompensationExtension compensationExtension = context.GetExtension <CompensationExtension>(); Fx.Assert(compensationExtension != null, "CompensationExtension must be valid"); compensationExtension.WorkflowCompensation = context.CreateBookmark(new BookmarkCallback(OnCompensate)); compensationExtension.WorkflowConfirmation = context.CreateBookmark(new BookmarkCallback(OnConfirm)); Fx.Assert(compensationExtension.WorkflowCompensationScheduled != null, "compensationExtension.WorkflowCompensationScheduled bookmark must be setup by now"); context.ResumeBookmark(compensationExtension.WorkflowCompensationScheduled, null); }
private void CancelChildWorkItem(IList <Guid> parthToChild, NativeActivityContext context) { ICancellableWorkItemWithChildren cancellationRoot = RootWorkItem.Get(context).GoToChild(parthToChild) as ICancellableWorkItemWithChildren; if (cancellationRoot != null) { BookmarkResumptionResult cancelationRequestResult = context.ResumeBookmark( new Bookmark(WorkItemCancelationScope.CancelableWorkItemBookmarkName(cancellationRoot.Id)), cancellationRoot); if (cancelationRequestResult != BookmarkResumptionResult.Success) { WorkItemCancelationScope.MarkTasksAsCancelled(cancellationRoot, context, "Because cancellation request."); } } }
protected override void Execute(NativeActivityContext context) { CompensationExtension extension = context.GetExtension <CompensationExtension>(); long compensationId = this.compensationId.Get(context); CompensationTokenData tokenData = extension.Get(compensationId); CompensationToken token = new CompensationToken(tokenData); this.currentCompensationToken.Set(context, token); tokenData.IsTokenValidInSecondaryRoot = true; context.Properties.Add("System.Compensation.CompensationToken", token); tokenData.BookmarkTable[CompensationBookmarkName.OnConfirmation] = context.CreateBookmark(new BookmarkCallback(this.OnConfirmation)); tokenData.BookmarkTable[CompensationBookmarkName.OnCompensation] = context.CreateBookmark(new BookmarkCallback(this.OnCompensation)); tokenData.BookmarkTable[CompensationBookmarkName.OnCancellation] = context.CreateBookmark(new BookmarkCallback(this.OnCancellation)); Bookmark bookmark = tokenData.BookmarkTable[CompensationBookmarkName.OnSecondaryRootScheduled]; tokenData.BookmarkTable[CompensationBookmarkName.OnSecondaryRootScheduled] = null; context.ResumeBookmark(bookmark, compensationId); }
private void FindStepAndSchedule(NativeActivityContext context) { Queue <int> lastposition = (Queue <int>)context.Properties.Find(Constants._LastPosition); Queue <int> currentposition = (Queue <int>)context.Properties.Find(Constants._CurrentPosition); Command cmd = (Command)context.Properties.Find(Constants._Command); int current = lastposition.Count > 0 ? lastposition.Dequeue() : -1; if (lastposition.Count == 0 && cmd == Command.Next) { current++; } if (current < 0) { current = 0; } if (current >= 0 && current < this.activities.Count) { bool HasBack = (bool)context.Properties.Find(Constants._HasBack); if (!HasBack && current > 0) { context.Properties.Update(Constants._HasBack, true); } bool HasNext = (bool)context.Properties.Find(Constants._HasNext); if (!HasNext && current < this.activities.Count - 1) { context.Properties.Update(Constants._HasNext, true); } context.Properties.Update(Constants._LastPosition, lastposition); currentposition.Enqueue(current); context.Properties.Update(Constants._CurrentPosition, currentposition); ScheduleStep(context, current); } else { Bookmark bm = this.ResumeParent.Get(context); if (bm != null) { context.ResumeBookmark(bm, cmd); } } }
private void OnTriggerCompleted(NativeActivityContext context, ActivityInstance completedInstance) { PickState pickState = (PickState)context.Properties.Find(pickStateProperty); if (completedInstance.State == ActivityInstanceState.Closed && pickState.TriggerCompletionBookmark != null) { // We're the first trigger! We win! context.ResumeBookmark(pickState.TriggerCompletionBookmark, context.ActivityInstanceId); pickState.TriggerCompletionBookmark = null; pickState.ExecuteActionBookmark = context.CreateBookmark(new BookmarkCallback(OnExecuteAction)); } else if (!context.IsCancellationRequested) { // We didn't win, but we haven't been requested to cancel yet. // We'll just create a bookmark to keep ourselves from completing. context.CreateBookmark(); } // else // { // No need for an else since default cancelation will cover it! // } }
protected override void Execute(NativeActivityContext context) { var compensationExtension = context.GetExtension <CompensationExtension>(); Fx.Assert(compensationExtension != null, "CompensationExtension must be valid"); var compensationId = this.compensationId.Get(context); Fx.Assert(compensationId != CompensationToken.RootCompensationId, "CompensationId passed to the SecondaryRoot must be valid"); var compensationToken = compensationExtension.Get(compensationId); Fx.Assert(compensationToken != null, "CompensationTokenData must be valid"); var token = new CompensationToken(compensationToken); this.currentCompensationToken.Set(context, token); compensationToken.IsTokenValidInSecondaryRoot = true; context.Properties.Add(CompensationToken.PropertyName, token); Fx.Assert(compensationToken.BookmarkTable[CompensationBookmarkName.OnConfirmation] == null, "Bookmark should not be already initialized in the bookmark table."); compensationToken.BookmarkTable[CompensationBookmarkName.OnConfirmation] = context.CreateBookmark(new BookmarkCallback(OnConfirmation)); Fx.Assert(compensationToken.BookmarkTable[CompensationBookmarkName.OnCompensation] == null, "Bookmark should not be already initialized in the bookmark table."); compensationToken.BookmarkTable[CompensationBookmarkName.OnCompensation] = context.CreateBookmark(new BookmarkCallback(OnCompensation)); Fx.Assert(compensationToken.BookmarkTable[CompensationBookmarkName.OnCancellation] == null, "Bookmark should not be already initialized in the bookmark table."); compensationToken.BookmarkTable[CompensationBookmarkName.OnCancellation] = context.CreateBookmark(new BookmarkCallback(OnCancellation)); var onSecondaryRootScheduled = compensationToken.BookmarkTable[CompensationBookmarkName.OnSecondaryRootScheduled]; Fx.Assert(onSecondaryRootScheduled != null, "onSecondaryRootScheduled bookmark must be already registered."); compensationToken.BookmarkTable[CompensationBookmarkName.OnSecondaryRootScheduled] = null; context.ResumeBookmark(onSecondaryRootScheduled, compensationId); }
protected override void Execute(NativeActivityContext context) { if (this.Activities.Count > 0) { Bookmark bm = context.Properties.Find(Constants._ContainsChildWizard) as Bookmark; if (bm != null) { context.ResumeBookmark(bm, true); } Bookmark parentbm = context.Properties.Find(Constants._ResumeParent) as Bookmark; if (parentbm != null) { this.ResumeParent.Set(context, parentbm); } Bookmark ResumeParent = context.CreateBookmark(ResumeParentCallBack, BookmarkOptions.NonBlocking | BookmarkOptions.MultipleResume); context.Properties.Update(Constants._ResumeParent, ResumeParent); FindStepAndSchedule(context); } }
void ResumeParentCallBack(NativeActivityContext context, Bookmark bookmark, object input) { int current = this.LastIndex.Get(context); Command cmd = (Command)input; current++; Queue <int> currentposition = new Queue <int>(); if (current >= 0 && current < this.Activities.Count) { bool HasBack = (bool)context.Properties.Find(Constants._HasBack); if (!HasBack && current > 0) { context.Properties.Update(Constants._HasBack, true); } bool HasNext = (bool)context.Properties.Find(Constants._HasNext); if (!HasNext && current < this.activities.Count - 1) { context.Properties.Update(Constants._HasNext, true); } currentposition.Enqueue(current); context.Properties.Update(Constants._CurrentPosition, currentposition); ScheduleStep(context, current); } else { Bookmark bm = this.ResumeParent.Get(context); if (bm != null) { context.ResumeBookmark(bm, cmd); } } }
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; } }
void ResumeParentCallBack(NativeActivityContext context, Bookmark bookmark, object input) { int current = this.LastIndex.Get(context); Command cmd = (Command)input; current++; Queue<int> currentposition = new Queue<int>(); if (current >= 0 && current < this.Activities.Count) { bool HasBack = (bool)context.Properties.Find(Constants._HasBack); if (!HasBack && current > 0) context.Properties.Update(Constants._HasBack, true); bool HasNext = (bool)context.Properties.Find(Constants._HasNext); if (!HasNext && current < this.activities.Count - 1) context.Properties.Update(Constants._HasNext, true); currentposition.Enqueue(current); context.Properties.Update(Constants._CurrentPosition, currentposition); ScheduleStep(context, current); } else { Bookmark bm = this.ResumeParent.Get(context); if (bm != null) context.ResumeBookmark(bm, cmd); } }
private void FindStepAndSchedule(NativeActivityContext context) { Queue<int> lastposition = (Queue<int>)context.Properties.Find(Constants._LastPosition); Queue<int> currentposition = (Queue<int>)context.Properties.Find(Constants._CurrentPosition); Command cmd = (Command)context.Properties.Find(Constants._Command); int current = lastposition.Count > 0 ? lastposition.Dequeue() : -1; if (lastposition.Count == 0 && cmd == Command.Next) { current++; } if (current < 0) current = 0; if (current >= 0 && current < this.activities.Count) { bool HasBack = (bool)context.Properties.Find(Constants._HasBack); if (!HasBack && current > 0) context.Properties.Update(Constants._HasBack,true); bool HasNext = (bool)context.Properties.Find(Constants._HasNext); if (!HasNext && current < this.activities.Count-1) context.Properties.Update(Constants._HasNext, true); context.Properties.Update(Constants._LastPosition, lastposition); currentposition.Enqueue(current); context.Properties.Update(Constants._CurrentPosition, currentposition); ScheduleStep(context, current); } else { Bookmark bm = this.ResumeParent.Get(context); if (bm != null) context.ResumeBookmark(bm, cmd); } }
private void ResumeExecutionActionBookmark(PickState pickState, NativeActivityContext context) { context.ResumeBookmark(pickState.ExecuteActionBookmark, null); pickState.ExecuteActionBookmark = null; }
private void OnTriggerCompleted(NativeActivityContext context, System.Activities.ActivityInstance completedInstance) { Pick.PickState state = (Pick.PickState) context.Properties.Find("System.Activities.Statements.Pick.PickState"); if ((completedInstance.State == ActivityInstanceState.Closed) && (state.TriggerCompletionBookmark != null)) { context.ResumeBookmark(state.TriggerCompletionBookmark, context.ActivityInstanceId); state.TriggerCompletionBookmark = null; state.ExecuteActionBookmark = context.CreateBookmark(new BookmarkCallback(this.OnExecuteAction)); } else if (!context.IsCancellationRequested) { context.CreateBookmark(); } }
protected override void Execute(NativeActivityContext context) { Bookmark continueProperty = (Bookmark)context.Properties.Find("ContinueBookmark"); Bookmark willNeverBeResumed = context.CreateBookmark(); var result = context.ResumeBookmark(continueProperty, willNeverBeResumed); }
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 ResumeExecutionActionBookmark(PickState pickState, NativeActivityContext context) { Fx.Assert(pickState.ExecuteActionBookmark != null, "This should have been set by the branch."); context.ResumeBookmark(pickState.ExecuteActionBookmark, null); pickState.ExecuteActionBookmark = null; }
void OnTriggerCompleted(NativeActivityContext context, ActivityInstance completedInstance) { PickState pickState = (PickState)context.Properties.Find(pickStateProperty); if (completedInstance.State == ActivityInstanceState.Closed && pickState.TriggerCompletionBookmark != null) { // We're the first trigger! We win! context.ResumeBookmark(pickState.TriggerCompletionBookmark, context.ActivityInstanceId); pickState.TriggerCompletionBookmark = null; pickState.ExecuteActionBookmark = context.CreateBookmark(new BookmarkCallback(OnExecuteAction)); } else if (!context.IsCancellationRequested) { // We didn't win, but we haven't been requested to cancel yet. // We'll just create a bookmark to keep ourselves from completing. context.CreateBookmark(); } // else // { // No need for an else since default cancelation will cover it! // } }
protected override void Execute(NativeActivityContext context) { CompensationExtension compensationExtension = context.GetExtension<CompensationExtension>(); Fx.Assert(compensationExtension != null, "CompensationExtension must be valid"); long compensationId = this.compensationId.Get(context); Fx.Assert(compensationId != CompensationToken.RootCompensationId, "CompensationId passed to the SecondaryRoot must be valid"); CompensationTokenData compensationToken = compensationExtension.Get(compensationId); Fx.Assert(compensationToken != null, "CompensationTokenData must be valid"); CompensationToken token = new CompensationToken(compensationToken); this.currentCompensationToken.Set(context, token); compensationToken.IsTokenValidInSecondaryRoot = true; context.Properties.Add(CompensationToken.PropertyName, token); Fx.Assert(compensationToken.BookmarkTable[CompensationBookmarkName.OnConfirmation] == null, "Bookmark should not be already initialized in the bookmark table."); compensationToken.BookmarkTable[CompensationBookmarkName.OnConfirmation] = context.CreateBookmark(new BookmarkCallback(OnConfirmation)); Fx.Assert(compensationToken.BookmarkTable[CompensationBookmarkName.OnCompensation] == null, "Bookmark should not be already initialized in the bookmark table."); compensationToken.BookmarkTable[CompensationBookmarkName.OnCompensation] = context.CreateBookmark(new BookmarkCallback(OnCompensation)); Fx.Assert(compensationToken.BookmarkTable[CompensationBookmarkName.OnCancellation] == null, "Bookmark should not be already initialized in the bookmark table."); compensationToken.BookmarkTable[CompensationBookmarkName.OnCancellation] = context.CreateBookmark(new BookmarkCallback(OnCancellation)); Bookmark onSecondaryRootScheduled = compensationToken.BookmarkTable[CompensationBookmarkName.OnSecondaryRootScheduled]; Fx.Assert(onSecondaryRootScheduled != null, "onSecondaryRootScheduled bookmark must be already registered."); compensationToken.BookmarkTable[CompensationBookmarkName.OnSecondaryRootScheduled] = null; context.ResumeBookmark(onSecondaryRootScheduled, compensationId); }