I’m writing a couple of UI specs for work and I decided to give ‘Sketch Flow’ a run. Sketch Flow is an component of Expression Blend which gives it early stage design tools. You can lay out the flow of your interface and use ‘wiggly styles’ to draw controls. The advantage of these imprecise controls is that you (the designer) doesn’t get caught up with perfection and that your audience (peers + stakeholders) can clearly see that the UI is still a work in progress. This level of implicit communication is never to be underestimated during featue design. This video from MIX gives a good overview of the product: http://videos.visitmix.com/MIX09/C01F.

I’m not sure I’d ever convert my Sketch Flow projects to a full Silverlight or WPF project (as the product intends) – but there is huge value in simply having a more formal way of documenting UI design.

BTW: Sorry for being slow on the blogging lately. I’ve been working on semi-secret and rather internally focused infrastructure things. Thus I’ve had not too much to blog about. I’ve been a lot of Silverlight 3.0 in my ’spare’ time and I’m enjoying where the product is going from a Line of Business apps perspective.

In this basic tutorial we’ll focus on two basic scenarios:

1. Service Bus Client in a Windows Azure Web or Worker Role
2. Service Bus Listener in a Windows Azure Worker Role

Pre-Requisites

You’ll need to do some basic setup before you start coding. This tutorial assumes you have accounts for Windows Azure and .NET Services, have completed ‘Hello World’ style tutorials and have downloaded and installed all the relevant SDKs.

Full Trust Code

.NET Services required Full Trust to run. You’ll need to set the ‘enableNativeCodeExecution’ attribute to be true in the ServiceDefinition.csdef file of your Windows Azure Project.

<?xml
version=“1.0“
encoding=“utf-8“?>

<ServiceDefinition
name=“AzureSample“
xmlns=“http://schemas.microsoft.com/ServiceHosting/2008/10/ServiceDefinition“>

<WebRole
name=“WebRole“
enableNativeCodeExecution=“true“>

<InputEndpoints>

<!– Must use port 80 for http and port 443 for https when running in the cloud –>

<InputEndpoint
name=“HttpIn“
protocol=“http“
port=“80“ />

</InputEndpoints>

</WebRole>

<WorkerRole
name=“WorkerRole“
enableNativeCodeExecution=“true“>

</WorkerRole>

</ServiceDefinition>

Service Bus Client

In this example we’ll create a normal Service Bus Listener and run that on-premise. This Listener will receive messages from the Service Bus and display them in a console window. We’ll also create a small client library which can be run from a Windows Azure Web or Worker role.

Our scenario is a simple one: Imagine you wanted to get real time logging information from your Windows Azure application. Instead of writing to the Windows Azure log API, manually transferring the logs to a blob and then download the data – we’ll write out directly to the Service Bus.

The Listener

This is a super simple Console Application consisting of 3 files: Program.cs, ILogContract and ILogService. This Listener differs slightly from a regular Service Bus application. It packages Microsoft.ServiceBus.dll directly in its bin (ie. It doesn’t care if you have the SDK or Redist installed) and it sets all the WCF/SB config in code. Becareful: By packaging Microsoft.ServiceBus.dll yourself you are now responsible for servicing (ie. Updating) this dll on any clients you distribute it to. You’ll also note that the User Name, Password and Service Bus URI have been stored in AppSettings.

ILogContract.cs

using System;

using System.ServiceModel;

using System.Collections.Generic;

namespace AzureSample

{

[ServiceContract(Name = "ILogContract", Namespace = "http://tempuri.org/")]

public
interface
ILogContract

{

[OperationContract]

void WriteToLog(DateTime eventDt, string source, string text);

}

public
interface
ILogChannel : ILogContract, IClientChannel { }

LogService.cs

using System;

using System.ServiceModel;

using System.Text;

namespace AzureSample

{

[ServiceBehavior(Name = "LogService", Namespace = "http://tempuri.org/")]

class
LogService: ILogContract

{

public
void WriteToLog(DateTime eventDt, string source, string text)

{

Console.WriteLine(string.Format(“From {0} at {1}: {2}”, eventDt.ToString(), source, text));

}

}

}

Program.cs

using System;

using System.Configuration;

using System.ServiceModel;

using System.ServiceModel.Description;

using Microsoft.ServiceBus;

using Microsoft.ServiceBus.Description;

namespace AzureSample

{

class
Program

{

static
void Main(string[] args)

{

string endPoint = ConfigurationSettings.AppSettings["EndPoint"];

string userName = ConfigurationSettings.AppSettings["UserName"];

string password = ConfigurationSettings.AppSettings["Password"];

Uri uri = new
Uri(endPoint);

TransportClientEndpointBehavior userNamePasswordServiceBusCredential = new
TransportClientEndpointBehavior();

userNamePasswordServiceBusCredential.CredentialType = TransportClientCredentialType.UserNamePassword;

userNamePasswordServiceBusCredential.Credentials.UserName.UserName = userName;

userNamePasswordServiceBusCredential.Credentials.UserName.Password = password;

ServiceHost host = new
ServiceHost(typeof(LogService), uri);

ContractDescription contractDescription = ContractDescription.GetContract(typeof(ILogContract), typeof(LogService));

ServiceEndpoint serviceEndPoint = new
ServiceEndpoint(contractDescription);

serviceEndPoint.Address = new
EndpointAddress(uri);

serviceEndPoint.Binding = new
NetTcpRelayBinding();

serviceEndPoint.Behaviors.Add(userNamePasswordServiceBusCredential);

host.Description.Endpoints.Add(serviceEndPoint);

host.Open();

Console.WriteLine(String.Format(“Listening at: {0}”, endPoint));

Console.WriteLine(“Press [Enter] to exit”);

Console.ReadLine();

host.Close();

}

}

}

App.config

<?xml
version=“1.0“
encoding=“utf-8“ ?>

<configuration>

<appSettings>

<add
key=“UserName“
value=“MY SOLUTION NAME“/>

<add
key=“Password“
value=“MY PASSWORD“/>

<add
key=“EndPoint“
value=“sb://mysolutionname.servicebus.windows.net/sample/log/“/>

</appSettings>

</configuration>

The Client

Now we need to start sending some messages to the client. We’ll create a class which we can easily re-use in a Web or Worker project. In fact you could run this class on pretty much any remote hosting environment. You’ll also need to store some credentials and the URI in the web.config or app.config for a web or worker role respectively.

ServiceBusLoggerClass.cs

This class can be added as an external DLL or directly to the Worker/Web Role. Remember it needs Microsoft.ServiceBus.dll to work.

using System;

using System.ServiceModel;

using System.ServiceModel.Activation;

using Microsoft.ServiceBus;

namespace AzureSample

{

public
class
ServiceBusLogger

{

public
ILogChannel Channel {get;set;}

public ServiceBusLogger(string endPoint, string userName, string password)

{

Uri uri = new
Uri(endPoint);

TransportClientEndpointBehavior userNamePasswordServiceBusCredential = new
TransportClientEndpointBehavior();

userNamePasswordServiceBusCredential.CredentialType = TransportClientCredentialType.UserNamePassword;

userNamePasswordServiceBusCredential.Credentials.UserName.UserName = userName;

userNamePasswordServiceBusCredential.Credentials.UserName.Password = password;

ChannelFactory<ILogChannel> channelFactory = new
ChannelFactory<ILogChannel>();

channelFactory.Endpoint.Address = new
EndpointAddress(uri);

channelFactory.Endpoint.Binding = new
NetTcpRelayBinding();

channelFactory.Endpoint.Contract.ContractType = typeof(ILogChannel);

channelFactory.Endpoint.Behaviors.Add(userNamePasswordServiceBusCredential);

this.Channel = channelFactory.CreateChannel();

}

}

}

Calling the Logger – eg. A Worker Role

using System;

using System.Collections.Generic;

using System.Threading;

using System.Linq;

using System.Text;

using Microsoft.ServiceHosting.ServiceRuntime;

using System.Configuration;

using AzureSample;

namespace AzureSample_WorkerRole

{

public
class
WorkerRole : RoleEntryPoint

{

public
override
void Start()

{

string endPoint = ConfigurationSettings.AppSettings["EndPoint"];

string userName = ConfigurationSettings.AppSettings["UserName"];

string password = ConfigurationSettings.AppSettings["Password"];

ServiceBusLogger logger = new
ServiceBusLogger(endPoint, userName, password);

logger.Channel.WriteToLog(DateTime.UtcNow, “Worker Role”, “Role Started”);

while (true)

{

Thread.Sleep(1000);

logger.Channel.WriteToLog(DateTime.UtcNow, “Worker Role”, “Working…”);

}

}

public
override
RoleStatus GetHealthStatus()

{

// This is a sample worker implementation. Replace with your logic.

return
RoleStatus.Healthy;

}

}

}

SampleOutput

Here is some sample output from the console:

Listening at: sb://*******.servicebus.windows.net/sample/log/

Press [Enter] to exit

From 5/23/2009 4:30:44 AM at Worker Role: Role Started

From 5/23/2009 4:30:51 AM at Worker Role: Working…

From 5/23/2009 4:30:52 AM at Worker Role: Working…

From 5/23/2009 4:30:53 AM at Worker Role: Working…

From 5/23/2009 4:30:54 AM at Worker Role: Working…

From 5/23/2009 4:30:55 AM at Worker Role: Working…

Hosting a Listener in Worker Role

It’s relatively straight forward to host a Service Bus Listener in a Worker Role. Here is a version of the Calculator Service running inside Worker Role.

CalculatorService.c s

Here is the CalculatorService.cs from the .NET Services SDK to refresh your memory. I’ve added this class directly to my worker role. I’ve remove the Access Control helpers from this sample for simplicity’s sake.

namespace Microsoft.ServiceBus.Samples

{

using System;

using System.Runtime.Serialization;

using System.ServiceModel;

using System.ServiceModel.Channels;

// Define a service contract.

[ServiceContract(Name = "Calculator", Namespace = "http://Microsoft.ServiceModel.Samples")]

public
interface
ICalculator

{

[OperationContract(Action = "Add", ReplyAction = "AddResponse")]

double Add(double n1, double n2);

[OperationContract(Action = "Subtract", ReplyAction = "SubtractResponse")]

double Subtract(double n1, double n2);

[OperationContract(Action = "Multiply", ReplyAction = "MultiplyResponse")]

double Multiply(double n1, double n2);

[OperationContract(Action = "Divide", ReplyAction = "DivideResponse")]

double Divide(double n1, double n2);

}

// Service class which implements the service contract.

public
class
CalculatorService : ICalculator

{

public
double Add(double n1, double n2)

{

return n1 + n2;

}

public
double Subtract(double n1, double n2)

{

return n1 – n2;

}

public
double Multiply(double n1, double n2)

{

return n1 * n2;

}

public
double Divide(double n1, double n2)

{

return n1 / n2;

}

}

}

WorkerRole.cs

Here is my WorkerRole.cs. I’ve configured my Service Bus listener with code only (with App Settings for the URI and credentials only). I’ve also physically included the Microsoft.ServiceBus.dll in my project. You’ll also note I’ve over-ridden the Stop() method of RoleEntryPoint to close the Host when the Worker Role shuts down.

using System;

using System.Collections.Generic;

using System.Threading;

using System.Linq;

using System.Text;

using Microsoft.ServiceHosting.ServiceRuntime;

using System.Configuration;

using Microsoft.ServiceBus.Samples;

using System.ServiceModel;

using System.ServiceModel.Description;

using Microsoft.ServiceBus;

using Microsoft.ServiceBus.Description;

namespace AzureSample_WorkerRole

{

public
class
WorkerRole : RoleEntryPoint

{

private
ServiceHost host;

public
override
void Start()

{

string endPoint = ConfigurationSettings.AppSettings["EndPoint"];

string userName = ConfigurationSettings.AppSettings["UserName"];

string password = ConfigurationSettings.AppSettings["Password"];

Uri uri = new
Uri(endPoint);

TransportClientEndpointBehavior userNamePasswordServiceBusCredential = new
TransportClientEndpointBehavior();

userNamePasswordServiceBusCredential.CredentialType = TransportClientCredentialType.UserNamePassword;

userNamePasswordServiceBusCredential.Credentials.UserName.UserName = userName;

userNamePasswordServiceBusCredential.Credentials.UserName.Password = password;

host = new
ServiceHost(typeof(CalculatorService), uri);

ContractDescription contractDescription = ContractDescription.GetContract(typeof(ICalculator), typeof(CalculatorService));

ServiceEndpoint serviceEndPoint = new
ServiceEndpoint(contractDescription);

serviceEndPoint.Address = new
EndpointAddress(uri);

serviceEndPoint.Binding = new
NetTcpRelayBinding();

serviceEndPoint.Behaviors.Add(userNamePasswordServiceBusCredential);

host.Description.Endpoints.Add(serviceEndPoint);

host.Open();

while (true)

{

//Loop

}

}

public
override
void Stop()

{

host.Close();

     base.Stop();

}

public
override
RoleStatus GetHealthStatus()

{

// This is a sample worker implementation. Replace with your logic.

return
RoleStatus.Healthy;

}

}

}

Advanced Scenarios

In these examples we used a basic NetTcpRelay Binding. You could easily imagine expanding these very simple scenarios to take advantage of other bindings, queues and routes provided by the Service Bus.

Our Marketing Folks are running a dev contest. More info here and here. Hopefully we’ll see some innovative use of .NET Services in the contest.

Do they still make phones without a mute button? The number of people who can’t hit mute during a large teleconference beggars belief. Is there some awkward psychological principle at play which causes people to not realize?

Perhaps they should teach teleconference etiquette in business school…

The dominant user interface technology for line of business applications today is the web. The intranet/internet delivered web app burst onto the scene a few years ago and left many ‘fat clients’ lying obsolete in it’s wake. The promise of easy deployment and ‘interface ubiquity’ was tantalising for CIOs and Sys Admins everywhere.

Recently there has been rumblings about performance and usability of these web based apps. The use of the AJAX technique has helped – bringing ‘fat client-esque’ performance to browser based applications.

Flash and Silverlight are now at a point where they are truly viable options for LOB systems. Previously both technologies had a strong focus on consumer/media scenarios. I believe that these Rich Internet Application (RIA) technologies are a good fit for LOB. The promise of browser based deployment along with the power of the client is a nice fit. The promise of easier dev/debug/test is also attractive (ie. debugging AJAX is troublesome at best).

While playing around with Silverlight 3.0 you can certainly see the LOB focused investments. The .NET RIA Services also provides middle tier technologies which eases some middle tier architectural head aches.

Give it a try… you won’t be disappointed.