manuelfoerster.net

atlas-based workflow designer

manu — Wed, 13 Sep 2006 12:34:17 +0000

finally, jon flanders put his atlas-powered workflow designer online. you can read about it and download it at [1], or have a look at the online demo at [2].
looks like a good point to start from for hosting the designer in a custom web application.

[1] atlas based workflow designer
[2] online demo

cutting edge sudoku

manu — Thu, 17 Aug 2006 08:34:07 +0000

great!
i just noticed Ashish Shetty’s post about his netfx3-based p2p version of sudoku [1], get it at [2].
his implementation takes advantage of windows communication foundation, windows presentation foundation as well as windows workflow foundation, requiring the june ctp available at [3].

for solving your daily sudoku without the need of installing anything you could also point your browser at [4].

[1] http://nerddawg.blogspot.com/2006/07/sudoku.html
[2] sudoku at netfx3.com
[3] netfx3 june ctp
[4] websudoku

two more wwf books in the queue

manu — Wed, 19 Jul 2006 12:38:06 +0000

there are two more books on the windows workflow foundation listed at amazon and waiting to be published:

(scheduled for october 2006 according to amazon)

(scheduled for november 2006 according to amazon)

i’m sure there will be ’nuff reading matter (at least on the windows workflow foundation) this winter!

WinFX renamed

manu — Sat, 17 Jun 2006 13:57:11 +0000

As you might have noticed, WinFX recently became .Net 3.0 [1]. They set up a nice community site at [2], this is also where the WF now resides [3].
At [4] you can find a comprehensive overview of blogs related to the WF, aggregating blogs of the WF team members at Microsoft together with community blogs. That’s really great, ’cause now subscribing to one single newsfeed keeps you up to date.
Thanks for the link!

[1] Welcome to NetFx3.com
[2] Microsoft .NET Framework 3.0 Community (NetFx3)
[3] Windows Workflow Foundation
[4] WF related blogs

another WWF book in sight

manu — Mon, 05 Jun 2006 16:38:59 +0000

Todd Kitta [1] just dropped me a note [2], he is working on a book entitled “Professional Windows Workflow Foundation”. As he posted [3] on his blog, the book is going to be published by Wrox Press late 2006/early 2007, i’m sure it is worth waiting for!

And yes, the reflector [4] is definitely one of the most important tools when working with the wwf by now.

[1] Todd Kitta’s Integration and Workflow Blog
[2] http://www.manuelfoerster.net/wordpress/64/#comments
[3] Professional Windows Workflow Foundation
[4] Reflector for .NET

essential windows workflow foundation

manu — Sat, 03 Jun 2006 09:26:55 +0000

really lookin’ forward to dharma shukla’s [1] book “essential windows workflow foundation”. as the last book on the wwf [2] (still the only one available) is kind of deprecated (only covers beta 1) and not at all in-depth (which it wasn’t meant to be, so i’m not complaining ), i think it’s time to release a new one.

[1] http://www.dharmashukla.com/
[2]http://www.samspublishing.com/title/0672328488

custom activity libraries - compile time validation issue

manu — Mon, 24 Apr 2006 20:40:07 +0000

there is a quite annoying problem with custom activity libraries in beta 2 of the windows workflow foundation.
compiling activity libraries with ActivityValidators yields errors like Activity ‘foo’ validation failed: Property ‘bar’ is not set.

according to [1], beta 1 only ran the validators if the activity was part of a workflow. now beta 2 also runs the validators at compile time, which obviously can’t work for properties you just don’t know how to set before design time.
now you can either see if the activity is actually used in a workflow by simply checking it for a parent before validation:

if (activity.Parent == null)
{
return new ValidationErrorCollection();
}
//validation goes here…

or you make your library an ordinary c# project by removing the

import Project=”$(MSBuildExtensionsPath)\Microsoft\Windows Workflow Foundation\v3.0\Workflow.Targets”

tag from your library’s build file.

[1] msdn wwf forum

Custom WorkflowPersistenceServices

manu — Thu, 09 Mar 2006 23:38:03 +0000

WWF Beta 2 comes along with a SqlWorkflowPersistenceService for persisting the state of longrunning workflows. As this service only works with Microsoft SQL Server or the Express Edition, you might think about creating your own persistence service which could target any other storage medium, like other relational databases, files, or - in this case - datasets.

For a short introduction to the WWF persistence services see [1], a comprehensive overview of a workflow’s lifecycle (and the persistence points) is described in [2].

As a first simple approach, i tried storing the workflows in a dataset with one table, which consits of the following columns:

Blocked : boolean
Info : string
InstanceID : Guid
DateTime : DateTime
Activities : byte[]
StateID : Guid
Status : int
Type : int
Unlocked : boolean

To implement a custom persistence service for your workflows, you just have to inherit from WorkflowPersistenceService (in System.Workflow.Hosting) and override the following methods:

protected override void SaveWorkflowInstanceState(Activity rootActivity, bool unlock);
protected override Activity LoadWorkflowInstanceState(Guid instanceId);
protected override void UnlockWorkflowInstanceState(Activity state);
protected override void SaveCompletedContextActivity(Activity rootActivity);
protected override Activity LoadCompletedContextActivity(Guid activityId, Activity outerActivity);
protected override bool UnloadOnIdle(Activity activity);

