Microsoft Windows Workflow Foundation 4.0 Cookbook

Create a Workflow Console Application project:

After starting Visual Studio 2010, select File | New Project. A dialog is presented, as shown in the following screenshot. Under the Visual C# section, select Workflow, and choose Workflow Console Application. Name the project HelloWorkflow. Name the solution Chapter01 and make sure to create a directory for the solution.

Author the workflow program:

First, drag a Sequence activity to the designer from Toolbox, next drag a WriteLine activity into the Sequence activity. Finally, input "Hello Workflow" in the expression box of the WriteLine activity. We can see in the following screenshot:

Run it:

Press Ctrl+F5 to run the project without debugging. The result is as shown in the following screenshot:

Create a Console Application project:

Create a new Console Application project under the Chapter01 solution. Name the project HelloCodeWorkflow. The following screenshot shows the Console Application new project dialog:

Add reference to the System.Activities assembly:

By default, a new Console Application doesn't have reference to the System.Activities assembly, due to which we need to perform this step.

Create workflow definition code:

Open Program.cs file and change the code present as follows:

using System.Activities;
using System.Activities.Statements;

namespace HelloCodeWorkflow {
    class Program {
        static void Main(string[] args) {
            WorkflowInvoker.Invoke(new HelloWorkflow());
        }
    }

    public class HelloWorkflow:Activity {
        public HelloWorkflow() {
            this.Implementation = () => new Sequence {
                Activities = {
                    new WriteLine(){Text="Hello Workflow"}
                }
            };
        }
    }
}

Run it:

Set HelloCodeWorkflow as StartUp project and press Ctrl+F5 to run it. As expected, the result should be just like the previous result shown.

Create a workflow project:

Create a new Workflow Console Application under the Chapter01 solution. Name the project UseInArgument .

Author the WF program:

Create a workflow as shown in the following screenshot:

Write code to host the workflow.

Open the Program.cs file and change the host code as follows:

using System.Activities;
using System.Activities.Statements;

namespace UseInArgument {
class Program {
        static void Main(string[] args) {
            WorkflowInvoker.Invoke(new Workflow1() 
            {
                FirstName="Andrew",
                SecondName="Zhu"
            });
        }
    }
}

Run it:

Set UseInArgument as StartUp project. Press Ctrl+F5 to build and run the workflow without debugging. The application should run in a console window and print the following message:

Create a workflow project:

Create a new Workflow Console Application under the Chapter01 solution; name the project as UseOutArgument.

Author a workflow:

Author the workflow shown in the following screenshot. Here are the detailed actions:

Write code to host the workflow:

Open Program.cs file and change the host code as follows:

using System;
using System.Activities;
using System.Collections.Generic;

namespace UseOutArgument {
    class Program {
        static void Main(string[] args) {
            IDictionary<string,object> output=
                WorkflowInvoker.Invoke(new Workflow1());
            Console.WriteLine(output["OutMessage"]);
        }
    }
}

Run it:

Set UseOutArgument as Startup project. Press Ctrl+F5 to build and run the workflow without debugging. The application should run in a console window and print the message as shown in the next screenshot:

Create a workflow project:

Create a new Workflow Console Application under the Chapter01 solution and name the project as UseInOutArgument.

Author a workflow:

Create an InOutArgument type argument: InOutMessage. Author a WF program as shown in the following screenshot. In the Assign activity textbox, type InOutMessage = "Now, I am an OutMessage".

Write code to host the workflow:

Open the Program.cs file and alter the code as shown:

using System;
using System.Activities;
using System.Activities.Statements;
using System.Collections.Generic;

namespace UseInOutArgument{
    class Program{
        static void Main(string[] args){
            IDictionary<string, object> input =
                new Dictionary<string, object>() 
            { 
                {"InOutMessage","Now, I am InMessage"}
            };
            IDictionary<string,object> output=
                WorkflowInvoker.Invoke(new Workflow1(),input);
            Console.WriteLine(output["InOutMessage"]);
        }
    }
}

Run it:

Set UseInOutArgument as Startup project. Press Ctrl+F5 to build and run the workflow without debugging. The application should run in a console window and print the message as shown in the following screenshot:

Create a workflow project:

Create a new Workflow Console Application under the Chapter01 solution and name the project as UseVariable.

Author a workflow:

