Andreas Erben's posts : Visual Studio 2005

Visual Studio 2010 Beta 2 availability

Andreas Erben — Mon, 19 Oct 2009 16:08:41 GMT

Mary Jo beat me to it. Visual Studio 2010 Beta 2 is available.

RTM March 22, 2010 (exact date? crazy! :) )

Interesting is the new naming that includes “Visual Studio Ultimate”.

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.

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.

WCF designer revisited: Efforts on the way, not coming as part of any product yet

Andreas Erben — Thu, 07 Jun 2007 00:19:46 GMT

Damir recently posted about a WCF designer, or rather that there is no WCF designer yet and it does not seem to be on the immediate roadmap for Orcas / Visual Studio 2008.

Let me look deeper into the promise of the WCF designer..

Chris Smith said in early 2006 he is working on the WCF designer experience. But what are the actual developments we actually see?

1. VS 2005 extensions for .NET Framework 3.0 (WCF & WPF) & VS 2008 ("Orcas")

The "Visual Studio 2005 extensions for .NET Framework 3.0 (WCF & WPF)" have been referred to as "WCF designer" in the blog post "Introducing the <DataContract>" by Thom Robbins. Those features will be available in Visual Studio 2008 (codename: Orcas). They might not "deserve" the name though when comparing with what people actually might expect when hearing "WCF designer".

2. Patterns & Practices: Service Factory

There is speculation that the "Service Factory" from Patterns&Practices will basically contain or be what people will then call "WCF designer". Currently the recent developments are available at Codeplex, check out the newer builds. Check out the Service Factory Blogs.As of the time of the posting though, this does NOT work with Orcas yet.

Taken from Don Smith's blog post "First Service Factory v3 Community Drop" here are two pictures of what to expect

There are newer builds available already.

3. Community effort: DSLFactory Utilities

Last but not least I want to point your attention to the efforts of the French speaking community http://dslfactory.org/. Check out codeplex here: http://www.codeplex.com/DslFactoryUtilities.

They posted how it can look like:

This is synchronized with code.

Not bad at all!

Not part of any product yet

We see various efforts underway inside Microsoft and inside the community, but there is no product yet that will ship anything WCF designer-like. Please note that "Service Factory" is something "unsupported" as long as it resides in "Patterns&Practices" and does not count as a product.

I hope this overview gets you started on the quest for the WCF designer :)

Legoboto: hajimemashou, LEGO MINDSTORMS NXT, sensor eventing

Andreas Erben — Wed, 18 Apr 2007 23:45:00 GMT

In the previous posts I offered some sample code for motor movement and dealing with sensors of the LEGO MINDSTORMS NXT product used with Bram Fokke's .NET API NXT#.

One important feature of the API was not covered before: Eventing

For each sensor you can register an event handler for when the data of the event handler changes. This implies that you poll the data from the sensor of course.

Here is the sample code:

using System;
using System.Collections.Generic;
using System.Text;
using Bram.NxtSharp;
 
namespace LegoNxtConsoleSample
{
    class Program
    {
        const string c_BluetoothComPort = "COM4";
 
 
        static void pressureSensorValueChangedEventHandler(NxtSensor sensor)
        {
            if (sensor is NxtPressureSensor)
            {
                NxtPressureSensor pressureSensor = (NxtPressureSensor)sensor;
                Console.Write("Pressure rawvalue:" + pressureSensor.RawValue + " means that sensor is ");
                if (pressureSensor.IsPressed)
                    Console.WriteLine("pressed");
                else
                    Console.WriteLine("not pressed");
            }
            else
            {
                Console.WriteLine("Problem: NxtPressureSensure expected but not received");
            }
        }
 
        static void SensorEventingDemo()
        {
            Console.WriteLine("pressure sensor eventing demo, running for 30 seconds");
            NxtBrick brick = new NxtBrick();
            brick.COMPortName = c_BluetoothComPort;
            brick.AutoPoll = true;
            NxtPressureSensor pressureSensor = new NxtPressureSensor();
            pressureSensor.AutoPoll = true;
            pressureSensor.AutoPollDelay = 50;
            pressureSensor.Brick = brick;
            brick.Sensor1 = pressureSensor;
            pressureSensor.ValueChanged += new SensorEvent(pressureSensorValueChangedEventHandler);
            //best practice: connect all sensors and motors first
            brick.Connect();
            System.Threading.Thread.Sleep(30000);
            brick.Disconnect();
        }
 
 
        static void Main(string[] args)
        {
            SensorEventingDemo(); 
        }     }
}

