public event PropertyChangedEventHandler PropertyChanged; 

        internal void RaisePropertyChanged(string propertyName)
        {
            var handler = PropertyChanged;
            if (handler != null)
                handler(this, new PropertyChangedEventArgs(propertyName));
        }

A much simpler approach is to instead do this

        public event PropertyChangedEventHandler PropertyChanged = delegate { };

        internal void RaisePropertyChanged(string propertyName)
        {
            // No need for null check because of empty delegate
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }

which eleminates the need for the null check and eliminates the potential race conditions in multi-threaded code.

BackgroundWorker is a class that was introduced with in Windows Forms 2.0 to simplify executing work on background threads allowing UI developers to easily keep their UIs responsive by not tying up the UI thread. It’s a tool that was very useful and if you don’t already know then you’ll probably be very pleased to find out that you can still use BackgroundWorker in WPF. This is because BackgroundWorker uses AsyncOperationManager which in turn uses SynchronizationContext to marshall work. In Windows Forms AsyncOperationManager gets a WindowsFormsSynchronizationContext class from the Forms application that derives from the SynchronizationContext class and uses it for marshalling. When using WPF a DispatcherSynchronizationContext is fetched by AsyncOperationManager which allows for easy marshalling of calls to background threads using BackgroundWorker.

Below is sample code for a simple form that will take your name as input and the write out “Hello ” as output after a 5 second delay. If you run the application you will see that it is responsive during the delay and that you can resize and move the windows around as you should be able to when doing work on background threads. The demo also shows how to pass a value (your name) from the UI to the background thread.

Xaml

<Window x:Class="WpfBackgroundWorker.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Window1" Height="300" Width="300">
    <StackPanel>
        <TextBlock x:Name="Header" >Enter your name</TextBlock>
        <TextBox x:Name="InputTextBox" />
        <Button x:Name="DoWorkButton" Content="Do work" Click="DoWorkButton_Click" />
        <TextBlock x:Name="OutputTextBlock" />
    </StackPanel>
</Window>

Code behind

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.ComponentModel;
using System.Threading;

namespace WpfBackgroundWorker
{
    /// <summary>
    /// Interaction logic for Window1.xaml
    /// </summary>
    public partial class Window1 : Window
    {
        private BackgroundWorker _backgroundWorker;

        public Window1()
        {
            InitializeComponent();

            // Will use DispatcherSynchronizationContext
            _backgroundWorker = new BackgroundWorker();

            // Wire up event handlers
            _backgroundWorker.DoWork
                += new DoWorkEventHandler(_backgroundWorker_DoWork);
            _backgroundWorker.RunWorkerCompleted
                += new RunWorkerCompletedEventHandler(_backgroundWorker_RunWorkerCompleted);
        }

        void _backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            string result = (string)e.Result;

            if (e.Cancelled)
            {
                OutputTextBlock.Text = "Cancelled";
            }
            else if (e.Error != null)
            {
                OutputTextBlock.Text = "Exception: " + e.Error.Message;
            }
            else
            {
                OutputTextBlock.Text = result;
            }
        }

        void _backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            // Wait 5 seconds to simulate long running work
            Thread.Sleep(5000);

            // Assign the result to the Result property
            // of the DoWorkEventArgs
            // object. This is will be available to the
            // RunWorkerCompleted eventhandler.
            e.Result = "Hello " + e.Argument.ToString();
        }

        private void DoWorkButton_Click(object sender, RoutedEventArgs e)
        {
            if (string.IsNullOrEmpty(InputTextBox.Text))
            {
                MessageBox.Show("You must enter a name.");
                return;
            }

            // Do work on background thread
            _backgroundWorker.RunWorkerAsync(InputTextBox.Text);
        }
    }
}

Simply substitue the GUID for the WF instance that you want to find out tracking details about and then fire the query to see the tracking data.

declare  @WorkflowInstanceInternalId   bigint

select   @WorkflowInstanceInternalId = WorkflowInstanceInternalId
from dbo.WorkflowInstance
where
         WorkflowInstanceId = 'E3573C8D-96D7-47C9-AE64-CB3E197A18CE'

select   wie.EventDateTime,
         'Workflow ' + twe.Description [Status],
         wie.EventOrder,
         '' [QualifiedName],
         '' [TypeName],
         '' [UserDataKey],
         '' [UserData_str]
from dbo.WorkflowInstanceEvent wie
   inner join dbo.TrackingWorkflowEvent twe
      on (wie.TrackingWorkflowEventId = twe.TrackingWorkflowEventId)
