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; }