C# Activity.SetValue方法代碼示例

 protected override bool ApplyTo(Activity rootActivity)
 {
     if (rootActivity == null)
     {
         return false;
     }
     RuleDefinitions definitions = rootActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
     if (definitions == null)
     {
         definitions = new RuleDefinitions();
         rootActivity.SetValue(RuleDefinitions.RuleDefinitionsProperty, definitions);
     }
     bool flag = false;
     if (definitions.Conditions.RuntimeMode)
     {
         definitions.Conditions.RuntimeMode = false;
         flag = true;
     }
     try
     {
         definitions.Conditions.Add(this.ConditionDefinition);
     }
     finally
     {
         if (flag)
         {
             definitions.Conditions.RuntimeMode = true;
         }
     }
     return true;
 }

 public void SetWhenCondition(Activity activity, ActivityCondition handler)
 {
     if (activity.Parent is ConditionedActivityGroup)
     {
         activity.SetValue(ConditionedActivityGroup.WhenConditionProperty, handler);
     }
 }

 private static bool TryCompensateLastCompletedChildActivity(ActivityExecutionContext context, Activity targetActivity, IActivityEventListener<ActivityExecutionStatusChangedEventArgs> statusChangeHandler, bool isimmediateCompensation)
 {
     SortedDictionary<int, CompensationInfo> sortedListOfCompensatableTargets = new SortedDictionary<int, CompensationInfo>();
     if (targetActivity is CompositeActivity)
     {
         if (CollectCompensatableTargetActivities(targetActivity as CompositeActivity, sortedListOfCompensatableTargets, isimmediateCompensation))
         {
             return true;
         }
         if (CollectCompensatableActiveContexts(context, targetActivity, sortedListOfCompensatableTargets, isimmediateCompensation))
         {
             return true;
         }
         CollectCompensatableCompletedContexts(context, targetActivity, sortedListOfCompensatableTargets, isimmediateCompensation);
         if (sortedListOfCompensatableTargets.Count == 0)
         {
             CompleteRevokedExecutionContext(targetActivity, context);
             return false;
         }
         int? nullable = targetActivity.GetValue(CompensationHandlingFilter.LastCompensatedOrderIdProperty) as int?;
         int num = -1;
         CompensationInfo info = null;
         foreach (int num2 in sortedListOfCompensatableTargets.Keys)
         {
             if (nullable.HasValue)
             {
                 int? nullable2 = nullable;
                 int num3 = num2;
                 if ((nullable2.GetValueOrDefault() < num3) && nullable2.HasValue)
                 {
                     break;
                 }
             }
             info = sortedListOfCompensatableTargets[num2];
             num = num2;
         }
         if (info == null)
         {
             CompleteRevokedExecutionContext(targetActivity, context);
             return false;
         }
         targetActivity.SetValue(CompensationHandlingFilter.LastCompensatedOrderIdProperty, num);
         if ((info.TargetActivity != null) && (info.TargetActivity is ICompensatableActivity))
         {
             info.TargetActivity.RegisterForStatusChange(Activity.StatusChangedEvent, statusChangeHandler);
             context.CompensateActivity(info.TargetActivity);
             return true;
         }
         if ((info.TargetExecutionInfo != null) && (info.TargetExecutionContextManager != null))
         {
             ActivityExecutionContext context2 = info.TargetExecutionContextManager.DiscardPersistedExecutionContext(info.TargetExecutionInfo);
             if (context2.Activity is ICompensatableActivity)
             {
                 context2.Activity.RegisterForStatusChange(Activity.StatusChangedEvent, statusChangeHandler);
                 context2.CompensateActivity(context2.Activity);
                 return true;
             }
             if (context2.Activity is CompositeActivity)
             {
                 Activity lastCompensatableChild = GetLastCompensatableChild(context2.Activity as CompositeActivity);
                 if (lastCompensatableChild != null)
                 {
                     lastCompensatableChild.RegisterForStatusChange(Activity.StatusChangedEvent, statusChangeHandler);
                     context2.CompensateActivity(lastCompensatableChild);
                     return true;
                 }
                 return TryCompensateLastCompletedChildActivity(context2, context2.Activity, statusChangeHandler, false);
             }
         }
         else if ((info.TargetExecutionContext != null) && (info.TargetExecutionContext.Activity is CompositeActivity))
         {
             Activity activity = GetLastCompensatableChild(info.TargetExecutionContext.Activity as CompositeActivity);
             if (activity != null)
             {
                 activity.RegisterForStatusChange(Activity.StatusChangedEvent, statusChangeHandler);
                 info.TargetExecutionContext.CompensateActivity(activity);
                 return true;
             }
             return TryCompensateLastCompletedChildActivity(info.TargetExecutionContext, info.TargetExecutionContext.Activity, statusChangeHandler, false);
         }
     }
     return false;
 }

 internal static RuleDefinitions Load_Rules_RT(Activity declaringActivity)
 {
     RuleDefinitions rules = declaringActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
     if (rules == null)
     {
         rules = ConditionHelper.GetRuleDefinitionsFromManifest(declaringActivity.GetType());
         if (rules != null)
             declaringActivity.SetValue(RuleDefinitions.RuleDefinitionsProperty, rules);
     }
     return rules;
 }

 private void CreateTransaction(Activity atomicActivity)
 {
     TransactionalProperties properties = new TransactionalProperties();
     TransactionOptions options = new TransactionOptions();
     WorkflowTransactionOptions transactionOptions = TransactedContextFilter.GetTransactionOptions(atomicActivity);
     options.IsolationLevel = transactionOptions.IsolationLevel;
     if (options.IsolationLevel == IsolationLevel.Unspecified)
     {
         options.IsolationLevel = IsolationLevel.Serializable;
     }
     options.Timeout = transactionOptions.TimeoutDuration;
     CommittableTransaction transaction = new CommittableTransaction(options);
     properties.Transaction = transaction;
     WorkflowTrace.Runtime.TraceEvent(TraceEventType.Information, 0, string.Concat(new object[] { "Workflow Runtime: WorkflowExecutor: instanceId: ", this.InstanceIdString, " .Created enlistable transaction ", transaction.GetHashCode(), " with timeout ", options.Timeout, ", isolation ", options.IsolationLevel }));
     properties.LocalQueuingService = new WorkflowQueuingService(this.qService);
     atomicActivity.SetValue(TransactionalPropertiesProperty, properties);
     this.currentAtomicActivity = atomicActivity;
     this.atomicActivityEvent = new ManualResetEvent(false);
     WorkflowTrace.Runtime.TraceEvent(TraceEventType.Information, 0, "Workflow Runtime: WorkflowExecutor: instanceId: " + this.InstanceIdString + " .Set CurrentAtomicActivity to " + atomicActivity.Name);
 }

 public void SetWorkflowServiceAttributes(Activity activity, WorkflowServiceAttributes value)
 {
     activity.SetValue(ReceiveActivity.WorkflowServiceAttributesProperty, value);
 }

 internal static void ProcessDefTag(WorkflowMarkupSerializationManager serializationManager, XmlReader reader, Activity activity, bool newSegment, string fileName)
 {
     ResourceManager manager = new ResourceManager("System.Workflow.ComponentModel.StringResources", typeof(ActivityBind).Assembly);
     if (reader.NodeType == XmlNodeType.Attribute)
     {
         string str;
         if (((str = reader.LocalName) != null) && (str == "Class"))
         {
             activity.SetValue(WorkflowMarkupSerializer.XClassProperty, reader.Value);
         }
         else
         {
             serializationManager.ReportError(new WorkflowMarkupSerializationException(string.Format(CultureInfo.CurrentCulture, manager.GetString("UnknownDefinitionTag"), new object[] { "x", reader.LocalName, "http://schemas.microsoft.com/winfx/2006/xaml" }), (reader is IXmlLineInfo) ? ((IXmlLineInfo) reader).LineNumber : 1, (reader is IXmlLineInfo) ? ((IXmlLineInfo) reader).LinePosition : 1));
         }
     }
     else
     {
         bool flag = false;
         bool isEmptyElement = reader.IsEmptyElement;
         int depth = reader.Depth;
         do
         {
             switch (reader.NodeType)
             {
                 case XmlNodeType.Element:
                 {
                     string localName = reader.LocalName;
                     if (localName != null)
                     {
                         if (localName == "Code")
                         {
                             if (isEmptyElement)
                             {
                                 flag = true;
                             }
                             break;
                         }
                         bool flag1 = localName == "Constructor";
                     }
                     serializationManager.ReportError(new WorkflowMarkupSerializationException(string.Format(CultureInfo.CurrentCulture, manager.GetString("UnknownDefinitionTag"), new object[] { "x", reader.LocalName, "http://schemas.microsoft.com/winfx/2006/xaml" }), (reader is IXmlLineInfo) ? ((IXmlLineInfo) reader).LineNumber : 1, (reader is IXmlLineInfo) ? ((IXmlLineInfo) reader).LinePosition : 1));
                     return;
                 }
                 case XmlNodeType.Text:
                 case XmlNodeType.CDATA:
                 {
                     int num2 = (reader is IXmlLineInfo) ? ((IXmlLineInfo) reader).LineNumber : 1;
                     int num3 = (reader is IXmlLineInfo) ? ((IXmlLineInfo) reader).LinePosition : 1;
                     CodeSnippetTypeMember member = new CodeSnippetTypeMember(reader.Value) {
                         LinePragma = new CodeLinePragma(fileName, Math.Max(num2 - 1, 1))
                     };
                     member.UserData[UserDataKeys.CodeSegment_New] = newSegment;
                     member.UserData[UserDataKeys.CodeSegment_ColumnNumber] = (num3 + reader.Name.Length) - 1;
                     CodeTypeMemberCollection members = activity.GetValue(WorkflowMarkupSerializer.XCodeProperty) as CodeTypeMemberCollection;
                     if (members == null)
                     {
                         members = new CodeTypeMemberCollection();
                         activity.SetValue(WorkflowMarkupSerializer.XCodeProperty, members);
                     }
                     members.Add(member);
                     break;
                 }
                 case XmlNodeType.EndElement:
                     if (reader.Depth == depth)
                     {
                         flag = true;
                     }
                     break;
             }
         }
         while (!flag && reader.Read());
     }
 }

        public void CheckpointInstanceState(Activity atomicActivity)
        {
            // Note that the WF4 runtime does not create checkpoints.  If the transaction aborts, the workflow aborts.  
            // We are following the WF4 behavior and not creating a checkpoint.

            TransactionOptions tranOpts = new TransactionOptions();
            WorkflowTransactionOptions atomicTxn = TransactedContextFilter.GetTransactionOptions(atomicActivity);

            tranOpts.IsolationLevel = atomicTxn.IsolationLevel;
            if (tranOpts.IsolationLevel == IsolationLevel.Unspecified)
            {
                tranOpts.IsolationLevel = IsolationLevel.Serializable;
            }

            tranOpts.Timeout = atomicTxn.TimeoutDuration;

            TransactionalProperties transactionProperties = new TransactionalProperties();
            atomicActivity.SetValue(WorkflowExecutor.TransactionalPropertiesProperty, transactionProperties);
            this.ServiceProvider.CreateTransaction(tranOpts);
            this.currentAtomicActivity = atomicActivity;
            this.scheduler.Pause();
        }

        private void SerializeToMarkup(Activity workflow, string fileName)
        {
            workflow.SetValue(WorkflowMarkupSerializer.XClassProperty, null);

            using (XmlWriter xmlWriter = XmlWriter.Create(fileName))
            {
                WorkflowMarkupSerializer markupSerializer = new WorkflowMarkupSerializer();
                markupSerializer.Serialize(xmlWriter, workflow);
            }

            RuleDefinitions ruleDefinitions = workflow.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
            if (ruleDefinitions != null)
            {
                if (ruleDefinitions.Conditions.Count > 0 || ruleDefinitions.RuleSets.Count > 0)
                {
                    String rulesFileName = GetRulesFileName(fileName);
                    using (XmlWriter xmlWriter = XmlWriter.Create(rulesFileName))
                    {
                        WorkflowMarkupSerializer markupSerializer = new WorkflowMarkupSerializer();
                        markupSerializer.Serialize(xmlWriter, ruleDefinitions);
                    }
                }
            }
        }

 internal static RuleDefinitions Load_Rules_RT(Activity declaringActivity)
 {
     RuleDefinitions ruleDefinitionsFromManifest = declaringActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
     if (ruleDefinitionsFromManifest == null)
     {
         ruleDefinitionsFromManifest = GetRuleDefinitionsFromManifest(declaringActivity.GetType());
         if (ruleDefinitionsFromManifest != null)
         {
             declaringActivity.SetValue(RuleDefinitions.RuleDefinitionsProperty, ruleDefinitionsFromManifest);
         }
     }
     return ruleDefinitionsFromManifest;
 }