Windows Workflow Foundation

Programming Windows Workflow Foundation Book Review

Adam Calderon — Sun, 22 Apr 2007 15:01:00 GMT

I just recently finished reading Programming Windows Workflow Foundation (Practical WF Techniques and Examples using XAML and C#) by K. Scott Allen and thought I would share my views on this very practical book.

I have been working with WF for quite a while and one of the hardest things about this technology is getting your hands around everything it can do. Scott has done a great job of walking you through the technology in a manner that enables you to not only grasp the concepts but also get some code up and running quickly. The progression of the book was well thought out getting you started on creating workflows [Chapter 2] and then progressing through sequential workflows [Chapter 3], base activities [Chapter 4], custom activities [Chapter 5], hosting workflows [Chapter 6], State Machine Workflows [Chapter 7], workflow communication [Chapter 8] and finally rules and conditions [Chapter 9]. The thing that I like about this approach is typically in most projects you will have a team of varying roles and skills and the book in my view caters to this by tackling WF development from the perspective of a workflow developer (Chapters 1,2,3,4,7,9) early on in the book and then moving to a host developer (Chapters 5,6,8) for the final half of the book. You will notice I grouped chapters 7 and 9 in with the first half of the book since I feel these topics are very workflow developer centric and the introduction to the local communication service in chapter 3 should give you enough information to tackle these topics earlier than they are presented.

This book is a fast paced book that is designed to get you up and running quickly but at the same time is not so huge that you can’t get through it quickly. It’s size (233 pages) limits what you can cover but I think Scott does a good job of presenting the topics in a detailed enough manner that you can then dive into the SDK if you need to go deeper and know what you are looking for when you do. The book has all of code online at Packt Publishing which makes it easy to follow along as you read the book. I would recommend this book to someone who is new to WF and needs a book that can quickly guide them through getting started with the technology.

Latest Workflow Article in .NET Developers Journal

Adam Calderon — Mon, 05 Feb 2007 16:20:00 GMT

My latest article Using Workflow Foundation in creating dynamic navigation applications in ASP.NET is now available online. The sample application referenced in the article is unfortunately not on the website so I included it here.

File Attachment: WebNavigationDemo.zip (248 KB)

WF XAML vs Code

Adam Calderon — Fri, 12 Jan 2007 18:41:00 GMT

I have been working with Windows Workflow Foundation (WF) for quite a while now and have been going back and forth on how I want to have the designer create my workflow. I figured I would blog about what I know (pro and con) about the two methods and see if I can spark some debate on the subject. The decision on how the workflow is created is made every time you choose a workflow template from the Visual Studio Designer. The two choices are (1) workflow with definition expressed as Xaml and user code in a separate code file or (2) workflow with definition and user code in same code file. These description of option 2 is a little off (I took it from the VS designer) because two physical files are really created one where you put your code and the second where VS puts it’s code and is in the form “xxx.designer.cs” in my case since I use C#. So what’s the big deal you ask?

The deal with the two workflow formats listed above is how you use them, how easy it is to work with them and how hard it is to modify things. How you use them really focuses on one thing which is are you going to work with the workflows dynamically. If not than you really don’t care how they are represented. If you work with a workflow dynamically using XAML you going to load the workflows using an XmlReader like this.

        using (XmlReader reader = XmlReader.Create("Workflow1.xoml"))
        {
            WorkflowInstance instance = workflowRuntime.CreateWorkflow(reader);
            instance.Start();
        }

If you plan to do things this way you have a few things to consider. One is how difficult it is going to be to edit the XAML since currently there is no intellisence support in VS for it. Second is how hard it is going to be to debug things. Here is a contrived example I came up with. The following works and there are not errors.

Next I changed CodeActivity to CodeeActivity.

Now when I compile I get the following error “Could not deserialize object. The type 'System.Workflow.Activities.CodeeActivity' could not be resolved.”. The problem with this is that I don’t get much help from the editor in where this is. No squiggly lines or anything. Now this is by no means a show stopper but it is a productivity issue that you should think about. To continue on the debugging topic for just a little more think about the errors you could encounter when calling workflowRuntime.CreateWorkflow(reader) in the above code sample. If the XAML has errors like our contrived example above you will be dealing with the WorkflowValidationFailedException which is thrown if the XAML is invalid. This exception will contain data that you can use to figure out what is going on but again this is another added level of complexity you need to be aware of. Finally there is the issue of code behind. Since the XAML is just that a XAML file your code behind is not included. This changes how you can create a workflow and really forces you to use a more complex approach to workflow development that can sometimes require creating a custom activity to perform some simple logic that could have been done in code behind. So before you read on I want to make one thing clear. The XAML approach is not bad and provides possibilities not available in the code version but there are some things to think about if you use it.

Now let’s look at the code version. This style is similar to what the WinForms designer has been doing for a while. You have a series of .NET code statements that build up a workflow. The above activity example looks like this in the code version.

/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
System.Diagnostics.DebuggerNonUserCode]
private void InitializeComponent()
{
    this.CanModifyActivities = true;
    this.codeActivity1 = new System.Workflow.Activities.CodeActivity();
    //
    // codeActivity1
    //
    this.codeActivity1.Name = "codeActivity1";
    this.codeActivity1.ExecuteCode += new System.EventHandler(this.codeActivity1_ExecuteCode);
    //
    // Workflow1
    //
    this.Activities.Add(this.codeActivity1);
    this.Name = "Workflow1";
    this.CanModifyActivities = false;
}