Ohayo gozaimashita, Legoboto-san, NXT: come to your sensors (LEGO MINDSTORMS NXT)

Andreas Erben — Wed, 18 Apr 2007 23:27:00 GMT

In the previous post I offered some sample code for motor movement of the LEGO MINDSTORMS NXT product used with Bram Fokke's .NET API NXT#.

In this post I will give info about how to use the different types of sensors.

Out-of-the-box you get 4 different sensors.

Pressure (button)
Sound
Light
Sonar

Pressure, as the name says, measures how much pressure is applied. The API will pretty much treat it as a button.

Sound measures the level, the amplitude, of sound – or noise. It has two modes: a "human" mode, scaled to the human hearing, and a normal mode.

The Light sensor can find out for you if it is dark or not. It has an active (red) light you can turn on, with the reflections from that red light you can detect objects in darkness or you can tell the difference between the colors red or blue.

Sonar tells you the distance the sensor has to the next objects in the direction it is pointing. It operates with reflections from ultrasonic sound waves. Note that if you get too close you are actually blocking the sound getting out and it will not be reflected in a way that makes sense. So when you actually touch an object, it can jump to the maximum possible value suddenly.

But here goes the sample code:

using System;
using System.Collections.Generic;
using System.Text;
using Bram.NxtSharp;
 
namespace LegoNxtConsoleSample
{
    class Program
    {
        const string c_BluetoothComPort = "COM4";
 
