C# ActivityExecutionContext.InitializeActivity方法代码示例

 private void NotifyChangesToChildExecutors(IWorkflowCoreRuntime workflowCoreRuntime, Activity contextActivity, IList<WorkflowChangeAction> changeActions)
 {
     foreach (WorkflowChangeAction action in changeActions)
     {
         if (action is ActivityChangeAction)
         {
             CompositeActivity activity = contextActivity.TraverseDottedPathFromRoot(((ActivityChangeAction) action).OwnerActivityDottedPath) as CompositeActivity;
             if ((activity != null) && IsActivityExecutable(activity))
             {
                 ISupportWorkflowChanges activityExecutor = ActivityExecutors.GetActivityExecutor(activity) as ISupportWorkflowChanges;
                 if (activityExecutor == null)
                 {
                     throw new ApplicationException(SR.GetString("Error_WorkflowChangesNotSupported", new object[] { activity.GetType().FullName }));
                 }
                 using (workflowCoreRuntime.SetCurrentActivity(activity))
                 {
                     using (ActivityExecutionContext context = new ActivityExecutionContext(activity))
                     {
                         if (action is AddedActivityAction)
                         {
                             Activity activity2 = activity.Activities[((AddedActivityAction) action).Index];
                             if (IsActivityExecutable(activity2))
                             {
                                 activity2.OnActivityExecutionContextLoad(context.Activity.RootActivity.WorkflowCoreRuntime);
                                 context.InitializeActivity(activity2);
                                 activityExecutor.OnActivityAdded(context, activity2);
                             }
                         }
                         else if (action is RemovedActivityAction)
                         {
                             RemovedActivityAction action2 = (RemovedActivityAction) action;
                             if (IsActivityExecutable(action2.OriginalRemovedActivity))
                             {
                                 activityExecutor.OnActivityRemoved(context, action2.OriginalRemovedActivity);
                                 if (action2.OriginalRemovedActivity.ExecutionResult != ActivityExecutionResult.Uninitialized)
                                 {
                                     action2.OriginalRemovedActivity.Uninitialize(context.Activity.RootActivity.WorkflowCoreRuntime);
                                     action2.OriginalRemovedActivity.SetValue(Activity.ExecutionResultProperty, ActivityExecutionResult.Uninitialized);
                                 }
                                 action2.OriginalRemovedActivity.OnActivityExecutionContextUnload(context.Activity.RootActivity.WorkflowCoreRuntime);
                                 action2.OriginalRemovedActivity.Dispose();
                             }
                         }
                     }
                 }
             }
         }
     }
 }

        public ActivityExecutionContext CreateExecutionContext(Activity activity)
        {
            if (this.ownerContext == null)
                throw new ObjectDisposedException("ActivityExecutionContextManager");

            if (activity == null)
                throw new ArgumentNullException("activity");

            if (!this.ownerContext.IsValidChild(activity, true))
                throw new ArgumentException(SR.GetString(SR.AEC_InvalidActivity), "activity");

            Activity copiedActivity = activity.Clone();
            ((IDependencyObjectAccessor)copiedActivity).InitializeInstanceForRuntime(this.ownerContext.Activity.WorkflowCoreRuntime);

            //Reset the cloned tree for execution.
            Queue<Activity> activityQueue = new Queue<Activity>();
            activityQueue.Enqueue(copiedActivity);

            while (activityQueue.Count != 0)
            {
                Activity clonedActivity = activityQueue.Dequeue();
                if (clonedActivity.ExecutionStatus != ActivityExecutionStatus.Initialized)
                {
                    clonedActivity.ResetAllKnownDependencyProperties();
                    CompositeActivity compositeActivity = clonedActivity as CompositeActivity;

                    if (compositeActivity != null)
                    {
                        for (int i = 0; i < compositeActivity.EnabledActivities.Count; ++i)
                        {
                            activityQueue.Enqueue(compositeActivity.EnabledActivities[i]);
                        }

                        ISupportAlternateFlow alternateFlow = compositeActivity as ISupportAlternateFlow;

                        if (alternateFlow != null)
                        {
                            for (int i = 0; i < alternateFlow.AlternateFlowActivities.Count; ++i)
                            {
                                activityQueue.Enqueue(alternateFlow.AlternateFlowActivities[i]);
                            }
                        }
                    }
                }
            }

            // get active context activities and add it to this one
            IList<Activity> activeContexts = (IList<Activity>)this.ownerContext.Activity.ContextActivity.GetValue(Activity.ActiveExecutionContextsProperty);
            if (activeContexts == null)
            {
                activeContexts = new List<Activity>();
                this.ownerContext.Activity.ContextActivity.SetValue(Activity.ActiveExecutionContextsProperty, activeContexts);
            }
            activeContexts.Add(copiedActivity);

            // prepare the copied activity as a context activity
            ActivityExecutionContextInfo contextInfo = new ActivityExecutionContextInfo(activity.QualifiedName, this.ownerContext.WorkflowCoreRuntime.GetNewContextActivityId(), Guid.NewGuid(), this.ownerContext.ContextId);
            copiedActivity.SetValue(Activity.ActivityExecutionContextInfoProperty, contextInfo);
            copiedActivity.SetValue(Activity.ActivityContextGuidProperty, contextInfo.ContextGuid);
            ActivityExecutionContext newExecutionContext = null;
            try
            {
                // inform workflow runtime
                this.ownerContext.Activity.WorkflowCoreRuntime.RegisterContextActivity(copiedActivity);

                // return the new context
                newExecutionContext = new ActivityExecutionContext(copiedActivity);
                this.executionContexts.Add(newExecutionContext);
                newExecutionContext.InitializeActivity(newExecutionContext.Activity);
                return newExecutionContext;
            }
            catch (Exception)
            {
                if (newExecutionContext != null)
                {
                    this.CompleteExecutionContext(newExecutionContext);
                }
                else
                {
                    activeContexts.Remove(copiedActivity);
                }
                throw;
            }
        }

        private void NotifyChangesToChildExecutors(IWorkflowCoreRuntime workflowCoreRuntime, Activity contextActivity, IList<WorkflowChangeAction> changeActions)
        {
            foreach (WorkflowChangeAction action in changeActions)
            {
                if (!(action is ActivityChangeAction))
                    continue;

                CompositeActivity ownerActivity = contextActivity.TraverseDottedPathFromRoot(((ActivityChangeAction)action).OwnerActivityDottedPath) as CompositeActivity;
                if (ownerActivity == null || !WorkflowChanges.IsActivityExecutable(ownerActivity))
                    continue;

                ISupportWorkflowChanges compositeActivityExecutor = ActivityExecutors.GetActivityExecutor(ownerActivity) as ISupportWorkflowChanges;
                if (compositeActivityExecutor == null)
                    throw new ApplicationException(SR.GetString(SR.Error_WorkflowChangesNotSupported, ownerActivity.GetType().FullName));

                using (workflowCoreRuntime.SetCurrentActivity(ownerActivity))
                {
                    using (ActivityExecutionContext executionContext = new ActivityExecutionContext(ownerActivity))
                    {
                        if (action is AddedActivityAction)
                        {
                            Activity addedActivity = ownerActivity.Activities[((AddedActivityAction)action).Index];
                            if (WorkflowChanges.IsActivityExecutable(addedActivity))
                            {
                                addedActivity.OnActivityExecutionContextLoad(executionContext.Activity.RootActivity.WorkflowCoreRuntime);
                                executionContext.InitializeActivity(addedActivity);
                                compositeActivityExecutor.OnActivityAdded(executionContext, addedActivity);
                            }
                        }
                        else if (action is RemovedActivityAction)
                        {
                            RemovedActivityAction removedActivityAction = (RemovedActivityAction)action;
                            if (WorkflowChanges.IsActivityExecutable(removedActivityAction.OriginalRemovedActivity))
                            {
                                compositeActivityExecutor.OnActivityRemoved(executionContext, removedActivityAction.OriginalRemovedActivity);
                                if (removedActivityAction.OriginalRemovedActivity.ExecutionResult != ActivityExecutionResult.Uninitialized)
                                {
                                    removedActivityAction.OriginalRemovedActivity.Uninitialize(executionContext.Activity.RootActivity.WorkflowCoreRuntime);
                                    removedActivityAction.OriginalRemovedActivity.SetValue(Activity.ExecutionResultProperty, ActivityExecutionResult.Uninitialized);
                                }
                                removedActivityAction.OriginalRemovedActivity.OnActivityExecutionContextUnload(executionContext.Activity.RootActivity.WorkflowCoreRuntime);
                                removedActivityAction.OriginalRemovedActivity.Dispose();
                            }
                        }
                    }
                }
            }
        }

        internal void RegisterWithRuntime(WorkflowRuntime workflowRuntime)
        {
            _isInstanceValid = true;
            _runtime = workflowRuntime;
            using (new ServiceEnvironment(this.rootActivity))
            {
                using (SetCurrentActivity(this.rootActivity))
                {
                    using (ActivityExecutionContext executionContext = new ActivityExecutionContext(this.rootActivity, true))
                        executionContext.InitializeActivity(this.rootActivity);
                }

                //
                // Tell the runtime that the instance is ready 
                // so that internal components can set up event subscriptions
                this._runtime.WorkflowExecutorCreated(this, false);

                //
                // Fire first events
                FireWorkflowExecutionEvent(this, WorkflowEventInternal.Creating);
            }
        }

 internal void RegisterWithRuntime(System.Workflow.Runtime.WorkflowRuntime workflowRuntime)
 {
     this._isInstanceValid = true;
     this._runtime = workflowRuntime;
     using (new ServiceEnvironment(this.rootActivity))
     {
         using (this.SetCurrentActivity(this.rootActivity))
         {
             using (ActivityExecutionContext context = new ActivityExecutionContext(this.rootActivity, true))
             {
                 context.InitializeActivity(this.rootActivity);
             }
         }
         this._runtime.WorkflowExecutorCreated(this, false);
         this.FireWorkflowExecutionEvent(this, WorkflowEventInternal.Creating);
     }
 }

        public void Initialize(Activity definition, IDictionary<string, object> inputs, bool hasNameCollision)
        {
            this.rootActivity.SetValue(Activity.ActivityExecutionContextInfoProperty,
                new ActivityExecutionContextInfo(this.rootActivity.QualifiedName, this.GetNewContextActivityId(), instanceId, -1));
            this.rootActivity.SetValue(Activity.ActivityContextGuidProperty, instanceId);

            SetInputParameters(definition, this.rootActivity, inputs, hasNameCollision);

            ((IDependencyObjectAccessor)this.rootActivity).InitializeActivatingInstanceForRuntime(
                null,
                this);

            this.rootActivity.FixUpMetaProperties(definition);

            TimerQueue = new TimerEventSubscriptionCollection(this, this.instanceId);

            using (new ServiceEnvironment(this.rootActivity))
            {
                using (SetCurrentActivity(this.rootActivity))
                {
                    RegisterContextActivity(this.rootActivity);

                    using (ActivityExecutionContext executionContext = new ActivityExecutionContext(this.rootActivity, true))
                    {
                        executionContext.InitializeActivity(this.rootActivity);
                    }
                }
            }
        }

 public ActivityExecutionContext CreateExecutionContext(Activity activity)
 {
     ActivityExecutionContext context2;
     if (this.ownerContext == null)
     {
         throw new ObjectDisposedException("ActivityExecutionContextManager");
     }
     if (activity == null)
     {
         throw new ArgumentNullException("activity");
     }
     if (!this.ownerContext.IsValidChild(activity, true))
     {
         throw new ArgumentException(SR.GetString("AEC_InvalidActivity"), "activity");
     }
     Activity item = activity.Clone();
     ((IDependencyObjectAccessor) item).InitializeInstanceForRuntime(this.ownerContext.Activity.WorkflowCoreRuntime);
     Queue<Activity> queue = new Queue<Activity>();
     queue.Enqueue(item);
     while (queue.Count != 0)
     {
         Activity activity3 = queue.Dequeue();
         if (activity3.ExecutionStatus != ActivityExecutionStatus.Initialized)
         {
             activity3.ResetAllKnownDependencyProperties();
             CompositeActivity activity4 = activity3 as CompositeActivity;
             if (activity4 != null)
             {
                 for (int i = 0; i < activity4.EnabledActivities.Count; i++)
                 {
                     queue.Enqueue(activity4.EnabledActivities[i]);
                 }
                 ISupportAlternateFlow flow = activity4;
                 if (flow != null)
                 {
                     for (int j = 0; j < flow.AlternateFlowActivities.Count; j++)
                     {
                         queue.Enqueue(flow.AlternateFlowActivities[j]);
                     }
                 }
             }
         }
     }
     IList<Activity> list = (IList<Activity>) this.ownerContext.Activity.ContextActivity.GetValue(Activity.ActiveExecutionContextsProperty);
     if (list == null)
     {
         list = new List<Activity>();
         this.ownerContext.Activity.ContextActivity.SetValue(Activity.ActiveExecutionContextsProperty, list);
     }
     list.Add(item);
     ActivityExecutionContextInfo info = new ActivityExecutionContextInfo(activity.QualifiedName, this.ownerContext.WorkflowCoreRuntime.GetNewContextActivityId(), Guid.NewGuid(), this.ownerContext.ContextId);
     item.SetValue(Activity.ActivityExecutionContextInfoProperty, info);
     item.SetValue(Activity.ActivityContextGuidProperty, info.ContextGuid);
     ActivityExecutionContext context = null;
     try
     {
         this.ownerContext.Activity.WorkflowCoreRuntime.RegisterContextActivity(item);
         context = new ActivityExecutionContext(item);
         this.executionContexts.Add(context);
         context.InitializeActivity(context.Activity);
         context2 = context;
     }
     catch (Exception)
     {
         if (context != null)
         {
             this.CompleteExecutionContext(context);
         }
         else
         {
             list.Remove(item);
         }
         throw;
     }
     return context2;
 }