The MessageQueue class in StorageClient contains the polling inbuilt  infrastructure and delivers the message via eventing:

mqObj.MessageReceived += new MessageReceivedEventHandler(mqObj_MessageReceived);
mqObj.PollInterval = 1000; // poll interval in milliseconds
mqObj.StartReceiving(); // starts polling

The event handler fires whenever a message is received, in addition, when there are no more messages the client will begin polling the queue at the  PollInterval

In this code sample no timeout is set and so the default is selected from the Timeout property of the MessageQueue class (which in turn defaults to 30 seconds).

1. Set up Authentication Details and Create a New Queue

The below code adds the the storage authentication details, creates a queue storage object (which is the storage container that the Message Queues are placed in), then creates a message queue and finally adds a message to that queue:

string accName = “devacc1″;

string accKey = “accountKeyStringxxxx”;

string address = “http://127.0.0.1:10001″;

StorageAccountInfo acObj = new StorageAccountInfo(new Uri(address), null, accName, accKey);

QueueStorage qsObj = QueueStorage.Create(acObj);

MessageQueue mqObj = qsObj.GetQueue(“azureSupportString”);

mq.CreateQueue();

Message msgObj = new Message(DateTime.Now.ToString());

mqObj.PutMessage(msgObj);

2. Receiving a Message from the Queue

The code for receiving a message from a queue is very straightforward. Use the GetMessage method of the MessageQueue with the time out in seconds passed in as a parameter. This timeout is the time that routine has a lock on the message, if it is not deleted within the timeout time other processes will be able to access it.
The GetMessage method returns null if there is no message on the queue so your code needs to check for that. Also note that the message remains on the queue if it is not deleted so call the DeleteMessage method to delete the message.

Message msgObj = mqObj.GetMessage(3);
if (msgObj != null)
{
Console.WriteLine(msgObj.ContentAsString());
mqObj.DeleteMessage(msgObj);
}

We can also add Queue Polling to this routine

See the full announcement for more details.

Creating Local Blob Storage

1. First we need to set up connection string to the Azure storage account. In the Cloud Service project in the Visual Studio Solution Explorer double-click the role which will use Azure storage in the Roles folder. This should bring up the configuration page for the Role. Navigate to the Settings tab and click ‘Add Setting’ , then provide a name for the setting (such as StorageConnectionString) , set the type to ConnectionString and click the ‘…’ button in the Value field. This will bring up the Storage Connection String dialog. Initially we will be developing and testing the storage on the local server so select the Use Development Storage radio button and click OK:
   
2. In the code behind for the page which will interact with the blob storage add the following declaration to the top of the page to import the relevant namespaces (for a larger project this should be done in the web.config)
   using Microsoft.WindowsAzure;
   usingMicrosoft.WindowsAzure.StorageClient;
3. Add an instance of an Azure storage account :
   CloudStorageAccount account = CloudStorageAccount.FromConfigurationSetting(“StorageConnectionString”);
4. Create a CloudBlobClient object which will perform the main blob functions against the storage account. Then use the BlobClient object to create a CloudBlobContainer (all blobs must be stored in a container):
   CloudBlobClient blobClient = account.CreateCloudBlobClient();
   CloudBlobContainer container = blobClient.GetContainerReference(“hellocloud”);
5. Now we need to set the viewing permissions for the blob, in this example we will be setting the blob for public access so it can be viewed by anyone. This is done at the container level by creating a BlobContainerPermissions object and setting the object’s permissions to public and then passing the object to the container’s SetPermissions method.
   BlobContainerPermissions containerPermissions = new BlobContainerPermissions();
   containerPermissions.PublicAccess = BlobContainerPublicAccessType.Container;
   container.SetPermissions(containerPermissions);
6. Create an CloudBlockBlob object which will manage the individual blob and then set the URI to access the blob:
   CloudBlockBlob blob;
   blob = container.GetBlockBlobReference(Guid.NewGuid().ToString());
7. For this example we will simply place a string in the blob (however it could be used for a file using the Upload file method of the blob object.
   blob.UploadText(“AzureSupport text”)
8. The blob is now available at the URI:
   blob.Uri.ToString()

Move the Blob Storage to Azure online storage

1. Navigate to your Windows Azure developer portal, and click “New Service” (which is located above the Windows Azure tab).
2. Click Storage Account
3. Enter a Service Label and click Create
4. On the Create a Service – Storage Account page, enter a Public Storage Account Name and then configure the Storage Account Affinity Group (it is recommended that you create a new affinity group if there is not existing groups). Click ‘Create’ and the storage should be created.
5. We will now modify the Connection String for the Visual Studio project to point to this account. To do this we need to repeat Step 1 of Create Local Blob Storage above, but enter select the Enter Storage Credentials radio button and enter the Account Name we just created and the  Access Key (which is the Primary Access Key shown in the Azure developer portal). You can also specify the endpoints for accessing the storage:
   
6. Now you can deploy your application as shown in the Deploying the App on Azure tutorial. You can also enable the Azure CDN for your app.