        static void SensorDemo()
        {
            //sensors
            //the general use pattern of attaching sensors and
            //looping through sensors is similar and so not shown here
            int i = 0;
 
            NxtBrick brick;
            brick = new NxtBrick();
            brick.COMPortName = c_BluetoothComPort;
            brick.Connect();
 
 
            NxtPressureSensor pressureSensor = new NxtPressureSensor();
            pressureSensor.Brick = brick;
            brick.Sensor1 = pressureSensor;
            pressureSensor.InitSensor();
 
            NxtSoundSensor soundSensor = new NxtSoundSensor();
            soundSensor.Brick = brick;
            brick.Sensor2 = soundSensor;
            Console.WriteLine("sound sensor adjusted for human ear");
            soundSensor.AdjustForHumanEar = true;
            soundSensor.InitSensor();
            i = 0;
            while (i++ < 10)
            {
                soundSensor.Poll();
                Console.WriteLine("sound sensor raw value:" + soundSensor.Value);
                Console.WriteLine("sound sensor value:" + soundSensor.Value);
                System.Threading.Thread.Sleep(500);
            }
 
            Console.WriteLine("sound sensor not adjusted for human ear");
            soundSensor.AdjustForHumanEar = false;
            soundSensor.InitSensor();
            i = 0;
            while (i++ < 10)
            {
                soundSensor.Poll();
                Console.WriteLine("sound sensor raw value:" + soundSensor.RawValue);
                Console.WriteLine("sound sensor value:" + soundSensor.Value);
                System.Threading.Thread.Sleep(500);
            }
 
 
            //lightsensor used uninitialized
            NxtLightSensor lightSensor = new NxtLightSensor();
            lightSensor.Brick = brick;
            brick.Sensor3 = lightSensor;
 
 
            Console.WriteLine("raw lightsensor value before poll:" + lightSensor.RawValue);
            Console.WriteLine("lightsensor value before poll:" + lightSensor.Value);
            lightSensor.Poll();
            Console.WriteLine("raw lightsensor value:"+lightSensor.RawValue);
            //note that this behaves differently when "initialized"
            //but only when brick was "off" before or different sensor was
            //used
            Console.WriteLine("lightsensor value:" + lightSensor.Value);
 
            //initSensor is done at brick.Connect(), so usually attach sensors first,
            //then connect brick!
            lightSensor.InitSensor();
            Console.WriteLine("raw initialized lightsensor value before poll:" + lightSensor.RawValue);
            Console.WriteLine("initialized lightsensor value before poll:" + lightSensor.Value);
            lightSensor.Poll();
            Console.WriteLine("raw lightsensor value:" + lightSensor.RawValue);
            Console.WriteLine("initialized lightsensor value:" + lightSensor.Value);
 
 
            //turn on ligth on lightSensor, needs InitSensor for change of lightstatus
            lightSensor.Active = true;
            lightSensor.InitSensor();
            Console.WriteLine("raw active lightsensor value before poll:"
                              + lightSensor.RawValue);
            Console.WriteLine("lightsensor active value before poll:"
                + lightSensor.Value);
            lightSensor.Poll();
            Console.WriteLine("raw active lightsensor value:" + lightSensor.RawValue);
            Console.WriteLine("active lightsensor value:" + lightSensor.Value);
 
            //turnoff light
            lightSensor.Active = false;
            lightSensor.InitSensor();
 
            //autopolling lightsensor 
            brick.AutoPoll = true;
            lightSensor.AutoPoll = true;
            lightSensor.AutoPollDelay = 1000;
            //note that usually you will set up
            //sensors and autopoll before first brick.Connect()
            //which will do StartPolling for you
            brick.StartPolling();
            while (i++ < 20)
            {
                //this should show that AutoPollDelay matters
                Console.WriteLine("Light sensor raw value:"+lightSensor.RawValue);
                System.Threading.Thread.Sleep(500);
            }
            brick.StopPolling();
 
 
            //sonar sensor measures distance
            NxtSonar sonarSensor = new NxtSonar();
            sonarSensor.Brick = brick;
            brick.Sensor4 = sonarSensor;
            sonarSensor.InitSensor();
            i = 0;
            while (i++ < 20)
            {
                sonarSensor.Poll();
                Console.WriteLine("Sonar sensor raw value:"+sonarSensor.RawValue);
                System.Threading.Thread.Sleep(500);
            }
 
 
            //disconnect Sensor2
            brick.Sensor2 = null; 
            foreach(NxtSensorPort sensorPort in brick.SensorPorts())
            {
                Console.Write(sensorPort.ToString()+" ");
                if (brick.GetSensor(sensorPort) == null)
                    Console.WriteLine("is not connected");
                else
                    Console.WriteLine("is connected with a "
                        + brick.GetSensor(sensorPort).ToString());
            }
 
 
            foreach(NxtSensor sensor in brick.ConnectedSensors())
            {
                sensor.Poll();
                Console.WriteLine(sensor.GetType().Name + " is connected to port " + sensor.Port.ToString() + " and has value " + sensor.RawValue);
            }
            //of further interest could be:
            //sensor.LastResult of type NxtGetInputValues
 
 
            brick.Disconnect();
        }
 
        static void Main(string[] args)
        {
            SensorDemo();
        }
    }
}

Domo arigato, Mr. Legoboto NXT#, turn the motor on (LEGO MINDSTORMS NXT)

Andreas Erben — Wed, 18 Apr 2007 22:53:00 GMT

We found that LEGO did a great job in delivering the MINDSTORMS NXT products (note that this link might point to the next version of MINDSTORMS products in the future and not to NXT anymore).

It is a great for learning purposes and can actually be used with Microsoft Robotics Studio. However, you might want to have a more basic way of controlling the robot, but there is no native C# interface available right now.

Bram Fokke did a great job in actually writing a C# based interface for controlling MindStorms NXT named NXT#. Even though I would not agree with every little implementation detail, he deserves a lot of respect and credit for that.
However, there could be more sample code.

The API offers a LOT more than what I will discuss here. I only deal with the basic features: How to control the motors and maybe later how to read the sensors. So I recommend you check it out yourself.

There are a lot of issues when controlling the robot. So expect funny behavior. Like for example when sending two identical commands to the robot in some time delay so that the first command actually executed already, it might just refuse to execute the second one. Also some other commands resulted in a "non"-movement, even so they should have done something. So – please feel free to experiment, and please add own exception-handling code. After all this is about experimenting and learning.

