Andreas Erben's posts : BizTalk

Dublin, Velocity and more bundled up as AppFabric

Andreas Erben — Tue, 17 Nov 2009 19:32:03 GMT

Microsoft is bundling up some functionality from previously separated product codenames, e.g. Velocity and Dublin and bundling them as AppFabric.

Download the Beta here: http://msdn.microsoft.com/en-us/windowsserver/ee695849.aspx

Interested in training on some of that new functionality? Contact me!

Cloud Proxy Demo / Simple BizTalk Workflow Services End-to-end demo

Andreas Erben — Thu, 02 Oct 2008 09:55:00 GMT

(German version may be written at a later time / Deutsche Version wird gegebenenfalls später geschrieben)

This post combines several concepts from several posts about BizTalk Workflow Services. You should read the intro, about flow control, about send&receive activities and about the little trick to hide some code in conditions. Additionally we will showcase binding of properties in BizTalk Workflow Services.

What shall be achieved?

We want a workflow instance to communicate with a service and be called back by the service. Then the workflow should do something and wait for the client to fetch the result of the work done.

Some challenges:

How to get the WorkflowInstanceId to the service?
How to get information back to the workflow?
How to pass the information from one activity in the workflow to another activity?
How to get the information back to the service?

Challenge 1: How to get the WorkflowInstanceId to the service?

There is currently no out-of-the-box way to access the WorkflowInstanceId and there is no "setter" activity to store a value somewhere. To do this, we will use the technique described in here, where we hide code in conditions to send information via the CloudServiceBusSend activity to the service.

We will use the following condition for that.

System.Convert.ToBoolean(((System.ServiceBus.Workflow.CloudServiceBusSend) this.GetActivityByName("cloudServiceBusSend1") ).GetType().GetProperty("Body").SetValue(this.GetActivityByName("cloudServiceBusSend1"), "<Echo xmlns='http://samples.microsoft.com/ServiceModel/Relay/'><text></text> </Echo>".Insert(69, this.WorkflowInstanceId.ToString()), null)) || True

Note that this condition results in an Xml-string that is longer than 8192 characters. You will have to strip whitespace from that Xml-string to be able to upload it to BizTalk Workflow Services.

Challenge 2: How to get information back to the workflow?

Fortunately we received the InstanceId, now we need to tell the workflow that we want it to do something for us. Unfortunately CloudServiceBusSend so far does not work with returned values. So: The only way to call the workflow is through the CloudHttpReceive activity and we need the InstanceId to call the proper instance. Using the CloudHttpReceive was demonstrated here.

Challenge 3: How to pass the information from one activity in the workflow to another activity?

As mentioned, we have no activities for getting/setting or manipulating data. We could either employ the previously mentioned trick to hide some code in conditions or we can use property binding. We will do the latter.

We bind the request property of a CloudHttpReceive activity to the URL property of a CloudHttpSend activity. So, the URL of the CloudHttpSend will be "filled" by the incoming WebHttpRequest and when CloudHttpSend gets executed it will request data from the URL that was supplied externally.

Activity=cloudHttpSend1, Path=URL

The complete activity with activity binding would look like this:

<ns0:CloudHttpReceive Request="{ActivityBind cloudHttpSend1,Path=URL}" x:Name="cloudHttpReceive1" StatusCode="0" Response="Hello" />

Challenge 4: How to get the information back to the service?

To solve that challenge we can either use a CloudServiceBusSend or we can have the service asking the workflow via a CloudHttpReceive activity. We will use CloudHttpReceive in this case because we want the service to "control" when it asks for the result.

The workflow

Now let us look at the complete workflow first

and as Xoml definition:

<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:CloudServiceBusSend x:Name="cloudServiceBusSend1" URL="sb://connect.biztalk.net/services/YOURUSERNAMEHERE/EchoService/" Response="" Body="&lt;Echo xmlns='http://samples.microsoft.com/ServiceModel/Relay/'&gt; &lt;text&gt;Original&lt;/text&gt;&lt;/Echo&gt;" Action="http://samples.microsoft.com/ServiceModel/Relay/EchoContract/Echo" ConnectionMode="RelayedDuplexSession" />
      <ns0:CloudHttpReceive Request="{ActivityBind cloudHttpSend1,Path=URL}" x:Name="cloudHttpReceive1" StatusCode="0" Response="Hello" />
      <ns0:CloudHttpSend x:Name="cloudHttpSend1" StatusCode="0" URL="http://www.microsoft.com" Method="GET" Request="{x:Null}" RequestContentType="{x:Null}" Response="{ActivityBind cloudHttpReceive2,Path=Response}" />
      <ns0:CloudHttpReceive Request="{x:Null}" x:Name="cloudHttpReceive2" StatusCode="0" Response="Bye" />
      <ns0:CloudDelay x:Name="cloudDelay1" Timeout="00:00:10" />
    </ns0:CloudSequence>
  </ns0:CloudWhile>
</SequentialWorkflowActivity>

Let's look at the activities from top to bottom.

There is not really anything to say about cloudSequence1.

The cloudWhile1 activity has the condition set as seen in Challenge 1.

The condition is represented by this Xml structure:

<RuleDefinitions xmlns="http://schemas.microsoft.com/winfx/2006/xaml/workflow">
  <RuleDefinitions.Conditions>
    <RuleExpressionCondition Name="While Condition">
      <RuleExpressionCondition.Expression>
        <ns0:CodeBinaryOperatorExpression Operator="BooleanOr" xmlns:ns0="clr-namespace:System.CodeDom;Assembly=System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
          <ns0:CodeBinaryOperatorExpression.Left>
            <ns0:CodeMethodInvokeExpression>
              <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:CodeMethodInvokeExpression>
                      <ns0:CodeMethodInvokeExpression.Parameters>
                        <ns0:CodePrimitiveExpression>
                          <ns0:CodePrimitiveExpression.Value>
                            <ns1:Int32 xmlns:ns1="clr-namespace:System;Assembly=mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">69</ns1:Int32>
                          </ns0:CodePrimitiveExpression.Value>
                        </ns0:CodePrimitiveExpression>
                        <ns0:CodeMethodInvokeExpression>
                          <ns0:CodeMethodInvokeExpression.Method>
                            <ns0:CodeMethodReferenceExpression MethodName="ToString">
                              <ns0:CodeMethodReferenceExpression.TargetObject>
                                <ns0:CodePropertyReferenceExpression PropertyName="WorkflowInstanceId">
                                  <ns0:CodePropertyReferenceExpression.TargetObject>
                                    <ns0:CodeThisReferenceExpression />
                                  </ns0:CodePropertyReferenceExpression.TargetObject>
                                </ns0:CodePropertyReferenceExpression>
                              </ns0:CodeMethodReferenceExpression.TargetObject>
                            </ns0:CodeMethodReferenceExpression>
                          </ns0:CodeMethodInvokeExpression.Method>
                        </ns0:CodeMethodInvokeExpression>
                      </ns0:CodeMethodInvokeExpression.Parameters>
                      <ns0:CodeMethodInvokeExpression.Method>
                        <ns0:CodeMethodReferenceExpression MethodName="Insert">
                          <ns0:CodeMethodReferenceExpression.TargetObject>
                            <ns0:CodePrimitiveExpression>
                              <ns0:CodePrimitiveExpression.Value>
                                <ns1:String xmlns:ns1="clr-namespace:System;Assembly=mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">&lt;Echo xmlns='http://samples.microsoft.com/ServiceModel/Relay/'&gt;&lt;text&gt;&lt;/text&gt; &lt;/Echo&gt;</ns1:String>
                              </ns0:CodePrimitiveExpression.Value>
                            </ns0:CodePrimitiveExpression>
                          </ns0:CodeMethodReferenceExpression.TargetObject>
                        </ns0:CodeMethodReferenceExpression>
                      </ns0:CodeMethodInvokeExpression.Method>
                    </ns0:CodeMethodInvokeExpression>
                    <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>
          </ns0:CodeBinaryOperatorExpression.Left>
          <ns0:CodeBinaryOperatorExpression.Right>
            <ns0:CodePrimitiveExpression>
              <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>
          </ns0:CodeBinaryOperatorExpression.Right>
        </ns0:CodeBinaryOperatorExpression>
      </RuleExpressionCondition.Expression>
    </RuleExpressionCondition>
  </RuleDefinitions.Conditions>
</RuleDefinitions>

For "copy/paste" purposes, here is the whitespace-stripped Xml-representation:

