Search results matching tag 'VS 2005'

Visual Studio 2010 Beta 2 availability

aerben — 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

aerben — 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

aerben — 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.

Build Setup 'unrecoverable build error'

nstorandt — Wed, 16 Jan 2008 14:14:00 GMT

If you receive a ‚Unrecoverable build error‘ when trying to build a Setup Project in Visual Studio 2005 or 2008 try at first the official resolution of MS http://support.microsoft.com/kb/329214/EN-US/.

If its still produces this error try this:

regsvr32 ole32.dll

greets nadine

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

aerben — 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 :)

Visual Studio Designer Problems

nstorandt — Thu, 19 Apr 2007 09:46:00 GMT

Today i ran into problems with the visual studio 2005 designer and custom controls.

The only error message which was shown to me was not so helpfull so I beginn to search the internet for problems with the designer and i found a nice page from a german guy.

He is explaining a few problems with the designer and it helped me in my issue. He will go on to post problems and solutions for the VS Designer.

link

Legoboto: hajimemashou, LEGO MINDSTORMS NXT, sensor eventing

aerben — 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)

aerben — 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)

aerben — 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

aerben — 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.