But how did we get into LEGO MINDSTORMS NXT in the first place? Well, partially it was also a collateral from dealing with RFID. RFID is all about sensors and reacting to it. So, we wanted to look around a little and ended up with a toy that proved to be a lot more than just a toy.

In fact, if we are dealing with hands-on-people, we like to use this product sometimes to do customer demos with it, since it makes some business-integration or business process scenarios suddenly so much more interesting, when you actually see something happening in the physical world.

This first session will only deal with controlling the motor.

Preparations: You have to pair your LEGO MINDSTORMS NXT brick with your bluetooth interface. You have to assign an outgoing com-port to your robot. Then you need to remember the actual name of the COM-port and put it in the code. The code-sample has a COM-port "COM4" but it could be entirely different and easily be a number of COM10 or higher.
The LEGO MINDSTORMS NXT brick has to be turned on before you connect. And finally - be sure you have enough batteries. One set will probably last only a day or so when you play around for a longer while.

Here comes the sample code:

using System;
using System.Collections.Generic;
using System.Text;
using Bram.NxtSharp;
 
namespace LegoNxtConsoleSample
{
    class Program
    {
        const string c_BluetoothComPort = "COM4";
 
        static void MotorDemo()
        {
            NxtBrick brick;
            brick = new NxtBrick();
            brick.COMPortName = c_BluetoothComPort;
            brick.Connect();
 
 
            //select MotorB and turn 180 degrees
            NxtMotor motor1;
            motor1 = new NxtMotor();
            //unfortunately this is necessary, should be wrapped by the API
            //e.g. by "AttachMotor"
            motor1.Brick = brick;
            //that will actually reattach motor to different port
            //if port was already set
            brick.MotorB = motor1;
            //brick.MotorB=motor1 wraps
            //brick.AttachMotor(NxtMotorPort.PortB, motor1);
            Console.WriteLine("turn motor B 180 degrees backwards");
            motor1.Turn(-50, 180);
            System.Threading.Thread.Sleep(2000);
            //will not stop the motor apruptly
            Console.WriteLine("coast motor B");
            motor1.Coast();
            System.Threading.Thread.Sleep(2000);
            Console.WriteLine("turn motor B 180 degrees");
            //turns the other direction and let the other motor start after that
            motor1.Turn(75, 180);
 
 
            //attach MotorC in a different way and turn
            NxtMotor motor2 = new NxtMotor();
            motor2.Brick = brick;
            //will also use "AttachMotor" internally
            motor2.Port = NxtMotorPort.PortC;
            Console.WriteLine("turn motor C until break or coast is sent");
            motor2.Turn(60, 0);
            System.Threading.Thread.Sleep(2000);
            Console.WriteLine("brake motor C");
            motor2.Brake();
 
            //break MotorB also if still running
            Console.WriteLine("brake motor B if still running");
            motor1.Brake();
 
 
            //use SetOutputState for motor C
            Console.WriteLine("turn motor C with granular control, " +
                               "flip first (should change direction)");
            motor2.Flip = !motor2.Flip;
            motor2.SetOutputState(50, NxtMotorMode.MotorOn | NxtMotorMode.Regulated,
            NxtMotorRegulationMode.MotorSpeed, 0, NxtMotorRunState.Running, 1000);
            System.Threading.Thread.Sleep(2000);
            Console.WriteLine("brake motor C");
            motor2.Brake();
 
 
            //iterate through Motorports, not depending on connection state
            foreach (NxtMotorPort motorPort in brick.MotorPorts())
            {
                motor1 = brick.GetMotor(motorPort);//returns null when motor not set
                if (motor1 != null)
                {
                    Console.WriteLine(motorPort.ToString() + " is connected");
                }
                else
                {
                    Console.WriteLine(motorPort.ToString() + " is not connected");
                }
            }
 
 
            //only motors where the brick and port were set are shown here.
            foreach (NxtMotor motor in brick.ConnectedMotors())
            {
                Console.WriteLine("reset motorposition for motor with port " + motor.Port.ToString());
                motor.ResetPosition(false);
            }
 
 
            brick.Disconnect();
        }
 
        static void Main(string[] args)
        {
            MotorDemo();
        }     }
}

Posting code to your blog from Visual Studio

Andreas Erben — Wed, 18 Apr 2007 12:14:13 GMT