<RuleDefinitions xmlns="http://schemas.microsoft.com/winfx/2006/xaml/workflow"><RuleDefinitions.Conditions><RuleExpressionCondition Name="While Condition"><RuleExpressionCondition.Expression><ns0:CodeBinaryOperatorExpression Operator="BooleanOr" xmlns:ns0="clr-namespace:System.CodeDom;Assembly=System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"><ns0:CodeBinaryOperatorExpression.Left><ns0:CodeMethodInvokeExpression><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:CodeMethodInvokeExpression><ns0:CodeMethodInvokeExpression.Parameters><ns0:CodePrimitiveExpression><ns0:CodePrimitiveExpression.Value><ns1:Int32 xmlns:ns1="clr-namespace:System;Assembly=mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">69</ns1:Int32></ns0:CodePrimitiveExpression.Value></ns0:CodePrimitiveExpression><ns0:CodeMethodInvokeExpression><ns0:CodeMethodInvokeExpression.Method><ns0:CodeMethodReferenceExpression MethodName="ToString"><ns0:CodeMethodReferenceExpression.TargetObject><ns0:CodePropertyReferenceExpression PropertyName="WorkflowInstanceId"><ns0:CodePropertyReferenceExpression.TargetObject><ns0:CodeThisReferenceExpression /></ns0:CodePropertyReferenceExpression.TargetObject></ns0:CodePropertyReferenceExpression></ns0:CodeMethodReferenceExpression.TargetObject></ns0:CodeMethodReferenceExpression></ns0:CodeMethodInvokeExpression.Method></ns0:CodeMethodInvokeExpression></ns0:CodeMethodInvokeExpression.Parameters><ns0:CodeMethodInvokeExpression.Method><ns0:CodeMethodReferenceExpression MethodName="Insert"><ns0:CodeMethodReferenceExpression.TargetObject><ns0:CodePrimitiveExpression><ns0:CodePrimitiveExpression.Value><ns1:String xmlns:ns1="clr-namespace:System;Assembly=mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">&lt;Echo xmlns='http://samples.microsoft.com/ServiceModel/Relay/'&gt;&lt;text&gt;&lt;/text&gt; &lt;/Echo&gt;</ns1:String></ns0:CodePrimitiveExpression.Value></ns0:CodePrimitiveExpression></ns0:CodeMethodReferenceExpression.TargetObject></ns0:CodeMethodReferenceExpression></ns0:CodeMethodInvokeExpression.Method></ns0:CodeMethodInvokeExpression><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></ns0:CodeBinaryOperatorExpression.Left><ns0:CodeBinaryOperatorExpression.Right><ns0:CodePrimitiveExpression><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></ns0:CodeBinaryOperatorExpression.Right></ns0:CodeBinaryOperatorExpression></RuleExpressionCondition.Expression></RuleExpressionCondition></RuleDefinitions.Conditions></RuleDefinitions>

cloudServiceBusSend1 is configured like this with the "Body" property actually at execution time being overwritten by the condition of cloudWhile1.

cloudHttpReceive1 will get data in the "Request" property and put it into the "URL" property of cloudHttpSend1.

cloudHttpSend1 will find it's URL property overwritten by the data received at cloudHttpReceive1. Then it will execute the WebHttpRequest and put the body of the result in the "Response" property of cloudHttpReceive2.

cloudHttpReceive2 looks very empty. The "Response" property however will be overwritten by the data bound in cloudHttpSend1.

cloudDelay1 is configured to wait 10 seconds.

Create this workflow by copy/pasting the Xoml and rules and setting the type name to "SimpleEnd2End".

The service

Now you need to set up the service. To do that work on a copy of Program Files\Microsoft BizTalk Services SDK\Samples\Communication\GettingStarted\Echo.

You will need to modify the file "EchoService.cs".

Modify the "using" statements like this:

using System;
using System.ServiceModel;
using System.Threading;
using System.Net;
using System.IO;
using System.Text;

Copy the methods "CallHttpReceiveActivityWithLogin", "GetTokenGrantingToken" and "CallHttpReceiveActivity" from the code snippet at the bottom of send&receive activities to the class "EchoService".

Modify the "Echo"-method like this:

public string Echo(string text)
{
    Console.WriteLine(text + ":InstanceId received");
    Threading.ThreadStart starter = delegate { HttpCall(text); };
    new Threading.Thread(starter).Start();
    return "nothing to return really";        
}

You see that a new thread will be started with a delegate to HttpCall(text). This is because the service shall continue processing after returning from the "Echo"-method

Add a method "HttpCall" like this:

private void HttpCall(string instanceId)
{
    Console.WriteLine(instanceId+":Thread started");
    string username = "YOURUSERNAME";
    string password = "YOURPASSWORD";
    string workflowTypeName = "SimpleEnd2End";
    string activityName1 = "cloudHttpReceive1";
    string activityName2 = "cloudHttpReceive2";
    string dummyString = "does not matter";
    string urlToGet = "http://www.daenet.eu";
    //wait a bit before the first call
    Thread.Sleep(1000);
    Console.WriteLine(instanceId + ":request "+urlToGet);
    string result1 = CallHttpReceiveActivityWithLogin(
                                urlToGet, username, password,
                                workflowTypeName, activityName1,
                                instanceId);
    //wait a bit before the second call to allow loading of URL
    Thread.Sleep(5000);
    Console.WriteLine(instanceId + ":retrieve data for "
                      + urlToGet);
    string result2 = CallHttpReceiveActivityWithLogin(
                                dummyString, username, password,
                                workflowTypeName, activityName2,
                                instanceId);
    Console.WriteLine(instanceId + ":WebHttpResponse length "
                      + result2.Length);
    Console.WriteLine(instanceId + ":Thread exits");
}

After some initialization this method waits for 1 second and then does a WebHttpRequest to the activity cloudHttpReceive1, sending "http://www.daenet.eu" in the body of the request (which will then overwrite "http://www.microsoft.com" in the cloudHttpSend1 activity). At the same time the workflow in the cloud should continue and retrieve the wanted data. Then it waits another 5 seconds and executes another WebHttpRequest, but this time to the activity cloudHttpReceive2, where it will retrieve the result of what the workflow hopefully loaded meanwhile from the passed URL. Some output is printed to the console and the method and thread exits.
Please note that the workflow itself however will loop endlessly and likely block at some point since it may reach a CloudHttpReceive when there is nobody to send anymore.

For your convenience, the complete code of the modified file "EchoService.cs":

//---------------------------------------------------------------------------------
// Microsoft (R) BizTalk Services
// Software Development Kit
// 
// Copyright (c) Microsoft Corporation. All rights reserved.  
// Copyright (c) of modifications: Andreas Erben
// THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, 
// EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES 
// OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. 
//---------------------------------------------------------------------------------
 
namespace System.ServiceBus.Samples
{
    using System;
    using System.ServiceModel;
    using System.Threading;
    using System.Net;
    using System.IO;
    using System.Text;
 
 
    [ServiceBehavior(Name = "EchoService",
        Namespace = "http://samples.microsoft.com/ServiceModel/Relay/")]
    class EchoService : EchoContract
    {
        public string Echo(string text)
        {
            Console.WriteLine(text + ":InstanceId received");
            Threading.ThreadStart starter = delegate { HttpCall(text); };
            new Threading.Thread(starter).Start();
            return "nothing to return really";        
        }
 
        private void HttpCall(string instanceId)
        {
            Console.WriteLine(instanceId+":Thread started");
            string username = "YOURUSERNAME";
            string password = "YOURPASSWORD";
            string workflowTypeName = "SimpleEnd2End";
            string activityName1 = "cloudHttpReceive1";
            string activityName2 = "cloudHttpReceive2";
            string dummyString = "does not matter";
            string urlToGet = "http://www.daenet.eu";
            //wait a bit before the first call
            Thread.Sleep(1000);
            Console.WriteLine(instanceId + ":request "+urlToGet);
            string result1 = CallHttpReceiveActivityWithLogin(
                                        urlToGet, username, password,
                                        workflowTypeName, activityName1,
                                        instanceId);
            //wait a bit before the second call to allow loading of URL
            Thread.Sleep(5000);
            Console.WriteLine(instanceId + ":retrieve data for "
                              + urlToGet);
            string result2 = CallHttpReceiveActivityWithLogin(
                                        dummyString, username, password,
                                        workflowTypeName, activityName2,
                                        instanceId);
            Console.WriteLine(instanceId + ":WebHttpResponse length "
                              + result2.Length);
            Console.WriteLine(instanceId + ":Thread exits");
        }
 
        static string CallHttpReceiveActivityWithLogin(
                    string requestBody, string username, string password,
                    string workflowTypeName, string activityName,
                    string instanceId)
        {
            string token = GetTokenGrantingToken(username, password);
            return CallHttpReceiveActivity(
                                    requestBody, username, token,
                                    workflowTypeName, activityName,
                                    instanceId);
        }
 
