C# Activities.Variable类代码示例

        static Activity CreateWorkflow()
        {
            Variable<string> x = new Variable<string>() { Name = "x" };
            Variable<string> y = new Variable<string>() { Name = "y" };
            Variable<string> z = new Variable<string>() { Name = "z" };

            // Create a workflow with three bookmarks: x, y, z. After all three bookmarks
            // are resumed (in any order), the concatenation of the values provided
            // when the bookmarks were resumed is written to output.
            return new Sequence
            {
                Variables = { x, y, z },
                Activities =
                {
                    new System.Activities.Statements.Parallel
                    {
                        Branches =
                        {
                            new Read<string>() { BookmarkName = "x", Result = x },
                            new Read<string>() { BookmarkName = "y", Result = y },
                            new Read<string>() { BookmarkName = "z", Result = z }
                        }
                    },
                    new WriteLine
                    {
                        Text = new InArgument<string>((ctx) => "x+y+z=" + x.Get(ctx) + y.Get(ctx) + z.Get(ctx))
                    }
                }
            };
        }

 public Send()
 {
     Func<Activity> func = null;
     this.isOneWay = true;
     this.TokenImpersonationLevel = System.Security.Principal.TokenImpersonationLevel.Identification;
     if (func == null)
     {
         func = delegate {
             if (this.internalSend == null)
             {
                 return null;
             }
             if (this.requestFormatter == null)
             {
                 return this.internalSend;
             }
             Variable<Message> variable = new Variable<Message> {
                 Name = "RequestMessage"
             };
             this.requestFormatter.Message = new OutArgument<Message>(variable);
             this.requestFormatter.Send = this;
             this.internalSend.Message = new InArgument<Message>(variable);
             return new NoPersistScope { Body = new Sequence { Variables = { variable }, Activities = { this.requestFormatter, this.internalSend } } };
         };
     }
     base.Implementation = func;
 }

        // Builds a sequence of two CompensableActivites where the first is explicitly compensated
        static Activity CompensateACompensableActivity()
        {
            Variable<CompensationToken> token = new Variable<CompensationToken>();

            return new Sequence
            {
                Variables = { token },
                Activities =
                {
                    new WriteLine { Text = "Start of workflow" },

                    new CompensableActivity()
                    {
                        Body = new WriteLine() { Text = "CompensableActivity1: Body" },
                        CompensationHandler = new WriteLine() { Text = "CompensableActivity1: Compensation Handler" },
                        ConfirmationHandler = new WriteLine() { Text = "CompensableActivity1: Confirmation Handler" },
                        Result = token,
                    },

                    new CompensableActivity()
                    {
                        Body = new WriteLine() { Text = "CompensableActivity2: Body" },
                        CompensationHandler = new WriteLine() { Text = "CompensableActivity2: Compensation Handler" },
                        ConfirmationHandler = new WriteLine() { Text = "CompensableActivity2: Confirmation Handler" },
                    },

                    new Compensate()
                    {
                        Target = token,
                    },

                    new WriteLine { Text = "End of workflow" }
                }
            };
        }

 public MySequence()
     : base()
 {
     this.children = new Collection<Activity>();
     this.variables = new Collection<Variable>();
     this.currentIndex = new Variable<int>();
 }

        private static Activity CreateRulesInterop()
        {
            //Create the variables needed to be passed into the 35 Ruleset
            Variable<int> discountLevel = new Variable<int> { Default = 1 };
            Variable<double> discountPoints = new Variable<double> { Default = 0.0 };
            Variable<string> destination = new Variable<string> { Default = "London" };
            Variable<double> price = new Variable<double> { Default = 1000.0 };
            Variable<double> priceOut = new Variable<double> { Default = 0.0 };

            Sequence result = new Sequence
            {
                Variables = {discountLevel, discountPoints, destination, price, priceOut},
                Activities =
                {
                    new WriteLine { Text = new InArgument<string>(env => string.Format("Price before applying Discount Rules = {0}", price.Get(env).ToString())) },
                    new WriteLine { Text = "Invoking Discount Rules defined in .NET 3.5"},
                    new Interop()
                    {
                        ActivityType = typeof(TravelRuleSet),
                        ActivityProperties =
                        {
                            //These bind to the dependency properties of the 35 custom ruleset
                            { "DiscountLevel", new InArgument<int>(discountLevel) },
                            { "DiscountPoints", new InArgument<double>(discountPoints) },
                            { "Destination", new InArgument<string>(destination) },
                            { "Price", new InArgument<double>(price) },
                            { "PriceOut", new OutArgument<double>(priceOut) }
                        }
                    },
                    new WriteLine {Text = new InArgument<string>(env => string.Format("Price after applying Discount Rules = {0}", priceOut.Get(env).ToString())) }
                }
            };
            return result;
        }

 public SendInstanceIdScope()
     : base()
 {
     this.children = new Collection<Activity>();
     this.variables = new Collection<Variable>();
     this.currentIndex = new Variable<int>();
 }

 private static WorkflowService CreateService()
 {
     Variable<string> message = new Variable<string> { Name = "message" };
     Receive receiveString = new Receive
     {
         OperationName = "Print",
         ServiceContractName = XName.Get("IPrintService", "http://tempuri.org/"),
         Content = new ReceiveParametersContent
         {
             Parameters = 
             {
                 {"message", new OutArgument<string>(message)}
             }
         },
         CanCreateInstance = true
     };
     Sequence workflow = new Sequence()
     {
         Variables = { message },
         Activities =
         {    
             receiveString,    
             new WriteLine                        
             {    
                 Text = new InArgument<string>(env =>("Message received from Client: " + message.Get(env)))   
             },
         },
     };
     return new WorkflowService
     {
         Name = "PrintService",
         Body = workflow
     };
 }

        private static Activity CreatePrintProcessActivity(Variable<Collection<Process>> processes)
        {
            var proc = new DelegateInArgument<Process>("process");

            return new Sequence
            {
                Activities =
                {
                    // Loop over processes and print them out.
                    new ForEach<Process>
                    {
                        Values = processes,
                        Body = new ActivityAction<Process>
                        {
                            Argument = proc,
                            Handler = new WriteLine
                            {
                                Text = new InArgument<string>(ctx => proc.Get(ctx).ToString()),
                            }
                        }
                    },

                    // Print out a new line.
                    new WriteLine(),
                }
            };
        }

        static Sequence CreateWorkflow()
        {
            Variable<int> count = new Variable<int> { Name = "count", Default = totalSteps };
            Variable<int> stepsCounted = new Variable<int> { Name = "stepsCounted" };

            return new Sequence()
            {
                Variables = { count, stepsCounted },
                Activities =
                {
                    new While((env) => count.Get(env) > 0)
                    {
                        Body = new Sequence
                        {
                            Activities =
                            {
                                new EchoPrompt {BookmarkName = echoPromptBookmark },
                                new IncrementStepCount(),
                                new Assign<int>{ To = new OutArgument<int>(count), Value = new InArgument<int>((context) => count.Get(context) - 1)}
                            }
                        }
                    },
                    new GetCurrentStepCount {Result = new OutArgument<int>(stepsCounted )},
                    new WriteLine { Text = new InArgument<string>((context) => "there were " + stepsCounted.Get(context) + " steps in this program")}}
            };
        }

 /// <summary>
 /// It's constructor.
 /// </summary>
 public StateMachine()
 {
     this.internalStates = new Collection<InternalState>();
     this.internalStateFuncs = new Collection<ActivityFunc<string, StateMachineEventManager, string>>();
     this.eventManager = new Variable<StateMachineEventManager> { Name = "EventManager", Default = new LambdaValue<StateMachineEventManager>(ctx => new StateMachineEventManager()) };
     this.onStateComplete = new CompletionCallback<string>(OnStateComplete);
 }

        // Creates a workflow that uses FindInTable activity without predicate to retrieve entities from a Sql Server Database
        static Activity CreateRetrieveWithoutPredicateWF()
        {
            Variable<IList<Role>> roles = new Variable<IList<Role>>();
            DelegateInArgument<Role> roleIterationVariable = new DelegateInArgument<Role>();

            return new Sequence()
            {
                Variables = { roles },
                Activities =
                {
                    new WriteLine { Text = "\r\nAll Roles (no predicates)\r\n==============" },
                    new FindInSqlTable<Role>
                    {
                        ConnectionString = cnn,
                        Result = new OutArgument<IList<Role>>(roles)
                    },
                    new ForEach<Role>
                    {
                        Values = new InArgument<IEnumerable<Role>>(roles),
                        Body = new ActivityAction<Role>()
                        {
                            Argument = roleIterationVariable ,
                            Handler = new WriteLine { Text = new InArgument<string>(env => roleIterationVariable.Get(env).Name) }
                        }
                    }
                }
            };
        }

        static Activity CreateWF()
        {
            Variable<string> message = new Variable<string>();

            return new Sequence()
            {
                Variables = { message },
                Activities =
                {
                    new AppendString()
                    {
                        Name = ".NET WF",
                        Result = message
                    },
                    new PrependString()
                    {
                        Name = message,
                        Result = message,
                    },
                    new WriteLine()
                    {
                        Text = message
                    }
                }
            };
        }

 public Receive()
 {
     Func<Activity> func = null;
     if (func == null)
     {
         func = delegate {
             if (this.internalReceive == null)
             {
                 return null;
             }
             if (this.requestFormatter == null)
             {
                 return this.internalReceive;
             }
             Variable<Message> variable = new Variable<Message> {
                 Name = "RequestMessage"
             };
             Variable<NoPersistHandle> variable2 = new Variable<NoPersistHandle> {
                 Name = "ReceiveNoPersistHandle"
             };
             this.internalReceive.Message = new OutArgument<Message>(variable);
             this.requestFormatter.Message = new InOutArgument<Message>(variable);
             this.internalReceive.NoPersistHandle = new InArgument<NoPersistHandle>(variable2);
             this.requestFormatter.NoPersistHandle = new InArgument<NoPersistHandle>(variable2);
             return new Sequence { Variables = { variable, variable2 }, Activities = { this.internalReceive, this.requestFormatter } };
         };
     }
     base.Implementation = func;
 }

 public TestCaseActivity()
 {
     children = new Collection<Activity>();
     _currentIndex = new Variable<int>();
     ErrorLevel = OnError.Continue;
     OwnDataFirst = true;
 }

        static void Main()
        {
            Variable<string> v = new Variable<string>();
            Sequence s = new Sequence()
            {
                Variables = { v },
                Activities =
                {
                    new Assign<string>()
                    {
                        To = v,
                        Value = "hello, world"
                    },
                    new Interop()
                    {
                        ActivityType = typeof(WriteLine),
                        ActivityProperties =
                        {
                            // Bind the Text property of the WriteLine to the Variable v
                            { "Text", new InArgument<string>(v) }
                        },
                        ActivityMetaProperties =
                        {
                            // Provide a value for the Name meta-property of the WriteLine
                            { "Name", "WriteLine" }
                        }
                    }
                }
            };

            WorkflowInvoker.Invoke(s);
            Console.WriteLine("Press [enter] to exit");
            Console.ReadLine();
        }