where wie.WorkflowInstanceInternalId = @WorkflowInstanceInternalId
union
select   se.EventDateTime,
         aes.Description [Status],
         se.EventOrder,
         ai.QualifiedName,
         case when charindex('.',reverse(t.TypeFullName)) > 1
                   then right(t.TypeFullName,charindex('.',reverse(t.TypeFullName))-1)
                   else ''
            end [Type],
         '' [UserDataKey],
         '' [UserData_str]
from dbo.ActivityExecutionStatusEvent se
   inner join dbo.ActivityExecutionStatus aes
      on (se.ExecutionStatusId = aes.ExecutionStatusId)
   inner join dbo.ActivityInstance ai
      on (se.ActivityInstanceId = ai.ActivityInstanceId)
   inner join dbo.WorkflowInstance wi
      on (ai.WorkflowInstanceInternalId = wi.WorkflowInstanceInternalId)
   left join dbo.Activity a
      on (a.WorkflowTypeId = wi.WorkflowTypeId
      and ai.QualifiedName = a.QualifiedName)
   inner join dbo.Type t
      on (a.ActivityTypeId = t.TypeId)
where se.WorkflowInstanceInternalId = @WorkflowInstanceInternalId
union
select   ue.EventDateTime,
         'UserData' [Status],
         ue.EventOrder,
         ai.QualifiedName,
         '' [TypeName],
         ISNULL(ue.UserDataKey, '') [UserDataKey],
         ue.UserData_str
from dbo.vw_UserEvent ue
   inner join dbo.ActivityInstance ai
      on (ue.ActivityInstanceId = ai.ActivityInstanceId)
where ue.WorkflowInstanceInternalId = @WorkflowInstanceInternalId
order by EventOrder,
         EventDateTime

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Workflow.Runtime;
using System.Workflow.Runtime.Hosting;
using System.Workflow.ComponentModel;
using Oracle.DataAccess.Client;
using Oracle.DataAccess.Types;
using System.Data;
using System.Configuration;
using System.IO;
using System.Diagnostics.CodeAnalysis;
using System.Threading;
using System.Collections.Specialized;
using System.Transactions;
namespace OracleWorkflowDemoService
{
    class OraclePersistenceService : WorkflowPersistenceService, IPendingWork
    {
        private readonly object _lockTimer;
        private readonly TimeSpan _loadInterval;
        private Timer _loadIntervalTimer;

        public OraclePersistenceService(NameValueCollection parameters)
            : this(parameters["UnloadOnIdle"] != null ? bool.Parse(parameters["UnLoadOnIdle"]) : false,
                parameters["InstanceOwnershipDuration"] != null ? int.Parse(parameters["InstanceOwnershipDuration"]) : 0,
                parameters["LoadInterval"] != null ? int.Parse(parameters["LoadInterval"]) : 0)
        {
        }

        protected OraclePersistenceService(Boolean unloadOnIdle, int instanceOwnershipDuration, int loadInterval)
        {
            _lockTimer = new object();
            _loadInterval = new TimeSpan(0,0,loadInterval);
        }       

        protected override void Start()
        {
            base.Start();
        }

