Andreas Erben's posts : BizTalk Server, Windows Workflow Foundation

Exciting things for “Dublin” and “Velocity” coming up today, 11/17/2009

Andreas Erben — Tue, 17 Nov 2009 15:29:57 GMT

Some exciting things for “Dublin” and “Velocity” will be given to the world today at Microsoft PDC 2009. Too bad that I am still under NDA for this :)

Workflow Cloudbusting / Hiding code & logic in conditions in Workflow Foundation and BizTalk Workflow Services

Andreas Erben — Mon, 29 Sep 2008 16:31:00 GMT

(German version may come at a later time / Deutsche Version wird eventuell nachgereicht)

First of all: Please play around with BizTalk Workflow Services and share what you find out. I feel lonely ;)

This post deals with BizTalk Workflow Services. However, most of it also applies to general Workflow Foundation.

You might notice that in the BizTalk Workflow Services of the current BizTalk Labs SDK you do not find any activities that allow you to "set" a value or to execute custom code.

This makes implementing complex logic practically impossible since you cannot react in a meaningful way to data that you get through a send/receive.

However, there is a "dirty" trick you can use: Hide your logic in a rules-condition.
The following is a proof-of-concept and there are likely things that could be done better :)

Take the same preparations as in my intro to BizTalk Workflow Services having your command line output up and running to receive and display messages. Remember what I wrote regarding flow control for BizTalk Workflow Services.

Now look at this really simple workflow definition

and it's even simpler XOML representation (sorry that it will not fit in most web browsers - please copy/paste to read):

<SequentialWorkflowActivity x:Class="WorkflowProject1.Workflow1" x:Name="Workflow1" xmlns:ns0="http://schemas.microsoft.com/2007/11/CloudWorkflowActivityLibrary" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/workflow">
  <ns0:CloudWhile x:Name="cloudWhile1">
    <ns0:CloudWhile.Condition>
      <RuleConditionReference ConditionName="While Condition" />
    </ns0:CloudWhile.Condition>
    <ns0:CloudSequence x:Name="cloudSequence1">
      <ns0:CloudIfElse x:Name="cloudIfElse1">
        <ns0:CloudIfElseBranch x:Name="cloudIfElseBranch1">
          <ns0:CloudIfElseBranch.Condition>
            <RuleConditionReference ConditionName="R" />
          </ns0:CloudIfElseBranch.Condition>
        </ns0:CloudIfElseBranch>
      </ns0:CloudIfElse>
      <ns0:CloudServiceBusSend x:Name="cloudServiceBusSend1" URL="sb://connect.biztalk.net/services/ChatRooms/watchdog/MulticastService/" Response="{x:Null}" Body="&lt;Chat xmlns='http://samples.microsoft.com/ServiceModel/Relay/'&gt; &lt;nickName&gt;watchdog&lt;/nickName&gt; &lt;text&gt;Original&lt;/text&gt;&lt;/Chat&gt;" Action="http://samples.microsoft.com/ServiceModel/Relay/MulticastContract/Chat" ConnectionMode="RelayedMulticast" />
      <ns0:CloudDelay x:Name="cloudDelay1" Timeout="00:00:10" />
    </ns0:CloudSequence>
  </ns0:CloudWhile>
</SequentialWorkflowActivity>

It looks pretty normal, right? In the CloudServiceBusSend activity you send a string saying "Original" to our "watchdog".

However, have a look at the rule expression referenced in

<RuleConditionReference ConditionName="R" />

that looks pretty funny.

System.Convert.ToBoolean(((System.ServiceBus.Workflow.CloudServiceBusSend)this.GetActivityByName("cloudServiceBusSend1")).GetType().GetProperty("Body").SetValue(this.GetActivityByName("cloudServiceBusSend1"), "<Chat xmlns='http://samples.microsoft.com/ServiceModel/Relay/'> <nickName>watchdog</nickName> <text>Modified</text></Chat>", null))

What does it do? First of all, it makes sure, that the condition has a valid value through

System.Convert.ToBoolean()

Now, it will evaluate the inner "condition" that is in fact a hidden "set" command.
At first it gets the Activity "cloudServiceBusSend1" and ensures it is of the desired type through:

(System.ServiceBus.Workflow.CloudServiceBusSend)this.GetActivityByName("cloudServiceBusSend1")

Then, no that type we get the type and get the property "Body".

.GetType().GetProperty("Body")