The work in the code behind version happens in the InitializeComponent method and at the end of the method the Code activity is added to the workflow. So with this approach you do get intellisence and it is easy to debug but it’s a little harder to read and you don’t get any ability to dynamically bring in a workflow since the code to create it (see below) requires the type of the workflow. Now I want to say that you can create a workflow dynamically in this case but you have to use a little reflection to make it happen and it’s not a easy as the above XmlReader code.

using(WorkflowRuntime workflowRuntime = new WorkflowRuntime())
{

WorkflowInstance instance = workflowRuntime.CreateWorkflow(typeof(WorkflowRepresentationChoices.Workflow1));
instance.Start();

}

The other thing in your favor here is that the workflow will be compiled and validated when you load it. In the case of the XAML and the XmlReader the validation occurs as the workflow is created.

So with all of this said what do you choose? If you are a code person you choose the code version and if you need to do things dynamically you use reflection. If you are an xml person you use XAML and you design you workflows in an abstract manner (use activities for everything) if you want to load them dynamically. Of course if you are doing things dynamically and do have a bunch of files in a directory, being able to open them up in an editor and seeing what they do can be helpful. For me I so desperately want a full fledged intellisense XAML editor that I can use to go back and forth with like I can do in WPF. I just love that experience.

I am teaching a class on Windows Workflow Foundation

Adam Calderon — Mon, 08 Jan 2007 21:32:00 GMT

I will be teaching a class on Windows Workflow Foundation at UCSD Extensions starting on January 22. I am totally impressed with the folks at UCSD Extensions for being at the cutting edge and offering a class like this so early. If you are interested in learning more about the class please visit UCSD Extensions

WF Presentation at San Diego .NET Developers Group

Adam Calderon — Wed, 04 Oct 2006 10:24:00 GMT

Thanks for showing up to my presentation on Windows Workflow. Here are the slides and demo code. If you are interested I will be teaching a class on Windows Workflow at UCSD Extensions. Here is the link: http://www.extension.ucsd.edu/studyarea/index.cfm?vCourse=CSE-40989

File Attachment: Introduction to Windows Workflow Foundation.ppt (2176 KB)

File Attachment: Intro to WF.zip (502 KB)

XAML a closer look

Adam Calderon — Fri, 21 Jul 2006 17:08:00 GMT

XAML (Extensible Application Markup Language) is an xml based language for creating trees of .NET objects. It is being used not only in Windows Presentation Foundation (WPF) but also in Windows Workflow Foundation (WF). The strenght behind this language is it’s human readable and writeable. This channel 9 video There's Something About XAML presented by Rob Relyea a Program Manager on the WPF team talks about the history of XAML, how it's been designed, how it works, what a BAML file is and what's in it, how the build process works, thoughts on debugging, tooling, and much more. This is a really cool video with lots of great content.