C# Activity.GetActivityByName方法代碼示例

 internal static void InitializeCorrelationTokenCollection(Activity activity, CorrelationToken correlator)
 {
     if ((correlator != null) && !string.IsNullOrEmpty(correlator.OwnerActivityName))
     {
         string ownerActivityName = correlator.OwnerActivityName;
         Activity activityByName = activity.GetActivityByName(ownerActivityName);
         if (activityByName == null)
         {
             activityByName = Helpers.ParseActivityForBind(activity, ownerActivityName);
         }
         if (activityByName == null)
         {
             throw new ArgumentException("ownerActivity");
         }
         CorrelationTokenCollection tokens = activityByName.GetValue(CorrelationTokenCollection.CorrelationTokenCollectionProperty) as CorrelationTokenCollection;
         if (tokens == null)
         {
             tokens = new CorrelationTokenCollection();
             activityByName.SetValue(CorrelationTokenCollection.CorrelationTokenCollectionProperty, tokens);
         }
         if (!tokens.Contains(correlator.Name))
         {
             tokens.Add(correlator);
         }
     }
 }

 private static void CollectCompensatableCompletedContexts(ActivityExecutionContext context, Activity targetActivity, SortedDictionary<int, CompensationInfo> sortedListOfCompensatableTargets, bool immediateCompensation)
 {
     ActivityExecutionContextManager executionContextManager = context.ExecutionContextManager;
     for (int i = executionContextManager.CompletedExecutionContexts.Count - 1; i >= 0; i--)
     {
         ActivityExecutionContextInfo targetExecutionInfo = executionContextManager.CompletedExecutionContexts[i];
         if (((byte) (targetExecutionInfo.Flags & PersistFlags.NeedsCompensation)) != 0)
         {
             Activity activityByName = targetActivity.GetActivityByName(targetExecutionInfo.ActivityQualifiedName, true);
             if ((activityByName != null) && (!immediateCompensation || !IsActivityInBackWorkBranch(targetActivity, activityByName)))
             {
                 sortedListOfCompensatableTargets.Add(targetExecutionInfo.CompletedOrderId, new CompensationInfo(targetExecutionInfo, executionContextManager));
             }
         }
     }
 }

 public override bool Evaluate(Activity activity, IServiceProvider provider)
 {
     if (activity == null)
     {
         throw new ArgumentNullException("activity");
     }
     if (string.IsNullOrEmpty(this._condition))
     {
         throw new InvalidOperationException(SR.GetString("Error_MissingConditionName", new object[] { activity.Name }));
     }
     RuleDefinitions ruleDefinitions = null;
     if (string.IsNullOrEmpty(this.declaringActivityId))
     {
         CompositeActivity declaringActivity = null;
         ruleDefinitions = GetRuleDefinitions(activity, out declaringActivity);
     }
     else
     {
         ruleDefinitions = (RuleDefinitions) activity.GetActivityByName(this.declaringActivityId).GetValue(RuleDefinitions.RuleDefinitionsProperty);
     }
     if ((ruleDefinitions == null) || (ruleDefinitions.Conditions == null))
     {
         throw new InvalidOperationException(SR.GetString("Error_MissingRuleConditions"));
     }
     RuleCondition condition = ruleDefinitions.Conditions[this._condition];
     if (condition == null)
     {
         return true;
     }
     Activity enclosingActivity = Helpers.GetEnclosingActivity(activity);
     RuleValidation validation = new RuleValidation(enclosingActivity);
     if (!condition.Validate(validation))
     {
         throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.ConditionValidationFailed, new object[] { this._condition }));
     }
     RuleExecution execution = new RuleExecution(validation, enclosingActivity, provider as ActivityExecutionContext);
     return condition.Evaluate(execution);
 }

        internal static void InitializeCorrelationTokenCollection(Activity activity, CorrelationToken correlator)
        {
            if (correlator != null && !String.IsNullOrEmpty(correlator.OwnerActivityName))
            {
                string ownerActivityId = correlator.OwnerActivityName;
                Activity owner = activity.GetActivityByName(ownerActivityId);
                if (owner == null)
                    owner = System.Workflow.Activities.Common.Helpers.ParseActivityForBind(activity, ownerActivityId);
                if (owner == null)
                    throw new ArgumentException("ownerActivity");

                CorrelationTokenCollection collection = owner.GetValue(CorrelationTokenCollection.CorrelationTokenCollectionProperty) as CorrelationTokenCollection;
                if (collection == null)
                {
                    collection = new CorrelationTokenCollection();
                    owner.SetValue(CorrelationTokenCollection.CorrelationTokenCollectionProperty, collection);
                }

                if (!collection.Contains(correlator.Name))
                {
                    collection.Add(correlator);
                }
            }
        }

 private static bool CollectCompensatableActiveContexts(ActivityExecutionContext context, Activity targetActivity, SortedDictionary<int, CompensationInfo> sortedListOfCompensatableTargets, bool immediateCompensation)
 {
     foreach (ActivityExecutionContext context2 in context.ExecutionContextManager.ExecutionContexts)
     {
         if ((targetActivity.GetActivityByName(context2.Activity.QualifiedName, true) != null) && (!immediateCompensation || !IsActivityInBackWorkBranch(targetActivity, context2.Activity)))
         {
             if ((context2.Activity is ICompensatableActivity) && (((context2.Activity.ExecutionStatus == ActivityExecutionStatus.Compensating) || (context2.Activity.ExecutionStatus == ActivityExecutionStatus.Faulting)) || (context2.Activity.ExecutionStatus == ActivityExecutionStatus.Canceling)))
             {
                 return true;
             }
             if (context2.Activity is CompositeActivity)
             {
                 Activity[] compensatableChildren = GetCompensatableChildren(context2.Activity as CompositeActivity);
                 if (compensatableChildren != null)
                 {
                     int key = 0;
                     foreach (Activity activity in compensatableChildren)
                     {
                         int num2 = (int) activity.GetValue(Activity.CompletedOrderIdProperty);
                         if (key < num2)
                         {
                             key = num2;
                         }
                     }
                     if (key != 0)
                     {
                         sortedListOfCompensatableTargets.Add(key, new CompensationInfo(context2));
                     }
                 }
                 CollectCompensatableActiveContexts(context2, targetActivity, sortedListOfCompensatableTargets, immediateCompensation);
                 CollectCompensatableCompletedContexts(context2, targetActivity, sortedListOfCompensatableTargets, immediateCompensation);
             }
         }
     }
     return false;
 }

 private static void CompleteRevokedExecutionContext(Activity targetActivity, ActivityExecutionContext context)
 {
     ActivityExecutionContext[] array = new ActivityExecutionContext[context.ExecutionContextManager.ExecutionContexts.Count];
     context.ExecutionContextManager.ExecutionContexts.CopyTo(array, 0);
     foreach (ActivityExecutionContext context2 in array)
     {
         if (targetActivity.GetActivityByName(context2.Activity.QualifiedName, true) != null)
         {
             if (context2.Activity.ExecutionStatus == ActivityExecutionStatus.Closed)
             {
                 CompleteRevokedExecutionContext(context2.Activity, context2);
             }
             context.ExecutionContextManager.CompleteExecutionContext(context2);
         }
     }
 }

 private static bool IsOwnerActivitySame(string ownerActivityName, string existingOwnerActivityName, Activity currentActivity, Activity existingActivity)
 {
     if (ownerActivityName.Equals(existingOwnerActivityName))
     {
         return true;
     }
     Activity activityByName = currentActivity.GetActivityByName(ownerActivityName);
     if (activityByName == null)
     {
         activityByName = Helpers.ParseActivityForBind(currentActivity, ownerActivityName);
     }
     Activity activity2 = currentActivity.GetActivityByName(existingOwnerActivityName);
     if (activity2 == null)
     {
         activity2 = Helpers.ParseActivityForBind(existingActivity, existingOwnerActivityName);
     }
     return (((activityByName != null) && (activity2 != null)) && activityByName.QualifiedName.Equals(activity2.QualifiedName));
 }

        public override bool Evaluate(Activity activity, IServiceProvider provider)
        {
            if (activity == null)
            {
                throw new ArgumentNullException("activity");
            }
            if (string.IsNullOrEmpty(this._condition))
            {
                throw new InvalidOperationException(SR.GetString(SR.Error_MissingConditionName, activity.Name));
            }

            RuleDefinitions defs = null;

            if (string.IsNullOrEmpty(this.declaringActivityId))
            {
                // No Runtime Initialization.
                CompositeActivity declaringActivity = null;
                defs = RuleConditionReference.GetRuleDefinitions(activity, out declaringActivity);
            }
            else
            {
                // Runtime Initialized.
                defs = (RuleDefinitions)activity.GetActivityByName(declaringActivityId).GetValue(RuleDefinitions.RuleDefinitionsProperty);
            }

            if ((defs == null) || (defs.Conditions == null))
            {
                throw new InvalidOperationException(SR.GetString(SR.Error_MissingRuleConditions));
            }

            RuleCondition conditionDefinitionToEvaluate = defs.Conditions[this._condition];
            if (conditionDefinitionToEvaluate != null)
            {
                Activity contextActivity = System.Workflow.Activities.Common.Helpers.GetEnclosingActivity(activity);
                RuleValidation validation = new RuleValidation(contextActivity);
                if (!conditionDefinitionToEvaluate.Validate(validation))
                {
                    string message = string.Format(CultureInfo.CurrentCulture, Messages.ConditionValidationFailed, this._condition);
                    throw new InvalidOperationException(message);
                }

                RuleExecution context = new RuleExecution(validation, contextActivity, provider as ActivityExecutionContext);
                return conditionDefinitionToEvaluate.Evaluate(context);
            }
            else
            {
                // no condition, so defaults to true
                return true;
            }
        }

        private static bool IsOwnerActivitySame(string ownerActivityName, string existingOwnerActivityName, Activity currentActivity, Activity existingActivity)
        {
            if (ownerActivityName.Equals(existingOwnerActivityName))
                return true;

            Activity owner = currentActivity.GetActivityByName(ownerActivityName);
            if (owner == null)
                owner = Helpers.ParseActivityForBind(currentActivity, ownerActivityName);

            Activity existingowner = currentActivity.GetActivityByName(existingOwnerActivityName);
            if (existingowner == null)
                existingowner = Helpers.ParseActivityForBind(existingActivity, existingOwnerActivityName);

            if (owner != null && existingowner != null && owner.QualifiedName.Equals(existingowner.QualifiedName))
                return true;

            return false;
        }