on the property "Body" we execute SetValue

.SetValue(targetObject, propertyValueObject, indexValuesObject[])

that takes three parameters. Relevant here is the Activity being the targetObjet and the value we want to set being a string.

.SetValue(this.GetActivityByName("cloudServiceBusSend1"),
"<Chat xmlns='http://samples.microsoft.com/ServiceModel/Relay/'> <nickName>watchdog</nickName> <text>Modified</text></Chat>",
null)

Now what did we just do? We modified a property of an activity in the workflow so that, were the activity initialized this way it would send the string "Modified" to our "watchdog".

Now look at the output of the workflow. This gets really interesting:

Even though the "If" condition got evaluated before the activity cloudServiceBusDelay1 got executed, the first time the activity still sent "Original" and not "Modified". However, when the loop executed the second time, it displayed the string "Modified".

Think about it. This gives quite some insight about the order how things are done in WF. Well, admittedly, we did a property manipulation in a pretty nasty way here and there were no DependencyProperties involved and so on.

Now, just for your information, notice that the rules file for this rule is really long.

<RuleDefinitions xmlns="http://schemas.microsoft.com/winfx/2006/xaml/workflow">
  <RuleDefinitions.Conditions>
    <RuleExpressionCondition Name="While Condition">
      <RuleExpressionCondition.Expression>
        <ns0:CodePrimitiveExpression xmlns:ns0="clr-namespace:System.CodeDom;Assembly=System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
          <ns0:CodePrimitiveExpression.Value>
            <ns1:Boolean xmlns:ns1="clr-namespace:System;Assembly=mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">true</ns1:Boolean>
          </ns0:CodePrimitiveExpression.Value>
        </ns0:CodePrimitiveExpression>
      </RuleExpressionCondition.Expression>
    </RuleExpressionCondition>
    <RuleExpressionCondition Name="R">
      <RuleExpressionCondition.Expression>
        <ns0:CodeMethodInvokeExpression xmlns:ns0="clr-namespace:System.CodeDom;Assembly=System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
          <ns0:CodeMethodInvokeExpression.Parameters>
            <ns0:CodeMethodInvokeExpression>
              <ns0:CodeMethodInvokeExpression.Parameters>
                <ns0:CodeMethodInvokeExpression>
                  <ns0:CodeMethodInvokeExpression.Parameters>
                    <ns0:CodePrimitiveExpression>
                      <ns0:CodePrimitiveExpression.Value>
                        <ns1:String xmlns:ns1="clr-namespace:System;Assembly=mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">cloudServiceBusSend1</ns1:String>
                      </ns0:CodePrimitiveExpression.Value>
                    </ns0:CodePrimitiveExpression>
                  </ns0:CodeMethodInvokeExpression.Parameters>
                  <ns0:CodeMethodInvokeExpression.Method>
                    <ns0:CodeMethodReferenceExpression MethodName="GetActivityByName">
                      <ns0:CodeMethodReferenceExpression.TargetObject>
                        <ns0:CodeThisReferenceExpression />
                      </ns0:CodeMethodReferenceExpression.TargetObject>
                    </ns0:CodeMethodReferenceExpression>
                  </ns0:CodeMethodInvokeExpression.Method>
                </ns0:CodeMethodInvokeExpression>
                <ns0:CodePrimitiveExpression>
                  <ns0:CodePrimitiveExpression.Value>
                    <ns1:String xmlns:ns1="clr-namespace:System;Assembly=mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">&lt;Chat xmlns='http://samples.microsoft.com/ServiceModel/Relay/'&gt; &lt;nickName&gt;watchdog&lt;/nickName&gt; &lt;text&gt;Modified&lt;/text&gt;&lt;/Chat&gt;</ns1:String>
                  </ns0:CodePrimitiveExpression.Value>
                </ns0:CodePrimitiveExpression>
                <ns0:CodePrimitiveExpression />
              </ns0:CodeMethodInvokeExpression.Parameters>
              <ns0:CodeMethodInvokeExpression.Method>
                <ns0:CodeMethodReferenceExpression MethodName="SetValue">
                  <ns0:CodeMethodReferenceExpression.TargetObject>
                    <ns0:CodeMethodInvokeExpression>
                      <ns0:CodeMethodInvokeExpression.Parameters>
                        <ns0:CodePrimitiveExpression>
                          <ns0:CodePrimitiveExpression.Value>
                            <ns1:String xmlns:ns1="clr-namespace:System;Assembly=mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">Body</ns1:String>
                          </ns0:CodePrimitiveExpression.Value>
                        </ns0:CodePrimitiveExpression>
                      </ns0:CodeMethodInvokeExpression.Parameters>
                      <ns0:CodeMethodInvokeExpression.Method>
                        <ns0:CodeMethodReferenceExpression MethodName="GetProperty">
                          <ns0:CodeMethodReferenceExpression.TargetObject>
                            <ns0:CodeMethodInvokeExpression>
                              <ns0:CodeMethodInvokeExpression.Method>
                                <ns0:CodeMethodReferenceExpression MethodName="GetType">
                                  <ns0:CodeMethodReferenceExpression.TargetObject>
                                    <ns0:CodeCastExpression TargetType="System.ServiceBus.Workflow.CloudServiceBusSend, System.ServiceBus.Workflow, Version=0.12.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35">
                                      <ns0:CodeCastExpression.Expression>
                                        <ns0:CodeMethodInvokeExpression>
                                          <ns0:CodeMethodInvokeExpression.Parameters>
                                            <ns0:CodePrimitiveExpression>
                                              <ns0:CodePrimitiveExpression.Value>
                                                <ns1:String xmlns:ns1="clr-namespace:System;Assembly=mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">cloudServiceBusSend1</ns1:String>
                                              </ns0:CodePrimitiveExpression.Value>
                                            </ns0:CodePrimitiveExpression>
                                          </ns0:CodeMethodInvokeExpression.Parameters>
                                          <ns0:CodeMethodInvokeExpression.Method>
                                            <ns0:CodeMethodReferenceExpression MethodName="GetActivityByName">
                                              <ns0:CodeMethodReferenceExpression.TargetObject>
                                                <ns0:CodeThisReferenceExpression />
                                              </ns0:CodeMethodReferenceExpression.TargetObject>
                                            </ns0:CodeMethodReferenceExpression>
                                          </ns0:CodeMethodInvokeExpression.Method>
                                        </ns0:CodeMethodInvokeExpression>
                                      </ns0:CodeCastExpression.Expression>
                                    </ns0:CodeCastExpression>
                                  </ns0:CodeMethodReferenceExpression.TargetObject>
                                </ns0:CodeMethodReferenceExpression>
                              </ns0:CodeMethodInvokeExpression.Method>
                            </ns0:CodeMethodInvokeExpression>
                          </ns0:CodeMethodReferenceExpression.TargetObject>
                        </ns0:CodeMethodReferenceExpression>
                      </ns0:CodeMethodInvokeExpression.Method>
                    </ns0:CodeMethodInvokeExpression>
                  </ns0:CodeMethodReferenceExpression.TargetObject>
                </ns0:CodeMethodReferenceExpression>
              </ns0:CodeMethodInvokeExpression.Method>
            </ns0:CodeMethodInvokeExpression>
          </ns0:CodeMethodInvokeExpression.Parameters>
          <ns0:CodeMethodInvokeExpression.Method>
            <ns0:CodeMethodReferenceExpression MethodName="ToBoolean">
              <ns0:CodeMethodReferenceExpression.TargetObject>
                <ns0:CodeTypeReferenceExpression Type="System.Convert, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
              </ns0:CodeMethodReferenceExpression.TargetObject>
            </ns0:CodeMethodReferenceExpression>
          </ns0:CodeMethodInvokeExpression.Method>
        </ns0:CodeMethodInvokeExpression>
      </RuleExpressionCondition.Expression>
    </RuleExpressionCondition>
  </RuleDefinitions.Conditions>