        static string GetTokenGrantingToken(string userName, string password)
        {
            string tokenUrl = string.Format(
                "https://{0}/issuetoken.aspx?u={1}&p={2}",
                "identity.biztalk.net",
                userName,
                password);
 
            HttpWebRequest tokenRequest = (HttpWebRequest)WebRequest.Create(tokenUrl);
            HttpWebResponse tokenResponse = (HttpWebResponse)tokenRequest.GetResponse();
 
            using (Stream responseStream = tokenResponse.GetResponseStream())
            {
                byte[] tokenBody = new byte[500];
                int tokenBodyLength = responseStream.Read(tokenBody, 0, 500);
                return Encoding.UTF8.GetString(tokenBody, 0, tokenBodyLength);
            }
        }
 
        static string CallHttpReceiveActivity(
                            string requestBody, string username, string token,
                            string workflowTypeName, string activityName,
                            string instanceId)
        {
            Uri address = new Uri(@"http://workflow.biztalk.net/servicesHttp/"
                        + username + "/workflows/" + workflowTypeName +
                        "/instances/" + instanceId + "/" + activityName);
            HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(address);
            //this adds the retrieved token as a header
            request.Headers.Add("X-MS-Identity-Token", token);
            request.Method = "POST";
            request.ContentType = "text/plain";
            //send the body
            byte[] requestBodyBytes = Encoding.UTF8.GetBytes(requestBody);
            request.ContentLength = requestBodyBytes.Length;
            using (Stream requestStream = request.GetRequestStream())
            {
                requestStream.Write(requestBodyBytes, 0, requestBodyBytes.Length);
                requestStream.Flush();
            }
 
            HttpWebResponse response = (HttpWebResponse)request.GetResponse();
            using (Stream responseStream = response.GetResponseStream())
            {
 
                using (StreamReader reader = new StreamReader(responseStream,
                                                              Encoding.UTF8))
                {
                    return reader.ReadToEnd();
                }
            }
        }
    }
}

Running the sample

Start the modifed "Echo"-sample that will start-up its self-hosted ServiceBus endpoint.
Create 1 or more instances of the type SimpleEnd2End.
Start the instances of SimpleEnd2End.
Watch the output in the console of the modified "Echo"-sample until you are happy and press enter.

The output for 1 workflow instance:

d81d8ba2-3137-4a6d-aafe-c6c8c5eea1a8:InstanceId received
d81d8ba2-3137-4a6d-aafe-c6c8c5eea1a8:Thread started
d81d8ba2-3137-4a6d-aafe-c6c8c5eea1a8:request http://www.daenet.eu
d81d8ba2-3137-4a6d-aafe-c6c8c5eea1a8:retrieve data for http://www.daenet.eu
d81d8ba2-3137-4a6d-aafe-c6c8c5eea1a8:WebHttpResponse length 28427
d81d8ba2-3137-4a6d-aafe-c6c8c5eea1a8:Thread exits
d81d8ba2-3137-4a6d-aafe-c6c8c5eea1a8:InstanceId received
d81d8ba2-3137-4a6d-aafe-c6c8c5eea1a8:Thread started
d81d8ba2-3137-4a6d-aafe-c6c8c5eea1a8:request http://www.daenet.eu
d81d8ba2-3137-4a6d-aafe-c6c8c5eea1a8:retrieve data for http://www.daenet.eu
d81d8ba2-3137-4a6d-aafe-c6c8c5eea1a8:WebHttpResponse length 28427
d81d8ba2-3137-4a6d-aafe-c6c8c5eea1a8:Thread exits

The output for 2 concurrent workflow instances:

a7874223-e9d1-430c-b0f9-d36baf6d1076:InstanceId received
a7874223-e9d1-430c-b0f9-d36baf6d1076:Thread started
a7874223-e9d1-430c-b0f9-d36baf6d1076:request http://www.daenet.eu
befa13cf-4b4c-4118-82dc-4a94ef288952:InstanceId received
befa13cf-4b4c-4118-82dc-4a94ef288952:Thread started
befa13cf-4b4c-4118-82dc-4a94ef288952:request http://www.daenet.eu
a7874223-e9d1-430c-b0f9-d36baf6d1076:retrieve data for http://www.daenet.eu
befa13cf-4b4c-4118-82dc-4a94ef288952:retrieve data for http://www.daenet.eu
a7874223-e9d1-430c-b0f9-d36baf6d1076:WebHttpResponse length 28427
a7874223-e9d1-430c-b0f9-d36baf6d1076:Thread exits
befa13cf-4b4c-4118-82dc-4a94ef288952:WebHttpResponse length 28427
befa13cf-4b4c-4118-82dc-4a94ef288952:Thread exits
a7874223-e9d1-430c-b0f9-d36baf6d1076:InstanceId received
a7874223-e9d1-430c-b0f9-d36baf6d1076:Thread started
a7874223-e9d1-430c-b0f9-d36baf6d1076:request http://www.daenet.eu
befa13cf-4b4c-4118-82dc-4a94ef288952:InstanceId received
befa13cf-4b4c-4118-82dc-4a94ef288952:Thread started
befa13cf-4b4c-4118-82dc-4a94ef288952:request http://www.daenet.eu
a7874223-e9d1-430c-b0f9-d36baf6d1076:retrieve data for http://www.daenet.eu
befa13cf-4b4c-4118-82dc-4a94ef288952:retrieve data for http://www.daenet.eu
a7874223-e9d1-430c-b0f9-d36baf6d1076:WebHttpResponse length 28427
a7874223-e9d1-430c-b0f9-d36baf6d1076:Thread exits
befa13cf-4b4c-4118-82dc-4a94ef288952:WebHttpResponse length 28427
befa13cf-4b4c-4118-82dc-4a94ef288952:Thread exits

This is part of the actual retrieved data to be found in result2 when breaking after the second call to the workflow:

Note that it will, as seen in the previous blog-post be wrapped in the XML representation of a string object containing the retrieved data. To get the actual data, you would need to parse that XML structure (even though it is a simple parse).

This is all for now, I hope it made BizTalk Workflow Services more "accessible".

Finally some advertisment: If you want to talk to us/me about BizTalk Workflow Services or other exciting technologies or approaches then contact us/me. "face 2 face" logistics are most easy in the US or Europe.

Cloudy messages / Send & Receive Activities in BizTalk Workflow Services

Andreas Erben — Thu, 02 Oct 2008 03:14:00 GMT

(German version may be provided at a later stage / Deutsche Version wird gegebenenfalls nachgereicht)

In previous posts, I gave an introduction to BizTalk Workflow Services, I wrote about flow control and rambled about tricks you can do in conditions.

This post will deal with the send and receive activities available now.

BizTalk Workflow Services offer the following send and receive activities:

CloudHttpReceive
CloudHttpSend
CloudServiceBusSend

CloudServiceBusSend

CloudServiceBusSend was already used in the introduction post, so I will start with this.

CloudServiceBusSend with ConnectionMode RelayedMultiCast

Please look at the provided sample typically at Program Files\Microsoft BizTalk Services SDK\Samples\Workflow\GettingStarted and find the activity "cloudServiceBusSend1".

The activity corresponds to the following Xoml-fragment:

<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;The Microsoft site is responding.&lt;/text&gt;&lt;/Chat&gt;" Action="http://samples.microsoft.com/ServiceModel/Relay/MulticastContract/Chat" ConnectionMode="RelayedMulticast" />

Select cloudServiceBusSend1 and look at the properties:

ConnectionMode

There are two implemented ConnectionModes: "RelayedMultiCast" and "RelayedDuplexSession".
RelayedMultiCast requires a contract that only contains OneWay operations. "RelayedDuplexSession" in contrast will theoretically allow a response, but there seems to be a bug in the present version and the response will get lost. The posted example uses the "RelayedMultiCast" ConnectionMode. It interacts with the sample Program Files\Microsoft BizTalk Services SDK\Samples\Communication\ExploringFeatures\ConnectionModes\Multicast.

URL

sb://connect.biztalk.net/services/ChatRooms/watchdog/MulticastService/

This is the URL of the ServiceBus address you are trying to reach. A WorkflowValidator will not only check it for being not empty but also use the scheme "sb".

Action

http://samples.microsoft.com/ServiceModel/Relay/MulticastContract/Chat

Nothing really surprising. It is best understood though when looking at the contract of the corresponding sample

[ServiceContract(Name = "MulticastContract", Namespace = "http://samples.microsoft.com/ServiceModel/Relay/")]
public interface MulticastContract
{
    [OperationContract(IsOneWay=true)]
    void Hello(string nickName);
 
    [OperationContract(IsOneWay = true)]
    void Chat(string nickName, string text);
 
    [OperationContract(IsOneWay = true)]
    void Bye(string nickName);
}

So, it is basically Namespace+Name+Operation.

Body

<Chat xmlns='http://samples.microsoft.com/ServiceModel/Relay/'> <nickName>watchdog</nickName> <text>The Microsoft site is responding.</text></Chat>