It is painful to post code to your blog without any special considerations. In the worst case you have to edit the resulting HTML yourself.

Working with Community Server gave me quite some pain here, so I looked around for some options that exist.

I found those methods:

Copy from Visual Studio to Word 2007, remove TABs, remove hard-returns and replace with shift-returns. Mark as preformatted-html. Post the post to Community Server. Then open the Community Server built in editor and paste the code again in there. Painful. Does not work very well.
Mike Stall suggests writing your own RTF to HTML converter: "Writing an RTF to HTML converter, posting code in blogs."
http://blogs.msdn.com/jmstall/archive/2006/10/20/rtf_5F00_html.aspx
A Visual Studio add-in that copies the source as HTML by Colin Coller: http://www.jtleigh.com/people/colin/software/CopySourceAsHtml/
listed in http://msdn.microsoft.com/msdnmag/issues/05/12/VisualStudioAddins/default.aspx.
Read also: http://www.jtleigh.com/people/colin/blog/archives/2004/10/copysourceashtm_1.html or http://www.jtleigh.com/people/colin/blog/archives/2004/10/copysourceashtm.html
A word macro that helps you with converting the code from Cory Smith: Format Code to HTML within a VS.NET 2K3 Macro (leveraging Microsoft Word)
http://addressof.com/blog/archive/2004/10/06/966.aspx
A JavaScript based formatter: http://www.dreamprojections.com/syntaxhighlighter/
Use a CSS stylesheet that formats code for you of Jean-Claude Manoli: http://manoli.net/csharpformat/
Further reading in the comments of Brad Adam's blog: http://blogs.msdn.com/brada/archive/2004/10/05/238427.aspx

I think the Visual Studio add-in solution is probably the most promising here.

Advanced WebSphere MQ connectivity in .NET apps, JMS without JVM

Andreas Erben — Sun, 15 Apr 2007 02:40:00 GMT

Using WebSphere MQ (still MQSeries for most of us) and the related products abbreviated WPM and alike from Microsoft .NET applications can be painstaking.

While there are enterprise application integration solutions and BizTalk Server can help quite a bit with connecting to the IBM MQ world, you are up to different tasks, when you really need native .NET code to deal with MQ directly.

Damir posted a small introduction to connecting to Websphere MQ in .NET a couple of days ago.

However, advanced WebSphere MQ scenarios will very often involve doing it the JMS way. We stumbled over this the first time when we were supposed to "only" connect to MQSeries and not to need any JMS-related things. But then we found out "oh, yes, we write our messages to topics". Topics however, are very JMSish and WebSphere MQ provides a "broker" that handles this for you. JMS was there again.
Until relatively recently, when you wanted to deal with topics, you only had options that either involved handling all the topic-logic yourself and putting together the appropriate messages manually, or you had to connect to a Java virtual machine somewhere (or even host the JVM yourself in your .NET app) and use code there. So, basically: "bummer".

IBM released the XMS.NET SupportPac in an updated version just very recently. Since links to that section change frequently it seems, I recommend using your favourite search engine for "XMS.NET" and a combination of the following terms "IBM - IA9H: IBM Message Service Client for .NET". We are dealing with a supported SupportPAC here, so as a paying customer of one of the applicable products, you can actually expect that someone cares.

The SupportPac wraps some of the built-in features of JMS for you.

Beware, the documentation is huge and there is a lot to consider.

What do you need besides of your favorite .NET tools: WebSphere MQ with at least patch-level version 6.0.1.1 (but with this you need additional hotfixes).

For the basic connectivity you have to consider the same things that Damir already talked in his post about. There are more things in regards to security, group memberships and so on, you might have to consider, but this post would explode if I would talk about that here. If you look through the API, you will find an example, but that is not very straightforward in my humble opinion. So below you find a simplified spaghetti-code version of connecting to a "topic" and consuming messages for the topic synchronously.

Beware: There are many, many options and properties that change the connection behavior completely. So, this simple example is really just one simple example for many possible scenarios that you might have.

using System;
using System.Collections.Generic;
using System.Text;
using System.Xml;
using IBM.XMS;
 