</RuleDefinitions>

Now, what if we change the workflow and the expression a bit:

We put the condition as a while-loop condition in this workflow:

represented by this XOML:

<SequentialWorkflowActivity x:Class="WorkflowProject1.Workflow1" x:Name="Workflow1" xmlns:ns0="http://schemas.microsoft.com/2007/11/CloudWorkflowActivityLibrary" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/workflow">
  <ns0:CloudWhile x:Name="cloudWhile1">
    <ns0:CloudWhile.Condition>
      <RuleConditionReference ConditionName="While Condition" />
    </ns0:CloudWhile.Condition>
    <ns0:CloudSequence x:Name="cloudSequence1">
      <ns0:CloudDelay x:Name="cloudDelay1" Timeout="00:00:10" />
      <ns0:CloudServiceBusSend x:Name="cloudServiceBusSend1" URL="sb://connect.biztalk.net/services/ChatRooms/watchdog/MulticastService/" Response="{x:Null}" Body="&lt;Chat xmlns='http://samples.microsoft.com/ServiceModel/Relay/'&gt; &lt;nickName&gt;watchdog&lt;/nickName&gt; &lt;text&gt;Original&lt;/text&gt;&lt;/Chat&gt;" Action="http://samples.microsoft.com/ServiceModel/Relay/MulticastContract/Chat" ConnectionMode="RelayedMulticast" />
    </ns0:CloudSequence>
  </ns0:CloudWhile>