What is actually being sent. A WorkflowValidator will check if it is valid XML.
In this example you see the outer element being named "Chat" like the operation that is going to be called on the interface with the namespace "http://samples.microsoft.com/ServiceModel/Relay/" of the ServiceContract. Then there are two string parameters, each represented by an XML-Tag corresponding to the parameter names of the operation: "nickName" with its value "watchdog" and "text" with its value "The Microsoft site is responding.".

Response

The response is empty, with RelayedMultiCast it will always stay empty even after the call (since it only involves OneWay operations) and unfortunately in the present CTP drop I found it impossible so far to be filled.

CloudServiceBusSend with ConnectionMode RelayedDuplexSession

Let's look at a slightly different configuration for this activity

<ns0:CloudServiceBusSend x:Name="cloudServiceBusSend1" URL="sb://connect.biztalk.net/services/andreaserben/EchoService/" Response="" Body="&lt;Echo xmlns='http://samples.microsoft.com/ServiceModel/Relay/'&gt; &lt;text&gt;Original&lt;/text&gt;&lt;/Echo&gt;" Action="http://samples.microsoft.com/ServiceModel/Relay/EchoContract/Echo" ConnectionMode="RelayedDuplexSession" />

with the properties being like

ConnectionMode

As mentioned "RelayedDuplexSession" will theoretically allow a response, but there seems to be a bug in the present version and the response will get lost. This example interacts with the sample Program Files\Microsoft BizTalk Services SDK\Samples\Communication\GettingStarted\Echo.

URL

sb://connect.biztalk.net/services/YOURWORKFLOWSERVICESUSERNAME/EchoService/

This is the URL of the ServiceBus address you are trying to reach in this case contains your username because this is how the "Echo" sample sets up its endpoint.

Action

http://samples.microsoft.com/ServiceModel/Relay/EchoContract/Echo

Again nothing really surprising. It is best understood though when looking at the contract of the corresponding sample

[ServiceContract(Name = "EchoContract", Namespace = "http://samples.microsoft.com/ServiceModel/Relay/")]
public interface EchoContract
{
    [OperationContract]
    string Echo(string text);
}
 

Again it is Namespace+Name+Operation. (Note that this is not a one-way operation now.)

Body

<Echo xmlns='http://samples.microsoft.com/ServiceModel/Relay/'> <text>Original</text></Echo>

The outer element is named "Echo" like the operation that is going to be called on the interface with the namespace "http://samples.microsoft.com/ServiceModel/Relay/" of the ServiceContract. Then there is the parameter "text" with its value "Original".

Response

The response is empty, here you would expect your value to show up that you get back from the ServiceBus as return values, however, it does not seem to work at the present time.

CloudHttpSend

Again look at the sample at Program Files\Microsoft BizTalk Services SDK\Samples\Workflow\GettingStarted and this time find the activity cloudHttpSend1.

The activity corresponds to the following Xoml-fragment:

<ns0:CloudHttpSend x:Name="cloudHttpSend1" StatusCode="0" URL="http://www.microsoft.com" Method="GET" Request="{x:Null}" RequestContentType="{x:Null}" Response="{x:Null}" />

Select the activity and look at its properties:

URL

http://www.microsoft.com

The address of the resource you want to access. The WorkflowValidator will allow the Uri-Schemes "http", "https" and "ftp". The URL has to be given in absolute format. (The actual access is done through HttpWebRequest).

Method

GET

Allowed values are "GET" and "POST".

RequestContentType

This only is being considered for the "POST"-method. An example would be "text/plain".

Request

This is only being considered for the "POST"-method. The string here will be written to the RequestStream of the HttpWebRequest by interpreting the the String as UTF8-encoded through Encoding.UTF8.GetBytes(REQUESTSTRING).

StatusCode

The StatusCode that the HTTP-Request receives will appear here after the call was being made.

Response

The "Response" property will contain the content of the ResponseStream of the HttpWebRequest interpreted as UTF8-encoded.

There is really not much more to it, I will however try to give an end-to-end example that utilizes this activity in a bit more meaningful manner.

CloudHttpReceive

CloudHttpReceive is tough to impossible to figure out with the given documentation as to date.

Let me first quote the documentation:

CloudHttpReceive: This activity receives an HTTP request at the URI http://workflow.biztalk.net/servicesHttp/<UserName>/workflows/<WorkflowTypeName>/instances/
<InstanceId>/<ActivityName> and returns a response. The HTTP listener uses Identity service access control and the operation name "Send"

Properties

Response: the HTTP content to send in response to the HTTP request

StatusCode: the HTTP status code to return in response to the HTTP request

Request: the content of the received HTTP request. This property is set by the activity when a request is received.

It sounds easier than it is.

This is the smallest possible workflow utilizing this activity:

and its corresponding Xoml-definition:

<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:CloudHttpReceive Request="{x:Null}" x:Name="cloudHttpReceive1" StatusCode="0" Response="Hello" />
</SequentialWorkflowActivity>

A closer look of the Xoml-fragment of that very simple cloudHttpReceive:

<ns0:CloudHttpReceive Request="{x:Null}" x:Name="cloudHttpReceive1" StatusCode="0" Response="Hello" />

It corresponds to those properties:

Request

This property will contain the string you received in the Request-Stream interpreted as UTF8-encoded.

Response

What you set here will be returned to the caller.

StatusCode

This is the statuscode that you will send to the caller.

Log in to BizTalk Workflow Services and create a type named "MinimalHttpReceive" with that Xoml definition and click "save changes".

Note that you did not need to provide a rules definition.

Create an instance of that type and start it and look at your instance manager:

Note the GUID of the workflow instance: 7bf7a7c4-82f5-4935-9c03-62ba1e7991aa
This will vary for you and you will have to remember your own GUID.

Now start the workflow instance and go to this URL in your browser:

http://workflow.biztalk.net/servicesHttp/YOURUSERNAMEHERE/workflows/MinimalHttpReceive/instances/YOURGUIDHERE/cloudHttpReceive1

If your browser does not display the complete URL, here it is again as a link:
http://workflow.biztalk.net/servicesHttp/YOURUSERNAMEHERE/workflows/
MinimalHttpReceive/instances/YOURGUIDHERE/cloudHttpReceive1

You should see something like this:

Now you need to log in with the username and password (or respective Information Card) that you used to create the workflow type and instance.

Then you should see something like that:

<string xmlns="http://schemas.microsoft.com/2003/10/Serialization/">Hello</string>

Your workflow should have been changed to "Completed" state.

Now what is interesting here is that you do not receive a pure string "Hello" but actually an XML serialization representation of the object string with content "Hello".

Sending to CloudHttpReceive programmatically

Ok, but now how can you do this programmatically? As you might realize, the challenge is the need to "log in". Unfortunately you cannot just use NetworkCredentials to log in but need to make a little detour.

At first you need to retrieve a token for logging in. You can find an example how to do it in this sample: Program Files\Microsoft BizTalk Services SDK\Samples\Workflow\ExploringFeatures\CreateWorkflowAPIs in Program.cs method GetTokenGrantingToken.

I took the liberty of modifying the method slightly and to remove any dependency to the SDK:

static string GetTokenGrantingToken(string userName, string password)
{
    string tokenUrl = string.Format(
        "https://{0}/issuetoken.aspx?u={1}&p={2}",
        "identity.biztalk.net",
        userName,
        password);
 
    HttpWebRequest tokenRequest = (HttpWebRequest)WebRequest.Create(tokenUrl);
    HttpWebResponse tokenResponse = (HttpWebResponse)tokenRequest.GetResponse();
 
    using (Stream responseStream = tokenResponse.GetResponseStream())
    {
        byte[] tokenBody = new byte[500];
        int tokenBodyLength = responseStream.Read(tokenBody, 0, 500);
        return Encoding.UTF8.GetString(tokenBody, 0, tokenBodyLength);
    }
}

It is pretty straightforward. Basically it is a simple HTTPS request to this URL:

https://identity.biztalk.net/issuetoken.aspx?u=YOURUSERNAME&p=YOURPASSWORD

Now, the string that you received represents your token and you need to attach that as a header of type "X-MS-Identity-Token" to your WebHttpRequest you want to send to your workflow instance.

request.Headers.Add("X-MS-Identity-Token", token);

This is the code-snipped for a method encapsulating the whole request:

