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;
}
}
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 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);
}
}
private void ResumeExecutionActionBookmark(PickState pickState, NativeActivityContext context)
{
context.ResumeBookmark(pickState.ExecuteActionBookmark, null);
pickState.ExecuteActionBookmark = null;
}
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);
}