public Bookmark CreateBookmark(BookmarkCallback callback, System.Activities.ActivityInstance owningInstance, BookmarkOptions options)
{
Bookmark bookmark = Bookmark.Create(this.GetNextBookmarkId());
this.AddBookmark(bookmark, callback, owningInstance, options);
this.UpdateAllExclusiveHandles(bookmark, owningInstance);
return bookmark;
}
public BookmarkCallbackWrapper(BookmarkCallback callback, ActivityInstance owningInstance, BookmarkOptions bookmarkOptions)
: base(callback, owningInstance)
{
Fx.Assert(callback != null || bookmarkOptions == BookmarkOptions.None, "Either we have a callback or we only allow SingleFire, Blocking bookmarks.");
this.Options = bookmarkOptions;
}
public BookmarkCallbackWrapper(BookmarkCallback callback, ActivityInstance owningInstance, BookmarkOptions bookmarkOptions)
: base(callback, owningInstance)
{
Fx.Assert(callback != null || bookmarkOptions == BookmarkOptions.None, "Either we have a callback or we only allow SingleFire, Blocking bookmarks.");
this.Options = bookmarkOptions;
}
public void Invoke(NativeActivityContext context, Bookmark bookmark, object value)
{
EnsureCallback(bookmarkCallbackType, bookmarkCallbackParameters);
BookmarkCallback bookmarkCallback = (BookmarkCallback)this.Callback;
bookmarkCallback(context, bookmark, value);
}
// Token: 0x06001664 RID: 5732 RVA: 0x0002762B File Offset: 0x0002662B
public Bookmark(string name, BookmarkCallback bookmarkCallback, BookmarkOptions options, ActivityExecutionContext context)
{
this.name = name;
this.bookmarkCallback = bookmarkCallback;
this.options = options;
this.context = context;
}
public InternalState(State state)
{
this.state = state;
this.DisplayName = state.DisplayName;
this.onEntryComplete = new CompletionCallback(OnEntryComplete);
this.onTriggerComplete = new CompletionCallback(OnTriggerComplete);
this.onConditionComplete = new CompletionCallback <bool>(OnConditionComplete);
this.onExitComplete = new CompletionCallback(OnExitComplete);
this.onChildStateComplete = new CompletionCallback <string>(OnChildStateComplete);
this.completeStateCallback = new BookmarkCallback(CompleteState);
this.evaluateConditionCallback = new BookmarkCallback(StartEvaluateCondition);
this.currentRunningTriggers = new Variable <int>();
this.hasRunningChildState = new Variable <bool>();
this.isExiting = new Variable <bool>();
this.evaluateConditionBookmark = new Variable <Bookmark>();
this.completeStateBookmark = new Variable <Bookmark>();
this.internalStates = new Collection <InternalState>();
this.internalTransitions = new Collection <InternalTransition>();
this.internalStateFuncs = new Collection <ActivityFunc <string, StateMachineEventManager, string> >();
this.triggerInternalTransitionMapping = new Dictionary <Activity, InternalTransition>();
}
private void CompleteTransactionCore(NativeActivityContext context, BookmarkCallback callback)
{
context.ThrowIfDisposed();
if (this.rootTransaction != null)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.CannotCompleteRuntimeOwnedTransaction));
}
if (!context.HasRuntimeTransaction)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.NoRuntimeTransactionExists));
}
if (!this.isHandleInitialized)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.UnInitializedRuntimeTransactionHandle));
}
if (this.SuppressTransaction)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.RuntimeTransactionIsSuppressed));
}
context.CompleteTransaction(this, callback);
}
internal void SetupWorkflowCompensationBehavior(NativeActivityContext context, BookmarkCallback callback, Activity workflowCompensationBehavior)
{
this.WorkflowCompensationScheduled = context.CreateBookmark(callback);
context.ScheduleSecondaryRoot(workflowCompensationBehavior, null);
this.Add(0L, new CompensationTokenData(0L, 0L));
this.IsWorkflowCompensationBehaviorScheduled = true;
}
public void Invoke(NativeActivityContext context, System.Activities.Bookmark bookmark, object value)
{
base.EnsureCallback(bookmarkCallbackType, bookmarkCallbackParameters);
BookmarkCallback callback = (BookmarkCallback)base.Callback;
callback(context, bookmark, value);
}
public void CompleteTransaction(NativeActivityContext context, BookmarkCallback callback)
{
if (callback == null)
{
throw FxTrace.Exception.ArgumentNull("callback");
}
this.CompleteTransactionCore(context, callback);
}
public void CompleteTransaction(NativeActivityContext context, BookmarkCallback callback)
{
if (callback == null)
{
throw FxTrace.Exception.ArgumentNull("callback");
}
this.CompleteTransactionCore(context, callback);
}
public Bookmark CreateBookmark(BookmarkCallback callback, System.Activities.ActivityInstance owningInstance, BookmarkOptions options)
{
Bookmark bookmark = Bookmark.Create(this.GetNextBookmarkId());
this.AddBookmark(bookmark, callback, owningInstance, options);
this.UpdateAllExclusiveHandles(bookmark, owningInstance);
return(bookmark);
}
// Token: 0x06001651 RID: 5713 RVA: 0x00027208 File Offset: 0x00026208
public Bookmark CreateNamedBookmark(string name, BookmarkCallback callback, BookmarkOptions options)
{
Bookmark bookmark = new Bookmark(name, callback, options, this);
bookmark.Closed += this.OnBookmarkClosed;
this.bookmarks.Add(bookmark);
return(bookmark);
}
public ReceiveFileChanges()
{
this.noPersistHandle = new Variable <NoPersistHandle>();
this.receiveCompleteBookmark = new Variable <Bookmark>()
{
Name = "ReceiveBookmark"
};
this.receiveCompleteCallback = new BookmarkCallback(this.OnReceiveNotification);
}
public FolderWatcher()
{
// create the variables to hold the NoPersistHandle and Bookmark
this.noPersistHandle = new Variable <NoPersistHandle>();
this.bookmarkWatcher = new Variable <Bookmark>();
this.bookmarkCallback = new BookmarkCallback(OnFileWatcherCallback);
this.WatchSubfolders = false;
}
public static Bookmark CreateBookmark(this NativeActivityContext context, WaitForTaskAction action, BookmarkCallback callback)
{
using (StringWriter writer = new StringWriter())
{
SERIALIZER.Serialize(writer, action);
return context.CreateBookmark(writer.ToString(), callback);
}
}
public InteropEnvironment(InteropExecutor interopExecutor, NativeActivityContext nativeActivityContext, BookmarkCallback bookmarkCallback, Interop activity, Transaction transaction)
{
this.executor = interopExecutor;
this.nativeActivityContext = nativeActivityContext;
this.Activity = activity;
this.executor.ServiceProvider = this;
this.bookmarkCallback = bookmarkCallback;
this.transaction = transaction;
this.OnEnter();
}
public InteropEnvironment(InteropExecutor interopExecutor, NativeActivityContext nativeActivityContext, BookmarkCallback bookmarkCallback, Interop activity, Transaction transaction)
{
this.executor = interopExecutor;
this.nativeActivityContext = nativeActivityContext;
this.Activity = activity;
this.executor.ServiceProvider = this;
this.bookmarkCallback = bookmarkCallback;
this.transaction = transaction;
this.OnEnter();
}
public Bookmark CreateBookmark(string name, BookmarkCallback callback, System.Activities.ActivityInstance owningInstance, BookmarkOptions options)
{
Bookmark key = new Bookmark(name);
if ((this.bookmarks != null) && this.bookmarks.ContainsKey(key))
{
throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.BookmarkAlreadyExists(name)));
}
this.AddBookmark(key, callback, owningInstance, options);
this.UpdateAllExclusiveHandles(key, owningInstance);
return key;
}
public FileCopy()
{
// add the validation to the list of validations for this activity
this.Constraints.Add(ConstraintHelper.VerifiyNoChildPersistActivity <FileCopy>());
// create the variables to hold the NoPersistHandle and Bookmark
this.noPersistHandle = new Variable <NoPersistHandle>();
this.bookmarkProgress = new Variable <Bookmark>();
this.bookmarkProgressCallback = new BookmarkCallback(OnExtensionProgress);
this.StepIncrement = 1;
}
protected override void Execute(NativeActivityContext context)
{
if (context.IsInNoPersistScope)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.CannotPersistInsideNoPersist));
}
if (onPersistCompleteCallback == null)
{
onPersistCompleteCallback = new BookmarkCallback(Persist.OnPersistComplete);
}
context.RequestPersist(onPersistCompleteCallback);
}
public Bookmark CreateBookmark(string name, BookmarkCallback callback, System.Activities.ActivityInstance owningInstance, BookmarkOptions options)
{
Bookmark key = new Bookmark(name);
if ((this.bookmarks != null) && this.bookmarks.ContainsKey(key))
{
throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.BookmarkAlreadyExists(name)));
}
this.AddBookmark(key, callback, owningInstance, options);
this.UpdateAllExclusiveHandles(key, owningInstance);
return(key);
}
protected override void Execute(NativeActivityContext context)
{
if (context.IsInNoPersistScope)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.CannotPersistInsideNoPersist));
}
if (onPersistCompleteCallback == null)
{
onPersistCompleteCallback = new BookmarkCallback(Persist.OnPersistComplete);
}
context.RequestPersist(onPersistCompleteCallback);
}
public Bookmark CreateBookmark(BookmarkCallback callback, ActivityInstance owningInstance, BookmarkOptions options)
{
Fx.Assert(this.scope == null, "We only support named bookmarks within bookmark scopes right now.");
Bookmark bookmark = Bookmark.Create(GetNextBookmarkId());
AddBookmark(bookmark, callback, owningInstance, options);
//Regular bookmarks are never important
UpdateAllExclusiveHandles(bookmark, owningInstance);
return(bookmark);
}
public FileCopy()
{
// add the validation to the list of validations for this activity
this.Constraints.Add(ConstraintHelper.VerifiyNoChildPersistActivity<FileCopy>());
// create the variables to hold the NoPersistHandle and Bookmark
this.noPersistHandle = new Variable<NoPersistHandle>();
this.bookmarkProgress = new Variable<Bookmark>();
this.bookmarkProgressCallback = new BookmarkCallback(OnExtensionProgress);
this.StepIncrement = 1;
}
/// <summary>
/// Creates a bookmark name for the given callback.
/// </summary>
/// <param name="context"></param>
/// <param name="callback"></param>
/// <returns></returns>
public static string CreateTwilioBookmarkName(this NativeActivityContext context, BookmarkCallback callback)
{
var activity = callback.Target as Activity;
if (activity == null)
throw new ArgumentException("Callback must be instance method of Activity.");
return string.Format("{0}_{1}_{2}_{3}",
activity.Id,
activity.DisplayName,
callback.Method.Name,
Math.Abs(Guid.NewGuid().GetHashCode()));
}
protected override void Execute(NativeActivityContext context)
{
if (context.IsInNoPersistScope)
{
throw Microsoft.CoreWf.Internals.FxTrace.Exception.AsError(new InvalidOperationException(SR.CannotPersistInsideNoPersist));
}
if (s_onPersistCompleteCallback == null)
{
s_onPersistCompleteCallback = new BookmarkCallback(OnPersistComplete);
}
context.RequestPersist(s_onPersistCompleteCallback);
}
public Bookmark CreateBookmark(string name, BookmarkScope scope, BookmarkCallback callback, System.Activities.ActivityInstance owningInstance, BookmarkOptions options)
{
BookmarkManager manager = null;
BookmarkScope key = scope;
if (scope.IsDefault)
{
key = this.defaultScope;
}
if (!this.bookmarkManagers.TryGetValue(key, out manager))
{
throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.RegisteredBookmarkScopeRequired));
}
return(manager.CreateBookmark(name, callback, owningInstance, options));
}
public Bookmark CreateBookmark(string name, BookmarkCallback callback, ActivityInstance owningInstance, BookmarkOptions options)
{
Bookmark toAdd = new Bookmark(name);
if (this.bookmarks != null && this.bookmarks.ContainsKey(toAdd))
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.BookmarkAlreadyExists(name)));
}
AddBookmark(toAdd, callback, owningInstance, options);
//Regular bookmarks are never important
UpdateAllExclusiveHandles(toAdd, owningInstance);
return(toAdd);
}
public InternalState(System.Activities.Statements.State state)
{
this.state = state;
base.DisplayName = state.DisplayName;
this.onEntryComplete = new CompletionCallback(this.OnEntryComplete);
this.onTriggerComplete = new CompletionCallback(this.OnTriggerComplete);
this.onConditionComplete = new CompletionCallback <bool>(this.OnConditionComplete);
this.onExitComplete = new CompletionCallback(this.OnExitComplete);
this.evaluateConditionCallback = new BookmarkCallback(this.StartEvaluateCondition);
this.currentRunningTriggers = new Variable <int>();
this.isExiting = new Variable <bool>();
this.evaluateConditionBookmark = new Variable <Bookmark>();
this.internalTransitions = new Collection <InternalTransition>();
this.triggerInternalTransitionMapping = new Dictionary <Activity, InternalTransition>();
}
public Bookmark CreateBookmark(string name, BookmarkCallback callback, ActivityInstance owningInstance, BookmarkOptions options)
{
Bookmark toAdd = new Bookmark(name);
if (this.bookmarks != null && this.bookmarks.ContainsKey(toAdd))
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.BookmarkAlreadyExists(name)));
}
AddBookmark(toAdd, callback, owningInstance, options);
//Regular bookmarks are never important
UpdateAllExclusiveHandles(toAdd, owningInstance);
return toAdd;
}
private void AddBookmark(Bookmark bookmark, BookmarkCallback callback, System.Activities.ActivityInstance owningInstance, BookmarkOptions options)
{
if (this.bookmarks == null)
{
this.bookmarks = new Dictionary<Bookmark, BookmarkCallbackWrapper>(Bookmark.Comparer);
}
bookmark.Scope = this.scope;
BookmarkCallbackWrapper wrapper = new BookmarkCallbackWrapper(callback, owningInstance, options) {
Bookmark = bookmark
};
this.bookmarks.Add(bookmark, wrapper);
owningInstance.AddBookmark(bookmark, options);
if (TD.CreateBookmarkIsEnabled())
{
TD.CreateBookmark(owningInstance.Activity.GetType().ToString(), owningInstance.Activity.DisplayName, owningInstance.Id, ActivityUtilities.GetTraceString(bookmark), ActivityUtilities.GetTraceString(bookmark.Scope));
}
}
public Bookmark CreateBookmark(string name, BookmarkScope scope, BookmarkCallback callback, ActivityInstance owningInstance, BookmarkOptions options)
{
Fx.Assert(scope != null, "We should never have a null scope.");
var lookupScope = scope;
if (scope.IsDefault)
{
lookupScope = this.defaultScope;
}
if (!this.bookmarkManagers.TryGetValue(lookupScope, out var manager))
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.RegisteredBookmarkScopeRequired));
}
return(manager.CreateBookmark(name, callback, owningInstance, options));
}
private void AddBookmark(Bookmark bookmark, BookmarkCallback callback, System.Activities.ActivityInstance owningInstance, BookmarkOptions options)
{
if (this.bookmarks == null)
{
this.bookmarks = new Dictionary <Bookmark, BookmarkCallbackWrapper>(Bookmark.Comparer);
}
bookmark.Scope = this.scope;
BookmarkCallbackWrapper wrapper = new BookmarkCallbackWrapper(callback, owningInstance, options)
{
Bookmark = bookmark
};
this.bookmarks.Add(bookmark, wrapper);
owningInstance.AddBookmark(bookmark, options);
if (TD.CreateBookmarkIsEnabled())
{
TD.CreateBookmark(owningInstance.Activity.GetType().ToString(), owningInstance.Activity.DisplayName, owningInstance.Id, ActivityUtilities.GetTraceString(bookmark), ActivityUtilities.GetTraceString(bookmark.Scope));
}
}
protected override void Execute(NativeActivityContext executionContext)
{
CorrelationRequestContext context;
CorrelationHandle handle = (this.CorrelatesWith == null) ? null : this.CorrelatesWith.Get(executionContext);
bool flag = false;
CorrelationHandle ambientCorrelation = null;
if (handle == null)
{
ambientCorrelation = executionContext.Properties.Find(CorrelationHandle.StaticExecutionPropertyName) as CorrelationHandle;
flag = true;
if (ambientCorrelation != null)
{
handle = ambientCorrelation;
}
}
if ((handle != null) && handle.TryAcquireRequestContext(executionContext, out context))
{
ReceiveMessageInstanceData instance = new ReceiveMessageInstanceData(context);
if (flag)
{
instance.SetAmbientCorrelation(ambientCorrelation);
}
this.ClientScheduleOnReceivedMessage(executionContext, instance);
}
else
{
if (ambientCorrelation == null)
{
ambientCorrelation = executionContext.Properties.Find(CorrelationHandle.StaticExecutionPropertyName) as CorrelationHandle;
}
if ((!this.IsOneWay && (ambientCorrelation == null)) && (CorrelationHandle.GetExplicitChannelCorrelation(executionContext, this.correlationInitializers) == null))
{
throw System.ServiceModel.Activities.FxTrace.Exception.AsError(new InvalidOperationException(System.ServiceModel.Activities.SR.ReceiveMessageNeedsToPairWithSendMessageForTwoWayContract(this.OperationName)));
}
BookmarkScope scope = (handle != null) ? handle.EnsureBookmarkScope(executionContext) : executionContext.DefaultBookmarkScope;
if (this.onMessageBookmarkCallback == null)
{
this.onMessageBookmarkCallback = new BookmarkCallback(this.OnMessage);
}
executionContext.CreateBookmark(this.OperationBookmarkName, this.onMessageBookmarkCallback, scope);
}
}
private void CompleteTransactionCore(NativeActivityContext context, BookmarkCallback callback)
{
context.ThrowIfDisposed();
if (this.rootTransaction != null)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.CannotCompleteRuntimeOwnedTransaction));
}
if (!context.HasRuntimeTransaction)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.NoRuntimeTransactionExists));
}
if (!this.isHandleInitialized)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.UnInitializedRuntimeTransactionHandle));
}
if (this.SuppressTransaction)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.RuntimeTransactionIsSuppressed));
}
context.CompleteTransaction(this, callback);
}
public void Execute(NativeActivityContext context
, Func <NativeActivityContext, CancellationToken, Task <Action <NativeActivityContext> > > onExecute
, BookmarkCallback callback)
{
_noPersistHandle.Get(context).Enter(context);
Bookmark bookmark = context.CreateBookmark(callback);
BookmarkResumptionHelper bookmarkHelper = context.GetExtension <BookmarkResumptionHelper>();
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
_cancellationTokenSource.Set(context, cancellationTokenSource);
_bookmarkResumed.Set(context, false);
// TODO: Review the continuation.
onExecute(context, cancellationTokenSource.Token).ContinueWith(t =>
{
// We resume the bookmark only if the activity wasn't
// cancelled since the cancellation removes any bookmarks.
if (cancellationTokenSource.IsCancellationRequested == false)
{
object executionResult = null;
if (t.IsFaulted)
{
executionResult = t.Exception.InnerException;
}
else
{
executionResult = t.Result;
}
bookmarkHelper.ResumeBookmark(bookmark, executionResult);
}
});
}
internal void SetupWorkflowCompensationBehavior(NativeActivityContext context, BookmarkCallback callback, Activity workflowCompensationBehavior)
{
this.WorkflowCompensationScheduled = context.CreateBookmark(callback);
Fx.Assert(workflowCompensationBehavior != null, "WorkflowCompensationBehavior must be valid");
context.ScheduleSecondaryRoot(workflowCompensationBehavior, null);
// Add the root compensationToken to track all root CA execution order.
this.Add(CompensationToken.RootCompensationId, new CompensationTokenData(CompensationToken.RootCompensationId, CompensationToken.RootCompensationId));
this.IsWorkflowCompensationBehaviorScheduled = true;
}
public Bookmark CreateBookmark(string name, BookmarkScope scope, BookmarkCallback callback, ActivityInstance owningInstance, BookmarkOptions options)
{
Fx.Assert(scope != null, "We should never have a null scope.");
BookmarkManager manager = null;
BookmarkScope lookupScope = scope;
if (scope.IsDefault)
{
lookupScope = this.defaultScope;
}
if (!this.bookmarkManagers.TryGetValue(lookupScope, out manager))
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.RegisteredBookmarkScopeRequired));
}
return manager.CreateBookmark(name, callback, owningInstance, options);
}
/// <summary>
/// Creates a point at which an activity can be resumed.
/// </summary>
/// <param name="context"></param>
/// <param name="callback"></param>
/// <returns></returns>
public static Bookmark CreateTwilioBookmark(this NativeActivityContext context, BookmarkCallback callback)
{
return(context.CreateBookmark(CreateTwilioBookmarkName(context, callback), callback));
}
public BookmarkCallbackWrapper(BookmarkCallback callback, ActivityInstance owningInstance)
: this(callback, owningInstance, BookmarkOptions.None)
{
}
public void CompleteTransaction (NativeActivityContext context, BookmarkCallback callback)
{
throw new NotImplementedException ();
}
public void CompleteTransaction(NativeActivityContext context, BookmarkCallback callback)
{
throw new NotImplementedException();
}
/// <summary>
/// Creates a point at which an activity can be resumed.
/// </summary>
/// <param name="context"></param>
/// <param name="callback"></param>
/// <returns></returns>
public static Bookmark CreateTwilioBookmark(this NativeActivityContext context, BookmarkCallback callback)
{
return context.CreateBookmark(CreateTwilioBookmarkName(context, callback), callback);
}
// Activity Entry point: Phase 1: Execute
// A separate code-path for extension based execution least impacts
// the existing workflow hosts. In the future we will add an extension from
// workflowservicehost and always use the extension.
protected override void Execute(NativeActivityContext executionContext)
{
SendReceiveExtension sendReceiveExtension = executionContext.GetExtension<SendReceiveExtension>();
if (sendReceiveExtension != null)
{
this.ExecuteUsingExtension(sendReceiveExtension, executionContext);
}
else
{
// this activity's runtime DU particpation(UpdateInstance) is dependent on
// the following server side logic for resolving CorrelationHandle and creating a protocol bookmark.
CorrelationHandle followingCorrelation = (this.CorrelatesWith == null) ? null : this.CorrelatesWith.Get(executionContext);
bool triedAmbientCorrelation = false;
CorrelationHandle ambientCorrelation = null;
if (followingCorrelation == null)
{
ambientCorrelation = executionContext.Properties.Find(CorrelationHandle.StaticExecutionPropertyName) as CorrelationHandle;
triedAmbientCorrelation = true;
if (ambientCorrelation != null)
{
followingCorrelation = ambientCorrelation;
}
}
CorrelationRequestContext requestContext;
if (followingCorrelation != null && followingCorrelation.TryAcquireRequestContext(executionContext, out requestContext))
{
// Client receive that is following a send.
ReceiveMessageInstanceData instance = new ReceiveMessageInstanceData(requestContext);
// for perf, cache the ambient correlation information
if (triedAmbientCorrelation)
{
instance.SetAmbientCorrelation(ambientCorrelation);
}
ClientScheduleOnReceivedMessage(executionContext, instance);
}
else
{
// Server side receive
// Validation of correlatesWithHandle
if (ambientCorrelation == null)
{
ambientCorrelation = executionContext.Properties.Find(CorrelationHandle.StaticExecutionPropertyName) as CorrelationHandle;
}
if (!this.IsOneWay && ambientCorrelation == null)
{
CorrelationHandle channelCorrelationHandle = CorrelationHandle.GetExplicitRequestReplyCorrelation(executionContext, this.correlationInitializers);
if (channelCorrelationHandle == null)
{
// With a two-way contract, we require a request/reply correlation handle
throw FxTrace.Exception.AsError(new InvalidOperationException(
SR2.ReceiveMessageNeedsToPairWithSendMessageForTwoWayContract(this.OperationName)));
}
}
BookmarkScope bookmarkScope = (followingCorrelation != null) ? followingCorrelation.EnsureBookmarkScope(executionContext) : executionContext.DefaultBookmarkScope;
if (this.onMessageBookmarkCallback == null)
{
this.onMessageBookmarkCallback = new BookmarkCallback(this.OnMessage);
}
executionContext.CreateBookmark(this.OperationBookmarkName, this.onMessageBookmarkCallback, bookmarkScope);
}
}
}
internal void SetupWorkflowCompensationBehavior(NativeActivityContext context, BookmarkCallback callback, Activity workflowCompensationBehavior)
{
this.WorkflowCompensationScheduled = context.CreateBookmark(callback);
context.ScheduleSecondaryRoot(workflowCompensationBehavior, null);
this.Add(0L, new CompensationTokenData(0L, 0L));
this.IsWorkflowCompensationBehaviorScheduled = true;
}
public BookmarkCallbackWrapper(BookmarkCallback callback, ActivityInstance owningInstance)
: this(callback, owningInstance, BookmarkOptions.None)
{
}
// Token: 0x06001650 RID: 5712 RVA: 0x000271FC File Offset: 0x000261FC
public Bookmark CreateNamedBookmark(string name, BookmarkCallback callback)
{
return(this.CreateNamedBookmark(name, callback, BookmarkOptions.SingleResume));
}
internal void SetupWorkflowCompensationBehavior(NativeActivityContext context, BookmarkCallback callback, Activity workflowCompensationBehavior)
{
this.WorkflowCompensationScheduled = context.CreateBookmark(callback);
Fx.Assert(workflowCompensationBehavior != null, "WorkflowCompensationBehavior must be valid");
context.ScheduleSecondaryRoot(workflowCompensationBehavior, null);
// Add the root compensationToken to track all root CA execution order.
this.Add(CompensationToken.RootCompensationId, new CompensationTokenData(CompensationToken.RootCompensationId, CompensationToken.RootCompensationId));
this.IsWorkflowCompensationBehaviorScheduled = true;
}
public Bookmark CreateBookmark(BookmarkCallback callback, ActivityInstance owningInstance, BookmarkOptions options)
{
Fx.Assert(this.scope == null, "We only support named bookmarks within bookmark scopes right now.");
Bookmark bookmark = Bookmark.Create(GetNextBookmarkId());
AddBookmark(bookmark, callback, owningInstance, options);
//Regular bookmarks are never important
UpdateAllExclusiveHandles(bookmark, owningInstance);
return bookmark;
}