static string CallHttpReceiveActivity(
                    string requestBody, string username, string token,
                    string workflowTypeName, string activityName,
                    string instanceId)
{
 
    Uri address = new Uri(@"http://workflow.biztalk.net/servicesHttp/"
                + username + "/workflows/" + workflowTypeName +
                "/instances/" + instanceId + "/" + activityName);
    HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(address);
    //this adds the retrieved token as a header
    request.Headers.Add("X-MS-Identity-Token", token);
    request.Method = "POST";
    request.ContentType = "text/plain";
    //send the body
    byte[] requestBodyBytes = Encoding.UTF8.GetBytes(requestBody);
    request.ContentLength = requestBodyBytes.Length;
    using (Stream requestStream = request.GetRequestStream())
    {
        requestStream.Write(requestBodyBytes, 0, requestBodyBytes.Length);
        requestStream.Flush();
    }
 
    HttpWebResponse response = (HttpWebResponse)request.GetResponse();
    using (Stream responseStream = response.GetResponseStream())
    {
 
        using (StreamReader reader = new StreamReader(responseStream,
                                                      Encoding.UTF8))
        {
            return reader.ReadToEnd();
        }
    }
}

You can combine both like this:

static string CallHttpReceiveActivityWithLogin(
                    string requestBody, string username, string password,
                    string workflowTypeName, string activityName,
                    string instanceId)
{
    string token = GetTokenGrantingToken(username, password);
    return CallHttpReceiveActivity(
                            requestBody, username, token,
                            workflowTypeName, activityName,
                            instanceId);
}

And an example call to the same workflow instance that we accessed above through the browser would be:

string userName = "YOURUSERNAME";
string password = "YOURPASSWORD";
string workflowTypeName = "MinimalHttpReceive";
string activityName = "cloudHttpReceive1";
string instanceId = "7bf7a7c4-82f5-4935-9c03-62ba1e7991aa";//YOUR GUID HERE INSTEAD
string requestBody="Text to send to cloud";
string result = CallHttpReceiveActivityWithLogin(
                        requestBody, userName, password,
                        workflowTypeName, activityName,
                        instanceId);

For the sake of completeness here the complete code together:

using System;
using System.Text;
using System.Net;
using System.IO;
 
namespace SendToHttpReceive
{
    class Program
    {
        static void Main(string[] args)
        {
 
            string userName = "YOURUSERNAME";
            string password = "YOURPASSWORD";
            string workflowTypeName = "MinimalHttpReceive";
            string activityName = "cloudHttpReceive1";
            string instanceId = "7bf7a7c4-82f5-4935-9c03-62ba1e7991aa";//YOUR GUID HERE INSTEAD
            string requestBody="Text to send to cloud";
            string result = CallHttpReceiveActivityWithLogin(
                                    requestBody, userName, password,
                                    workflowTypeName, activityName,
                                    instanceId);
            Console.WriteLine(result);
            Console.ReadLine();
        }
 
 
        static string CallHttpReceiveActivityWithLogin(
                            string requestBody, string username, string password,
                            string workflowTypeName, string activityName,
                            string instanceId)
        {
            string token = GetTokenGrantingToken(username, password);
            return CallHttpReceiveActivity(
                                    requestBody, username, token,
                                    workflowTypeName, activityName,
                                    instanceId);
        }
 
        static string GetTokenGrantingToken(string userName, string password)
        {
            string tokenUrl = string.Format(
                "https://{0}/issuetoken.aspx?u={1}&p={2}",
                "identity.biztalk.net",
                userName,
                password);
 
            HttpWebRequest tokenRequest = (HttpWebRequest)WebRequest.Create(tokenUrl);
            HttpWebResponse tokenResponse = (HttpWebResponse)tokenRequest.GetResponse();
 
            using (Stream responseStream = tokenResponse.GetResponseStream())
            {
                byte[] tokenBody = new byte[500];
                int tokenBodyLength = responseStream.Read(tokenBody, 0, 500);
                return Encoding.UTF8.GetString(tokenBody, 0, tokenBodyLength);
            }
        }
 
 
 
        static string CallHttpReceiveActivity(
                            string requestBody, string username, string token,
                            string workflowTypeName, string activityName,
                            string instanceId)
        {
 
            Uri address = new Uri(@"http://workflow.biztalk.net/servicesHttp/"
                        + username + "/workflows/" + workflowTypeName +
                        "/instances/" + instanceId + "/" + activityName);
            HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(address);
            //this adds the retrieved token as a header
            request.Headers.Add("X-MS-Identity-Token", token);
            request.Method = "POST";
            request.ContentType = "text/plain";
            //send the body
            byte[] requestBodyBytes = Encoding.UTF8.GetBytes(requestBody);
            request.ContentLength = requestBodyBytes.Length;
            using (Stream requestStream = request.GetRequestStream())
            {
                requestStream.Write(requestBodyBytes, 0, requestBodyBytes.Length);
                requestStream.Flush();
            }
 
            HttpWebResponse response = (HttpWebResponse)request.GetResponse();
            using (Stream responseStream = response.GetResponseStream())
            {
 
                using (StreamReader reader = new StreamReader(responseStream,
                                                              Encoding.UTF8))
                {
                    return reader.ReadToEnd();
                }
            }
        }
    }
}

Running that against a running workflow instance will (not surprisingly) result in this output:

In a future post I will try to show an "end-to-end"-demo that actually integrates a lot of what was shown previously and achieves bidirectional communication with a service in the cloud and has your workflow doing something that the service requests.

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.

Codename "Dublin" - Microsoft's Distributed Application Server

Andreas Erben — Wed, 17 Sep 2008 18:01:44 GMT

(German version below / deutsche Version weiter unten)

I did not find blog entries about this elsewhere, so here we go. Disclaimer: Nobody shared this information actively with me, and no confidential information was leaked to me, I happened to find it in public sources and derived my conclusion:

It seems that Microsoft's SOA/BPM strategy has found another codename complementing "OSLO". While OSLO focuses more on the integrated and system-wide modeling experience, the codename "DUBLIN" stands for the Distributed Application Server.

Previously the Distributed Application Server was thought to be part of the "wave of OSLO related technologies". I conclude that this means that the product roadmap is maturing.

Welcome new codename :)

(German version/ Deutsche Version)

Da ich sonst keine Blogeinträge hierüber gefunden habe. Diese Information wurde mir weder in irgendeiner Form aktiv zugetragen, und es wurde mir auch keine vertrauliche Information mitgeteilt, sondern ich habe dies aus öffentlich zugänglichen Quellen und dann meine eigenen Schlüsse gezogen:

Es scheint, dass die SOA/BPM-Strategie von Microsoft einen neuen Codenamen gefunden hat, der "OSLO" ergänzen soll. Während OSLO mehr auf die integrierte und systemweite Modellierungsbotschaft abzielt, steht der Codename "DUBLIN" für den Distributed Application Server.

Vorher hat man über den Distributed Application Server meist nur als Teil der Welle der OSLO-relevanten Technologien gesprochen. Ich schließe daraus, dass die Produkt-Roadmap deutlich gereift ist.

Willkommen neuer Codename :)

A flow control in the cloud / Flow control activities & BizTalk Workflow Services

Andreas Erben — Sat, 09 Aug 2008 01:49:25 GMT

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

This post is a continuation of my intro to BizTalk Workflow Services.

When orchestrating anything or in more simple words, when implementing an algorithm, we typically need a type of flow control. What is the order of the commands? How do we set conditions? How do we repeat something? This also is necessary when wanting to run an algorithm in the cloud. We are using BizTalk Workflow Services to describe what we want to do in the cloud. The tool we have are workflow activities.

BizTalk Workflow Services have a limited set of flow control activities:

CloudIfElse (and CloudIfElseBranch )
CloudWhile
CloudSequence

This does not seem much, but together with a place to store your data it theoretically lets people implement all types of algorithms.

CloudIfElse (and CloudIfElseBranch ) work very much like their regular equivalents. However, remember that those activities are in fact a new implementation and are not identical to IfElse or IfElseBranch.

Practically you will have to remember when setting rules, that you can only use declarative rule conditions (stay tuned in some days for a post about declarative rule conditions). Trying to use a code condition in the CloudIfElseBranch will result in this:

The CloudIfElse activity needs a minimum of one cloudIfElseBranches but can have more than 2:

You can add a branch:

That branch will be always added to the right:

Notice that now cloudIfElseBranch2 displays an error (exclamation mark in red circle) because we did not set a condition on the cloudIfElseBranch2 yet. The error did not display earlier, because the last CloudIfElseBranch in fact does not need a condition to be set. The CloudIfElseBranches' conditions are evaluated from the left to the right.

If we do not like the position of a CloudIfElseBranch , we can change their position with the help of the context menu easily:

We move it to the left, so we expect the cloudIfElseBranch2 (and it's red exclamation mark circle) now to be on the very left side:

The CloudWhile activity is again the cloud version of the regular While branch. And this neat activity is at the same time the reason for the CloudSequence activity. The CloudWhile activity only allows one inner child activity to be repeated. So, what you need is a Sequence activity. However, currently you cannot use a non-cloud activity in a cloud-based workflow.

Even though as we have seen in my previous post the cloud-workflow itself is a SequenceActivity, it cannot contain a SequenceActivity but needs a CloudSequence activity instead.

Trying to use a non-cloud activity will result in the following validation error when trying to save the XOML in the web-form:

The workflow failed validation

Type System.Workflow.Activities.SequenceActivity, System.Workflow.Activities, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35 is not marked as authorized in the application configuration file.

This makes a CloudWhile with more than one activity to look like this:

In one of the next posts I will look at the other activities and a bit deeper into the conditions you can use.

A little "disclaimer": Some readers wondered why I explain very simple things here. My reasoning is that I expect completely new users to want to get started with cloud technologies without digging through the workflow foundation's fundamentals first. They will want to look at the workflow foundation's basics soon enough anyways. But it could be overwhelming for new readers and people interested in BizTalk Services to have to know too much before getting started. I aim at giving people an easier start.

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.

Don't cache your DeviceConnection in an EventHandler / Eine DeviceConnection sollte man nicht in einem Eventhandler cachen

Andreas Erben — Wed, 11 Jun 2008 08:29:38 GMT

(German version below / deutsche Version weiter unten)

A while ago I talked to someone who knows BizTalk RFID inside out about that sometimes it just takes too long to open a connection to a device in an EventHandler.

The advice I received was, why not caching the connection to the device in the EventHandler, possibly opening it in the in the Init() method and keeping it open.

Out of respect I gave it serious thought and now seriously recommend NOT to do that.

When opening the connection in the Init()-method takes too long or has any slight problems, it will mess up starting up the whole process pipeline.
You would need to build thread safety around it. Though this is not the biggest concern, it is something you should not do.
There is a reason why a DeviceConnection implements IDisposable and allows you to use the using statement.
You effectively disable the chance of any other event handler in another process or even in another piece of software, e.g. a webservice, to access the device normally because you are hogging the connection the whole time.
Connection caching should be implemented by the device provider implementation, because only this piece of software can have appropriate knowledge.
In my opinion mechanisms like connection pooling should be part of the application stack in fact.

There might be isolated cases where it still makes sense to cache a connection in an EventHandler, but those should be pretty rare.

(German version / deutsche Version)

For einiger Zeit unterhielt ich mich mit jemandem, der/die BizTalk RFID in- und auswendig kennt darüber, dass es manchmal einfach zu lange dauert, in einem EventHandler eine Verbindung zu einem Gerät zu öffnen.

Ich erhielt den Ratschlag, warum ich nicht die DeviceConnection im EventHandler cachen würde und sie vielleicht schon in der Init()-Methode öffnen würde und danach einfach offen lassen.

Aus Respekt gegenüber meinem Gesprächspartner habe ich ernsthaft darüber nachgedacht und empfehle nun sehr ernsthaft, dies NICHT zu tun.

Wenn das Öffnen der Verbindung in der Init()-Methode zu lange dauert, oder ein kleines Problem dabei auftritt, wird das den Startvorgang für die ganze Prozess-Pipeline stören.
Man muss um die Verbindung herum eine ordentliche Thread-Safety herum bauen. Auch wenn das nicht das Hauptproblem sein sollte, ist es einfach etwas, was man vermeiden sollte.
Es gibt einen Grund, warum die DeviceConnection IDisposable implementiert und so das using-Statement zulässt.
Man entzieht jedem anderen EventHandler in einem anderen Prozess oder auch einer anderen Software, z.B. einem Webservice, die Chance, selbst normal auf das Device zuzugreifen, weil man die ganze Zeit die Verbindung blockiert.
Eigentlich sollte man Connection Caching in einer Device Provider Implementierung vorfinden, da nur diese "wissen" kann, was das Device wirklich benötigt.
Meiner Meinung nach sollten Connection Pooling Mechanismen auch bei RFID Teil des Applikationsstack sein.

Es mag einzelne, isolierte Szenarien geben, wo es Sinn machen kann, eine DeviceConnection in einem EventHandler zu cachen, dies sollte aber wirklich ziemlich selten erforderlich sein.

Typical setting of IOPorts in BizTalk RFID / Typisches Setzen von IOPorts in BizTalk RFID

Andreas Erben — Mon, 05 May 2008 07:26:34 GMT

(German version below / deutsche Version weiter unten)

When wanting to set an IOPort in BizTalk RFID, to for example switch on a specific light connected to an RFID reader, you basically deal with bits and bytes that you set somewhere. There are typically two ways of how this is implemented in a device:

the device will encode several signal lines in a bitmask in just one port (e.g. implemented by Intermec)
the device will have a port for each and every line (e.g. implemented by Sirit)

Depending on the implementation and your hardware you will have to set a bit to 0 or to 1 to actually activate the line (usually to 1).

So, when wanting to set the second and third line, this could look like this in the first case (e.g. Intermec):

byte[] bitValue = BitConverter.GetBytes(6);
connection.SetProperty("ThePortName",
        StandardDevicePropertyGroups.Source,
        SourcePropertyGroup.PortOutputValue,
        bitValue, null);

and like this in the second case (e.g. Sirit):

byte[] bitValue = BitConverter.GetBytes(1);
connection.SetProperty("PortNameOfLine2",
        StandardDevicePropertyGroups.Source,
        SourcePropertyGroup.PortOutputValue,
        bitValue, null);
connection.SetProperty("PortNameOfLine3",
        StandardDevicePropertyGroups.Source,
        SourcePropertyGroup.PortOutputValue,
        bitValue, null);

(German version)

Wenn man einen IOPort in BizTalk RFID setzen möchte, um beispielsweise ein bestimmtes Licht, welches an einen RFID Reader angeschlossen ist, anzuschalten, hat man vereinfacht gesagt mit Bits und Bytes zu tun, die man irgendwo setzen muss. Typischerweise gibt es zwei Herangehensweisen, wie dies in einem Gerät implementiert ist:

das Gerät kodiert verschiedene Leitungen in einer Bitmaske in nur einem Port (z.B. so durch Intermec implementiert)
das Gerät hat einen Port für jede einzelne Leitung (z. B. so bei Sirit zu finden)

Je nach Implementierung und der vorliegenden Hardware muss man nun den Wert jeweils zu 0 oder 1 setzen, um die Leitung zu aktivieren (normalerweise auf 1).

Wenn man also die zweite und dritte Leitung aktivieren möchte, würde das im ersten Fall (z.B. bei Intermec) so aussehen:

byte[] bitValue = BitConverter.GetBytes(6);
connection.SetProperty("ThePortName",
        StandardDevicePropertyGroups.Source,
        SourcePropertyGroup.PortOutputValue,
        bitValue, null);

und so im zweiten Fall (z.B. bei Sirit):

byte[] bitValue = BitConverter.GetBytes(1);
connection.SetProperty("PortNameOfLine2",
        StandardDevicePropertyGroups.Source,
        SourcePropertyGroup.PortOutputValue,
        bitValue, null);
connection.SetProperty("PortNameOfLine3",
        StandardDevicePropertyGroups.Source,
        SourcePropertyGroup.PortOutputValue,
        bitValue, null);

daenet wins German innovation prize 2008 for SOA / daenet gewinnt den Innovationspreis 2008 für die Kategorie SOA

Andreas Erben — Thu, 06 Mar 2008 15:41:43 GMT

(German version below / deutsche Version weiter unten)

Now I can finally talk about it. Our daenet SOA Suite now has officially been awarded with an important prize. "http://www.imittelstand.de/auszeichnungen/innovationspreis2008/kategoriesieger/soa.html" The "Innovationspreis 2008" (innovation prize 2008) specifically considers the needs of the so called "Mittelstand". The "Mittelstand" is the engine and the driver of the economy in Germany. Even though it means roughly "medium sized businesses", many of them are international, globalized companies with 10000 employees and more that in the US most often would be called enterprises. What is special about them is the down-to-earth "can-do" attitude and the need for fast return of investment (ROI) coupled with a high level of innovation.

So we are very proud that our SOA solution is being recognized as the BEST SOA solution for the most important customers that possibly could exist for all the right reasons.

The jury was huge and impressive, both academically apt and still with the mindset of delivering value is the key differentiator in life.

Why did we target the needs of the "Mittelstand"? Because we see that a lot of SOA approaches are far too complex for most companies and therefore too much being talked about and too little is being actually done. Being suitable for "Mittelstand" in my opinion automatically means being suitable for enterprises with the advantage that you can "scale" the approach down even to the departmental level.

In future posts I will likely talk more about what the daenet SOA Suite can do... until then: just ask me if you are interested.

(German version / deutsche Version)

Nun kann ich endlich darüber sprechen. Unsere daenet SOA Suite wurde offiziell mit einem wichtigen Preis ausgezeichnet. "http://www.imittelstand.de/auszeichnungen/innovationspreis2008/kategoriesieger/soa.html" Der "Innovationspreis 2008" berücksichtigt besonders die Bedürfnisse des sogenannten "Mittelstand". Der Mittelstand ist der Motor der deutschen Wirtschaft. Auch wenn es eigentlich "Mittelgroße Firmen" bedeutet, sind viele dieser in Wirklichkeit internationale, globalisierte Firmen mit 10000 und mehr Angestellten, die in den USA oft "enterprises" genannt würden. Besonders am Mittelstand ist die Bodenständigkeit und die "wir machen's möglich"-Einstellung, welche aber mit der Notwendigkeit einhergeht, einen schnellen Investitionsrückfluss (ROI) zu erreichen, der mit einem hohen Innovationsbedarf und hoher Innovationskraft gekoppelt ist.

Also sind wir sehr stolz, dass unsere SOA Lösung als die BESTE SOA Lösung für diese Kundenzielgruppe anerkannt wurde, welche sicherlich aus all den richtigen Gründen heraus gesehen die wichtigste Kundenzielgruppe überhaupt ist.

Die Jury selbst war groß und beeindruckend: Akademisch qualifiziert und gleichzeitig mit dem Bewusstsein, dass "Werte schaffen" der Hauptunterscheidungsgrund im Leben ist.

Warum haben wir speziell die Bedürfnisse des "Mittelstand" adressiert? Weil wir sehen, dass viele SOA Ansätze bei weitem zu komplex für die meisten Firmen sind und deshalb zu viel geredet und zu wenig gehandelt wird. Wenn eine Lösung für den Mittelstand geeignet ist, heisst das meiner Meinung nach, dass sie automatisch auch für Konzerne geeignet ist aber den Vorteil mitbringt, nach "unten" skalierbar zu sein, also selbst auf Abteilungsebene einsetzbar zu sein.

In künftigen Artikeln werde ich wahrscheinlich mehr darüber schreiben, was die daenet SOA Suite alles kann... bis dahin: Bitte fragen Sie mich, wenn Sie Interesse haben!

Huge surprise today around daenet and SOA / Heute große Überraschung rund um daenet und SOA

Andreas Erben — Thu, 06 Mar 2008 12:35:18 GMT

(German version below / deutsche Version weiter unten)

Expect a huge surprise today. I am waiting for the official press info to leak out so nobody is upset with me that I talk about it. What I can tell you is that it is around daenet and SOA. It will be one more reason to talk to us when it comes to this topic :)