Add a Sequence activity, click the Sequence activity, create an Int32 NumberCounter variable, and set its Scope to Sequence. Then, author the workflow as shown in the following screenshot. In the second Assign activity type NumberCounter=NumberCounter+1.

Run it:

Set UseVariable as Startup project. Press Ctrl+F5 to build and run the workflow without debugging. The application should run in a console window and print the following message:

Create a workflow project:

Create a new Workflow Console Application under the Chapter01 solution and name the project as UseWorkflowApplication.

Author a workflow:

In the opening Workflow1.xaml designer, click on Arguments, create two Int32 InArguments for Number1 and Number2. Create an Int32 OutArgument for Result. Add an Assign activity to the workflow designer panel. In the Assign activity, type Result=Number1+Number2.

Write code to host the workflow:

Open Program.cs file and change code as follow:

using System;
using System.Activities;
using System.Activities.Statements;
using System.Threading;
using System.Collections.Generic;

namespace UseWorkflowApplication{
    class Program{
        static void Main(string[] args){
            AutoResetEvent syncEvent = 
               new AutoResetEvent(false);
            IDictionary<string, object> input = 
               new Dictionary<string, object>()
            {
                {"Number1",123},
                {"Number2",456}
            };
            IDictionary<string,object> output=null;
            WorkflowApplication wfApp = 
               new WorkflowApplication(new Workflow1(),input);
            wfApp.Completed = 
            delegate(WorkflowApplicationCompletedEventArgs e)
            {
                Console.WriteLine("Workflow thread id:"+
                        Thread.CurrentThread.ManagedThreadId);
                output = e.Outputs;
                syncEvent.Set();
            };
            wfApp.Run();
            syncEvent.WaitOne();
            Console.WriteLine(output["Result"].ToString());
            Console.WriteLine("Host thread  id:"+Thread.CurrentThread.ManagedThreadId);
        }
    }
}

Run it:

Set UseWorkflowApplication as Startup project. Press Ctrl+F5 to build and run the workflow without debugging. The application should run in a console window and print the following message:

Create a workflow project:

Create a new Workflow Console Application under the Chapter01 solution and name the project as UseBookmark. Next, add a code file to this project and name the file as MyReadLineActivity. We can see this in the following screenshot:

Customize the activity with Bookmark:

Fill the opening MyReadLineActivity.cs file with the following code:

using System.Activities;
namespace UseBookmark{
    public class MyReadLine : NativeActivity<string>{
        [RequiredArgument]
        public InArgument<string> BookmarkName { get; set; }
        protected override void Execute(
            NativeActivityContext context)
        {
            context.CreateBookmark(BookmarkName.Get(context),
                     new BookmarkCallback(OnResumeBookmark));
        }
        protected override bool CanInduceIdle
        {
            get
            {
                { return true;}
            }
        }
        public void OnResumeBookmark(
            NativeActivityContext context,
            Bookmark bookmark,
            object obj)
        {
            Result.Set(context, (string)obj);
        }
    }
}

Save the file and press F6 to build the project so that the activity will appear in the WF designer activity toolbox.

Author a workflow:

Open Workflow1.xaml and author the workflow as shown in the following screenshot:

Write code to host the workflow:

Open Program.csfile and change the code as follows:

using System;
using System.Linq;
using System.Activities;
using System.Activities.Statements;
using System.Threading;

namespace UseBookmark{
    class Program{
        static void Main(string[] args)
        {
            AutoResetEvent syncEvent = 
                new AutoResetEvent(false);
            string bookmarkName="GreetingBookmark";
            WorkflowApplication wfApp = 
                new WorkflowApplication(new Workflow1()
            {
                BookmarkNameInArg=bookmarkName
            });
            wfApp.Completed = delegate(
                WorkflowApplicationCompletedEventArgs e)
            {
                syncEvent.Set();
            };
            wfApp.Run();
            wfApp.ResumeBookmark(bookmarkName, 
                Console.ReadLine());
            syncEvent.WaitOne();
        }
    }
}

Run it:

Set UseBookmark as Startup project. Press Ctrl+F5 to build and run the workflow without debugging. The application should run in a console window and print the message as shown in the following screenshot:

Create a workflow project:

Create a new Workflow Console Application under the Chapter01 solution and name the project ConvertWFInstanceToXML. Delete the Workflow1.xaml file that is created by default.

