public override bool Execute(ActivityExecutor executor, BookmarkManager bookmarkManager)
{
NativeActivityContext nativeContext = executor.NativeActivityContextPool.Acquire();
try
{
nativeContext.Initialize(this.ActivityInstance, executor, bookmarkManager);
this.callbackWrapper.Invoke(nativeContext, this.bookmark, this.state);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
this.ExceptionToPropagate = e;
}
finally
{
nativeContext.Dispose();
executor.NativeActivityContextPool.Release(nativeContext);
}
return true;
}
public override bool Execute(ActivityExecutor executor, BookmarkManager bookmarkManager)
{
NativeActivityFaultContext faultContext = null;
try
{
faultContext = new NativeActivityFaultContext(base.ActivityInstance, executor, bookmarkManager, this.propagatedException, this.originalExceptionSource);
this.callbackWrapper.Invoke(faultContext, this.propagatedException, this.propagatedFrom);
if (!faultContext.IsFaultHandled)
{
base.SetExceptionToPropagateWithoutAbort(this.propagatedException);
}
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
base.ExceptionToPropagate = exception;
}
finally
{
if (faultContext != null)
{
faultContext.Dispose();
}
}
return true;
}
internal sealed override void InternalExecute(System.Activities.ActivityInstance instance, ActivityExecutor executor, BookmarkManager bookmarkManager)
{
AsyncOperationContext asyncContext = executor.SetupAsyncOperationBlock(instance);
instance.IncrementBusyCount();
AsyncCodeActivityContext context = new AsyncCodeActivityContext(asyncContext, instance, executor);
bool flag = false;
try
{
IAsyncResult result = this.BeginExecute(context, OnExecuteComplete, asyncContext);
if (result == null)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.BeginExecuteMustNotReturnANullAsyncResult));
}
if (!object.ReferenceEquals(result.AsyncState, asyncContext))
{
throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.BeginExecuteMustUseProvidedStateAsAsyncResultState));
}
if (result.CompletedSynchronously)
{
this.EndExecute(context, result);
asyncContext.CompleteOperation();
}
flag = true;
}
finally
{
context.Dispose();
if (!flag)
{
asyncContext.CancelOperation();
}
}
}
internal WorkflowDataContext(ActivityExecutor executor, ActivityInstance activityInstance, bool includeLocalVariables)
{
this.executor = executor;
this.activityInstance = activityInstance;
this.IncludesLocalVariables = includeLocalVariables;
this.properties = CreateProperties();
}
internal override void InternalAbort(System.Activities.ActivityInstance instance, ActivityExecutor executor, Exception terminationReason)
{
using (NativeActivityAbortContext context = new NativeActivityAbortContext(instance, executor, terminationReason))
{
this.Abort(context);
}
}
internal override void InternalExecute(System.Activities.ActivityInstance instance, ActivityExecutor executor, BookmarkManager bookmarkManager)
{
if (this.runtimeImplementation != null)
{
executor.ScheduleActivity(this.runtimeImplementation, instance, null, null, null);
}
}
internal WorkItem CreateWorkItem(ActivityInstance completedInstance, ActivityExecutor executor)
{
// We use the property to guard against the virtual method call
// since we don't need it in the common case
if (this.NeedsToGatherOutputs)
{
this.GatherOutputs(completedInstance);
}
CompletionWorkItem workItem;
if (this.checkForCancelation)
{
workItem = new CompletionWithCancelationCheckWorkItem(this, completedInstance);
}
else
{
workItem = executor.CompletionWorkItemPool.Acquire();
workItem.Initialize(this, completedInstance);
}
if (completedInstance.InstanceMap != null)
{
completedInstance.InstanceMap.AddEntry(workItem);
}
return workItem;
}
protected override void ReleaseToPool(ActivityExecutor executor)
{
base.ClearForReuse();
this.nextArgumentIndex = 0;
this.resultLocation = null;
this.argumentValueOverrides = null;
executor.ResolveNextArgumentWorkItemPool.Release(this);
}
public override void PostProcess(ActivityExecutor executor)
{
if ((this.completedInstance.State != ActivityInstanceState.Closed) && base.ActivityInstance.IsPerformingDefaultCancelation)
{
base.ActivityInstance.MarkCanceled();
}
base.PostProcess(executor);
}
public override bool Execute(ActivityExecutor executor, BookmarkManager bookmarkManager)
{
if ((base.CompletedInstance.State != ActivityInstanceState.Closed) && base.ActivityInstance.IsPerformingDefaultCancelation)
{
base.ActivityInstance.MarkCanceled();
}
return base.Execute(executor, bookmarkManager);
}
public BookmarkWorkItem(ActivityExecutor executor, bool isExternal, BookmarkCallbackWrapper callbackWrapper, Bookmark bookmark, object value)
: this(callbackWrapper, bookmark, value)
{
if (isExternal)
{
executor.EnterNoPersist();
this.ExitNoPersistRequired = true;
}
}
internal NativeActivityFaultContext(ActivityInstance executingActivityInstance,
ActivityExecutor executor, BookmarkManager bookmarkManager, Exception exception, ActivityInstanceReference source)
: base(executingActivityInstance, executor, bookmarkManager)
{
Fx.Assert(exception != null, "There must be an exception.");
Fx.Assert(source != null, "There must be a source.");
this.exception = exception;
this.source = source;
}
public ActivityExecutionWorkItem CreateWorkItem(ActivityExecutor executor, bool isExternal, Bookmark bookmark, object value)
{
if (this.IsCallbackNull)
{
return executor.CreateEmptyWorkItem(this.ActivityInstance);
}
else
{
return new BookmarkWorkItem(executor, isExternal, this, bookmark, value);
}
}
public void Dispose(ActivityExecutor executor)
{
if (FxTrace.ShouldTraceVerboseToTraceSource)
{
this.TraceCompleted();
}
if (this.IsPooled)
{
this.ReleaseToPool(executor);
}
}
internal sealed override void InternalCancel(System.Activities.ActivityInstance instance, ActivityExecutor executor, BookmarkManager bookmarkManager)
{
AsyncOperationContext context;
if (executor.TryGetPendingOperation(instance, out context))
{
using (AsyncCodeActivityContext context2 = new AsyncCodeActivityContext(context, instance, executor))
{
context.HasCalledAsyncCodeActivityCancel = true;
this.Cancel(context2);
}
}
}
internal override void InternalCancel(System.Activities.ActivityInstance instance, ActivityExecutor executor, BookmarkManager bookmarkManager)
{
NativeActivityContext context = executor.NativeActivityContextPool.Acquire();
try
{
context.Initialize(instance, executor, bookmarkManager);
this.Cancel(context);
}
finally
{
context.Dispose();
executor.NativeActivityContextPool.Release(context);
}
}
internal sealed override void InternalExecute(System.Activities.ActivityInstance instance, ActivityExecutor executor, BookmarkManager bookmarkManager)
{
CodeActivityContext context = executor.CodeActivityContextPool.Acquire();
try
{
context.Initialize(instance, executor);
this.Execute(context);
}
finally
{
context.Dispose();
executor.CodeActivityContextPool.Release(context);
}
}
public override void PostProcess(ActivityExecutor executor)
{
if ((base.ExceptionToPropagate != null) && !this.skipActivityInstanceAbort)
{
executor.AbortActivityInstance(base.ActivityInstance, base.ExceptionToPropagate);
}
else if (base.ActivityInstance.UpdateState(executor))
{
Exception exception = executor.CompleteActivityInstance(base.ActivityInstance);
if (exception != null)
{
base.ExceptionToPropagate = exception;
}
}
}
public void ClearAllWorkItems(ActivityExecutor executor)
{
if (this.firstWorkItem != null)
{
this.firstWorkItem.Release(executor);
this.firstWorkItem = null;
if (this.workItemQueue != null)
{
while (this.workItemQueue.Count > 0)
{
this.workItemQueue.Dequeue().Release(executor);
}
}
}
this.workItemQueue = null;
}
public WorkItem GenerateWorkItem(ActivityInstance completedInstance, ActivityExecutor executor)
{
if (this.callbackWrapper != null)
{
return this.callbackWrapper.CreateWorkItem(completedInstance, executor);
}
else
{
// Variable defaults and argument expressions always have a parent
// and never have a CompletionBookmark
if (completedInstance.State != ActivityInstanceState.Closed && completedInstance.Parent.HasNotExecuted)
{
completedInstance.Parent.SetInitializationIncomplete();
}
return new EmptyWithCancelationCheckWorkItem(completedInstance.Parent, completedInstance);
}
}
public override void PostProcess(ActivityExecutor executor)
{
if (this.ExceptionToPropagate != null && !skipActivityInstanceAbort)
{
executor.AbortActivityInstance(this.ActivityInstance, this.ExceptionToPropagate);
}
else if (this.ActivityInstance.UpdateState(executor))
{
// NOTE: exceptionToPropagate could be non-null here if this is a Fault work item.
// That means that the next line could potentially overwrite the exception with a
// new exception.
Exception newException = executor.CompleteActivityInstance(this.ActivityInstance);
if (newException != null)
{
this.ExceptionToPropagate = newException;
}
}
}
public void RunMirrorDelete()
{
var code = @"
using System;
namespace MyModels
{
public class student
{
public string id {get;set;}
public student_data data { get; set; }
}
public class student_data
{
public string name {get;set;}
public int age {get;set;}
}
}
";
var assemblyName = "t_123_v_1.1";
var wellKnownTypeContainer = new WellKnownTypeContainer();
var typeContainer = new TypeContainer(wellKnownTypeContainer);
var assembly = DynamicModelLoader.Load(assemblyName, code);
foreach (var type in assembly.GetTypes())
{
typeContainer.Add(type);
}
var descriptorContainer = new DescriptorContainer(new WellKnownDescriptorContainer());
descriptorContainer.Add(new MirrorDeleteDescriptor());
var customActivityParser = new CustomActivityParser(descriptorContainer, typeContainer);
var definition = LoadDefinition("mirrorDelete");
var activity = customActivityParser.Parse(JsonSerializer.Deserialize <JsonElement>(definition));
var compiler = new ActivityCompiler(typeContainer);
compiler.Compile("nnn", "mmmm", activity);
var executor = new ActivityExecutor(null);
executor.Run(activity);
}
sealed internal override void InternalExecute(ActivityInstance instance, ActivityExecutor executor, BookmarkManager bookmarkManager)
{
// first set up an async context
AsyncOperationContext asyncContext = executor.SetupAsyncOperationBlock(instance);
instance.IncrementBusyCount();
AsyncCodeActivityContext context = new AsyncCodeActivityContext(asyncContext, instance, executor);
bool success = false;
try
{
IAsyncResult result = BeginExecute(context, AsyncCodeActivity.OnExecuteComplete, asyncContext);
if (result == null)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.BeginExecuteMustNotReturnANullAsyncResult));
}
if (!object.ReferenceEquals(result.AsyncState, asyncContext))
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.BeginExecuteMustUseProvidedStateAsAsyncResultState));
}
if (result.CompletedSynchronously)
{
EndExecute(context, result);
asyncContext.CompleteOperation();
}
success = true;
}
finally
{
context.Dispose();
if (!success)
{
asyncContext.CancelOperation();
}
}
}
internal bool ResolveVariables(ActivityExecutor executor)
{
this.substate = Substate.ResolvingVariables;
bool flag = true;
IList <Variable> implementationVariables = this.Activity.ImplementationVariables;
IList <Variable> runtimeVariables = this.Activity.RuntimeVariables;
int count = implementationVariables.Count;
int num2 = runtimeVariables.Count;
if ((count > 0) || (num2 > 0))
{
using (ActivityContext context = executor.GetResolutionContext(this))
{
for (int i = 0; i < count; i++)
{
Variable variable = implementationVariables[i];
context.Activity = variable.Default;
if (!variable.TryPopulateLocation(executor, context))
{
Location specificLocation = this.environment.GetSpecificLocation(variable.Id);
executor.ScheduleExpression(variable.Default, this, this.environment, specificLocation.CreateReference(true));
flag = false;
}
}
for (int j = 0; j < num2; j++)
{
Variable variable2 = runtimeVariables[j];
context.Activity = variable2.Default;
if (!variable2.TryPopulateLocation(executor, context))
{
Location location2 = this.environment.GetSpecificLocation(variable2.Id);
executor.ScheduleExpression(variable2.Default, this, this.environment, location2.CreateReference(true));
flag = false;
}
}
}
}
return(flag);
}
public void ClearAllWorkItems(ActivityExecutor executor)
{
if (this.firstWorkItem != null)
{
this.firstWorkItem.Release(executor);
this.firstWorkItem = null;
if (this.workItemQueue != null)
{
while (this.workItemQueue.Count > 0)
{
WorkItem item = this.workItemQueue.Dequeue();
item.Release(executor);
}
}
}
Fx.Assert(this.workItemQueue == null || this.workItemQueue.Count == 0, "We either didn't have a first work item and therefore don't have anything in the queue, or we drained the queue.");
// For consistency we set this to null even if it is empty
this.workItemQueue = null;
}
internal System.Activities.Runtime.WorkItem CreateWorkItem(System.Activities.ActivityInstance completedInstance, ActivityExecutor executor)
{
CompletionWorkItem item;
if (this.NeedsToGatherOutputs)
{
this.GatherOutputs(completedInstance);
}
if (this.checkForCancelation)
{
item = new CompletionWithCancelationCheckWorkItem(this, completedInstance);
}
else
{
item = executor.CompletionWorkItemPool.Acquire();
item.Initialize(this, completedInstance);
}
if (completedInstance.InstanceMap != null)
{
completedInstance.InstanceMap.AddEntry(item);
}
return item;
}
sealed internal override void InternalAbort(ActivityInstance instance, ActivityExecutor executor, Exception terminationReason)
{
if (executor.TryGetPendingOperation(instance, out AsyncOperationContext asyncContext))
{
try
{
if (!asyncContext.HasCalledAsyncCodeActivityCancel)
{
asyncContext.IsAborting = true;
InternalCancel(instance, executor, null);
}
}
finally
{
// we should always abort outstanding contexts
if (asyncContext.IsStillActive)
{
asyncContext.CancelOperation();
}
}
}
}
internal sealed override void InternalAbort(System.Activities.ActivityInstance instance, ActivityExecutor executor, Exception terminationReason)
{
AsyncOperationContext context;
if (executor.TryGetPendingOperation(instance, out context))
{
try
{
if (!context.HasCalledAsyncCodeActivityCancel)
{
context.IsAborting = true;
this.InternalCancel(instance, executor, null);
}
}
finally
{
if (context.IsStillActive)
{
context.CancelOperation();
}
}
}
}
internal void FinalizeState(ActivityExecutor executor, bool faultActivity, bool skipTracking)
{
if (faultActivity)
{
this.TryCancelParent();
this.state = ActivityInstanceState.Faulted;
}
if (this.state == ActivityInstanceState.Closed)
{
if ((executor.ShouldTrackActivityStateRecordsClosedState && !skipTracking) && executor.ShouldTrackActivity(this.Activity.DisplayName))
{
executor.AddTrackingRecord(new ActivityStateRecord(executor.WorkflowInstanceId, this, this.state));
}
}
else if (executor.ShouldTrackActivityStateRecords && !skipTracking)
{
executor.AddTrackingRecord(new ActivityStateRecord(executor.WorkflowInstanceId, this, this.state));
}
if (TD.ActivityCompletedIsEnabled())
{
TD.ActivityCompleted(this.Activity.GetType().ToString(), this.Activity.DisplayName, this.Id, this.State.ToString());
}
}
public BookmarkResumptionResult TryGenerateWorkItem(ActivityExecutor executor, bool isExternal, ref Bookmark bookmark, object value, System.Activities.ActivityInstance isolationInstance, out ActivityExecutionWorkItem workItem)
{
Bookmark internalBookmark = null;
BookmarkCallbackWrapper callbackWrapper = null;
if (!this.TryGetBookmarkFromInternalList(bookmark, out internalBookmark, out callbackWrapper))
{
workItem = null;
return(BookmarkResumptionResult.NotFound);
}
bookmark = internalBookmark;
if (!ActivityUtilities.IsInScope(callbackWrapper.ActivityInstance, isolationInstance))
{
workItem = null;
return(BookmarkResumptionResult.NotReady);
}
workItem = callbackWrapper.CreateWorkItem(executor, isExternal, bookmark, value);
if (!BookmarkOptionsHelper.SupportsMultipleResumes(callbackWrapper.Options))
{
this.Remove(bookmark, callbackWrapper);
}
return(BookmarkResumptionResult.Success);
}
private static void OnResumeAsyncCodeActivityBookmark(IAsyncResult result)
{
if (result.CompletedSynchronously)
{
return;
}
ActivityExecutor executor = (ActivityExecutor)result.AsyncState;
try
{
executor.EndResumeBookmark(result);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
executor.AbortWorkflowInstance(e);
}
}
public void handleAudioLevelUpdate(int audioLevel)
{
String timeStamp = EBookUtil.GetTimestamp();
Trace.WriteLine("audio level:" + audioLevel + "\t" + timeStamp);
if (audioLevel > EBookInteractiveSystem.initialNoiseSensitivity)
{
int start = 0;
double unixTime = EBookUtil.GetUnixTimeMillis();
if (preAudioLevel == 0)
{
//audio energy level jump
start = 1;
}
ActivityExecutor.add(new InternalAudioLevelChangeActivity(audioLevel, start, unixTime));
}
else if (audioLevel == 0 && preAudioLevel > 0 && audioLevel == 0)
{
//audio energy level drop
ActivityExecutor.add(new InternalAudioLevelChangeActivity(audioLevel, -1, 0));
}
preAudioLevel = audioLevel;
}
public bool FlushBookmarkScopeKeys(ActivityExecutor executor)
{
try
{
ICollection <InstanceKey> keysToDisassociate = executor.BookmarkScopeManager.GetKeysToDisassociate();
if ((keysToDisassociate != null) && (keysToDisassociate.Count > 0))
{
executor.DisassociateKeys(keysToDisassociate);
}
ICollection <InstanceKey> keysToAssociate = executor.BookmarkScopeManager.GetKeysToAssociate();
if ((keysToAssociate != null) && (keysToAssociate.Count > 0))
{
if (associateCallback == null)
{
associateCallback = Fx.ThunkCallback(new AsyncCallback(System.Activities.Runtime.WorkItem.OnAssociateComplete));
}
IAsyncResult result = executor.BeginAssociateKeys(keysToAssociate, associateCallback, new CallbackData(executor, this));
if (result.CompletedSynchronously)
{
executor.EndAssociateKeys(result);
}
else
{
return(false);
}
}
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
this.workflowAbortException = exception;
}
return(true);
}
public bool FlushBookmarkScopeKeys(ActivityExecutor executor)
{
try
{
ICollection<InstanceKey> keysToDisassociate = executor.BookmarkScopeManager.GetKeysToDisassociate();
if ((keysToDisassociate != null) && (keysToDisassociate.Count > 0))
{
executor.DisassociateKeys(keysToDisassociate);
}
ICollection<InstanceKey> keysToAssociate = executor.BookmarkScopeManager.GetKeysToAssociate();
if ((keysToAssociate != null) && (keysToAssociate.Count > 0))
{
if (associateCallback == null)
{
associateCallback = Fx.ThunkCallback(new AsyncCallback(System.Activities.Runtime.WorkItem.OnAssociateComplete));
}
IAsyncResult result = executor.BeginAssociateKeys(keysToAssociate, associateCallback, new CallbackData(executor, this));
if (result.CompletedSynchronously)
{
executor.EndAssociateKeys(result);
}
else
{
return false;
}
}
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
this.workflowAbortException = exception;
}
return true;
}
public bool FlushTracking(ActivityExecutor executor)
{
Fx.Assert(executor.HasPendingTrackingRecords, "We should not have been called if we don't have pending tracking records");
try
{
if (s_trackingCallback == null)
{
s_trackingCallback = Fx.ThunkCallback(new AsyncCallback(OnTrackingComplete));
}
IAsyncResult result = executor.BeginTrackPendingRecords(
s_trackingCallback,
new CallbackData(executor, this));
if (result.CompletedSynchronously)
{
executor.EndTrackPendingRecords(result);
}
else
{
// Completed async so we'll return false
return(false);
}
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
this.workflowAbortException = e;
}
return(true);
}
public override bool Execute(ActivityExecutor executor, BookmarkManager bookmarkManager)
{
NativeActivityFaultContext faultContext = null;
try
{
faultContext = new NativeActivityFaultContext(this.ActivityInstance, executor, bookmarkManager, this.propagatedException, this.originalExceptionSource);
this.callbackWrapper.Invoke(faultContext, this.propagatedException, this.propagatedFrom);
if (!faultContext.IsFaultHandled)
{
SetExceptionToPropagateWithoutAbort(this.propagatedException);
}
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
this.ExceptionToPropagate = e;
}
finally
{
if (faultContext != null)
{
faultContext.Dispose();
}
// Tell the executor to decrement its no persist count persistence of exceptions is disabled.
executor.ExitNoPersistForExceptionPropagation();
}
return(true);
}
public override void SetUp()
{
base.SetUp();
AutoMapperBootstrapper.ConfigureAutoMapper();
ObjectFactory.Configure(x => x.AddRegistry <StructureMapBootStrapper.TestMode>());
ObjectFactory.Configure(x => x.For <IActivityStore>().Use <ActivityStore>().Singleton());
var crateStorage = new CrateStorage(Crate.FromContent("", new OperationalStateCM()));
var crateDTO = CrateManager.ToDto(crateStorage);
var hubCommunicatorMock = new Mock <IHubCommunicator>();
hubCommunicatorMock.Setup(x => x.GetPayload(It.IsAny <Guid>()))
.ReturnsAsync(new PayloadDTO(Guid.NewGuid())
{
CrateStorage = crateDTO
});
ObjectFactory.Configure(cfg => cfg.For <IHubCommunicator>().Use(hubCommunicatorMock.Object));
CrateManagerHelper = new CrateManager();
_activityExecutor = ObjectFactory.GetInstance <ActivityExecutor>();
_activityStore = ObjectFactory.GetInstance <IActivityStore>();
var activityTemplateSummary = new ActivityTemplateSummaryDTO
{
Name = ExplicitTerminalActivityMock.ActivityTemplate.Name,
Version = ExplicitTerminalActivityMock.ActivityTemplate.Version,
TerminalName = ExplicitTerminalActivityMock.ActivityTemplate.Terminal.Name,
TerminalVersion = ExplicitTerminalActivityMock.ActivityTemplate.Terminal.Version
};
if (_activityStore.GetFactory(activityTemplateSummary.Name, activityTemplateSummary.Version) == null)
{
_activityStore.RegisterActivity <ExplicitTerminalActivityMock>(ExplicitTerminalActivityMock.ActivityTemplate);
}
}
public override bool Execute(ActivityExecutor executor, BookmarkManager bookmarkManager)
{
NativeActivityContext context = executor.NativeActivityContextPool.Acquire();
try
{
context.Initialize(base.ActivityInstance, executor, bookmarkManager);
this.callbackWrapper.Invoke(context, this.bookmark, this.state);
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
base.ExceptionToPropagate = exception;
}
finally
{
context.Dispose();
executor.NativeActivityContextPool.Release(context);
}
return(true);
}
internal void Abort(ActivityExecutor executor, BookmarkManager bookmarkManager, Exception terminationReason, bool isTerminate)
{
AbortEnumerator enumerator = new AbortEnumerator(this);
while (enumerator.MoveNext())
{
System.Activities.ActivityInstance current = enumerator.Current;
if (!current.HasNotExecuted)
{
current.Activity.InternalAbort(current, executor, terminationReason);
executor.DebugActivityCompleted(this);
}
if (current.PropertyManager != null)
{
current.PropertyManager.UnregisterProperties(current, current.Activity.MemberOf, true);
}
executor.TerminateSpecialExecutionBlocks(current, terminationReason);
executor.CancelPendingOperation(current);
executor.HandleRootCompletion(current);
current.MarkAsComplete(executor.RawBookmarkScopeManager, bookmarkManager);
current.state = ActivityInstanceState.Faulted;
current.FinalizeState(executor, false, !isTerminate);
}
}
internal HandleInitializationContext(ActivityExecutor executor, System.Activities.ActivityInstance scope)
{
this.executor = executor;
this.scope = scope;
}
sealed internal override void InternalAbort(ActivityInstance instance, ActivityExecutor executor, Exception terminationReason)
{
// no-op, this is only called if an exception is thrown out of execute
}
sealed internal override void InternalCancel(ActivityInstance instance, ActivityExecutor executor, BookmarkManager bookmarkManager)
{
Fx.Assert("Cancel should never be called on CodeActivity since it's synchronous");
}
internal override void InternalExecute(ActivityInstance instance, ActivityExecutor executor, BookmarkManager bookmarkManager) =>
throw Fx.AssertAndThrow("should never get here");
protected override void OnInitialize(HandleInitializationContext context)
{
this.owningInstance = context.OwningActivityInstance;
this.executor = context.Executor;
PerformDefaultRegistration();
}
protected override void ReleaseToPool(ActivityExecutor executor)
{
base.ClearForReuse();
executor.EmptyWorkItemPool.Release(this);
}
internal NativeActivityTransactionContext(ActivityInstance instance, ActivityExecutor executor, BookmarkManager bookmarks, RuntimeTransactionHandle handle)
: base(instance, executor, bookmarks)
{
this.executor = executor;
this.transactionHandle = handle;
}
public override void PostProcess(ActivityExecutor executor)
{
return;
}
protected void Initialize(object deserializedRuntimeState, DynamicUpdateMap updateMap)
{
ThrowIfAborted();
ThrowIfReadOnly();
this.executor = deserializedRuntimeState as ActivityExecutor;
if (this.executor == null)
{
throw FxTrace.Exception.Argument("deserializedRuntimeState", SR.InvalidRuntimeState);
}
this.executor.ThrowIfNonSerializable();
EnsureDefinitionReady();
WorkflowIdentity originalDefinitionIdentity = this.executor.WorkflowIdentity;
bool success = false;
Collection <ActivityBlockingUpdate> updateErrors = null;
try
{
if (updateMap != null)
{
// check if map is for implementaiton,
if (updateMap.IsForImplementation)
{
// if so, the definition root must be an activity
// with no public/imported children and no public/imported delegates.
if (DynamicUpdateMap.CanUseImplementationMapAsRoot(this.WorkflowDefinition))
{
updateMap = updateMap.AsRootMap();
}
else
{
throw FxTrace.Exception.AsError(new InstanceUpdateException(SR.InvalidImplementationAsWorkflowRoot));
}
}
updateMap.ThrowIfInvalid(this.WorkflowDefinition);
this.executor.WorkflowIdentity = this.DefinitionIdentity;
this.executor.UpdateInstancePhase1(updateMap, this.WorkflowDefinition, ref updateErrors);
ThrowIfDynamicUpdateErrorExists(updateErrors);
}
InitializeCore(null, null);
if (updateMap != null)
{
this.executor.UpdateInstancePhase2(updateMap, ref updateErrors);
ThrowIfDynamicUpdateErrorExists(updateErrors);
// Track that dynamic update is successful
if (this.Controller.TrackingEnabled)
{
this.Controller.Track(new WorkflowInstanceUpdatedRecord(this.Id, this.WorkflowDefinition.DisplayName, originalDefinitionIdentity, this.executor.WorkflowIdentity));
}
}
success = true;
}
catch (InstanceUpdateException updateException)
{
// Can't track through the controller because initialization failed
if (this.HasTrackingParticipant && this.TrackingProvider.ShouldTrackWorkflowInstanceRecords)
{
IList <ActivityBlockingUpdate> blockingActivities = updateException.BlockingActivities;
if (blockingActivities.Count == 0)
{
blockingActivities = new List <ActivityBlockingUpdate>
{
new ActivityBlockingUpdate(this.WorkflowDefinition, this.WorkflowDefinition.Id, updateException.Message)
}.AsReadOnly();
}
this.TrackingProvider.AddRecord(new WorkflowInstanceUpdatedRecord(this.Id, this.WorkflowDefinition.DisplayName, originalDefinitionIdentity, this.DefinitionIdentity, blockingActivities));
}
throw;
}
finally
{
if (updateMap != null && !success)
{
executor.MakeNonSerializable();
}
}
}
internal void Initialize(ActivityInstance instance, ActivityExecutor executor)
{
base.Reinitialize(instance, executor);
}
protected override void OnInitialize(HandleInitializationContext context)
{
this.owningInstance = context.OwningActivityInstance;
this.executor = context.Executor;
this.PerformDefaultRegistration();
}
internal abstract Location DeclareLocation(ActivityExecutor executor, ActivityInstance instance);
// This is only used by base classes which do not take
// part in pooling.
internal CodeActivityContext(ActivityInstance instance, ActivityExecutor executor)
: base(instance, executor)
{
}
// optional "fast-path" for initial value expressions that can be resolved synchronously internal abstract void PopulateDefault(ActivityExecutor executor, ActivityInstance parentInstance, Location location);
internal NativeActivityTransactionContext(System.Activities.ActivityInstance instance, ActivityExecutor executor, BookmarkManager bookmarks, RuntimeTransactionHandle handle) : base(instance, executor, bookmarks)
{
this.executor = executor;
this.transactionHandle = handle;
}
internal WorkflowInstanceControl(WorkflowInstance instance, ActivityExecutor executor)
{
_instance = instance;
_executor = executor;
}
public override bool Execute(ActivityExecutor executor, BookmarkManager bookmarkManager)
{
return true;
}
internal WorkflowInstanceControl(WorkflowInstance instance, ActivityExecutor executor)
{
this.instance = instance;
this.executor = executor;
}
public override bool Execute(ActivityExecutor executor, BookmarkManager bookmarkManager)
{
this.location.TemporaryResolutionEnvironment.CollapseTemporaryResolutionLocation(this.location);
return true;
}
public Callbacks(ActivityExecutor activityExecutor)
{
this.activityExecutor = activityExecutor;
}
internal AsyncOperationContext(ActivityExecutor executor, ActivityInstance owningActivityInstance)
{
_executor = executor;
_owningActivityInstance = owningActivityInstance;
}