</SequentialWorkflowActivity>

The condition itself looks like this:

System.Convert.ToBoolean(((System.ServiceBus.Workflow.CloudServiceBusSend)this.GetActivityByName("cloudServiceBusSend1")).GetType().GetProperty("Body").SetValue(this.GetActivityByName("cloudServiceBusSend1"), "<Chat xmlns='http://samples.microsoft.com/ServiceModel/Relay/'> <nickName>watchdog</nickName> <text>Modified</text></Chat>", null)) || True

It has a small modification since we want to ensure that the loop occurs - we force it to be "true" by using an "OR" operation with "true" on the result of the first part.

Be surprised or not, now the output is:

So, this time the condition got evaluated the first time before the activities inside the composite "while" activity were dealt with.

For those who cannot get enough and do not believe me that the condition gets evaluated and thus executed after every loop, I prepared a more complex condition to use in the earlier "IF-condition version" of the workflow:

System.Convert.ToBoolean(((System.ServiceBus.Workflow.CloudServiceBusSend)this.GetActivityByName("cloudServiceBusSend1")).GetType().GetProperty("Body").SetValue(this.GetActivityByName("cloudServiceBusSend1"), System.DateTime.Now.ToString("\\<\\C\\h\\a\\t\\ \\x\\m\\l\\n\\s\\=\\'\\h\\t\\t\\p\\:\\/\\/\\s\\a\\m\\p\\l\\e\\s\\.\\m\\i\\c\\r\\o\\s\\o\\f\\t\\.\\c\\o\\m\\/\\S\\e\\r\\v\\i\\c\\e\\M\\o\\d\\e\\l\\/\\R\\e\\l\\a\\y\\/\\'\\>\\<\\n\\i\\c\\k\\N\\a\\m\\e\\>\\w\\a\\t\\c\\h\\d\\o\\g\\<\\/\\n\\i\\c\\k\\N\\a\\m\\e\\>\\<\\t\\e\\x\\t\\>yyyyMMddHHmmss\\<\\/\\t\\e\\x\\t\\>\\<\\/\\C\\h\\a\\t\\>"), null))

The big difference is that I output the actual DateTime instead of "Modified".

If you ask yourself, why I did it in such a nasty way and not doing something with formatting parameters {0} or string concatenation. The reason is simple. Today we still have a limitation of having 8192 characters for the rules definition - and the resulting XML if I would use a nicer code without this nasty escaping would just be too long.

Here some example output:

Now, if we would not have that 8192 character limitation we could really do quite some nice tricks.

Clouding the flow of work / BizTalk Workflow Services Intro

Andreas Erben — Tue, 05 Aug 2008 10:44:00 GMT

(German version maybe coming later / deutsche Version folgt eventuell später)

http://workflow.biztalk.net now offers a CTP of BizTalk Workflow Services. Let's look at what that means.

First you should download the latest version of the SDK. Right now this is the file "BizTalk Services SDK Setup 0.12.185.2.exe". Please note that the availability of this site and all sub-sites of biztalk.net is at present not reliable at all. It can be taken down temporarily or even for extended periods of time. Please note that the information in this article is based on a very early pre-release version of something that might become a product. So, by the time you read it, this information may be outdated and plainly wrong.

If you do not have an account for BizTalk Services yet, now is the time to create one. Vista users, I recommend creating an information card. When setting a username/password. I also recommend not setting a password that you really want to be secure. Reason: There will be things like deployment samples where the password will be visible.

Assuming you did that, let's look at the SDK:

To actually see what is happening in the samples, you have to start another sample in
Program Files\Microsoft BizTalk Services SDK\Samples\Communication\ExploringFeatures\ConnectionModes\Multicast. This is the place where you will receive a friendly "Hello" from your workflow via the Internet Service Bus (ISB). Use "watchdog" as your chat session name.

