internal override void InternalAbort(System.Activities.ActivityInstance instance, ActivityExecutor executor, Exception terminationReason)
 {
     using (NativeActivityAbortContext context = new NativeActivityAbortContext(instance, executor, terminationReason))
     {
         this.Abort(context);
     }
 }

 internal WorkflowDataContext(ActivityExecutor executor, ActivityInstance activityInstance, bool includeLocalVariables)
 {
     this.executor = executor;
     this.activityInstance = activityInstance;
     this.IncludesLocalVariables = includeLocalVariables;
     this.properties = CreateProperties();
 }

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

        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 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 void Dispose(ActivityExecutor executor)
 {
     if (FxTrace.ShouldTraceVerboseToTraceSource)
     {
         this.TraceCompleted();
     }
     if (this.IsPooled)
     {
         this.ReleaseToPool(executor);
     }
 }

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

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

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

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