(German version / deutsche Version)

Heute kommt noch eine große Überraschung auf uns zu. Ich warte noch darauf, dass eine offizielle Presseinfo raussickert, so dass niemand sauer auf mich sein kann, dass ich darüber rede. Was ich jetzt schon sagen kann ist, dass es um daenet und SOA geht. Es wird ein weiterer Grund sein, mit uns über dieses Themengebiet zu sprechen :)

Typical processing of IOPortValueChangedEvents / Typische Verarbeitung von IOPortValueChangedEvents

Andreas Erben — Wed, 27 Feb 2008 11:13:58 GMT

(German version below, deutsche Version weiter unten)

When dealing with IOPortValueChangedEvents, you will have a method like this:

[RfidEventHandlerMethod]
public IOPortValueChangedEvent HandleIOPortValueChangedEvent(
    IOPortValueChangedEvent iOPortEvent)

What to do with it now?
After considering the DeviceName, the PortName, the Source and the Time-properties of the ioPortEvent, usually the most important piece of information is in the byte-array shown here:

byte[] iodata = iOPortEvent.GetPortValue();

(Of course can have VendorSpecificData also, but this special case is neglected here.)

What you want to do for each of these bytes is to be able to compare against it. We look at the "discrete" case where you do not care about continuous values but about specific lines being set somewhere, meaning that specific bits are set to "0" or "1".
This is "old-school". Typically this is done by two things:
1. Define a bitmask with the bits that interest you, use it with "AND" on the retrieved value
2. then compare the result with a value you provide. This gives you pretty good flexibility.
In the case of having only one element in the array above, this is simplified to:

byte ioValue = iodata[0];
ioValue = Convert.ToByte( ioValue & m_InputIOBitMask );
if (ioValue == m_InputIOValue)
{
   // do something
}

(German version, deutsche Version)

Wenn man mit IOPortValueChangedEvents zu tun hat, wird in der Regel eine derartige Methode vorliegen:

[RfidEventHandlerMethod]
public IOPortValueChangedEvent HandleIOPortValueChangedEvent(
    IOPortValueChangedEvent iOPortEvent)

Was nun?
Nachdem man DeviceName, PortName, Source und die Time-Properties von ioPortEvent beachtet hat, ist normalerweise der wirklich relevante Teil in diesem Byte-Array:

byte[] iodata = iOPortEvent.GetPortValue();

(Natürlich kann es auch VendorSpecificData geben, dieser Fall wird hier aber vernachlässigt)

Nun will man in der Lage sein, diese Bytes gegen etwas zu vergleichen. Wir betrachten den "diskreten" Fall, also wo man sich nicht um kontinuierliche Werte kümmert, sondern darum dass bestimmte Verbindungen irgendwo vorhanden sind. Dies bedeutet, dass bestimmte Bits auf "0" oder "1" sind.
Das ist "Old School". Typischerweise wird dies durch zwei Dinge erledigt:
1. Definiere eine BitMask mit den Bits, welche interessant sind und verknüpfe diese mit "UND" mit dem erhaltenen Wert
2. dann wird das Ergebnis mit einem Wert verglichen, für welchen wir uns interessieren. So erreicht man relativ große Flexibilität.
In dem Fall, dass nur ein Element im obigen Array ist, vereinfacht sich dies zu:

byte ioValue = iodata[0];
ioValue = Convert.ToByte( ioValue & m_InputIOBitMask );
if (ioValue == m_InputIOValue)
{
   // irgendwas machen
}

Presentation at the / Präsentation auf den 1st Worldwide Microsoft RFID Solution Days

Andreas Erben — Wed, 20 Feb 2008 03:29:44 GMT

(German version below / deutsche Version weiter unten)

Today I had the honor to present at the 1st Worldwide Microsoft RFID Solution Days (currently the corresponding page can be found here).

You can find my presentation here.

In the presentation I spoke about BizTalk RFID and about how a customer sees potential of real business problems to be solved easily with the help of RFID based technologies, about what the long-term vision is and what components can help building up a sound architecture at the same time.

I introduced the Sensor Service Bus, the daenet SOA Suite and XSYLON and what they can do for a customer.

When talking about the SOA Suite it might have been that some folks might have misunderstood me jokingingly saying that using a virtual distributed service bus with some processing done by the participants instead of the core server might lead to BizTalk selling less licenses. Well, the actual point behind this is, that the patterns introduced by the daenet SOA Suite in fact are different from BizTalk's hub/spoke approach. So, what it actually means is - well, you might sell less BizTalk licenses for the use cases where BizTalk is currently not a good fit anyways. (We are talking about direct communication between clients and services here.)

In the end I have a strong belief in that it is better to deliver customer satisfaction than to sell a product at all cost and have a customer that might end up being unhappy with the solution they get.

So, we are complementing BizTalk with new features and approaches, not competing with it.

(German version / deutsche Version)

Heute hatte ich die Ehre auf den ersten weltweiten Microsoft RFID Solution Days (zur Zeit kann die entsprechende Seite noch hier gefunden werden).

Meine Präsentation ist hier zu finden.

In der Präsentation sprach ich über BizTalk RFID und darüber, wie ein Kunde das Potential sieht, echte Probleme in Geschäftsprozessen mit RFID basierenden Technologien leicht zu lösen, was die langfristige Vision des Kunden ist und welche Komponenten helfen können, das Ganze in einer guten Architektur zu verankern sind.

Ich führte den Sensor Service Bus, die daenet SOA Suite und XSYLON ein und erklärte, was diese Komponenten für einen Kunden tun können.

Als ich über die SOA Suite gesprochen habe, haben mich möglicherweise einige mißverstanden, als ich aus Spaß gesagt habe, dass bei der Verwendung eines virtuellen verteilten Service Bus, wo Teile der Verarbeitung direkt bei den Partizipanten stattfindet, statt auf einem Server im Kern der Verarbeitung,dies dazu führen könnte, dass BizTalk weniger oft verkauft würde. Nun, der Knackpunkt dahinter ist, dass die Patterns, welche über die daenet SOA Suite eingeführt werden tatsächlich unterschiedlich gegenüber dem typischen Hub/Spoke Szenario des BizTalk ist. Was wirklich gemeint ist: Nun, vielleicht verkauft man weniger BizTalk Lizenzen für die Use Cases, wo BizTalk sowieso nicht gut passen würde (denn wir reden hier über die direkte Kommunikation zwischen Clients und Services).