In Program Files\Microsoft BizTalk Services SDK\Samples\Workflow\GettingStarted, you can find a definition of a simple "Cloud" Workflow together with rules.

To get started really quickly, you can look at

Program Files\Microsoft BizTalk Services SDK\Samples\Workflow\ExploringFeatures\CreateWorkflowAPIs.

This sample will, when you start it, ask for your credentials and upload a simple workflow to your BizTalk Services account.

I was a little paranoid, so I blanked out the password (now you know why you should not use a relevant password that you use elsewhere, since you might show this sample to someone and bang - there goes your password) and even the authentication token (even though the latter should not really be necessary... but you never know :) ). When doing that, leave it running for a bit before doing "Press any key to terminate workflow instance".

What should happen? Your workflow will start and will try to send a HTTP request to http://www.microsoft.com. If the HTTP-request status is less than 400, then it will send a message to the ISB (to "your" session) that it can reach the Microsoft website. If the site is not responding, then you will receive this information via ISB. The workflow will repeat this procedure every 30 seconds.

Look at the output of your MulticastSample:

(Again, paranoid me did not want to disclose the chat-name right now)

When setting it up, you should see something like that:

You can also create / edit your workflows online without using Visual Studio. No designer support though right now. So, let's edit this. First click on the line with the name of your workflow type ("mywatchdog" in this case). It will be marked in the browser and then click on "Edit".

(Note that "Add New" is not much different other than that you have to also specify a name for your new workflow type)

You see that only two tabs are present: Xoml and Rules. This means that the only thing that is uploaded are the XAML (.xoml) and including the rules definitions of your workflow. With other words - no code-behind/developer defined partial C# classes!

Typically you would just copy/paste your relevant XAML (XOML) and rules here.

In "Type Management" you can also "Create Instances". Doing that will add an instance to the "Manage Instance" page:

You could start an instance (if it is in a startable state) by selecting it and then clicking "Start". Note that when you see an instance that displays "Terminated" and the termination was because of an exception, then you can actually click on the link behind the word "Terminated" to get the top-level exception that caused the Workflow to terminate.

But what can you actually do with the Workflow Services right now? Remember, you are running them in the "cloud". And if you could do just anything, this could result in the whole platform getting vulnerable. So what Microsoft did was, to limit the types of activities you can run in the "cloud".

Right now those activities are:

CloudDelay
CloudHttpReceive
CloudHttpSend
CloudIfElse (and CloudIfElseBranch)
CloudSequence
CloudServiceBusSend
CloudWhile

This is a severely limiting subset of Workflow activities.

If you do not limit yourself to those activities, e.g. by adding something like

to your XOML, you will get "The workflow failed validation" when trying to save your changes.´

Now let's look at the workflow again in Visual Studio. I use Visual Studio 2008, the samples are made for Visual Studio 2005 with the Visual Studio 2005 Extensions for .Net Framework 3.0 (Windows Workflow Foundation).

We are working with Program Files\Microsoft BizTalk Services SDK\Samples\Workflow\GettingStarted now again.

Your workflow should look like this:

Open in the Menu Tools / Choose Toolbox Items... or select Choose Items... directly in the context-menu when right-clicking in the toolbox. In this window go to the tab "Activities".

The click "Browse..." and select the DLL "System.ServiceBus.Workflow.dll" in Program Files\Microsoft BizTalk Services SDK\Assemblies and choose "OK".

You should see something like that.

Select "OK" again and your toolbox should see some new activities at the bottom of the list.

And your project should look similar to this.

Now you are basically ready to build your own cloud-hosted workflows.

I think it is worth noting, that the workflow is at the root-level still a regular SequentialWorkflowActivity as seen in the code (which is however not used in the cloud but still it is still there in the project file. Do not put logic here. :) ):

public partial class Workflow1 : SequentialWorkflowActivity
{
}

and more importantly in the root node of the XAML:

<SequentialWorkflowActivity x:Class="WorkflowProject1.Workflow1" x:Name="Workflow1" xmlns:ns0="clr-namespace:System.ServiceBus.Workflow;Assembly=System.ServiceBus.Workflow, Version=0.12.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/workflow">

When looking at the rules, you will further notice that the rules have nothing cloud-specific besides of accessing the cloud-specific activities.

The next posts will look closer at the new activities and at some of the inner workings of the samples, we will further try to stretch what can be done.