namespace XMSTest
{
    class Program
    {
        static void Main(string[] args)
        {
            XMSFactoryFactory factoryFactory = XMSFactoryFactory.GetInstance(XMSC.CT_WMQ);
 
            Console.WriteLine("Before create connectionfactory");
            // Use the connection factories factory to create a connection factory
            IBM.XMS.IConnectionFactory connfactory = factoryFactory.CreateConnectionFactory();
            Console.WriteLine("created connectionfactory");
            // Set the properties
            connfactory.SetStringProperty(XMSC.WMQ_HOST_NAME, "MyHostNameOrIPAddressHere");
            connfactory.SetIntProperty(XMSC.WMQ_PORT, 1414);
            connfactory.SetIntProperty(XMSC.WMQ_CONNECTION_MODE, XMSC.WMQ_CM_CLIENT);//managed
            connfactory.SetStringProperty(XMSC.WMQ_QUEUE_MANAGER, "MainQM");
            connfactory.SetIntProperty(XMSC.WMQ_BROKER_VERSION, XMSC.WMQ_BROKER_V1);
 
            Console.WriteLine("Before create connection");
            using (IBM.XMS.IConnection conn = connfactory.CreateConnection())
            {
                Console.WriteLine("created connection");
 
                using (IBM.XMS.ISession session = conn.CreateSession(false, AcknowledgeMode.AutoAcknowledge))
                {
                    Console.WriteLine("Before create session with topic");
                    using (IBM.XMS.IDestination dest = session.CreateTopic("topic://MyOwn.TopicHere")) // Create a topic
                    {
                        Console.WriteLine("created session with topic");
                        dest.SetIntProperty(XMSC.DELIVERY_MODE, XMSC.DELIVERY_NOT_PERSISTENT);
                        Console.WriteLine("before create consumer");
                        using (IBM.XMS.IMessageConsumer consumer = session.CreateConsumer(dest))
                        {
                            Console.WriteLine("created consumer");
 
                            // Start the connection
                            conn.Start();
                            IMessage recvMsg = null;
                            int messagesReceived = 0;
                            // Receive specified number of messages 
 
                            while (
                                   messagesReceived < Convert.ToInt32(10))
                            {
                                recvMsg = null;
 
                                // Receive the message                                    
                                try
                                {
                                    recvMsg = consumer.Receive();
                                }
                                catch (System.Xml.XmlException xmlException)
                                {
                                    // we had cases where XMS.NET throws this
                                    // exception because the received message
                                    // had a tag-name put in an encoding that
                                    // resulted in invalid XML
                                    Console.WriteLine(xmlException.ToString());
                                }
                                catch (Exception otherException)
                                {
                                    Console.WriteLine(otherException.ToString());
                                }
                                // Increment the counter
                                messagesReceived++;
 
                                if (recvMsg != null)
                                {
                                    // Display that message was received.
                                    Console.WriteLine("Received message "+messagesReceived.ToString());
                                }
                                else
                                {
                                    Console.WriteLine("Message received was null or an error occurred.");
                                }
 
                            } // end of while
                        }
                    }
                }
            }
            Console.WriteLine("End. Press Enter");
            Console.ReadLine();
        }
    }
}

Note that this example does not set a username. This means that the username your code is running under will be sent to WebSphere MQ. In my case I had to add an account with my Windows accountname to at least the mqm group on a Linux machine like this:

adduser –g mqm myusername

followed by

passwd myusername

to set a proper password to make sure that nobody does funny things with my account that will be created on the Linux box.

WPF – where art thou’ my tools? Waiting for a pod of Orcas and other imperfections.

Andreas Erben — Sun, 11 Mar 2007 22:53:00 GMT

When working with Windows Presentation Foundation (WPF) you quickly run into limitations of current tool support and also encounter unexpected limitations.
This may or not change with the release of "Orcas", however, at the time of the initial post, Orcas is not available.

This post will be updated whenever I stumble across something that simply bothers me.

To work with WPF your usual set of tools will be

Visual Studio 2005 extensions for .NET Framework 3.0 (WCF & WPF), November 2006 CTP and potentially for the visually oriented folks: Expression Blend and Expression Design.

The typical developer typically will root for a solid support inside of Visual Studio 2005 rather than for a program from the Expression series.