Ich glaube fest daran, dass es besser ist, den Kunden zufrieden zu stellen, als um jeden Preis ein Produkt zu verkaufen und am Ende einen Kunden zu haben, der mit der gelieferten Lösung unglücklich ist.

Wir ergänzen also BizTalk um sinnvolle neue Features und Ansätze und stehen nicht im Wettbewerb damit.

Consideration when using PGL templates to Printronix printers - Was ist bei der Verwendung von PGL Templates für Printronix Drucker zu beachten

Andreas Erben — Wed, 06 Feb 2008 08:28:00 GMT

(German Version below - Deutsche Version weiter unten)

Read the release notes of the Printronix DSPI!

(This section relates to the DSPI available in February 2008)

One relevant part of it says:

The provider does not support locking tags using the Print Wizard. Tags must be locked using the LOCK option in the PGL template.

So, you need to adjust the template when you want to lock tags.

Then:

PGL templates must use DF1 for the Tag Identifier field.
PGL templates must use DF2 for the Tag Data field.
PGL templates must use DF3 for the Access Code field.
PGL templates must use DF4 for the Kill Code field.

For example this means that for BizTalk RFID to "know" what to do when you want to put the Tag Identifier field, you have to put "DF1" in your PGL template.

The SFCC must be ‘~’.

e.g. in the template:

~NORMAL

Do not forget to put "DISK" in your "~CREATE" line

For those who write/edit templates from scratch in PGL or whose tools for editing templates are perhaps flawed, it is important to remember that you need to put "DISK" in your "~CREATE" line.

Example:

~CREATE;RAFU450;216;DISK

If you forget this, then you will try endlessly to send the template to the printer through BizTalk RFID, it will not show up in the list of available templates! Actually BizTalk RFID will send the template just fine, but the printer is missing the instruction to save the template in the flash memory where it needs to be stored, so it will not be available for you.

Vista users (and others): Do not edit the supplied PGL-template examples with Notepad, use a good text editor

"Notepad" of Windows Vista unfortunately does not represent the usual line-feeds correctly (this also applies to some other text editor programs).

Example: RAFU450.pgl in Vista Notepad

Example how it should look like:

~CREATE;RAFU450;216;DISK
RFWTAG;96;EPC
96;DF1;H
STOP
RFWTAG;256;USR
256;DF2;H
STOP
END
~NORMAL

Please use another text-editor that ideally does not do anything fancy like gobbling up those characters or changing encoding or adding prefix bytes...

(German version / deutsche Version)

Die Release Notes des Printronix DSPI lesen!

(Dieser Bereich bezieht sich auf den DSPI, welcher Anfang Februar 2008 verfügbar war.)

Eine relevante Aussage ist:

The provider does not support locking tags using the Print Wizard. Tags must be locked using the LOCK option in the PGL template.

Also muss man im PGL Template vorsehen, dass ein Tag "gelockt" wird.

Dann:

PGL templates must use DF1 for the Tag Identifier field.
PGL templates must use DF2 for the Tag Data field.
PGL templates must use DF3 for the Access Code field.
PGL templates must use DF4 for the Kill Code field.

Dies bedeutet, dass wir die DF1 bis DF4 Felder für die Kern-Tag-Funktionalitäten nutzen müssen, welche BizTalk RFID benötigt. Zum Beispiel benötigt BizTalk RFID das "DF1"-Feld im Template um zu wissen, dass man das Tag Identifier Feld benutzen möchte..

The SFCC must be ‘~’.

Zum Beispiel also im Template:

~NORMAL

Nicht vergessen, "DISK" in der "~CREATE" Zeile anzufügen.

Für diejenigen, welche Templates verändern oder komplett manuell in PGL erzeugen, oder für diejenigen, welche Templates mit Tools verändern, welche vielleicht ein paar Problemchen haben, ein wichtiger Hinweis: In die "~CREATE"-Zeile muss ein "DISK".

Beispiel:

~CREATE;RAFU450;216;DISK

Wenn man dies vergisst, wird man immer wieder erfolglos versuchen, das Template über BizTalk RFID an den Drucker zu übertragen, es wird nie in der Liste der verfügbaren Templates auftauchen. Genauer gesagt macht BizTalk RFID alles richtig, das Template wird ordentlich an den Drucker geschickt, aber es fehlt die Anweisung, dass das Template im Flash Memory, wo es hin muss, abgespeicehrt wird - daher ist es nicht verfügbar.

Bei Problemen also ruhig einmal in einem guten Text Editor (nicht Notepad für Vista, dies stellt Zeilenumbrüche nicht gut dar) im PGL-Template nachschauen.

Vista Benutzer und andere: Die mitgelieferten PGL-Template Beispiele nicht mit Notepad verändern, sondern einen besseren Text Editor verwenden.

Das "Notepad" von Windows Vista stellt leider die üblichen Zeilenumbrüche nicht richtig dar (dies gilt auch für manche anderen Editoren).

Beispiel: RAFU450.pgl in Vista Notepad

Beispiel wie es aussehen sollte:

~CREATE;RAFU450;216;DISK
RFWTAG;96;EPC
96;DF1;H
STOP
RFWTAG;256;USR
256;DF2;H
STOP
END
~NORMAL

Bitte daher einen anderen Texteditor verwenden, der idealerweise keine derartigen Zeichen verschluckt und der auch nicht versucht das Encoding zu verändern oder Prefix-Bytes anzuhängen.

German/deutscher BizTalk RFID Webcast as part of the German/als Teil des deutschen BizTalk Server 2006 R2 Launch

Andreas Erben — Thu, 15 Nov 2007 18:49:00 GMT

(German version below, English version is very minimal since this post is targeted to the German audience)

On November 15, 2007, I presented BizTalk RFID in a webcast format to the German audience in German as part of the launch of BizTalk 2006 R2.

(German version)

Am 15. November 2007 durfte ich BizTalk RFID der deutschen Community im Rahmen des deutschen Microsoft BizTalk Server 2006 R2 Launch-Events vorführen.

Anbei stelle ich gerne allen die Slides hier zum Download zur Verfügung. Für Code-Beispiele und ähnliches möchte ich auf mein vorheriges Blog-Post zur TechEd Developers 2007 in Barcelona verweisen.

Leider war ich durch eine starke Erkältung und damit zusammenhängendem Doping, um den Webcast überhaupt durchführen zu können schwer "gehandicappt" und ich bitte die Teilnehmer um Nachsicht. Gerne spreche ich mit Interessierten im Nachgang über BizTalk RFID.

Der Webcast war leider nur eine Stunde lang und hatte den Anspruch, die technischen Aspekte einem gemischtem Publikum etwas näher zu bringen. Dies ist ein schwieriges Unterfangen, da das Produkt zu umfangreich und die Interessengruppen zu verschieden sind, um es allen recht zu machen. Ich hoffe, dass dennoch ein erstes Gefühl dafür entstand, was man mit Biztalk RFID erreichen kann, über viele Bereiche musste ich leider sehr schnell rüberfliegen und sehr oberflächlich bleiben. Wir wollten dennoch bewusst vermeiden, nur einen Feature-Rundflug mit Marketing-Slides über das Produkt zu machen, sondern zumindest einen kurzen Einblick in das "doing" geben, daher gab es in der Veranstaltung zum Beispiel kurz "Code" zu sehen und auch ein kommendes "SOA-Integrations Pattern", der Sensor Service Bus, wurde kurz vorgestellt.

Nach meiner Meinung wäre es sinnvoll, künftig mehrere Veranstaltungen zum Thema durchzuführen, welche sich beispielsweise wie folgt aufgliedern könnten:

Zielgruppe	Beschreibung
Alle	Allgemeiner Überblick ohne Entwicklung usw – im Gegensatz zu dem „alles in einer Stunde“
Entscheidungsträger/BDMs (Business Decision Maker), Business Analysten, Solution-Architekten	business value: typische Business Szenarien und wie man diese mit BizTalk RFID lösen kann, welchen Business Value BizTalk RFID bietet (z.B. Supply Chain, Asset Management usw.)
Software-Architekten, Entwickler	Architektonische und Integrations Patterns mit BizTalk RFID (vielleicht mit Vertiefung von Sensor Service Bus in gesonderter Session)
Softwareentwickler	Einführung in die synchronen BizTalk RFID APIs
Softwareentwickler	Einführung in die asynchrone BizTalk RFID Entwicklung
Softwareentwickler	Einführung in die DSPI Entwicklung
Architekten, Softwareentwickler	Best Practices, Business Rule Engine, Logging, Performance Aspekte... (lässt sich beliebig ausweiten)
Administratoren, IT-Pros	BizTalk RFID für den IT Pro
Entscheidungsträger/BDMs (Business Decision Maker)	Kundenstories
Alle	Workshops - mit Einbeziehung von Hardware