where SaveWorkflowInstanceState, LoadWorkflowInstanceState, SaveCompletedContextActivity and LoadCompletedContextActivity are the important ones to fill in.

There are two main methods for serialization and deserialization:

private void SerializeActivity(Activity rootActivity, Guid id)
{
if (rootActivity == null)
{
throw new ArgumentNullException(“rootActivity”);
}

PersistentWorkflow pwf = new PersistentWorkflow();
PersistentWorkflow.WorkflowInstanceRow newRow = pwf.WorkflowInstance.NewWorkflowInstanceRow();

WorkflowStatus status = (WorkflowStatus) rootActivity.GetValue(WorkflowInstance.WorkflowStatusProperty);
bool blocked = (bool) rootActivity.GetValue(WorkflowInstance.IsBlockedProperty);
string info = (string) rootActivity.GetValue(WorkflowInstance.SuspendOrTerminateInfoProperty);
Guid guid = (Guid)rootActivity.GetValue(Activity.ActivityContextGuidProperty);
newRow.InstanceID = (Guid) rootActivity.GetValue(WorkflowInstance.WorkflowInstanceIdProperty);
if ((status != WorkflowStatus.Completed) && (status != WorkflowStatus.Terminated))
{
newRow.Activities = WorkflowPersistenceService.GetDefaultSerializedForm(rootActivity);
}
else
{
newRow.Activities = new byte[0];
}
newRow.Status = (int) status;
newRow.Blocked = blocked;
newRow.Info = info;
newRow.StateID = guid;
newRow.Unlocked = true;
TimerEventSubscriptionCollection collection1 = (TimerEventSubscriptionCollection) rootActivity.GetValue(WorkflowInstance.TimerCollectionProperty);
TimerEventSubscription subscription1 = collection1.Peek();
newRow.DateTime = (subscription1 == null) ? DateTime.MaxValue : ((DateTime) subscription1.ExpiresAt);

pwf.WorkflowInstance.AddWorkflowInstanceRow(newRow);
string filename = FBaseDir + “\\“ + id.ToString() + “.xml”;
pwf.WriteXml(filename);
}

private object DeserializeActivity(Activity RootActivity, Guid id)
{
string filename = FBaseDir + “\\“ + id.ToString() + “.xml”;
PersistentWorkflow pwf = new PersistentWorkflow();
pwf.ReadXml(filename);

byte[] instanceState = ((PersistentWorkflow.WorkflowInstanceRow)pwf.WorkflowInstance.Rows[0]).Activities;

Activity result = RestoreFromDefaultSerializedForm(instanceState, null) ;

return result;
}

As you can see, deserializing the workflow instance is just calling one method (coming with the baseclass) on the activities entry of the dataset.
Now you might wonder why the other information is persisted when serializing: you will need when managing long running workflows whose lifetime exceeds that of the application’s instance, maybe i will cover that one in another post.

Invoking the (de)serialization is done in the four load and save methods you have to override:

protected override void SaveWorkflowInstanceState(Activity rootActivity, bool unlock)
{
SerializeActivity(rootActivity, (Guid)rootActivity.GetValue(Activity.ActivityContextGuidProperty));
}

protected override Activity LoadWorkflowInstanceState(Guid instanceId)
{
object obj = DeserializeActivity(null, instanceId);
return (Activity)obj;
}

protected override void SaveCompletedContextActivity(Activity rootActivity)
{
ActivityExecutionContext contextInfo = (ActivityExecutionContext)rootActivity.GetValue(Activity.ActivityContextGuidProperty);
SerializeActivity(rootActivity, contextInfo.ContextGuid);
}

protected override Activity LoadCompletedContextActivity(Guid activityId, Activity outerActivity)
{
object obj = DeserializeActivity(outerActivity, activityId);
return (Activity)obj;
}

So, the framework does the main part of the work, with GetDefaultSerializedForm and RestoreFromDefaultSerializedForm from the WorkflowPersistenceService baseclass.

For using this service in your application, you just have to add the persistence service to your workflow runtime:

workflowRuntime.AddService(new DatasetPersistenceService());

Comments appreciated, but keep in mind that this one was just a first quick and dirty approach, so be gentle.

[1] Window Workflow Foundation Runtime Services: The Persistence Service
[2] Managing Workflow’s Lifecycle

rule driven workflows

manu — Mon, 06 Mar 2006 21:26:13 +0000

with the rules capability in the windows workflow foundation [1], parts of business and application logic can be represented by more (policies) or less (conditioned activities) complex rulesets. the most important advantage is, that you can load and update those rulesets dynamically at runtime. e.g., validation logic, calculation, etc. could be sourced out of the application.

to get in touch with the rules engine, read the comprehensive introductory article at [2] and have a look at the corresponding hands on lab [3].
[4] shows how to host the ruleset designer in a custom application, for defining and modifying rules at runtime.

[1] windows workflow foundation
[2] Introduction to the Windows Workflow Foundation Rules Engine
[3] WWF Beta 2 Hands on Labs
[4] external ruleset toolkit