Intellisense won't recognize valid XAML patterns because the XSD does not seem to be complete.

For example the DataTemplate MSDN code will not be supported by IntelliSense:

Here DataTemplate and all childnodes of DataTemplate will not be recognized.

Other limitations include the visual designer that will just fail to load if you reference a namespace in the same assembly of the XAML included.

Take the start of the XAML of the ListBoxEvent sample from the SDK:

Because of the xmlns:src="clr-namespace:ListBoxEvent", the visual designer will tell you: "Whoops! Visual Studio has encountered an error reading the designer file. The errors are shown in the task list. Make appropriate changes to the designer file and then click on the Design button to try again."

In some cases also the method of then using a class of the referenced namespace as an ObjectType="x:Type src:MyTypeHere" in an ObjectDataProvider will not work and during the compile an error message will be raised that the class cannot be found. I have not been able to create a reasonably small example for that yet, though.

Worse: Even a commonly found way of displaying an image will mess up the designer:

Other pain-points:

XAML does not support generics yet.

There are folks who extend XAML, see the reference post by Mike Hillberg: Limited generics support in Xaml

The usual method is to use wrapper classes that inherit from a Generic (and usually have to fill the Generic in the constructor).

public class myColors : ObservableCollection<string>
{
     public myColors()
     {
          Add("LightBlue");
          Add("Pink");
          Add("Red");
          Add("Purple");
          Add("Blue");
          Add("Green");
      }
}

Note that this will also work with List<string> In a "one way" type of behaviour.

However you could always use Generics from the C# code if you do something like:

MyListBox.ItemSource=MyGenericListObject;
It is really just an issue about how XAML is getting parsed and not of WPF itself.
I do not understand why it does not seem to be permissible to use the syntax (or something similar) that you encounter in comparable scenarios like:
System.Collections.Generic.List'1[[System.String]]
or
System.Collections.Generic.Dictionary`2[[System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.Int32, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]

(At least I have not been able to get it working)

Vista blues with Visual Studio 2005

Andreas Erben — Fri, 16 Feb 2007 13:45:00 GMT

Yes, I know – Visual Studio 2005 is not yet supported under Vista.
Visual Studio 2005 SP1 for Vista is not yet out and only then it is promised that it will be supported. But I am getting my doubts it will work smoothly after SP1 is released. Too much is not quite right.
Simple things are often a pain, productivity has gone down, everybody in the team on the Vista bandwagon can sing about this.

Still, a developer who wants to be on the edge has no choice to do this even unsupported to gain the experiences now that he/she needs tomorrow, so I think it is time to share our pains.

See how creative Vista get´s in making our VS 2005 user experience so Aero, we can only fly away.

Check out the attachment below for an even more interactive experience.

svcutil.exe/wsdl.exe: issue with message part name "parameters"

Andreas Erben — Fri, 02 Feb 2007 01:16:00 GMT

In a WCF project we recently received a WSDL from our customer that we needed to build a client/proxy to.
So we used svcutil.exe to generate the C#-code we wanted.
To our surprise, the code did not contain the types of the contract we expected, but something like this:

[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]

[System.ServiceModel.ServiceContractAttribute(Namespace="http://MyService.namespace", ConfigurationName="MyService")]

public interface MyService

{

// CODEGEN: Generating message contract since the wrapper namespace (http://MyTypes.namespace) of message myMethodRequest does not match the default value (http://MyService.namespace)

[System.ServiceModel.OperationContractAttribute(Action="myMethod", ReplyAction="*")]

myMethodResponse myMethod(myMethodRequest request);

}

[System.Diagnostics.DebuggerStepThroughAttribute()]

[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]

[System.ServiceModel.MessageContractAttribute(WrapperName="Request", WrapperNamespace="http://MyTypes.namespace", IsWrapped=true)]

public partial class myMethodRequest

{

public myMethodRequest()

{

}

[System.Diagnostics.DebuggerStepThroughAttribute()]

[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]

[System.ServiceModel.MessageContractAttribute(WrapperName="Response", WrapperNamespace="http://MyTypes.namespace", IsWrapped=true)]

public partial class myMethodResponse

{

public myMethodResponse()

{

}

[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]

public interface MyServiceChannel : MyService, System.ServiceModel.IClientChannel

{

}

After a long time of experimenting around and not getting a clue, I tried the good old wsdl.exe, which gave me the following:

Microsoft (R) Web Services Description Language Utility
[Microsoft (R) .NET Framework, Version 2.0.50727.312]
Copyright (C) Microsoft Corporation. All rights reserved.
Error: Unable to import binding 'MyService_SoapHttp_Binding' from namespace 'http://MyService.namespace'.
- Unable to import operation 'myMethod'.
- These members may not be derived.

If you would like more help, please type "wsdl /?".

OK, so there was an issue with abstract types? Indeed, the WSDL contained abstract complexTypes and a complexType extending that abstract type for both, request and response.

I then simplified it by just making one of those types a simple type. And suddenly it worked. However, this was not satisfying.

When playing around with it, I ended up at the message parts which were like this:

At one point I changed one of the name attributes of the message part to something else, say:

and suddenly it worked.

I changed it back and did the same for the request.

So, I thought, it was a problem with the name property being duplicated. However, looking at other examples proved that this was not the case.

A section saying

would work just fine, we found.

It is a weird combination of: abstract types used in both request and response and the names of the message parts of request and response being both "parameters".

Here is the full "problem" wsdl to play with. Have fun.

<?xml version="1.0" encoding="UTF-8"?>
<definitions name="MyService" targetNamespace="http://MyService.namespace" xmlns="http://schemas.xmlsoap.org/wsdl/" xmlns:myns="http://MyTypes.namespace" xmlns:sdx="http://ServiceDescription.namespace" xmlns:tns="http://MyService.namespace" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/">
    <types>
        <schema attributeFormDefault="unqualified" elementFormDefault="unqualified" targetNamespace="http://MyTypes.namespace" version="1.1" xmlns="http://www.w3.org/2001/XMLSchema" xmlns:myns="http://MyTypes.namespace">
            <complexType abstract="true" name="RequestAbstractType">
                <attribute name="RequestID" type="integer" use="required"/>
            </complexType>
            <element name="Request" type="myns:RequestType"/>
            <complexType name="RequestType">
                <complexContent>
                    <extension base="myns:RequestAbstractType">
                        <sequence>
                            <element name="RequestNode" type="string"/>
                        </sequence>
                    </extension>
                </complexContent>
            </complexType>
            <complexType abstract="true" name="ResponseAbstractType">
                <attribute name="ResponseID" type="integer" use="required"/>
            </complexType>
            <element name="Response" type="myns:ResponseType"/>
            <complexType name="ResponseType">
                <complexContent>
                    <extension base="myns:ResponseAbstractType">
                        <sequence>
                            <element name="ResponseNode" type="string"/>
                        </sequence>
                    </extension>
                </complexContent>
            </complexType>
        </schema>
    </types>
    <message name="MyServiceRequest">
        <part element="myns:Request" name="parameters" />
    </message>
    <message name="MyServiceResponse">
        <part element="myns:Response" name="parameters" />
    </message>
    <portType name="MyService">
        <operation name="myMethod">
            <input message="tns:MyServiceRequest"/>
            <output message="tns:MyServiceResponse"/>
        </operation>
    </portType>
     <binding name="MyService_SoapHttp_Binding" type="tns:MyService">
<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
    <operation name="myMethod">
    <soap:operation soapAction="myMethod"/>
    <input>
        <soap:body use="literal"/>
    </input>
    <output>
        <soap:body use="literal"/>
    </output>
    </operation>
</binding>
<service name="MyServiceProvider">
    <serviceKey xmlns="http://MyServiceProvider.namespace">uddi:myservices.org:MyServiceProvider</serviceKey>
        <port binding="tns:MyService_SoapHttp_Binding" name="MyService_Http_Port">
            <soap:address location="http://myserver:12345/soap/MyServiceProvider"/>
        </port>
        <port binding="tns:MyService_SoapHttp_Binding" name="MyService_Https_Port">
            <soap:address location="https://myserver:12346/soap/MyServiceProvider"/>
        </port>
    </service>
</definitions>

The relevant samples are available for download as a .zip attachment.