Write code to create the workflow and its host:

Open Program.cs file and change the code as follows:

using System;
using System.Activities;
using System.Activities.Statements;
using System.Text;
using System.Xaml;
using System.Activities.XamlIntegration;
using System.IO;

namespace ConvertWFObjectToXML {
    class Program {
        static void Main(string[] args) {
            //Create a Workflow instance object
            ActivityBuilder ab = new ActivityBuilder();
            ab.Implementation = new Sequence() 
            {
                Activities =
                {
                    new WriteLine{Text="Message from Workflow"}
                }
            };

            //Convert Workflow instance to xml string
            StringBuilder sb = new StringBuilder();
            StringWriter sw = new StringWriter(sb);
            XamlWriter xw = 
                ActivityXamlServices.CreateBuilderWriter(
                new XamlXmlWriter(sw, 
                                  new XamlSchemaContext()));
            XamlServices.Save(xw, ab);
            Console.WriteLine(sb.ToString());
        }
    }
}

Run it:

Set ConvertWFInstanceToXML as Startup project. Press Ctrl+F5 to build and run the workflow without debugging. The application should run in a console window and print the message as shown in the following screenshot:

Create a workflow project:

Create a new Workflow Console Application under the Chapter01 solution and name the project as LoadUpWorkflowFromXML.

Author a workflow:

Author the Workflow1.xaml file; this workflow will print a string to console as shown in the following screenshot:

Create code to load up the workflow instance from an XAML string:

Open Program.cs file and change code as follow:

using System;
using System.Activities;
using System.Activities.Statements;
using System.IO;
using System.Collections;
using System.Text;
using System.Activities.XamlIntegration;

namespace LoadUpWorkflowFromXML {
    class Program {
        static void Main(string[] args) {
            string filePath=           @"C:\WF4Cookbook\Chapter01\LoadUpWFFromXML\Workflow1.xaml";
            string tempString="";
            StringBuilder xamlWFString = new StringBuilder();
            StreamReader xamlStreamReader = 
                new StreamReader(filePath);
            while (tempString != null){
                tempString = xamlStreamReader.ReadLine();
                if (tempString != null) {
                    xamlWFString.Append(tempString);
                }
            }
            Activity wfInstance = ActivityXamlServices.Load(
                new StringReader(xamlWFString.ToString()));
            WorkflowInvoker.Invoke(wfInstance);
        }
    }
}

Run it:

Set LoadUpWorkflowFromXML as Startup project. Press Ctrl+F5 to build and run the workflow without debugging. The application should run in a console window and print the message as shown in the following screenshot:

Add a Test Project to the solution:

Add a Test Project to the Chapter01 solution and name the project as UnitTestForWFProgram as shown in the following screenshot:

Add a workflow file to the Test Project:

Add a workflow activity to this project. Right-click the newly created Test Project, then go to Add | New Items… | Workflow | Activity and name the activity as WorkflowForTest.xaml. In the opening WF designer, create an OutArgument as OutMessage. Next, drag an Assign activity to the Designer panel and assign the string "Test Message" to the OutMessage argument as shown in the following screenshot:

Create unit test code:

Open the UnitTest1.cs file and fill the file with following code:

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Activities;

namespace UnitTestForWFProgram {
    [TestClass]
    public class UnitTest1 {
        [TestMethod]
        public void TestMethod1() {
            var output = 
                WorkflowInvoker.Invoke(new WorkflowForTest());
            Assert.AreEqual("Test Message", 
                            output["OutMessage"]);
        }
    }
}

Run it:

Set UnitTestForWorkflow as Startup project. Press Ctrl+F5 to build and run the test without debugging as shown in the following screenshot:

Create a workflow project:

Create a new Workflow Console Application project under the Charpter01 solution. Name the project as DebugWFProgram. In the opening WF designer panel, author a workflow as shown in the following screenshot:

Create workflow host code:

Open Program.cs file and change the code to:

using System.Activities;
using System.Activities.Statements;

namespace DebugWFProgram{
    class Program{
        static void Main(string[] args){
            WorkflowInvoker.Invoke(new Workflow1()
            { 
                InMessage="In Message"
            });
        }
    }
}

Set a debug break point:

Right-click an activity and select Breadpoint | Insert Breakpoint to add debug break point.

Debug it:

Press F5 to debug the WF Program; we can refer the following screenshot: