Nick Randolph's .NET Travels

New Windows Mobile build with Zooming

nick — Sat, 07 Nov 2009 02:25:49 GMT

In my continual quest to get more performance and better experience out of my HTC Touch Pro device (given the HTC WM6.1 performs so badly) I decided to give the latest build off XDA-developers a go. The following is taken from build 23504 which you can grab from the following link http://forum.xda-developers.com/showthread.php?t=580429. The main reason I wanted to upgrade was not so much for the improvements to the experience (since I’ve already seen some massive improvements over the last couple of builds), it was more to get some of the performance benefits that has been touted in the latest builds.

Now, unlike some of the other images available, this particular build is very vanilla in nature. It doesn’t include Touch Flo 3D, so it looks for the most part like Windows Mobile 6.5. One thing I did have to do was to change the keyboard configuration to match the Touch Pro. This is done with the following registry setting:

HKLM\HARDWARE\DEVICEMAP\KEYBD\CWSLayout to 0 (then restart)

The build does indeed appear to perform better. Navigation seems to be very responsive but this may be that it doesn’t have the overhead of the TouchFlo.

Now if you look at the first of the following images you will see that there is a rendering issue around the clock. This only seems to be on the today screen and as you can see in the second image, if you click in the notification area you get a set of expanded icons. The expanded notification bar is in full colour and has gesture support to allow you to easily scroll through the icons.

What caught my attention was the Zoom icon. Clicking on this zooms the current screen in (see third image). This is an awesome feature of this rom image as it allows you to zoom in on nearly anything that is rendered on the screen. Better yet, you can still interact with the contents of the screen whilst zoomed in – the fourth image shows the Getting Started page which is what is loaded when you click the icon in image 3.

Ramp Up Your Mobile Development Skills

nick — Sun, 01 Nov 2009 03:20:36 GMT

Looking for a quick way to get the basics of Windows Mobile development? Try the RampUp “Develop Windows Mobile 6 Applications” e-learning. Whilst this focuses on Windows Mobile 6 using VS2008, a lot of the points covered actually apply to all versions of the Windows Mobile platform. Topics include the following:

Level 1: Mobile Development Introduction
Level 2: Device Emulators
Level 3: Mobile Windows Forms Development
Level 4: Advanced Mobile Windows Forms Development
Level 5: SQL Server CE Introduction
Level 6: Security and Deployment
Level 7: Mobile Web Development

Office Developer Conference

nick — Thu, 29 Oct 2009 02:22:10 GMT

In case you hadn’t heard or had somehow forgotten, let me remind you that the Office Dev Con is on this weekend in Brisbane. Thanks to Graham and everyone else involved in making this happen – I feel honoured to be amongst the presenters. Full information on sessions and the presenters is available at http://www.officedevcon.com.au. Here’s my two sessions:

Title: Where’s my runtime? A tale of a mobile database engine.

One of the challenges of building rich client applications is often storing data. Whether this be caching data to improve look up performance or data entered by the user that needs to be persisted until a data connection is available, the dilemma is always what technology should you use? With only a small amount of data the answer is often a simple XML file but as the quantity of data, or in fact the complexity of the data, grows it becomes inevitable that you will want some sort of database in which to store your data.

In this session you’ll learn all about SQL Server Compact Edition (CE), a client side database technology that you can ship alongside your application. Unlike other database technologies SQL Server Compact doesn’t need to be installed and thus doesn’t require elevated privileges, making it ideal for both Office and ClickOnce applications. The session will give a brief overview of the technology, before diving into how you can use, configure, deploy and manage your databases.

Title: Document creation in the cloud with Windows Azure and the OpenXML SDK.

Since the release of Office 2007 there has been considerable work put into the Open XML SDK. Unlike previous versions of Word that relied on interop assemblies to do automation, with the new XML-based file formats you can automate document creation as and when you need to. In fact, with the Open XML SDK there is no reliance on Word, Excel or any other Office component. This makes it particularly useful for building services on the Windows Azure platform. This session will provide an overview of Windows Azure and the Open XML SDK, as well as showing how you can easily combine the two to build high volume, scalable document automation services hosted in the cloud.

Good and Bad news about WCF for Windows Mobile

nick — Mon, 19 Oct 2009 01:01:10 GMT

Given this post primarily contains a rant about WCF support within the .NET Compact Framework (ie Windows Mobile), I’ll start with the good points.

Further to a previous post on WCF for Windows Mobile the team at Microsoft have released an updated version of NetCFSvcUtil.exe that fixes the issue running under Vista SP2 and Windows 7. You can download it directly from their blog post on the NetCFSvcUtil QFE (great way to ship updates – an obscure blog that no-on.
There is a great whitepaper put together by a couple of MVPs talking about using WCF from the .NET Compact Framework: http://wcfguidanceformobile.codeplex.com/.

Ok, so now for the bad news.

If you’re thinking about using Basic Authentication, you can forget WCF. There is no support for nearly any practical scenario for using WCF unless you want to roll out X509 certificates. Honestly, whoever didn’t think that Basic Auth over SSL would be good to support…..
If you want to share types between client and server, think again. It appears that the /reference and /excludeType flags don’t work as they do with svcutil.exe which means a lot of messing around if you want to share types.
No built in support within Visual Studio for doing “Add Service Reference”

If you’re like me and spend most of your time in Visual Studio the last point is a real kick in the head – you mean I have to run NetCFSvcUtil from the commandline, Urgh! At this point I went “forget it – too hard, too broken, not worth the pain” and went back to “Add Web Reference” (which btw works for WCF endpoints that are configured with basicHttpBinding). This works well with both basic authentication and SSL so suits my scenario.

Now the issue I have with “Add Web Reference” is that it does silly things with certain types. For example Guids get converted to string. It also means that if you have two services (eg ServiceA.svc and ServiceB.svc that use the same type (eg Customer) you will end up with multiple types created on the client (eg ServiceA.Customer and ServiceB.Customer). The solution to this lies within the References.cs file that gets generated – this file contains all the types that get created as part of creating the proxy. If you remove all the additional generated classes (eg ServiceA.Customer). This will of course cause compile errors because the referenced types can’t be resolve. To fix this, add a reference to the assembly that contains the type and then add a using statement to the reference.cs to import the missing types.

One last point - In order for this to work you will probably have to annotate your shared types with xml attributes. For example:

[System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://myschemas/DataTransferObjects")]
public class Customer
{

I do wish that Microsoft would do something about the dire state of affair around WCF from .NET Compact Framework, but in the meantime I’d still with Add Web Reference.

Integrating Twitter into your Windows Mobile Widget

nick — Sun, 11 Oct 2009 13:36:00 GMT

I guess the first question that comes to mind is why would you want to integrate twitter into your widget. Until recently I would have agreed that it seems somewhat superfluous as there is an almost infinite number of Twitter clients out there, all claiming that they are better than all that have gone before them. However, I was recently trying to add a mechanism for commenting on items within a widget I was writing. Now I could have easily built yet another commenting system, involving the usual candidates of sql server backend, wrapped in a simple REST or SOAP service blah blah blah, but I came to the conclusion this would simply add to the overhead of managing the application, particularly since up until now the widget didn’t rely on any backend services. I figured since a lot of users would probably have Twitter accounts I could just let them use their account in order to make comments. The fact that their comments would be seen in their Twitter feed would just add some free advertising for my widget.

So, having chosen Twitter to handle comments I then had to work out the best way to integrate them. If you’ve used any of the current generation of Twitter clients out there you will be familiar with having to enter your username and password into the application – this is bad as you don’t really have any idea what else that application may be doing with your credentials. Of course, they would argue that they need to prompt for this information so that they can post on your behalf. Up until recently they would have been correct. However, Twitter now supports OAuth and in particular a permutation specifically designed to support desktop (or rich client) applications. In a nutshell this involves routing the user to Twitter, getting them to sign in there and then routing back to the calling application with a suitable authorisation token. For the desktop permutation there is an additional step which involves copying a one-time pin from Twitter into the calling application – this is because there is no way for Twitter to redirect back to your desktop application. This process can be used for integrating Twitter into your widget.

Now for the technical bits:

Step 1: Registration

You need to register your application with Twitter. This can be done at http://twitter.com/oauth_clients. Once registered you will be given a Consumer Key and Consumer Secret that you will need to take note of for use within your widget.

Step 2: Request Token

The first step in OAuth is to get a request token. This is done by issuing a POST to http://twitter.com/oauth/request_token, supplying the consumer key you have been allocated, a timestamp and nonce value. The request also needs to contain a SHA1 signature.
The return values (if successful) is a token and a token secret.

Step 3: Direct User to Twitter to Sign In

Once your widget has the request token and associated secret, you need to direct the user to Twitter.com so that they can log in and authorise your widget. To do this, direct them to “http://twitter.com/oauth/authorize?oauth_token= + Token + & oauth_callback=oob"
The user will log in and then be given an authorisation pin. They need to copy this and paste it (or type it) into your widget – you’ll need to give them a mechanism for doing this!

Step 4: Access Token

After the user has entered the authorisation pin you need to use it, coupled with the consumer key and request token to issue a POST to http://twitter.com/oauth/access_token.
This will return an access token that you can then use to post updates to Twitter.

Step 5: Post Updates

Updates are simply a POST to http://twitter.com/statuses/update.json with parameters that include the access token.

Acknowledgments to John Kristian who contributed a Javascript Library for OAuth. Other OAuth libraries are available for a variety of languages at http://oauth.net/code.

Full TwitterAPI Listing

Feel free to use this code. Note however that there is almost no error handling so that it’s easier to follow what’s going on.

var TwitterAPI = function() {
    return {
        ConsumerSecret: "<enter Consumer Secret from Twitter app registration>",
        ConsumerKey: "<enter Consumer Key from Twitter app registration>",
        SignatureMethod: "HMAC-SHA1",

        RegisterUser: function(callback, errorcallback) {

            var accessor = { consumerSecret: TwitterAPI.ConsumerSecret
                           , tokenSecret: ""
            };
            var message = { action: "http://twitter.com/oauth/request_token"
                  , method: "POST"
                  , parameters: []
            };
            message.parameters.push(["oauth_consumer_key", TwitterAPI.ConsumerKey]);
            message.parameters.push(["oauth_signature_method", TwitterAPI.SignatureMethod]);
            message.parameters.push(["oauth_timestamp", ""]);
            message.parameters.push(["oauth_nonce", ""]);
            message.parameters.push(["oauth_signature", ""]);
            OAuth.setTimestampAndNonce(message);
            OAuth.SignatureMethod.sign(message, accessor);
            var parameterMap = OAuth.getParameterMap(message.parameters);

            var params = TwitterAPI.buildParameters(parameterMap);

            var request = WidgetAPI.createXmlHttpRequest();
            request.open(message.method, message.action, true);
            request.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
            request.setRequestHeader("Content-length", params.length);
            request.setRequestHeader("Connection", "close");

            // Set the callback
            request.onreadystatechange = function() {
                if (request.readyState == 4) {

                    var params2 = request.responseText.split("&");
                    for (var i = 0; i < params2.length; i++) {
                        var bits = params2[ i ].split("=");
                        if (bits.length == 2 && bits[0] == "oauth_token") {
                            TwitterAPI.Token = bits[1];
                        }
                        if (bits.length == 2 && bits[0] == "oauth_token_secret") {
                            TwitterAPI.TokenSecret = bits[1];
                        }
                    }

                    if (!TwitterAPI.Token || TwitterAPI.Token == null) {
                        if (errorcallback) {
                            errorcallback();
                        }
                        return;
                    }

                    callback();

                    var url = "http://twitter.com/oauth/authorize?oauth_token=" + TwitterAPI.Token + "&oauth_callback=oob";
                    window.open(url);
                    request = null;
                }
            };

            request.send(params);
        },
        AuthenticateUser: function(pin, callback, errorcallback) {
            TwitterAPI.Pin = pin;
            var accessor = { consumerSecret: TwitterAPI.ConsumerSecret
                           , tokenSecret: TwitterAPI.TokenSecret
            };
            var message = { action: "http://twitter.com/oauth/access_token"
                  , method: "POST"
                  , parameters: []
            };
            message.parameters.push(["oauth_consumer_key", TwitterAPI.ConsumerKey]);
            message.parameters.push(["oauth_token", TwitterAPI.Token]);
            message.parameters.push(["oauth_signature_method", TwitterAPI.SignatureMethod]);
            message.parameters.push(["oauth_verifier", TwitterAPI.Pin]);
            message.parameters.push(["oauth_timestamp", ""]);
            message.parameters.push(["oauth_nonce", ""]);
            message.parameters.push(["oauth_signature", ""]);
            OAuth.setTimestampAndNonce(message);
            OAuth.SignatureMethod.sign(message, accessor);
            var parameterMap = OAuth.getParameterMap(message.parameters);

            var params = TwitterAPI.buildParameters(parameterMap);

            var request = WidgetAPI.createXmlHttpRequest();
            request.open(message.method, message.action, true);
            request.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
            request.setRequestHeader("Content-length", params.length);
            request.setRequestHeader("Connection", "close");

            // Set the callback
            request.onreadystatechange = function() {
                if (request.readyState == 4) {
                    var params2 = request.responseText.split("&");
                    for (var i = 0; i < params2.length; i++) {
                        var bits = params2[ i ].split("=");
                        if (bits.length == 2 && bits[0] == "oauth_token") {
                            TwitterAPI.Token = bits[1];
                        }
                        if (bits.length == 2 && bits[0] == "oauth_token_secret") {
                            TwitterAPI.TokenSecret = bits[1];
                        }
                    }

                    if (params2<2 || !TwitterAPI.Token || TwitterAPI.Token == null) {
                        errorcallback();
                        return;
                    }

                    callback();
                }
            };

            request.send(params);
        },
        PostComment: function(comment, callback, errorcallback) {
            accessor = { consumerSecret: TwitterAPI.ConsumerSecret
                   , tokenSecret: TwitterAPI.TokenSecret
            };
            message = { action: "http://twitter.com/statuses/update.json"
          , method: "POST"
          , parameters: []
            };
            message.parameters.push(["oauth_consumer_key", TwitterAPI.ConsumerKey]);
            message.parameters.push(["oauth_token", TwitterAPI.Token]);
            message.parameters.push(["status", comment]);
            message.parameters.push(["oauth_version", "1.0"]);
            message.parameters.push(["oauth_signature_method", TwitterAPI.SignatureMethod]);
            message.parameters.push(["oauth_timestamp", ""]);
            message.parameters.push(["oauth_nonce", ""]);
            message.parameters.push(["oauth_signature", ""]);

            accessor.tokenSecret = TwitterAPI.TokenSecret;
            OAuth.setTimestampAndNonce(message);
            OAuth.SignatureMethod.sign(message, accessor);
            var parameterMap = OAuth.getParameterMap(message.parameters);

            message.action = "http://twitter.com/statuses/update.json";
            params = TwitterAPI.buildParameters(parameterMap);
            //params += "&status=test";
            request = WidgetAPI.createXmlHttpRequest();
            request.open(message.method, message.action, true);
            request.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
            request.setRequestHeader("Content-length", params.length);
            //request.setRequestHeader("Connection", "close");

            // Set the callback
            request.onreadystatechange = function() {
                if (request.readyState == 4) {
                    callback();
                }
            }
            request.send(params);
        },
        buildParameters: function(parameterMap) {
            var params = "";
            for (var p in parameterMap) {
                if (params.length > 0) {
                    params += "&";
                }
                params += OAuth.percentEncode(p) + "=" + OAuth.percentEncode(parameterMap[p]) + "";
            }
            return params;
        }
    };
} ();

var Url = {

    // public method for url encoding
    encode: function(string) {
        return escape(this._utf8_encode(string));
    },

    // public method for url decoding
    decode: function(string) {
        return this._utf8_decode(unescape(string));
    },

    // private method for UTF-8 encoding
    _utf8_encode: function(string) {
        string = string.replace(/\r\n/g, "\n");
        var utftext = "";

        for (var n = 0; n < string.length; n++) {

            var c = string.charCodeAt(n);

            if (c < 128) {
                utftext += String.fromCharCode(c);
            }
            else if ((c > 127) && (c < 2048)) {
                utftext += String.fromCharCode((c >> 6) | 192);
                utftext += String.fromCharCode((c & 63) | 128);
            }
            else {
                utftext += String.fromCharCode((c >> 12) | 224);
                utftext += String.fromCharCode(((c >> 6) & 63) | 128);
                utftext += String.fromCharCode((c & 63) | 128);
            }

        }

        return utftext;
    },

    // private method for UTF-8 decoding
    _utf8_decode: function(utftext) {
        var string = "";
        var i = 0;
        var c = c1 = c2 = 0;

        while (i < utftext.length) {

            c = utftext.charCodeAt(i);

            if (c < 128) {
                string += String.fromCharCode(c);
                i++;
            }
            else if ((c > 191) && (c < 224)) {
                c2 = utftext.charCodeAt(i + 1);
                string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
                i += 2;
            }
            else {
                c2 = utftext.charCodeAt(i + 1);
                c3 = utftext.charCodeAt(i + 2);
                string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
                i += 3;
            }

        }

        return string;
    }

}

Your Phone, My Phone, they’re all Windows Phones….

nick — Wed, 07 Oct 2009 08:11:56 GMT

Well that should be the Microsoft chant with the simultaneous release of Windows Mobile 6.5, Marketplace and a host of complementary applications such as an updated MyPhone that’s available for download via Marketplace. If you’re like me, one of the cool new “premium” features of MyPhone is the ability find your lost phone. Here I’m showing the “known location” feature but you can get MyPhone to ring your phone, even if it’s on vibrate. I so want that feature for when I lose my phone (no pun intended….)

More Windows Mobile 6.5 builds

nick — Sun, 04 Oct 2009 12:12:30 GMT

Well almost on the eve of the public availability of Windows Mobile 6.5 I thought I’d again post about some of the new builds that I’ve been using. Over the past week or so I’ve been running build 53052 and today I’ve upgraded to build 53420. There aren’t any huge improvements over my previous post however the polish is really starting to show. In fact over the past week or so I would confidently say that I wouldn’t consider moving away from Windows Mobile and that for my day to day life it’s easier to use than an iphone. Anyhow, here are a few screenshots showing the polish as it continues to improve:

Merge Replication – The Ultimate Guide

nick — Tue, 22 Sep 2009 22:28:54 GMT

Enterprise Data Synchronization with Microsoft SQL Server 2008 and SQL Server Compact 3.5 Mobile Merge Replication by Rob Tiffany would have to be the ultimate guide when it comes to setting up and tuning merge replication between SQL Server and SQL Compact. Starting with the basics of what and how merge replication works, Rob then drops into a great level of detail that will be sure to help you if you get stuck. I would definitely have this book by my side when working with merge replication.

Cloud Costing

nick — Tue, 22 Sep 2009 10:07:06 GMT

Following a discussion on the OzAzure mailing list I went off hunting for what others had put together on calculating the ROI for building or migrating to Windows Azure. I’m not sure how I didn’t come across the Azure ROI Calculator earlier in my hunt for information on Windows Azure as it is the top 10 or so links when you search for Azure ROI. Anyhow, it provides a neat little Silverlight application for doing a basic ROI for cloud applications.

Of course where this gets interesting is when you compare it to the other offerings/alternatives in cloud space. I’m hoping that others out there will share their thoughts around costing the cloud.

Codemason Honours

nick — Wed, 02 Sep 2009 10:07:24 GMT

Well the results are in…. the finalists of the Master Codemason Competition have been announced across on the Codemasons blog. Congratulations to:

Luis Ortega with The Follow me Clock

Robert Crago with Musicradio

Darko Radiceski with AAMHatcheye

Don’t forget to go to Smackdown at TechEd to see the winning application.

Windows Azure, .NET Services from a Windows Mobile Widget

nick — Wed, 02 Sep 2009 00:06:00 GMT

[This post is based on the Windows Azure Tools for Microsoft Visual Studio July 2009 CTP]

That’s right, if you hadn’t guessed what I was working on with my previous posts on .NET Services (Tokens, Queues I, II, III, Routers I & II) I’ve been working towards accessing .NET Services from within a widget. I must apologise for the following as it’s just a code dump of a sample widget that shows how to create a queue and subscribe to an existing router. Note that if you are going to use this on a number of devices you need to create a unique queue on each device, otherwise you’ll end up subscribing to the router multiple times – this will cause duplicate messages in your queue and contention between the devices dequeuing the messages.

To get this widget to work, simply create a widget (Developing Widgets for Windows Mobile 6.5) and then copy the following code into your html file.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head>
    <title>Widget Chat</title>

      <script type="text/javascript">
          var theToken;
          var theRouter = "myrouter"
          var widgetQueue = "widget";

          function connect() {
              var solutionName = document.getElementById("SolutionNameText");
              var solutionPassword = document.getElementById("SolutionPasswordText");

              alert('Solution Name: ' + solutionName.value);
              alert('Solution Password: ' + solutionPassword.value);
              httpGetAuthenticationToken(solutionName.value, solutionPassword.value, createQueue);
          }

          function createQueue() {
              alert('Creating Queue');
              httpCreateQueue(theToken, widgetQueue, subscribeToRouter);
          }

          function subscribeToRouter() {
              alert('Subscribing to Router');
              httpSubscribeQueueToRouter(theToken, theRouter, widgetQueue, pollForMessage);
          }

          function pollForMessage() {
              httpDequeueMessage(theToken, widgetQueue, messageReceived, pollForMessage);
          }

          function messageReceived(message) {
              alert('Message Received: ' + message);
              pollForMessage();
          }

          function send() {
              var messageBox = document.getElementById("Message");
              httpRouteMessage(theToken, theRouter, messageBox.value);
          }

          function httpGetAuthenticationToken(username, password, callback) {
              try {
                  http = new XMLHttpRequest();
                  http.open("GET", "https://accesscontrol.windows.net/IssueToken.aspx?u=" + username + "&p=" + password);
                  http.onreadystatechange = function() {
                      if (http.readyState == 4) {
                          if (http.status == 200) {
                              theToken = http.responseText;
                              alert('Authenticated:' + theToken);
                              callback();
                          }
                          else {
                              alert('Authentication failed');
                          }
                      }
                  }
                  http.send();
              }
              catch (e) {
                  alert(e.message);
              }
          }

          function httpCreateQueue(token, queue, callback) {
              var policy = "<entry xmlns=\"http://www.w3.org/2005/Atom\">" +
"<QueuePolicy xmlns=\"http://schemas.microsoft.com/netservices/2009/05/servicebus/connect\">" +
    "<ExpirationInstant>2009-09-03T01:00:00.0000000Z</ExpirationInstant>" +
"</QueuePolicy>" +
"</entry>";

              http = new XMLHttpRequest();
              http.open("POST", "https://blogsample.servicebus.windows.net/" + queue, false);
              http.setRequestHeader("X-MS-Identity-Token", token);
              http.setRequestHeader("Content-type", "application/atom+xml;type=entry;charset=utf-8");
              http.onreadystatechange = function() {
                  if (http.readyState == 4) {
                      if (http.status == 201) {
                          var created = http.responseText;
                          alert('queue created: ' + created);

                      }
                      else {
                          alert('queue not created - ' + http.status);
                      }
                      callback();
                  }
              }
              http.send(policy);
          }

          function httpGetServiceList(token) {
              http = new XMLHttpRequest();
              http.open("GET", "https://blogsample.servicebus.windows.net/", false);
              http.setRequestHeader("X-MS-Identity-Token", token);
              http.onreadystatechange = function() {
                  if (http.readyState == 4 && http.status == 200) {
                      output = http.responseText;
                      alert(output);
                      // Do something with the service list
                      httpRenewQueue(token, "mobilequeue", output);
                  }
              }
              http.send();
          }

          function httpRenewQueue(token, queue, getResponse) {
              xmlDoc = new ActiveXObject("Microsoft.XMLDOM");
              xmlDoc.async = "false";
              xmlDoc.loadXML(getResponse);

              var entry;
              var entries = xmlDoc.getElementsByTagName("title");
              var i;
              for (i = 0; i < entries.length; i++) {
                  if (entries[ i ].childNodes[0].nodeValue == queue) {
                      entry = entries[ i ].parentNode;
                  }
              }
              entry.getElementsByTagName("ExpirationInstant")[0].childNodes[0].nodeValue = "2009-08-31T09:56:25.2951184Z";

              http = new XMLHttpRequest();
              http.open("PUT", "https://blogsample.servicebus.windows.net/" + queue + "/!(queue)", false);
              http.setRequestHeader("X-MS-Identity-Token", token);
              http.setRequestHeader("Content-type", "application/atom+xml;type=entry;charset=utf-8");
              http.onreadystatechange = function() {
                  if (http.readyState == 4 && http.status == 200) {
                      var output = http.responseText;
                      alert('renew: ' + output);
                      httpEnqueueMessage(token, queue, "Hi Everyone");
                  }
              }
              http.send(entry.xml);
          }

          function httpDeleteQueue(token, queue) {
              http = new XMLHttpRequest();
              http.open("DELETE", "https://blogsample.servicebus.windows.net/" + queue + "/!(queue)", false);
              http.setRequestHeader("X-MS-Identity-Token", token);
              http.onreadystatechange = function() {
                  if (http.readyState == 4 && http.status == 200) {
                      var deleted = http.responseText;
                      alert('deleted');
                  }
              }
              http.send();
          }

          function httpEnqueueMessage(token, queue, message) {
              http = new XMLHttpRequest();
              http.open("POST", "https://blogsample.servicebus.windows.net/" + queue, false);
              http.setRequestHeader("X-MS-Identity-Token", token);
              http.setRequestHeader("Content-type", "text/plain;charset=utf-8");
              http.onreadystatechange = function() {
                  if (http.readyState == 4 && http.status == 202) {
                      var output = http.responseText;
                      alert('enqueue: ' + output)
                      httpDequeueMessage(token, queue);
                  }
              }
              http.send(message);
          }

          function httpDequeueMessage(token, queue, callback, noMessageCallback) {
              http = new XMLHttpRequest();
              http.open("DELETE", "https://blogsample.servicebus.windows.net/" + queue + "/!(queue/head)?encoding=asreply&maxmessages=1&timeout=30", true);
              http.setRequestHeader("X-MS-Identity-Token", token);
              http.onreadystatechange = function() {
                  if (http.readyState == 4) {
                      if (http.status == 200) {
                          var output = http.responseText;
                          callback(output);
                      }
                      else {
                          noMessageCallback();
                      }
                  }
              }
              http.send();
          }

          function httpRouteMessage(token, router, message) {
              http = new XMLHttpRequest();
              http.open("POST", "https://blogsample.servicebus.windows.net/" + router, false);
              http.setRequestHeader("X-MS-Identity-Token", token);
              http.setRequestHeader("Content-type", "text/plain;charset=utf-8");
              http.onreadystatechange = function() {
                  if (http.readyState == 4) {
                      if (http.status == 202) {
                          var output = http.responseText;
                          alert('Send ok!');

                      }
                      else {
                          alert('Unable to send');
                      }
                  }
              }
              http.send(message);
          }

          function httpSubscribeQueueToRouter(token, router, queue, callback) {
              var policy = "<entry xmlns=\"http://www.w3.org/2005/Atom\">" +
              "<link rel='alternate' href='https://blogsample.servicebus.windows.net/" + queue + "' />" +
"<HttpHeaders xmlns=\"http://schemas.microsoft.com/netservices/2009/05/servicebus/connect\">" +
    "<HttpHeader name='X-MS-Identity-Token' value='" + token + "' />" +
"</HttpHeaders>" +
"</entry>";

              http = new XMLHttpRequest();
              http.open("POST", "https://blogsample.servicebus.windows.net/" + router + "/!(router/subscriptions)", false);
              http.setRequestHeader("X-MS-Identity-Token", token);
              http.setRequestHeader("Content-type", "application/atom+xml;type=entry;charset=utf-8");
              http.onreadystatechange = function() {
                  if (http.readyState == 4) {
                      if (http.status == 200) {
                          var created = http.responseText;
                          alert('subscribed ok:' + created);
                          callback();
                      }
                      else {
                          alert('not subscribed ok' + http.status);
                      }
                  }
              }
              http.send(policy);
          }

      </script>
</head>
<body>
    <p>
    Solution Name:<br />
    <input id="SolutionNameText" type="text" />
        <br />
    Solution Password:<br />
    <input id="SolutionPasswordText" type="password" /><br />
    <Button onclick="connect()">Connect</Button>
    </p>

    <p>
    Message:
        <br />
    <input id="Message" type="text" /><br />
    <Button onclick="send()">Send</Button>
    </p>

</body>
</html>

Windows Azure, Microsoft .NET Services – Working with Routers (II)

nick — Tue, 01 Sep 2009 06:31:12 GMT

[This post is based on the Windows Azure Tools for Microsoft Visual Studio July 2009 CTP]

In the previous post on Working with Routers I showed how you can create a router using a Http Post. A router is only really useful when it can actually route messages. To do this it needs one or more subscribers. As you can imagine creating a subscriber (as with other creates) involves a Http Post. When we created the router one of the links that was returned was the subscriptions url. All you really need to do to create a subscriber is send a Http Post to this url. Of course you need to send the url where you want messages to be routed to, and any other information that is required for the router to route messages. The upshot is that you end up sending an entry that looks similar to the following:

<entry xmlns="http://www.w3.org/2005/Atom">
<link rel="alternate" href="https://blogsample.servicebus.windows.net/myqueue" />
<HttpHeaders xmlns="http://schemas.microsoft.com/netservices/2009/05/servicebus/connect">
<HttpHeader name="X-MS-Identity-Token" value="zpleGHYQzEiRUXkdFd7UN+gBbBzSIuW5Bc2hIA==" />
</HttpHeaders>
</entry>

Of course, this needs to be sent as a Http Post:

private static string SubscribeQueueToRouter(string token, string router, string queue)
{
    string subscriptionsUri = "https://blogsample.servicebus.windows.net/" + router + "/!(router/subscriptions)";

    HttpWebRequest request = (HttpWebRequest)WebRequest.Create(subscriptionsUri);
    request.Headers.Add("X-MS-Identity-Token", token);
    request.Method = "POST";
    request.ContentType = "application/atom+xml;type=entry;charset=utf-8";

    XElement content = new XElement(XName.Get("entry", "http://www.w3.org/2005/Atom"),
                            new XElement(XName.Get("link", "http://www.w3.org/2005/Atom"),
                                new XAttribute("rel", "alternate"),
                                new XAttribute("href", "https://blogsample.servicebus.windows.net/" + queue)),
                            ServicesElement("HttpHeaders",
                                ServicesElement("HttpHeader",
                                    new XAttribute("name","X-MS-Identity-Token"),
                                    new XAttribute("value",token))));

    using (var requestStream = request.GetRequestStream())
    using (var writer = new System.IO.StreamWriter(requestStream))
    {
        writer.Write(content);
        writer.Flush();
    }

    using (var response = request.GetResponse())
    using (var responseStream = response.GetResponseStream())
    using (var reader = new StreamReader(responseStream))
    {
        return reader.ReadToEnd();
    }
}

In this example the link url provided is the tail of the queue (ie the url where you enqueue messages). The token is included in a HttpHeader element so that it can be routed as part of sending the message to the queue. You should expect a 200, Ok response. If you want to get a list of subscribers you can simply issue a Http Get to the subscriptions url. This will return a feed of the subscribers.

<feed xmlns="http://www.w3.org/2005/Atom">
   <title type="text">Subscriptions</title>
   <id>uuid:eb256797-2832-4f2b-afd9-ba3e4cfeeb7b;id=1869</id>
   <updated>2009-09-01T06:20:00Z</updated>
   <link rel="self" href="https://blogsample.servicebus.windows.net/myrouter/!(router/subscriptions)"></link>
   <entry>
     <id>uuid:eb256797-2832-4f2b-afd9-ba3e4cfeeb7b;id=1870</id>
      <title type="text">urn:uuid:90d62d9e-2a13-446c-951a-72046101fa17</title>
      <updated>2009-09-01T06:20:00Z</updated>
      <link rel="alternate" href="https://blogsample.servicebus.windows.net/myqueue"></link>
      <link rel="self" href="https://blogsample.servicebus.windows.net/myrouter/!(router/subscriptions/urn:uuid:90d62d9e-2a13-446c-951a-72046101fa17)"></link>
      <content type="text"></content>
      <Expires xmlns="http://schemas.microsoft.com/netservices/2009/05/servicebus/connect">2009-09-02T06:18:56.9899631Z</Expires>
      <NotifyTo xmlns="http://schemas.xmlsoap.org/ws/2004/08/eventing">
         <Address xmlns="http://www.w3.org/2005/08/addressing">https://blogsample.servicebus.windows.net/myqueue</Address>
      </NotifyTo>
      <HttpHeaders xmlns="http://schemas.microsoft.com/netservices/2009/05/servicebus/connect">
         <HttpHeader name="X-MS-Identity-Token" value="zpleGHYQzEiRUXkdFd7UN+gBbBzSIuW5Bc2hIA=="></HttpHeader>
      </HttpHeaders>
   </entry>
   <entry>
      <id>uuid:eb256797-2832-4f2b-afd9-ba3e4cfeeb7b;id=1871</id>
      <title type="text">urn:uuid:d27a29ab-46e4-49ca-9d1e-cd05bdc24d42</title>
      <updated>2009-09-01T06:20:00Z</updated>
      <link rel="alternate" href="https://blogsample.servicebus.windows.net/myqueue"></link>
      <link rel="self" href="https://blogsample.servicebus.windows.net/myrouter/!(router/subscriptions/urn:uuid:d27a29ab-46e4-49ca-9d1e-cd05bdc24d42)"></link>
      <content type="text"></content>
      <Expires xmlns="http://schemas.microsoft.com/netservices/2009/05/servicebus/connect">2009-09-02T06:01:01.0635156Z</Expires>
      <NotifyTo xmlns="http://schemas.xmlsoap.org/ws/2004/08/eventing">
         <Address xmlns="http://www.w3.org/2005/08/addressing">https://blogsample.servicebus.windows.net/myqueue</Address>
      </NotifyTo>
      <HttpHeaders xmlns="http://schemas.microsoft.com/netservices/2009/05/servicebus/connect">
         <HttpHeader name="X-MS-Identity-Token" value="J+rsqHMQzEgxQ3yu3JwyDv3J8wNgIQybBoxtng=="></HttpHeader>
      </HttpHeaders>
   </entry>
</feed>

Now the last thing to do is to send a message to the router. In the above example a message sent to the router will get routed through to the subscribed queue. As we did with enqueuing a message on a queue, to send a message to the router you do a Http Post to the alterate url of the router (this is also the original url that you used to create the router).

private static string SendMessageToRouter(string token, string router, string message)
{
    string routerUri = "https://blogsample.servicebus.windows.net/" + router;
    // send
    HttpWebRequest request = HttpWebRequest.Create(routerUri) as HttpWebRequest;
    request.Method = "POST";
    request.Headers.Add("X-MS-Identity-Token", token);
    request.ContentType = "text/plain;charset=utf-8";

    using (var requestStream = request.GetRequestStream())
    using (var writer = new System.IO.StreamWriter(requestStream))
    {
        writer.Write(message);
        writer.Flush();
    }

    using (var response = request.GetResponse())
    {
        return (response as HttpWebResponse).StatusCode.ToString();
    }
}

Again you should expect a 202, Accepted response. To retrieve the message off the destination queue, simply send a Http Delete message as discussed in Working with Queues (III).

Windows Azure, Microsoft .NET Services – Working with Routers (I)

nick — Tue, 01 Sep 2009 04:58:18 GMT

[This post is based on the Windows Azure Tools for Microsoft Visual Studio July 2009 CTP]

The last couple of posts have covered working with .NET Services queues (parts I, II and III). Now we move on to cover routers. Like I did previously I’ll cover creating and working with routers, before we move on to working with them in conjunction with queues.

To create a router you send a Http Post to the url that you want the router to reside at, supplying a RouterPolicy entry. The url has to belong to your solution url, so for example https://blogsample.servicebus.windows.net/myrouter. An example RouterPolicy would look like the following:

<entry xmlns="http://www.w3.org/2005/Atom">
<RouterPolicy xmlns="http://schemas.microsoft.com/netservices/2009/05/servicebus/connect">
    <Discoverability>Public</Discoverability>
    <ExpirationInstant>2009-09-01T05:18:06.9677603Z</ExpirationInstant>
    <TransportProtection>None</TransportProtection>
    <MaxSubscribers>2147483647</MaxSubscribers>
    <MessageDistribution>AllSubscribers</MessageDistribution>
</RouterPolicy>
</entry>

Now to send this:

private static string HttpCreateRouter(string token, string router)
{
    string routerUri = "https://blogsample.servicebus.windows.net/" + router;

    HttpWebRequest request = (HttpWebRequest)WebRequest.Create(routerUri);
    request.Headers.Add("X-MS-Identity-Token", token);
    request.Method = "POST";
    request.ContentType = "application/atom+xml;type=entry;charset=utf-8";

    XElement content = new XElement(XName.Get("entry", "http://www.w3.org/2005/Atom"),
                            ServicesElement("RouterPolicy",
                                ServicesElement("Discoverability","Public"),
                                ServicesElement("ExpirationInstant", DateTime.UtcNow.AddMinutes(30)),
                                ServicesElement("TransportProtection", "None"),
                                ServicesElement("MaxSubscribers", "2147483647"),
                                ServicesElement("MessageDistribution", "AllSubscribers")));

    using (var requestStream = request.GetRequestStream())
    using (var writer = new System.IO.StreamWriter(requestStream))
    {
            writer.Write(content);
            writer.Flush();
    }

    using (var response = request.GetResponse())
    using (var responseStream = response.GetResponseStream())
    using (var reader = new StreamReader(responseStream))
    {
        return reader.ReadToEnd();
    }
}

private static XElement ServicesElement(string element, params object[] content)
{
    return new XElement(XName.Get(element, "http://schemas.microsoft.com/netservices/2009/05/servicebus/connect"), content);
}

A note of warning… for some reason the order of the xml elements for the RouterPolicy does matter. Submitting them in a different order appears to cause a duplicate RouterPolicy entry. This will most likely be resolved for the production release but in the meantime if you are seeing weird RouterPolicy entries being returned this may be the cause.

When you run this code the response (assuming it is successful) should be a 201, Created. Subsequent Posts to this url will result in a 202, Accepted – note however this does not update or alter the router. In addition to the 201 status, the Post also returns information about the created router:

<entry xmlns="http://www.w3.org/2005/Atom">
   <id>uuid:0ae5cae9-6f3f-4fcc-8377-83f34c106124;id=1546</id>
   <title type="text">myrouter</title>
   <updated>2009-09-01T04:48:41Z</updated>
   <link rel="alternate" href="https://blogsample.servicebus.windows.net/myrouter/"/>
   <link rel="self" href="https://blogsample.servicebus.windows.net/myrouter/!(router)"/>
   <link rel="subscriptions" href="https://blogsample.servicebus.windows.net/myrouter/!(router/subscriptions)"/>
   <RouterPolicy xmlns="http://schemas.microsoft.com/netservices/2009/05/servicebus/connect" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
      <Discoverability>Public</Discoverability>
      <ExpirationInstant>2009-09-01T05:18:06.9677603Z</ExpirationInstant>
      <TransportProtection>None</TransportProtection>
      <MaxMessageSize>61440</MaxMessageSize>
      <BufferTimeout>PT10S</BufferTimeout>
      <MaxBufferLength>0</MaxBufferLength>
      <MaxBufferCapacity>0</MaxBufferCapacity>
      <MaxSubscribers>50</MaxSubscribers>
      <MessageDistribution>AllSubscribers</MessageDistribution>
      <PushDeliveryRetries>3</PushDeliveryRetries>
      <PushDeliveryTimeout>PT30S</PushDeliveryTimeout>
   </RouterPolicy>
</entry>

As with when you create a queue, the response contains a number of links.

alternate – This is the url you will use when placing new messages on the router.

self – This is the url you will now use to update, renew and delete the router.

subscriptions – This is the url that you use when subscribing to the router.

As you can see the process of creating a router is roughly the same as for a queue, with the only big difference being the RouterPolicy you need to supply. Querying, renewing and deleting a router is done exactly the same way as for a queue, with the exception you need to use the self url returned when you create the router (which ends in (router) instead of (queue)).

Windows Azure, Microsoft .NET Services – Working with Queues (III)

nick — Mon, 31 Aug 2009 02:21:49 GMT

[This post is based on the Windows Azure Tools for Microsoft Visual Studio July 2009 CTP]

In my previous posts, Working With Queues (I) & Working with Queues (II), I showed how you can create, query, renew and delete queues with the Windows Azure, Microsoft .NET Services. Now for the interesting stuff – let’s enqueue and dequeue messages.

As you can imagine enqueuing equates to Post(ing) a message to the tail of the queue, whilst dequeuing equates to delete(ing) from the head of the queue. In code, this is:

private static string EnqueueMessage(string token, string queue, string message)
{
    string queueUri = "https://blogsample.servicebus.windows.net/" + queue;

    // send
    HttpWebRequest request = HttpWebRequest.Create(queueUri) as HttpWebRequest;
    request.Method = "POST";
    request.Headers.Add("X-MS-Identity-Token", token);
    request.ContentType = "text/plain;charset=utf-8";

    using (var requestStream = request.GetRequestStream())
    using (var writer = new System.IO.StreamWriter(requestStream))
    {
        writer.Write(message);
        writer.Flush();
    }

    using (var response = request.GetResponse())
    {
        return (response as HttpWebResponse).StatusCode.ToString();
    }
}

private static string DequeueMessage(string token, string queue)
{
    string queueUri = "https://blogsample.servicebus.windows.net/" + queue + "/!(queue/head)?encoding=asreply&maxmessages=1&timeout=30";

    HttpWebRequest request = HttpWebRequest.Create(queueUri) as HttpWebRequest;
    request.ConnectionGroupName = "dequeue";
    request.Method = "DELETE";
    request.Headers.Add("X-MS-Identity-Token", token);
    request.ContentLength = 0;

    using (var response = request.GetResponse())
    using (var responseStream = response.GetResponseStream())
    using (var reader = new StreamReader(responseStream))
    {
        return reader.ReadToEnd();
    }
}

To enqueue a message you send a Http Post to the alternate link (otherwise known as the tail of the queue), ie https://blogsample.servicebus.windows.net/myqueue. You should get back a 202, Accepted response. When you are dequeuing a message you send a Http Delete to the queuehead link (otherwise known as the head of the queue), ie https://blogsample.servicebus.windows.net/myqueue/!(queue/head). You should get back a 200, Ok response, with the message in the content of the response.

As part of the Http Delete you can specify a timeout, in this case 30 seconds. This determines how long the request will wait for a message to appear on the queue before returning. If a message appears within this timeout you will get the message and a 200 response. If not, you will get a 204, No Content response.

And now to cover enqueuing and dequeuing in BLOCKED SCRIPT

function httpEnqueueMessage(token, queue, message) {
    http = new XMLHttpRequest();
    http.open("POST", "https://blogsample.servicebus.windows.net/" + queue, false);
    http.setRequestHeader("X-MS-Identity-Token", token);
    http.setRequestHeader("Content-type", "text/plain;charset=utf-8");
    http.onreadystatechange = function() {
        if (http.readyState == 4 && http.status == 202) {
            var output = http.responseText;
            // Do something…
        }
    }
    http.send(message);
}

function httpDequeueMessage(token, queue) {
    http = new XMLHttpRequest();
    http.open("DELETE", "https://blogsample.servicebus.windows.net/" + queue + "/!(queue/head)?encoding=asreply&maxmessages=1&timeout=20", false);
    http.setRequestHeader("X-MS-Identity-Token", token);
    http.onreadystatechange = function() {
        if (http.readyState == 4 && http.status == 200) {
            var output = http.responseText;
            // Do something...
        }
    }
    http.send();
}

Windows Azure, Microsoft .NET Services – Working with Queues (II)

nick — Mon, 31 Aug 2009 01:41:10 GMT

[This post is based on the Windows Azure Tools for Microsoft Visual Studio July 2009 CTP]

In my previous post, Working With Queues (I), I showed how you can create a queue using a Http Post message against the Windows Azure, Microsoft .NET Services. Now that we’ve created a queue, let’s look at how you can query, renew and delete your queue.

To query for the existence of a queue (and remember that when a queue expires it is no longer available) you just need to send a Http Get to the parent url. So for example if you had a queue https://blogsample.servicebus.windows.net/application1/myqueue you would send the Get to https://blogsample.servicebus.windows.net/application1. In our case because the queue we created previously was https://blogsample.servicebus.windows.net/myqueue we need to send the Http Get to https://blogsample.servicebus.windows.net/.

public static string GetServicesListing(string token)
{
    string listingUri = "https://blogsample.servicebus.windows.net/";

    HttpWebRequest request = (HttpWebRequest)WebRequest.Create(listingUri);
    request.Headers.Add("X-MS-Identity-Token", token);
    request.Method = "GET";
    request.ContentLength = 0;

    using (var response = request.GetResponse())
    using (var responseStream = response.GetResponseStream())
    using (var reader = new StreamReader(responseStream))
    {
        var output= reader.ReadToEnd();
        return output;
    }
}

When you run this code the response (assuming it is successful) should be a 200, Ok. In addition to the 200 status, the Get also returns information about services available under the url that the Get was sent to:

<feed xmlns="http://www.w3.org/2005/Atom">
   <title type="text">Publicly Listed Services</title>
   <subtitle type="text">This is the list of publicly-listed services currently available</subtitle>
   <id>uuid:c285faa1-b963-4668-918f-af7b99ec19ea;id=3944</id>
   <updated>2009-08-31T00:30:31Z</updated>
   <generator>Microsoft® .NET Services - Service Bus</generator>
   <entry>
      <id>uuid:c285faa1-b963-4668-918f-af7b99ec19ea;id=3945</id>
      <title type="text">myqueue</title>
      <updated>2009-08-31T00:30:31Z</updated>
      <link rel="alternate" href="https://blogsample.servicebus.windows.net/myqueue/"/>
      <link rel="self" href="https://blogsample.servicebus.windows.net/myqueue/!(queue)"/>
      <link rel="queuehead" href="https://blogsample.servicebus.windows.net/myqueue/!(queue/head)"/>
      <link rel="queuecontrol" href="https://blogsample.servicebus.windows.net/myqueue/!(queue/control)"/>
      <QueuePolicy xmlns="http://schemas.microsoft.com/netservices/2009/05/servicebus/connect" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
         <ExpirationInstant>2009-08-31T03:56:25.2951184Z</ExpirationInstant>
         <MaxMessageSize>61440</MaxMessageSize>
         <EnqueueTimeout>PT10S</EnqueueTimeout>
         <MaxConcurrentReaders>10</MaxConcurrentReaders>
         <MaxDequeueRetries>3</MaxDequeueRetries>
         <MaxMessageAge>PT10M</MaxMessageAge>
         <MaxQueueLength>2147483647</MaxQueueLength>
         <MaxQueueCapacity>10485760</MaxQueueCapacity>
      </QueuePolicy>
   </entry>
</feed>

And for the javascript version:

function httpGetServiceList(token) {
    http = new XMLHttpRequest();
    http.open("GET", "https://blogsample.servicebus.windows.net/", false);
    http.setRequestHeader("X-MS-Identity-Token", token);
    http.onreadystatechange = function() {
        if (http.readyState == 4 && http.status == 200) {
            output = http.responseText;
            // Do something with the service list
        }
    }
    http.send();
}

As you will have noticed, queues have an ExpirationInstant which is the instance when your queue will expire and be unavailable. In most cases this is not that desirable so you will want to periodically renew it. You do this by sending a Http Put to the self link address (ie https://blogsample.servicebus.windows.net/myqueue/!(queue)). Instead of just sending a new QueuePolicy you need to get the appropriate entry out of the service feed (retrieved using the Http Get we just discussed), update the QueuePolicy with the new expiration instant and then submit the whole entry in the content of the Http Put.

public static string RenewQueue(string token, string queue)
{
    string listing = GetServicesListing(token);
    XElement feed = XElement.Parse(listing);
    var content = (from entry in feed.Descendants(XName.Get("entry", "http://www.w3.org/2005/Atom"))
                  where entry.Element(XName.Get("title", "http://www.w3.org/2005/Atom")).Value == queue
                  select entry).FirstOrDefault();
    if (content == null)
    {
        return null;
    }

    // Update the expiration time
    content.Descendants(ServicesElementName("ExpirationInstant")).FirstOrDefault().SetValue(DateTime.UtcNow.AddMinutes(30));

    string queueUri = "https://blogsample.servicebus.windows.net/" + queue + "/!(queue)";

    HttpWebRequest request = (HttpWebRequest)WebRequest.Create(queueUri);
    request.Headers.Add("X-MS-Identity-Token", token);
    request.Method = "PUT";
    request.ContentType = "application/atom+xml;type=entry;charset=utf-8";

    using (var requestStream = request.GetRequestStream())
    using (var writer = new System.IO.StreamWriter(requestStream))
    {
        writer.Write(content);
        writer.Flush();
    }

    using (var response = request.GetResponse())
    using (var responseStream = response.GetResponseStream())
    using (var reader = new StreamReader(responseStream))
    {
        return reader.ReadToEnd();
    }
}
private static XName ServicesElementName(string element)
{
    return XName.Get(element, "http://schemas.microsoft.com/netservices/2009/05/servicebus/connect");
}

Here you should expect a 200, Ok response with the updated entry being returned in the response (you can use this to double-check the queue attributes were updated correctly). And now the same but in BLOCKED SCRIPT

function httpRenewQueue(token, queue, getResponse) {
    xmlDoc = new ActiveXObject("Microsoft.XMLDOM");
    xmlDoc.async = "false";
    xmlDoc.loadXML(getResponse);

    var entry;
    var entries = xmlDoc.getElementsByTagName("title");
    var i;
    for (i = 0; i < entries.length; i++) {
        if (entries.childNodes[0].nodeValue == queue) {
            entry = entries.parentNode;
        }
    }
    entry.getElementsByTagName("ExpirationInstant")[0].childNodes[0].nodeValue="2009-08-31T03:56:25.2951184Z";

    http = new XMLHttpRequest();
    http.open("PUT", "https://blogsample.servicebus.windows.net/" + queue + "/!(queue)", false);
    http.setRequestHeader("X-MS-Identity-Token", token);
    http.setRequestHeader("Content-type", "application/atom+xml;type=entry;charset=utf-8");
    http.onreadystatechange = function() {
    if (http.readyState == 4 && http.status == 200)
        {
            var output = http.responseText;
            // Do something…
        }
    }
    http.send(entry.xml);
}

Note that in these examples there is NO error handling and the expiration is hard coded – you will need to adjust this otherwise you will get a 500 Internal Server error if the expiration is in the past.

Ok, so finally you need to be able to delete your queue. This is done by sending a Http Delete message to the Self link, as follows:

public static string DeleteQueue(string token, string queue)
{
    string queueUri = "https://blogsample.servicebus.windows.net/" + queue + "/!(queue)";

    HttpWebRequest request = (HttpWebRequest)WebRequest.Create(queueUri);
    request.Headers.Add("X-MS-Identity-Token", token);
    request.Method = "DELETE";
    request.ContentLength = 0;
    using (var response = request.GetResponse())
    {
        return (response as HttpWebResponse).StatusCode.ToString();
    }
}

One important point here is that you must set the ContentLength to 0. You should expect a 200, Ok if the queue is deleted. For both the renew (ie Http Put) and delete (ie Http Delete) if the queue has expired, you can expect a 404, Not found exception to be raised. Lastly, let’s see the delete in BLOCKED SCRIPT

function httpDeleteQueue(token, queue) {
    http = new XMLHttpRequest();
    http.open("DELETE", "https://blogsample.servicebus.windows.net/" + queue +"/!(queue)", false);
    http.setRequestHeader("X-MS-Identity-Token", token);
    http.onreadystatechange = function() {
        if (http.readyState == 4 && http.status == 200) {
            var output = http.responseText;
            // Do something….
        }
    }
    http.send();
}