        protected override void OnStarted()
        {
            try
            {
                base.OnStarted();

                if (_loadInterval > TimeSpan.Zero)
                {
                    lock (_lockTimer)
                    {
                        _loadIntervalTimer = new Timer(LoadExpiredWorkflows, null, _loadInterval, _loadInterval);
                    }
                }

            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        protected override void OnStopped()
        {
            base.OnStopped();
        }

        protected override void Stop()
        {
            base.Stop();
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="scopeId"></param>
        /// <param name="outerActivity"></param>
        /// <returns></returns>
        protected override Activity LoadCompletedContextActivity(Guid scopeId, Activity outerActivity)
        {
            //get the workflow instance ID
            Guid instanceId = WorkflowEnvironment.WorkflowInstanceId;
            Activity activity = Deserialize(instanceId, scopeId, outerActivity);
            if (activity == null)
            {
                RaiseException(instanceId,
                "Unable to deserialize activity", null);
            }
            return activity;
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="instanceId"></param>
        /// <returns></returns>
        protected override Activity LoadWorkflowInstanceState(Guid instanceId)
        {
            Activity activity = Deserialize(instanceId, Guid.Empty, null);
            if (activity == null)
            {
                RaiseException(instanceId, "Unable to deserialize workflow", null);
            }
            return activity;
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="activity"></param>
        protected override void SaveCompletedContextActivity(Activity activity)
        {
            WorkItem workItem = new WorkItem();

            workItem.activity = activity;
            workItem.contextId = (Guid)activity.GetValue(Activity.ActivityContextGuidProperty);
            workItem.instanceId = WorkflowEnvironment.WorkflowInstanceId;
            workItem.State = WorkItem.workflowState.ActiveInstance;

            WorkflowEnvironment.WorkBatch.Add(this, workItem);
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="rootActivity"></param>
        /// <param name="unlock"></param>
        protected override void SaveWorkflowInstanceState(Activity rootActivity, bool unlock)
        {
            //get the workflow instance ID
            Guid WFinstanceId = WorkflowEnvironment.WorkflowInstanceId;

            //determine the status of the workflow
            WorkflowStatus status = WorkflowPersistenceService.GetWorkflowStatus(rootActivity);
            WorkItem workItem = new WorkItem();
            workItem.activity = rootActivity;
            workItem.instanceId = WFinstanceId;
            workItem.contextId = Guid.Empty;

            switch (status)
            {
                case WorkflowStatus.Completed:
                case WorkflowStatus.Terminated:
                    workItem.State = WorkItem.workflowState.Completed;
                    break;
                default:
                    workItem.State = WorkItem.workflowState.ActiveInstance;
                    break;
            }

            WorkflowEnvironment.WorkBatch.Add(this, workItem);
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="activity"></param>
        /// <returns></returns>
        protected override bool UnloadOnIdle(Activity activity)
        {
            //always unload on idle
            return true;
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="rootActivity"></param>
        protected override void UnlockWorkflowInstanceState(Activity rootActivity)
        {

        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="instanceId"></param>
        /// <param name="contextId"></param>
        /// <param name="activity"></param>
        private void Serialize(Guid instanceId, Guid contextId, Activity activity)
        {
            OracleConnection conn = new OracleConnection(ConfigurationManager.ConnectionStrings["OraclePersistenceService"].ConnectionString);
            try
            {
                string commandtext = "";
                string result = "";

                OracleCommand comd = new OracleCommand();
                comd.Connection = conn;
                comd.BindByName = true;

                TimerEventSubscriptionCollection timerEvent =
                    (TimerEventSubscriptionCollection)activity.GetValue(
                    TimerEventSubscriptionCollection.TimerCollectionProperty);

                DateTime nexttimer = new DateTime();

                if (timerEvent != null)
                {
                    TimerEventSubscription timerEventSubscription = timerEvent.Peek();
                    if (timerEventSubscription != null)
                        nexttimer = timerEventSubscription.ExpiresAt;
                }
                             
               
                OracleParameter param1 = comd.Parameters.Add("instanceid", OracleDbType.Char, 36);
                param1.Direction = ParameterDirection.Input;
                param1.Value = instanceId.ToString();

                OracleParameter param2 = comd.Parameters.Add("state", OracleDbType.Blob);
                param2.Direction = ParameterDirection.Input;
                param2.Value = GetDefaultSerializedForm(activity);

                OracleParameter param3 = comd.Parameters.Add("nexttimer", OracleDbType.TimeStamp);
                param3.Direction = ParameterDirection.Input;
                param3.Value = nexttimer.ToLocalTime();

                commandtext = "Select uidInstanceId from InstanceState where uidInstanceId = '" + instanceId.ToString() + "'";
                comd.CommandText = commandtext;

                conn.Open();

                result = (string)comd.ExecuteScalar();

                if (result == null)
                {
                    commandtext = " Insert into InstanceState (uidInstanceID,state,Modified,NextTimer) VALUES (:instanceid, :state,sysdate,:nexttimer) ";
                }
                else
                {
                    commandtext = " Update InstanceState set state = :state, Modified = sysdate, NextTimer = :nexttimer where uidInstanceId = :instanceid  ";
                }

                comd.CommandText = commandtext;               
                comd.ExecuteNonQuery();
             

                if (!contextId.Equals(Guid.Empty))
                {
                    commandtext = "Select contextId from ContextState where contextId = '" + contextId.ToString() + "'";
                    comd.CommandText = commandtext;
                    result = (string)comd.ExecuteScalar();

                    if (result == null)
                    {
                        commandtext = " Insert into ContextState (uidInstanceID,contextId,state,Modified,ActivityName) VALUES (:instanceid, :contextid, :state, sysdate,'" + activity.Name + "') ";
                    }
                    else
                    {
                        commandtext = " Update ContextState set state = :state, Modified = sysdate where uidInstanceId = :instanceid and contextId = :contextid ";
                    }

                    comd.Parameters.Remove(param3);
                    OracleParameter param4 = comd.Parameters.Add("contextid", OracleDbType.Char, 36);
                    param4.Direction = ParameterDirection.Input;
                    param4.Value = contextId.ToString();

                    comd.CommandText = commandtext;
                    comd.ExecuteNonQuery();

                }
                   

            }
            catch (Exception ex)
            {
                RaiseException(instanceId,
                "Exception in serialization", ex);
            }
            finally
            {
                if (conn.State == ConnectionState.Open)
                    conn.Close();

            }
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="instanceId"></param>
        /// <param name="contextId"></param>
        /// <param name="rootActivity"></param>
        /// <returns></returns>
        private Activity Deserialize(Guid instanceId, Guid contextId, Activity rootActivity)
        {
            Activity activity = null;
            OracleConnection conn = new OracleConnection(ConfigurationManager.ConnectionStrings["OraclePersistenceService"].ConnectionString);
            try
            {

                OracleCommand comd = new OracleCommand();
                string commandtext = "";

                comd.Connection = conn;
                comd.BindByName = true;

                OracleParameter param1 = comd.Parameters.Add("state", OracleDbType.Blob);
                param1.Direction = ParameterDirection.Output;

                OracleParameter param2 = comd.Parameters.Add("instanceid", OracleDbType.Char, 36);
                param2.Direction = ParameterDirection.Input;
                param2.Value = instanceId.ToString();

                if (!contextId.Equals(Guid.Empty))
                {
                    commandtext = "Begin SELECT state into :state from ContextState WHERE uidInstanceId = :instanceid and contextId = :contextid; END;";
                    OracleParameter param3 = comd.Parameters.Add("contextid", OracleDbType.Char, 36);
                    param3.Direction = ParameterDirection.Input;
                    param3.Value = contextId.ToString();
                }
                else
                {
                    commandtext = "Begin SELECT state into :state from InstanceState WHERE uidInstanceId = :instanceid; END;";
                }
                              
                comd.CommandText = commandtext;            
               
                conn.Open();
                comd.ExecuteNonQuery();

                activity = RestoreFromDefaultSerializedForm((byte[])((OracleBlob)(comd.Parameters[0].Value)).Value, rootActivity);               
               
            }
            catch (Exception ex)
            {
                RaiseException(instanceId,
                "Exception in deserialization", ex);
            }
            finally
            {
                if (conn.State == ConnectionState.Open)
                    conn.Close();

            }
            return activity;
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="instanceId"></param>
        private void DeleteWorkflow(Guid instanceId)
        {

            OracleConnection conn = new OracleConnection(ConfigurationManager.ConnectionStrings["OraclePersistenceService"].ConnectionString);
            try
            {
                OracleCommand comd = new OracleCommand(String.Concat("Delete InstanceState where uidInstanceId = '", instanceId.ToString(), "'"), conn);

                conn.Open();

                comd.ExecuteNonQuery();

                comd.CommandText = String.Concat("Delete contextstate where uidInstanceId = '", instanceId.ToString(), "'");
                comd.ExecuteNonQuery();

            }
            catch (Exception e)
            {
                RaiseException(instanceId,
                "Exception in deletion", e);
            }
            finally
            {
                if (conn.State == ConnectionState.Open)
                    conn.Close();

            }
        }

        private void RaiseException(Guid instanceId, String message, Exception ex)
        {
            if (ex == null)
            {
                throw new PersistenceException(
                String.Format("Workflow: {0} Error: {1}",
                instanceId, message));
            }
            else
            {
                throw new PersistenceException(
                String.Format("Workflow: {0} Error: {1}: Inner: {2}",
                instanceId, message, ex.Message), ex);
            }
        }

        #region IPendingWork Members

        public void Commit(Transaction transaction, System.Collections.ICollection items)
        {
            try
            {
                foreach (WorkItem item in items)
                {
                    if (item.State == WorkItem.workflowState.ActiveInstance)
                        Serialize(item.instanceId, item.contextId, item.activity);
                    else
                        DeleteWorkflow(item.instanceId);

                }
            }
            catch (Exception ex)
            {
                RaiseException(Guid.Empty, "Exception in commit", ex);
            }
        }

        public void Complete(bool succeeded, System.Collections.ICollection items)
        {

        }

        public bool MustCommit(System.Collections.ICollection items)
        {
            return true;
        }

        #endregion
      

        /// <summary>
        ///
        /// </summary>
        /// <param name="state"></param>
        private void LoadExpiredWorkflows(object state)
        {
            lock (_lockTimer)
            {
                if (State != WorkflowRuntimeServiceState.Started)
                    return;
               
                OracleConnection conn = new OracleConnection(ConfigurationManager.ConnectionStrings["OraclePersistenceService"].ConnectionString);
                try
                {
                    OracleCommand comd = new OracleCommand("Select uidInstanceId from InstanceState where nexttimer < sysdate ", conn);

                    conn.Open();

                    OracleDataReader reader = comd.ExecuteReader();

                    while (reader.Read())
                    {
                        Runtime.GetWorkflow(new Guid(reader["uidInstanceId"].ToString())).Load();
                    }

                }
                catch (Exception ex)
                {
                    RaiseException(Guid.Empty, "Exception in loading expired workflows", ex);
                }
                finally
                {
                    if (conn.State == ConnectionState.Open)
                        conn.Close();
                }               
            }
        }
    }
     

    class WorkItem
    {
        public Activity activity;
        public Guid instanceId;
        public Guid contextId;
        public workflowState State;

        public enum workflowState
        {
            /// <summary>
            /// Pending work item is for a workflow instance.
            /// </summary>
            ActiveInstance,
            /// <summary>
            /// Pending work item is for a completed scope.
            /// </summary>
            Completed
        }
   
    }
}

Hosting in a windows service has a few gotcha’s to it as I found out on my first WF project and I wanted to share those here to hopefully help others to get things running much quicker than I did.

Introduction

The code to host in a Windows service is the same as in any other windows application and you can find those details here. However, hosting in a Windows service needs some special handling and this is because you need to call WorkflowRuntime.StartRuntime(), WorkflowRuntime.StopRuntime(), and WorkflowRuntime.Dispose() on the same thread and the SCM (Service Control Manager) which is the Windows service that will call your Windows Services OnStart() and OnStop() methods will call these methods on different threads which is illustrated below. 

You will want to put WorkflowRuntime.StartRuntime() in your OnStart() method and you will want to put your calls to WorkflowRuntime.StopRuntime() and WorkflowRuntime.Dispose() in the OnStop() method and you will need a way to make sure that all of these calls are preformed on the same thread or you will exprience issues like server hangs on shutdown.

SyncronizationContext

A custom SynchronizationContext is the tool that I used to preform calls on the same thread. My code is based on the threading articles by mikeperetz and I won’t be covering the threading details in this article so please see Mike’s articles for those details. I’ve taken the code in that article series and created my own custom SynchronizationContext called MainThreadSynchronizationContext which is included in the sample code and allows for you to easily marshal calls to the same thread by using the Send method shown below.

    public partial class WorkflowServer : ServiceBase
    {
        private MainThreadSynchronizationContext _syncContext = null;
        WorkflowRuntime _runtime = null;

        public WorkflowServer()
        {
            InitializeComponent();
        }

        protected override void OnStart(string[] args)
        {
            // Create new thread using MainThreadSynchronizationContext and then
            // send message to call Start() on the new "Main WF Thread" thread
            _syncContext = new MainThreadSynchronizationContext("Main WF Thread");
            _syncContext.Send(Start, null);
        }

        // Will be called on "Main WF Thread"
        protected void Start(object data)
        {
            _runtime = new WorkflowRuntime();
            _runtime.StartRuntime();

            // Do other WF related processing
        }

        protected override void OnStop()
        {
            // Call Stop() on "Main WF Thread"
            _syncContext.Send(Stop, null);
        }

        // Will be called on "Main WF Thread"
        protected void Stop(object data)
        {
            _runtime.StopRuntime();
            _runtime.Dispose();
        }
    }

If you use this technique your server will start and stop nicely and you won’t experience any hangs on shutdown which was something we were seeing a lot on my current project.

Aborting SQL Server

The way it works is by creating a custom SQLWorkflowPersistenceService by deriving from SQLWorkflowPersistenceService and then overriding the save method as shown below.

protected override void SaveWorkflowInstanceState(Activity rootActivity, bool unlock)
{
WorkflowStatus workflowStatus = WorkflowPersistenceService.GetWorkflowStatus(rootActivity);
if (workflowStatus == WorkflowStatus.Terminated)
    {
string workflowError = WorkflowPersistenceService.GetSuspendOrTerminateInfo(rootActivity);
if (string.IsNullOrEmpty(workflowError))
            throw new Exception("Workflow terminated, forcing an abort!");
    }
base.SaveWorkflowInstanceState(rootActivity, unlock);
}

  As you can see when the status is WorkflowStatus.Terminatedan exception is thrown. When an exception is thrown from the service layer the associated WFI will abort which will effectively roll back to the last persistence point. This will allow you to restart the WFI from the last persistence point by redoing whatever external stimulus that caused it to start running before the exception occurred.

Gotchas

There are a few gotchas to be aware of when using this technique.

Duplicates in Tracking 

You will get duplicate entries in your tracking data. Tracking data is saved with ordinal values that specify the order that the tracked events occured in. When using the SQLTrackingService these ordinal values aren’t enforced to be unique. What happens is that the tracking service will keep writing until the point that the exception is thrown from your custom SQL persistence service and then when you restart your WFI the tracking service will start again from the same ordinal that it was on when the last persistence point was reached before the error and you will get duplicate entries with the same ordinal numbers. You can code around this and filter by ordinal and date to get a better view of what happened before and after the exception but it is something to be aware of.

Repeating Activities

Using this technique will effectively roll back your WFI to the last persistence point but this has the side effect that when you restart the WFI you will repeat all the activities that executed after the last persistence point and up till the activity that threw the error. I got around this on my current project by forcing persists after each activity executes by having my custom activities all derive from a base class that has the PersistOnClose attribute declared on it.

Every program answers two questions “what to do” and “when to do it.” Windows Workflow Foundation or WF is a part of the WinFX suite of tools which allows programmers to seperate the “what to do” and the “when to do it” and specifically allows you to declaratively model the “when to do it” allowing for easy creation of visual tools for working with the workflow logic. When using WF in this way one of the things you will need to learn to do is how to communicate back and forth between your WF code and your client code. This post will be covering the ExternalDataExchange service and how you can use it with built in activities to provide easy client\WF communications.

Background

Communication in WF is handled under the hood through queues which is out of the scope of this article but covered quite well in Essential Windows Workflow Foundation. For the purpose of this article we will be covering communication using built in WF services that take advantage of WF queuing abilities to communicate between client code and WF instances (WFIs) without you having to know the details. The way this works is show below.

Communication from the host (client) to the WFIs works by the host application calling into registered WF services to raise events that are then raised into WFIs. WFIs communicate with the host by calling methods on WF services which then turn around and call methods on the client. There are of course some details to work through here, like how to register services and how to wire up those services so that they can support this type of communication. The easiest way to do these things is to use the ExternalDataExchange service which is one of the core services that is included with WF. ExternalDataExchange allows you to register your own custom services with it and then provides all the plumbing needed to allow you to raise events from your services into workflows and allows your WFIs to call methods on your service for communicating back to your client code by mostly using interfaces and attributes. I will demonstrate this by showing the implementation of the ConsoleService.

ConsoleService

The ConsoleService is a contrived custom WF service that I’ve created that allows for writing to and reading from the console. The architecture of this service is shown below.

As you can see our Host Process will contain 3 components that will communicate with each other

1. Console – System.Console class which will write to and read from the console
   1. Calls ConsoleService.RaiseReadLine() to pass
2. WorkflowRuntime – this is the heart of WF and will be responsible for creating and running WFIs and then providing services for those WFIs to use. One of these services will be the ConsoleService.
3. WorkflowInstance – a running workflow

For this implementation the we will register the ExternalDataExchange service with the WorkflowRuntime and then we will create our ConsoleService and register it with the ExternalDataExchange service to allow us to communicate through our service to and from the System.Console from WFIs. One thing to keep in mind is that there are several ways of hosting the WorkflowRuntime and covering those is out of the scope of this article. You would most likely not host the WorkflowRuntime in a console applicaiton in production code. Let’s start by starting Visual Studio and creating a new Sequential Workflow Console Application project from under the Workflow project templates in visual studio.

This will generate the following code which I’ve commented to describe what each piece does

   class Program
   {
      static void Main(string[] args)
      {
         using (WorkflowRuntime workflowRuntime = new WorkflowRuntime())
         {
            // Thread wait handle used to block main thread until WFI thread completes
            AutoResetEvent waitHandle = new AutoResetEvent(false);

            // Wire up the WorkflowCompleted and WorkflowTerminated events on the WorkflowRuntime
            // and Set() the wait handle to allow main thread to be notified when this WFI completes
            workflowRuntime.WorkflowCompleted += delegate(object sender, WorkflowCompletedEventArgs e) { waitHandle.Set(); };
            workflowRuntime.WorkflowTerminated += delegate(object sender, WorkflowTerminatedEventArgs e)
            {
               Console.WriteLine(e.Exception.Message);
               waitHandle.Set();
            };

            // Create a workflow instance using the CreateWorkflow overload that allows creating a
            // WFI from a .Net type
            WorkflowInstance instance = workflowRuntime.CreateWorkflow(typeof(Echo.Workflow1));

            // Start the WFI
            instance.Start();

            // Wait for it to complete
            waitHandle.WaitOne();
         }
      }
   }

Next we need to create our ConsoleService. The key to being able to communicate back and forth with WFIs is implementing ExternalDataExchange attributed interface. Next add two interface, IReadLine and IWriteLine, to your project with the following definition. Make sure to add a reference to System.Workflow.Activities.

[ExternalDataExchange]
   public interface IReadLine
   {
      event EventHandler<ReadLineEventArgs> LineRead;
      void ReadLine();
   }

[ExternalDataExchange]
 public interface IWriteLine
 {
      void WriteLine(string text);
 }

The ExternalDataExchange attribute is all that you need to add to be able to raise events into WFIs and to be able to call methods from a WFI to a client. Any methods or events declared on the interface are ready for WF. Next we need to implement interfaces in our ConsoleService. Add a new class to your project called ConsoleService and add the code shown below.

   [Serializable]
   public class ConsoleService : IWriteLine, IReadLine
 {
      #region IWriteLine

      /// <summary>
      /// Allows WF instances to write a line of text to the console
      /// </summary>
      ///
<param name="text">Specfies text to be written out.</param>
      public void WriteLine(string text)
      {
         Console.WriteLine(text);
      }

      #endregion // IWriteLine

      #region IReadLine

      /// <summary>
      /// Raised to communicate that a line was read from the console and
      /// be delievered in the ReadLineEventArgs.Text
      /// </summary>
      public event EventHandler<ReadLineEventArgs> LineRead;

      /// <summary>
      /// Will read a line of text from the console and then raise the LineReadEvent
      /// </summary>
      ///
<param name="instanceId">Specfies instance ID of the WF instance that the LineRead event
      /// will be raised on.</param>
      public void ReadLine()
      {
         RaiseLineRead(WorkflowEnvironment.WorkflowInstanceId, Console.ReadLine());
      }

      /// <summary>
      /// Allows WF clients to raise LineRead event for WF instances
      /// </summary>
      ///
<param name="instanceId">Specifies the instanceId of the target WF instance</param>
      ///
<param name="text">Specifies line of text read from client</param>
      private void RaiseLineRead(Guid instanceId, string text)
      {
         if (LineRead != null)
         {
            LineRead(this, new ReadLineEventArgs(instanceId, text));
         }
      }

      #endregion // IReadLine
   }

Fist thing to note is that any class that is used to communicate with WFIs needs to be serializable which is accomplished by adding the Serializable attribute. Also, As you can see ConsoleService implements both IReadLine and IWriteLine. WriteLine is pretty self explanitory. This method can now becalled from a WFI by using a CallExternalMethodActivity, but more on that later. ReadLine takes a little more work because it requires two-way communication which requires both a method (WFI to client) and an event (client to WFI). The WFI will indicate to the console service that it wants to read a line by calling ReadLine() as shown below.

public void ReadLine()
      {
         RaiseLineRead(WorkflowEnvironment.WorkflowInstanceId, Console.ReadLine());
      }

This function grabs the currently running WFIs InstanceId using WorkflowEnvironment.WorkflowInstanceId and then passes as it to RaiseLineRead() along with the second argument which will be whatever text is read from the console using Console.ReadLine().

private void RaiseLineRead(Guid instanceId, string text)
      {
         if (LineRead != null)
         {
            LineRead(this, new ReadLineEventArgs(instanceId, text));
         }
      }

RaiseLineRead first checks to make sure that there are subscribers to the LineRead event which there will be as soon as the ConsoleService is registered with the WorkflowRuntime’s ExternalDataExchangeService. It then raises the event passing a this refernece as the sender and a new ReadLineEventArgs as the second argument which gets the target WFIs instanceId and the text that was written as the second argument. Now add a new class called ReadLineEventArgs to your project and add the following code.

   [Serializable]
   public class ReadLineEventArgs : ExternalDataEventArgs
 {
      private string m_text;

      public string Text
      {
         get { return m_text; }
         set { m_text = value; }
      }

      public ReadLineEventArgs(Guid instanceId, string text)
         : base(instanceId)
      {
         Text = text;
      }
 }

Again we must make our class serializable using the Serializable attribute and then for this EventArgs to work with ExternalDataExchange we mush derive our custom Event args from ExternalDataEventArgs which is also in the System.Workflow.Activities namespace. When an event is raised against the ExternalDataExchange service, the service will use the instanceId which is passed to the constructor to deliever the event to the correct WFI. I’ve added a Text property to ReadLineEventArgs which will be populated with the text entered at the console and delievered to the WFI via an instance of ReadLineEventArgs. Next we need to add our service to the WorkflowRuntime.

Registering ConsoleService

Now we will update our host program to register the ConsoleService. The full host code is shown below.

   class Program
   {
      static void Main(string[] args)
      {
         using (WorkflowRuntime workflowRuntime = new WorkflowRuntime())
         {
            // Thread wait handle used to block main thread until WFI thread completes
            AutoResetEvent waitHandle = new AutoResetEvent(false);

            // Wire up the WorkflowCompleted and WorkflowTerminated events on the WorkflowRuntime
            // and Set() the wait handle to allow main thread to be notified when this WFI completes
            workflowRuntime.WorkflowCompleted += delegate(object sender, WorkflowCompletedEventArgs e) { waitHandle.Set(); };
            workflowRuntime.WorkflowTerminated += delegate(object sender, WorkflowTerminatedEventArgs e)
            {
               Console.WriteLine(e.Exception.Message);
               waitHandle.Set();
            };

            // Add ExternalDataExchangeService for communications
            ExternalDataExchangeService externalDataExchangeService
               = new ExternalDataExchangeService();
            workflowRuntime.AddService(externalDataExchangeService);
            // Add ConsoleService to externalDataExchangeService service for commincation back
            // to the client
            ConsoleService consoleService = new ConsoleService();
            externalDataExchangeService.AddService(consoleService);

            // Create a workflow instance using the CreateWorkflow overload that allows creating a
            // WFI from a .Net type
            WorkflowInstance instance = workflowRuntime.CreateWorkflow(typeof(Echo.Workflow1));

            // Start the WFI
            instance.Start();

            // Wait for it to complete
            waitHandle.WaitOne();
         }
      }
   }

The code that registers that ConsoleService is shown below.

            // Add ExternalDataExchangeService for communications
            ExternalDataExchangeService externalDataExchangeService
               = new ExternalDataExchangeService();
            workflowRuntime.AddService(externalDataExchangeService);
            // Add ConsoleService to externalDataExchangeService service for commincation back
            // to the client
            ConsoleService consoleService = new ConsoleService();
            externalDataExchangeService.AddService(consoleService);

First we create an ExternalDataExchange instance and add it to the workflowRuntime instance via the AddServiceMethod. Now that the externalDataExchange instance is added to the WorkflowRuntime’s registered services we can now create an instance of the ConsoleService and add it to the externalDataExchange instance which will make the ConsoleService available for use by the WFIs that are hosted by this WorkflowRuntime. We do this using externalDataExchange.AddService().

Creating the Echo Workflow

Next we will update Workflow1 which was created when we created our project to add activites that allow us to create a simple console echo program that will write out whatever text is written in. To get started open Workflow1.CS in the designer by double clicking it in solution explorer. Next drag and drop a CallExternalMethodActivity from the toolbox onto the designer’s surface and look at it’s properties in the property window.

As you can see in this image, the UI will display validation errors for you both on the activity on the designer surface as well as next to the properties that need to be addressed. For our demo we want to write out “Please enter text to echo: ” to the console and so we need to select our IWriteLine interface for the InterfaceType and WriteLine for the MethodName. To do this first build your project then click on right side of InterfaceType and a button ‘…” will be displayed. Click that button then browse to the IWriteLine interface and select it as shown below.

After selecting the InterfaceType clicking on the MethodName text box will display a drop down of available methods and from the list select WriteLine. Once you select WriteLine notice that the parameters are dynamically added to the property window and you can now set the text parameter of WriteLine. Go ahead and set that to Please enter text to echo: and then set a more user friendly name for this activity like PromptForEchoText. Your property window should now look like this.

Go ahead and run the demo by clicking CTRL+F5 and you should see your text displayed to the command line window. So now we have sucessfully communicated from the WFI to the client now lets try and bring some data back into the WFI. To do this add one more CallExternalMethodActivity to your workflow definition in the designer with

(Name)
ReadLine

InterfaceType
IReadLine

MethodName
ReadLine

Then add another activity but this time add a HandleExternalEventActivity and set the properties to:

(Name)
HandleLineRead

InterfaceType
IReadLine

EventName
LineRead

And now your WF definition should look like this.

What we have now will

1. Ask for text
2. Call a ConsoleService.ReadLine to send a Console.ReadLine to the console
3. Handle the ConsoleService.ReadLine event that will be raised from the ConsoleService in  response to step 2

So now you might be wondering where is the Console.ReadLine text and how can we write it back out. For that lets start by taking a look at dynamic properties that popped up on the HandleLineRead activity. In the group you will see e. This is ReadLineEventArgs which was the ExternalDataEventArgs derived class that contains a Text property and this is where the text that was read from the console is got to be now. That makes the next question how do we get this value to another CallExternalMethod so that we can write back out to the console. For that we will use property binding and bind to a new property on the base class.

Start by clicking the “…” button in the HandleReadLine.e text box to open the property binding dialog. Select the Bind to a new member tab and then set it like below.

Now add a new CallExternalMethod activity to the end of the workflow with the following settings.

(Name)
EchoText

InterfaceType
IWriteLine

MethodName
WriteLine

Next we will again use property binding to get ReadLineEventArg.Text written out to the console. To do this click the “…” button in EchoText.text to open the property bind dialog and then browse to ReadLineEventArg.Text as shown below.

 Now run the program by clicking CTRL+F5.

Conclusion

Now you have the basics that are needed to communicate back and forth with clients through the ExternalDataExchange service. There are other options for communications including web services and WCF and you can roll your own with custom activites and services but ExternalDataExchange can be very handy and very quick to use.

I taught Windows Workflow Foundation 3.5 at TechFest at the University of Houston this year. It was a great time and I hope everyone who came out enjoyed the class. Below are links for downloading the PowerPoint presentation and also the code samples that I used during this class. I’m planning to make some proper articles with the code samples that walk through the same things I walked through in class and hopefully will have that up soon.

Windows Workflow Foundation 3.5 Presentation
Code Samples from TechFest