Technical Notes

Building Windows Azure Service Part7: Service Testing

michaelonmsdn — Wed, 05 Jan 2011 01:17:00 GMT

In this post, you will test the GuestBook application in the Development Fabric (aka, devfabric). The devfabric is a simulated environment for developing and testing Windows Azure applications on your test machine.

A Visual Studio project with source code is available at the end of this post to accompany the subject matter discussed.

In Visual Studio, press F5 to execute the service. The service builds and then launches the local development fabric. To show the development fabric UI, right-click its icon located in the system tray and select Show Development Fabric UI.

Figure 9 Development Fabric UI
Switch to Internet Explorer to view the GuestBook application.
Add a new entry to the guest book as described in the next steps.
Type your name and a message.
Choose an image to upload. It is a good idea to choose a large high resolution image because the guestbook service will resize it.
Click the pencil icon to submit the entry.

Figure 10 GuestBook Home Page

Once you submit an entry, the web role creates a new entry in the guest book table and uploads the photo to the Blob Storage. The page contains a timer that triggers a page refresh every 5 seconds, so the new entry should appear on the page after a brief interval.

Initially, the new entry contains a link to the blob that contains the uploaded image so it will appear with the same size as the original image.

Figure 11 GuestBook Image Original Size

After a few seconds, the page refreshes and displays the thumbnail that the worker role generated.

Figure 12 GuestBook Generated Thumbnail

For related topics, see the following posts.

Building Windows Azure Service Part6: Service Configuration

michaelonmsdn — Wed, 05 Jan 2011 00:42:00 GMT

You can update your service's configuration while the service is running without taking the service offline. The service configuration (.cscfg) file contains the service's configuration.

To change configuration information, you can either upload a new configuration file, or edit the configuration file in place and apply it to your running service. This does not apply to certificate changes that are always done off-line.

For more information about the service configuration files, see Service Configuration Schema.

For practical information on service configuration, see also Using Windows Azure Development Environment Essentials.

Handling Configuration Changes with Service Runtime Events

The Windows Azure Managed Library includes the Microsoft.WindowsAzure.ServiceRuntime namespace, which provides classes for interacting with the Windows Azure environment from code running in a role instance. The RoleEnvironment class defines events raised before and after a configuration change:

The RoleEnvironment.Changing event occurs before the configuration change is applied to a given instance of a role. This event may be cancelled, in which case Windows Azure recycles the role. When the role is recycled, the configuration change is applied before the role is brought back online again.
The RoleEnvironment.Changed event occurs after the configuration change has been applied to a given instance of a role.

The Changing and Changed events are raised regardless of the health of any particular role instance. The Windows Azure Managed Library does not provide a means of determining the health of other role instances, but you can implement such health assessments yourself if your service needs this functionality.

Changing Event

The Changing event allows you to manage how a role instance responds to a configuration change. Via the Changing event, an instance can respond to a configuration change in one of two ways:

The instance can accept the configuration change on the fly, without going offline.
The instance can cancel the Changing event, in which case Windows Azure takes the instance offline, applies the configuration change, and then brings the instance back online.

By cancelling the Changing event, you can ensure that the instance proceeds through an orderly shutdown sequence and is taken offline before the configuration change is applied. During the shutdown process, Windows Azure raises the Stopping event, then runs any code in the OnStop method.

The total interval allowed for an instance's shutdown sequence is 30 seconds; if your code has not finished running within this interval, the process will automatically be terminated.

You may wish to cancel the Changing event if:

Your role does not support on-the-fly configuration changes, and requires recycling in order to apply the change.
Your role is in the midst of performing work that should not be disrupted by a configuration change, and needs to proceed through the shutdown sequence before applying the change.

Configuration Related Exception

When running the application, the system can raise the following exception:

SetConfigurationSettingPublisher needs to be called before FromConfigurationSetting can be used

Usually this happens when a web role is migrated from an older Windows Azure SDK version and is caused by changes associated with the full IIS model introduced in newer SDK versions. In the newer version the SetConfigurationSettingPublisher and FromConfigurationSetting belong to different “app domains”. For more information, see How to Resolve….

To avoid the exception you must assure that the following code is executed in the OnStart method of the web and worker roles before calling FromConfigurationSetting . In the case of the web role you can execute the code in the Application_Start method in the Global.ascx.cs file.

CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
    {
        try
        {   // Retrieves the value of a setting in the service configuration file. 
            configSetter(RoleEnvironment.GetConfigurationSettingValue(configName));
        }
        catch (RoleEnvironmentException e)
        {

            System.Diagnostics.Trace.TraceError(e.Message);
            System.Threading.Thread.Sleep(5000);
        }
    });

For related topics, see the following posts.

Building Windows Azure Service Part1: Introduction
Building Windows Azure Service Part2: Service Project
Building Windows Azure Service Part3: Table Storage
Building Windows Azure Service Part4: Web Role UI Handler
Building Windows Azure Service Part5: Worker Role Background Tasks Handler
Building Windows Azure Service Part7: Service Testing

Building Windows Azure Service Part5: Worker Role Background Tasks Handler

michaelonmsdn — Sat, 01 Jan 2011 23:33:35 GMT

In this post you will create a worker role to read work items posted to a queue by the web role front-end. The worker role performs these tasks:

Extract the information about the guest book entry from the message queued by the web role in the Queue Storage.
Retrieve the user entry from the Table Storage.
Fetch the associated image from the Blob Storage and create a thumbnail and store it is as a blob.
Finally, update the entry to include the URL of the generated thumbnail.

To create the worker role

In Solution Explorer, right click the Roles node in the GuestBook project.
Select Add and click New Worker Role Project.
In the Add New Role Project dialog window, select the Worker Role category and choose the Worker Role template for the language of your choice.
In the name box, enter GuestBook_WorkerRole and click Add.

Figure 7 Creating Worker Role Project
In Solution Explorer, right-click the GuestBook_WorkerRole project and select Add Reference.
Switch to the Projects tab, select the GuestBookData project and click OK.
In Solution Explorer, right-click the GuestBook_WorkerRole project, select Add Reference,
Switch to the .Net tab, select the System.Drawing component and click OK.
Repeat the procedure in the previous steps to add a reference to the storage client API assembly, this time choosing the Microsoft.WindowsAzure.StorageClient component instead.

In the GuestBook_WorkerRole project, open the WorkerRole.cs file. Replace its content with the following code.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading;
using Microsoft.WindowsAzure.Diagnostics;
using Microsoft.WindowsAzure.ServiceRuntime;
using System.Drawing;
using System.IO;
using GuestBook_Data;
using Microsoft.WindowsAzure;
using Microsoft.WindowsAzure.StorageClient;

namespace GuestBook_WorkerRole
{
    public class WorkerRole : RoleEntryPoint
    {
        private CloudQueue queue;
        private CloudBlobContainer container;

        public override void Run()
        {
            Trace.TraceInformation("Listening for queue messages...");

            while (true)
            {
                try
                {
                    // retrieve a new message from the queue
                    CloudQueueMessage msg = queue.GetMessage();
                    if (msg != null)
                    {
                        // parse message retrieved from queue
                        var messageParts = msg.AsString.Split(new char[] { ',' });
                        var uri = messageParts[0];
                        var partitionKey = messageParts[1];
                        var rowkey = messageParts[2];
                        Trace.TraceInformation("Processing image in blob '{0}'.", uri);

                        // download original image from blob storage
                        CloudBlockBlob imageBlob = container.GetBlockBlobReference(uri);
                        MemoryStream image = new MemoryStream();
                        imageBlob.DownloadToStream(image);
                        image.Seek(0, SeekOrigin.Begin);

                        // create a thumbnail image and upload into a blob
                        string thumbnailUri = String.Concat(Path.GetFileNameWithoutExtension(uri), "_thumb.jpg");
                        CloudBlockBlob thumbnailBlob = container.GetBlockBlobReference(thumbnailUri);
                        thumbnailBlob.UploadFromStream(CreateThumbnail(image));

                        // update the entry in table storage to point to the thumbnail
                        var ds = new GuestBookEntryDataSource();
                        ds.UpdateImageThumbnail(partitionKey, rowkey, thumbnailBlob.Uri.AbsoluteUri);

                        // remove message from queue
                        queue.DeleteMessage(msg);

                        Trace.TraceInformation("Generated thumbnail in blob '{0}'.", thumbnailBlob.Uri);
                    }
                    else
                    {
                        System.Threading.Thread.Sleep(1000);
                    }
                }
                catch (StorageClientException e)
                {
                    Trace.TraceError("Exception when processing queue item. Message: '{0}'", e.Message);
                    System.Threading.Thread.Sleep(5000);
                }
            }
        }

        public override bool OnStart()
        {
            DiagnosticMonitor.Start("DiagnosticsConnectionString");

            // Restart the role upon all configuration changes
            RoleEnvironment.Changing += RoleEnvironmentChanging;


            // Set the global configuration setting publisher for the storage account, which 
            // will be called when the account access keys are updated in the service configuration file.
            // Calling SetConfigurationSettingPublisher in OnStart method is important otherwise the
            // system raises an exception when FromConfigurationSetting is called.
            CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
            {
                try
                {
                    configSetter(RoleEnvironment.GetConfigurationSettingValue(configName));
                }
                catch (RoleEnvironmentException e)
                {

                    Trace.TraceError(e.Message);
                    System.Threading.Thread.Sleep(5000);
                }
            });

            // Create a new instance of a CloudStorageAccount object from a specified configuration setting. 
            // This method may be called only after the SetConfigurationSettingPublisher 
            // method has been called to configure the global configuration setting publisher.
            // You can call the SetConfigurationSettingPublisher method in the OnStart method
            // of the worker role before calling FromConfigurationSetting.
            // If you do not do this, the system raises an exception. 
            var storageAccount = 
                CloudStorageAccount.FromConfigurationSetting("DataConnectionString");

            // initialize blob storage
            CloudBlobClient blobStorage = storageAccount.CreateCloudBlobClient();
            container = blobStorage.GetContainerReference("guestbookpics");

            // initialize queue storage 
            CloudQueueClient queueStorage = storageAccount.CreateCloudQueueClient();
            queue = queueStorage.GetQueueReference("guestthumbs");

            Trace.TraceInformation("Creating container and queue...");

            bool storageInitialized = false;
            while (!storageInitialized)
            {
                try
                {
                    // create the blob container and allow public access
                    container.CreateIfNotExist();
                    // container.CreateIfNotExist();
                    var permissions = container.GetPermissions();
                    permissions.PublicAccess = BlobContainerPublicAccessType.Container;
                    container.SetPermissions(permissions);

                    // create the message queue
                    queue.CreateIfNotExist();
                    storageInitialized = true;
                }
                catch (StorageClientException e)
                {
                    if (e.ErrorCode == StorageErrorCode.TransportError)
                    {
                        Trace.TraceError("Storage services initialization failure. "
                          + "Check your storage account configuration settings. If running locally, "
                          + "ensure that the Development Storage service is running. Message: '{0}'", e.Message);
                        System.Threading.Thread.Sleep(5000);
                    }
                    else
                    {
                        throw;
                    }
                }
            }

            return base.OnStart();
        }

        private void RoleEnvironmentChanging(object sender, RoleEnvironmentChangingEventArgs e)
        {
            if (e.Changes.Any(change => change is RoleEnvironmentConfigurationSettingChange))
                e.Cancel = true;
        }

        private Stream CreateThumbnail(Stream input)
        {
            var orig = new Bitmap(input);
            int width;
            int height;

            if (orig.Width > orig.Height)
            {
                width = 128;
                height = 128 * orig.Height / orig.Width;
            }
            else
            {
                height = 128;
                width = 128 * orig.Width / orig.Height;
            }

            var thumb = new Bitmap(width, height);

            using (Graphics graphic = Graphics.FromImage(thumb))
            {
                graphic.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
                graphic.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
                graphic.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.HighQuality;
                graphic.DrawImage(orig, 0, 0, width, height);
                var ms = new MemoryStream();
                thumb.Save(ms, System.Drawing.Imaging.ImageFormat.Jpeg);
                ms.Seek(0, SeekOrigin.Begin);
                return ms;
            }
        }
    }
}

Save and close the WorkerRole.cs file.
To configure the storage account used for worker role

In order for the worker role to use Windows Azure storage services, you must provide account settings as described next.
In Solution Explorer, expand the Role node in the GuestBook project.
Double click GuestBook_WokerRole to open the properties for this role and select Settings tab.
Click Add Settings.
In the Name column, enter DataConnectionString.
In the Type column, from the drop-down list, select ConnectionString.
In the Value column, from the drop-down list, select Use development storage.

Figure 8 Configuring Storage Account For Worker Role
Click OK.
Press Ctrl+S to save your changes.

For related topics, see the following posts.

Building Windows Azure Service Part4: Web Role UI Handler

michaelonmsdn — Thu, 30 Dec 2010 22:07:00 GMT

In this post, you will create the UI that enables the user to perform read, write operations on the GuestBookEntry table. You will update the web role project generated when you created the Windows Azure service. Specifically, you will perform the following tasks:

Add a page to the project that contains the UI to display the guest GuestBookEntry table.
Create the code that enables the user to store guest information in Table Storage and images in Blob Storage.
Finally, configure the storage account used by the web role.

Happy Holidays

To render the guest book

In Solution Explorer right-click the GuestBook_WebRole project, select Add Reference.
Add a reference to the Microsoft.WindowsAzure.StorageClient assembly.
Add a reference to the GuestBookData project.
Open the default.aspx file.
Replace the file content with the following markup.

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="GuestBook_WebRole._Default" %>

<!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 id="Head1" runat="server">
    <title>Windows Azure Guestbook</title>
    <link href="main.css" rel="stylesheet" type="text/css" />
</head>
<body>
    <form id="form1" runat="server">
    <asp:ScriptManager ID="ScriptManager1" runat="server">
    </asp:ScriptManager>
    <div class="general">
        <div class="title">
            <h1>
                Windows Azure GuestBook
            </h1>
        </div>
        <div class="inputSection">
            <dl>
                <dt>
                    <label for="NameLabel">Name:</label></dt>
                <dd>
                    <asp:TextBox 
                       ID="NameTextBox" 
                       runat="server" 
                       CssClass="field"/>
                    <asp:RequiredFieldValidator 
                      ID="NameRequiredValidator" 
                      runat="server" 
                      ControlToValidate="NameTextBox"
                      Text="*" />
                </dd>
                <dt>
                    <label for="MessageLabel">Message:</label>
                </dt>
                <dd>
                    <asp:TextBox 
                       ID="MessageTextBox" 
                       runat="server" 
                       TextMode="MultiLine" 
                       CssClass="field" />
                    <asp:RequiredFieldValidator 
                       ID="MessageRequiredValidator" 
                       runat="server" 
                       ControlToValidate="MessageTextBox"
                       Text="*" />
                </dd>
                <dt>
                    <label for="FileUpload1">Photo:</label></dt>
                <dd>
                    <asp:FileUpload 
                        ID="FileUpload1" 
                        runat="server" 
                        size="16" />
                    <asp:RequiredFieldValidator 
                        ID="PhotoRequiredValidator" 
                        runat="server" 
                        ControlToValidate="FileUpload1"
                        Text="*" />
                    <asp:RegularExpressionValidator 
                        ID="PhotoRegularExpressionValidator"
                        runat="server"
                        ControlToValidate="FileUpload1" 
                        ErrorMessage="Only .jpg or .png files are allowed"
                        ValidationExpression="([a-zA-Z\\].*(.jpg|.JPG|.png|.PNG)$)" />
                </dd>
            </dl>
            <div class="inputSignSection">
                <asp:ImageButton 
                       ID="SignButton" 
                       runat="server" 
                       AlternateText="Sign GuestBook"
                       onclick="SignButton_Click" 
                       ImageUrl="~/sign.png" 
                       ImageAlign="Bottom"  />
            </div>
        </div>
        <asp:UpdatePanel ID="UpdatePanel1" runat="server">
            <ContentTemplate>
                <asp:DataList 
                   ID="DataList1" 
                   runat="server" 
                   DataSourceID="ObjectDataSource1">
                    <ItemTemplate>
                        <div class="signature">
                            <div class="signatureImage">
                                <a href="<%# Eval("PhotoUrl") %>" target="_blank">
                                    <img src="<%# Eval("ThumbnailUrl") %>" 
                                         alt="<%# Eval("GuestName") %>" />
                                </a>
                            </div>
                            <div class="signatureDescription">
                                <div class="signatureName">
                                    <%# Eval("GuestName") %>
                                </div>
                                <div class="signatureSays">
                                    says
                                </div>
                                <div class="signatureDate">
                                    <%#((DateTime)Eval("Timestamp")).ToShortDateString() %>
                                </div>
                                <div class="signatureMessage">
                                    "<%# Eval("Message") %>"
                                </div>
                            </div>
                        </div>
                    </ItemTemplate>
                </asp:DataList>
                <asp:Timer 
                    ID="Timer1" 
                    runat="server"
                    Interval="15000"
                    OnTick="Timer1_Tick">
                </asp:Timer>
            </ContentTemplate>
        </asp:UpdatePanel>
        <asp:ObjectDataSource 
           ID="ObjectDataSource1"
           runat="server" 
           DataObjectTypeName="GuestBook_Data.GuestBookEntry"
           InsertMethod="AddGuestBookEntry"
           SelectMethod="Select" 
           TypeName="GuestBook_Data.GuestBookEntryDataSource">
        </asp:ObjectDataSource>
    </div>
    </form>
</body>

</html>

To store guest information in Table and Blob Storage

To allow the user to enter guest information and store the entry in Table Storage and the related image in the Blob Storage, you must execute the following steps.

In Solution Explorer open the default.aspx.cs file.
Replace the file content with the following code.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Net;
using GuestBook_Data;
using Microsoft.WindowsAzure;
using Microsoft.WindowsAzure.ServiceRuntime;
using Microsoft.WindowsAzure.StorageClient;
using System.Text;

namespace GuestBook_WebRole
{
    public partial class _Default : System.Web.UI.Page
    {
        private static bool storageInitialized = false;
        private static object gate = new Object();
        private static CloudBlobClient blobStorage;
        private static CloudQueueClient queueStorage;

        protected void Page_Load(object sender, EventArgs e)
        {
            if (!Page.IsPostBack)
            {
                Timer1.Enabled = true;
            }
        }

     
        protected void SignButton_Click(object sender, EventArgs e)
        {
            if (FileUpload1.HasFile)
            {
                InitializeStorage();
                
                // upload the image to blob storage
         CloudBlobContainer container = blobStorage.GetContainerReference("guestbookpics");
                string uniqueBlobName = string.Format("image_{0}.jpg",

Guid.NewGuid().ToString());
                CloudBlockBlob blob = 
container.GetBlockBlobReference(uniqueBlobName);
                blob.Properties.ContentType = FileUpload1.PostedFile.ContentType;
                blob.UploadFromStream(FileUpload1.FileContent);
                System.Diagnostics.Trace.TraceInformation(
"Uploaded image '{0}' to blob storage as '{1}'", 
FileUpload1.FileName, uniqueBlobName);

                // create a new entry in table storage
                GuestBookEntry entry = new GuestBookEntry() { GuestName = 
NameTextBox.Text, Message = MessageTextBox.Text, PhotoUrl = 
blob.Uri.ToString(), ThumbnailUrl = blob.Uri.ToString() };
                GuestBookEntryDataSource ds = new GuestBookEntryDataSource();
                ds.AddGuestBookEntry(entry);
                System.Diagnostics.Trace.TraceInformation(
"Added entry {0}-{1} in table storage for guest '{2}'", 
entry.PartitionKey, entry.RowKey, entry.GuestName);

                // queue a message to process the image
                var queue = queueStorage.GetQueueReference("guestthumbs");
                var message = new CloudQueueMessage(String.Format("{0},{1},{2}", 
uniqueBlobName, entry.PartitionKey, entry.RowKey));
                queue.AddMessage(message);
                System.Diagnostics.Trace.TraceInformation(
"Queued message to process blob '{0}'", uniqueBlobName);
            }

            NameTextBox.Text = "";
            MessageTextBox.Text = "";

            DataList1.DataBind();
        }

        protected void Timer1_Tick(object sender, EventArgs e)
        {
            DataList1.DataBind();
        }

        private void InitializeStorage()
        {
            if (storageInitialized)
            {
                return;
            }

            lock (gate)
            {
                if (storageInitialized)
                {
                    return;
                }

                try
                {
                    // Create a new instance of a CloudStorageAccount object from a specified configuration setting. 
                    // This method may be called only after the SetConfigurationSettingPublisher 
                    // method has been called to configure the global configuration setting publisher.
                    // You can call the SetConfigurationSettingPublisher method in the OnStart method
                    // of the web role or in the Application_Start method in the Global.asax.cs file.
                    // If you do not do this, the system raises an exception 
                    var storageAccount = 
                    CloudStorageAccount.FromConfigurationSetting("DataConnectionString");

                    // create blob container for images
                    blobStorage = storageAccount.CreateCloudBlobClient();
                    CloudBlobContainer container = 
                    blobStorage.GetContainerReference("guestbookpics");
                    container.CreateIfNotExist();

                    // configure container for public access
                    var permissions = container.GetPermissions();
                    permissions.PublicAccess = 
                        BlobContainerPublicAccessType.Container;
                    container.SetPermissions(permissions);

                    // create queue to communicate with worker role
                    queueStorage = storageAccount.CreateCloudQueueClient();
                    CloudQueue queue = 
                        queueStorage.GetQueueReference("guestthumbs");
                    queue.CreateIfNotExist();
                }
                catch (WebException)
                {
                
                    StringBuilder buffer = new StringBuilder();
                    buffer.Append("Storage services initialization failure.");
                    buffer.Append(" Check your storage account configuration settings.");
                    buffer.Append(" If running locally,");
                    buffer.Append(" ensure that the Development Storage service is running.");

                    throw new WebException(buffer.ToString());
                       
                }

                storageInitialized = true;
            }
        }
    }
}

To configure the storage account for the web role

In order for the web role to use the Windows Azure storage services, you must provide account settings as shown next.

In Solution Explorer, expand the Role node in the GuestBook project.
Double click GuestBook_WebRole to open the properties for this role and select Settings tab.
Click Add Settings.
In the Name column, enter DataConnectionString.
12. In the Type column from the drop-down list select ConnectionString.
13. In the Value column, from the drop-down list, select Use development storage.
14. Click OK. Then press Ctrl+S to save your changes.

Figure 6 Configuring Storage Account For Web Role

A storage account is a unique end- point for Windows Azure blob, queue and table services. You must create a storage account to use these services. For more information, see Windows Azure Platform.

This walkthrough uses the development storage included in the Windows Azure SDK development environment to simulate blob, queue, and table services available in the cloud. Windows Azure by default uses SQL Server Express to simulate these services. You can also use a local instance of the SQL Server. To do so you must define the connection string that the development storage can use to connect to the server. For more information, see Using Windows Azure Development Environment Essentials.

To use the development storage, you set the value of the UseDevelopmentStorage keyword in the connection string for the storage account to true. When you deploy your application to Windows Azure, you need to update the connection string to specify storage account settings including your account name and shared key. For example,
<Setting name="DataConnectionString" value="DefaultEndpointsProtocol=https;AccountName=YourAccountName;AccountKey=YourAccountKey" />

For related topics, see the following posts.

Building Windows Azure Service Part3: Table Storage

michaelonmsdn — Sun, 26 Dec 2010 22:21:00 GMT

This post shows how to create a project that contains the classes to store guest entries in Windows Azure Table Storage.

The Table Storage service offers semi-structured storage in the form of tables that contain collections of entities. Entities have a primary key and a set of properties, where a property is a (name, typed-value) pair. The Table Storage service primary key has the following two properties:

PartitionKey and RowKey keys that uniquely identify each entity in the table.
Every entity in the Table Storage service also has a Timestamp system property, which allows the service to keep track of when an entity was last modified. This Timestamp field is intended for system use and should not be accessed by the application.

The Table Storage API provides a TableServiceEntity class that defines the necessary properties, which you can use as the base class for your entities. This API is compliant with the REST API provided by Data Services and allows you to use the.NET Client Library for Data Services to work with data in the Table service using .NET objects.

Although the Table Storage does not enforce any schema for tables, which makes it possible for two entities in the same table to have different sets of properties, the GuestBook application uses a fixed schema to store its data.

In order to use the.NET Client Library for Data Services to access the data in Table Storage, you need to create a context class that derives from TableServiceContext, which itself derives from DataServiceContext in .NET Client Library for Data Services .

The Table Storage API allows applications to create the tables from the context class. For this to happen, the context class must expose each required table as a property of type IQueryable<SchemaClass>, where SchemaClass is the class that models the entities stored in the table.

In this post, you will perform the following tasks:

Create the data model project to contain the classes to store guest entries.
Create a schema class for the entities stored by the GuestBook application.
Create a context class to use .NET Client Library for Data Services to access the data in Table Storage.
Create a data source class that enables the creation of a data source object. The data source object can be bound to ASP.NET data controls which enable the user to access the Table Storage data.

To create the data model project

In Solution Explorer dialog right-click the GuestBook solution and select New Project.
In the Add New Project dialog window, choose the Windows category.
Select Class Library in the templates list.
In the Name box enter the GuestBook_Data.
Click OK.

Figure 5 Creating the Data Model Project
In Solution Explorer right-click the GuestBook_Data project.
Select Add Reference.
In the Add Reference window dialog select .NET tab.
Add reference to System.Data.Services.Client.
Repeat the previous steps to add a reference to Microsoft.WindowsAzure.StorageClient.
Delete the default Class1.cs generated by the template.

To create the schema class

This section shows how to create the class that defines the schema for the GuestBook table entries. Its parent class Microsoft.WindowsAzure.StorageClient.TableServiceEntity defines the properties required by every entity stored in a Windows Azure table.

Right-click the GuestBookData project, click Add New item.
In the Add New Item dialog window, select the Code category.
In the templates list select Class.
In the Name box enter GuestBookEntry.cs.
Click Add.
Open the GuestBookEntry.cs file and replace its content with the following code.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.WindowsAzure.StorageClient;

namespace GuestBook_Data
{
    /// <summary>
    /// The GuestBookEntry class defines the schema for each entry (row) 
    /// of the guest book table that stores guest information.
    /// <remarks>
    /// The parent class TableServiceEntity defines the properties required 
    /// by every entity that uses the Windows Azure Table Services. These      
    /// properties include PartitionKey and RowKey.
    /// </remarks>
    /// </summary>
    public class GuestBookEntry :
        Microsoft.WindowsAzure.StorageClient.TableServiceEntity
    {
        /// <summary>
        /// Create a new instance of the GuestBookEntry class and 
        /// initialize the requires keys.
        /// </summary>
        public GuestBookEntry()
        {
            // The partition key allows partitioning the data so that
            // there is a separate partition for each day of guest 
            // book entries. The partition key is used to assure 
            // load balancing for data access across fabric nodes (servers).
            PartitionKey = DateTime.UtcNow.ToString("MMddyyyy");

            // Row key allows sorting, this assures the rows are 
            // returned in time order.
            RowKey = string.Format("{0:10}_{1}",
                DateTime.MaxValue.Ticks - DateTime.Now.Ticks, Guid.NewGuid());
        }

        // Define the properties that contain guest information.
        public string Message { get; set; }
        public string GuestName { get; set; }
        public string PhotoUrl { get; set; }
        public string ThumbnailUrl { get; set; }
    }
}

To create the context class

This section shows how to create the context class that enables Windows Azure Table Storage services. Its parent class Microsoft.WindowsAzure.StorageClient.TableserviceContext manages the credentials required to access your account and provides support for a retry policy for update operations.

Right-click the GuestBookData project, click Add New item.
In the Add New Item dialog window, select the Code category.
In the templates list select Class.
In the Name box enter GuestBookDataContext.cs.
Click Add.
Open the GuestBookDataContext.cs file and replace its content with the following code.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.WindowsAzure;
using Microsoft.WindowsAzure.StorageClient;

namespace GuestBook_Data
{
    /// <summary>
    /// The GuestBookDataContext class enables Windows 
    /// Azure Table Services.
    /// <remarks>
    /// The parent class TableserviceContext manages the credentials 
    /// required to access account information and provides support for a 
    /// retry policy for update operations.
    /// </remarks> 
    /// </summary>
    public class GuestBookDataContext : TableServiceContext
    {
        /// <summary>
        /// Create an instance of the GuestBookDataContext class 
        /// and initialize the base
        /// class with storage access information.
        /// </summary>
        /// <param name="baseAddress"></param>
        /// <param name="credentials"></param>
        public GuestBookDataContext(string baseAddress,
            StorageCredentials credentials)
            : base(baseAddress, credentials)
        { }

        /// <summary>
        /// Define the property that returns the GuestBookEntry table.
        /// </summary>
        public IQueryable<GuestBookEntry> GuestBookEntry
        {
            get
            {
                return this.CreateQuery<GuestBookEntry>("GuestBookEntry");
            }
        }
    }
}

To create the data source class

This section shows how to create the data source class that allows for the creation of data source objects that can be bound to ASP.NET data controls and allow for the user to interact with the Table Storage.

Right-click the GuestBookData project, click Add New item.
In the Add New Item dialog window, select the Code category.
In the templates list select Class.
In the Name box enter GuestBookDataSource.cs.
Click Add.
Open the GuestBookDataSource.cs file and replace its content with the following code.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.WindowsAzure;
using Microsoft.WindowsAzure.StorageClient;

namespace GuestBook_Data
{
    /// <summary>
    /// The GuestBookEntryDataSource class allows for the creation of data 
    /// source objects that can be bound to ASP.NET data controls. These 
    /// controls enable the user to perform Create, Read, Update and Delete 
    /// (CRUD) operations. 
    /// </summary>
    public class GuestBookEntryDataSource
    {
        // Storage services account information.
        private static CloudStorageAccount storageAccount;

        // Context that allows the use of Windows Azure Table Services.
        private GuestBookDataContext context;

        /// <summary>
        /// Initializes storage account information and creates a table 
        /// using the defined context.
        /// <remarks>
        /// This constructor creates a table using the schema (model) 
        /// defined by the
        /// GuestBookDataContext class and the storage account information 
        /// contained in the configuration connection string settings.
        /// Declaring the constructor static assures that the initialization 
        /// tasks are performed only once.
        /// </remarks>
        /// </summary>
        static GuestBookEntryDataSource()
        {
            // Create a new instance of a CloudStorageAccount object from a specified configuration setting. 
            // This method may be called only after the SetConfigurationSettingPublisher 
            // method has been called to configure the global configuration setting publisher.
            // You can call the SetConfigurationSettingPublisher method in the OnStart method
            // of the web or worker role before calling FromConfigurationSetting.
            // If you do not do this, the system raises an exception.
            storageAccount = 
                CloudStorageAccount.FromConfigurationSetting("DataConnectionString");

            // Create table using the schema (model) defined by the
            // GuestBookDataContext class and the storage account information. 
            CloudTableClient.CreateTablesFromModel(
                typeof(GuestBookDataContext),
                storageAccount.TableEndpoint.AbsoluteUri,
                storageAccount.Credentials);
        }

        /// <summary>
        /// Initialize context used to access table storage and the retry policy.
        /// </summary>
        public GuestBookEntryDataSource()
        {
            // Initialize context using account information.
            this.context =
                new GuestBookDataContext(storageAccount.TableEndpoint.AbsoluteUri,
            storageAccount.Credentials);
            // Initialize retry update policy.
            this.context.RetryPolicy = RetryPolicies.Retry(3,
            TimeSpan.FromSeconds(1));
        }

        /// <summary>
        /// Gets the contents of the GuestBookentry table.
        /// </summary>
        /// <returns>
        /// results: the GuestBookEntry table contents.
        /// </returns>
        /// <remarks>
        /// This method retrieves today guest book entries by using the current
        /// date as the partition key. The web role uses this method to 
        /// bind the results to a data grid to display the guest book.
        /// </remarks>
        public IEnumerable<GuestBookEntry> Select()
        {
            var results = from g in this.context.GuestBookEntry
                          where g.PartitionKey ==
                DateTime.UtcNow.ToString("MMddyyyy")
                          select g;
            return results;
        }

        /// <summary>
        /// Insert new entries in the GuestBookEntry table.
        /// </summary>
        /// <param name="newItem"></param>
        public void AddGuestBookEntry(GuestBookEntry newItem)
        {

            this.context.AddObject("GuestBookEntry", newItem);
            this.context.SaveChanges();
        }

        /// <summary>
        /// Update the thumbnail URL for a table entry.
        /// </summary>
        /// <param name="partitionKey"></param>
        /// <param name="rowKey"></param>
        /// <param name="thumbUrl"></param>
        public void UpdateImageThumbnail(string partitionKey,
            string rowKey, string thumbUrl)
        {
            var results = from g in this.context.GuestBookEntry
                          where g.PartitionKey == partitionKey && g.RowKey ==
                rowKey
                          select g;

            var entry = results.FirstOrDefault<GuestBookEntry>();
            entry.ThumbnailUrl = thumbUrl;
            this.context.UpdateObject(entry);
            this.context.SaveChanges();
        }
    }
}

For related topics, see the following posts.

Building Windows Azure Service Part2: Service Project

michaelonmsdn — Mon, 20 Dec 2010 01:50:00 GMT

In this post, you will create a Windows Azure service project using Microsoft Visual Studio 2010.

To create the Windows Azure service project

From the start menu, select All Programs and right-click Microsoft Visual Studio 2010.
Choose Run as Administrator.If the User Account Control dialog appears, click Continue.
From the File menu, click New Project.
In the New Project dialog window expand the language of your choice (in this walkthrough, we are using C#) and then select Cloud.
In the templates list, select Windows Azure Cloud Service.
In the Name box, enter GuestBook.
In the Location box, enter the location where to store the project.
Click OK to create the project.

Figure 2 Creating Windows Azure Service Project
In the New Cloud Service Project dialog window, in the .NET Framework Roles panel select ASP.NET Web Role.
Click the right arrow to add an instance of the selected role to the solution.
The role shows in the Cloud Service Solution right panel.
Click the pencil icon.
Rename the role GuestBook_WebRole.
Click OK to create the cloud service solution.

Figure 3 Assigning Roles to the Service Project
In Solution Explorer review the project structure.

Figure 4 GuestBook Service Project Structure

As shown in the previous illustration, the solution contains two separate projects.

GuestBook project. It contains the following files and folder:

ServiceDefinition.csdef. This is the application definition file that specifies the application requirements for the Windows Azure fabric such as which roles are used, their trust level, the end points exposed by each role, the local storage requirements and the certificates used by the roles. It also defines specific application settings. The following code shows the content of the definition file.

<?xml version="1.0" encoding="utf-8"?>
<ServiceDefinition name="GuestBook" xmlns="http://schemas.microsoft.com/ServiceHosting/2008/10/ServiceDefinition">
  <WebRole name="GuestBook_WebRole">
    <InputEndpoints>
      <InputEndpoint name="HttpIn" protocol="http" port="80" />
    </InputEndpoints>
    <ConfigurationSettings>
      <Setting name="DiagnosticsConnectionString" />
      <Setting name="DataConnectionString" />
    </ConfigurationSettings>
  </WebRole>
  <WorkerRole name="GuestBook_WorkerRole">
    <ConfigurationSettings>
      <Setting name="DiagnosticsConnectionString" />
      <Setting name="DataConnectionString" />
    </ConfigurationSettings>
  </WorkerRole>
</ServiceDefinition>

ServicesConfiguration.cscfg. This is the configuration file that specifies the number of instances for each role and assigns the values for the configuration settings as defined in the ServiceDefinition.csdef file. The following code shows the content of the configuration file.

<?xml version="1.0"?>
<ServiceConfiguration serviceName="GuestBook" xmlns="http://schemas.microsoft.com/ServiceHosting/2008/10/ServiceConfiguration">
  <Role name="GuestBook_WebRole">
    <Instances count="1" />
    <ConfigurationSettings>
      <Setting name="DiagnosticsConnectionString" value="UseDevelopmentStorage=true" />
      <Setting name="DataConnectionString" value="UseDevelopmentStorage=true" />
    </ConfigurationSettings>
  </Role>
  <Role name="GuestBook_WorkerRole">
    <Instances count="1" />
    <ConfigurationSettings>
      <Setting name="DiagnosticsConnectionString" value="UseDevelopmentStorage=true" />
      <Setting name="DataConnectionString" value="UseDevelopmentStorage=true" />
    </ConfigurationSettings>
  </Role>
</ServiceConfiguration>

The separation between service definition and configuration enables you to update the settings of a deployed application by just uploading a new service configuration file.

Roles node. It enables you to configure what roles the cloud service includes that are web, worker or both. It also enables you to specify which project to associate with these roles.

Adding and configuring roles in the Roles node will update the definition and configuration files.

GuestBook_WebRole project. This is a standard ASP.NET web application modified for the Windows Azure environment. It contains an additional class that provides the entry point for the web role and contains methods for initializing, starting and stopping the role.

For related topics, see the following posts.

Building Windows Azure Service Part1: Introduction

michaelonmsdn — Mon, 20 Dec 2010 01:28:00 GMT

This is the first of several posts of a walkthrough whose goal is to build a cloud guest book service while exploring Windows Azure basic elements .

I wrote these posts to share my experience in learning Microsoft implementation of cloud computing. If you are new to the technology, my posts can help you to explore and learn about it.

The walkthrough demonstrates the use of Windows Azure Compute and Storage services, specifically:

Compute service: web and worker roles.
Storage service: blob, table and queues.

The information presented here has been adapted from a related article published on the Channel 9 site. For more information, see Introduction to Windows Azure.

In this walkthrough you will learn how to::

Create a Windows Azure service using web and worker roles.
Use Windows Azure storage services which include blobs, tables and queues.
Deploy the Windows Azure service.

A Windows Azure compute service consists of one or more web roles and worker roles.

A web role is an ASP.NET Web application accessible via an HTTP or HTTPS endpoint and is commonly the front-end for an application.
A worker role is a background-processing application and is typically found in the back-end.

A Windows Azure compute service may be comprised of one or both types of roles and can run multiple instances of each type. Windows Azure can add or remove role instances on demand allowing an application to quickly and economically scale-up or down when the need arises. For more information, see Windows Azure Compute Service.

Windows Azure storage services provide storage in the cloud, which includes blob services for storing text and binary data, table services for structured storage that can be queried, and queue services for reliable and persistent messaging between services. For more information, see Windows Azure Storage Services.

The following illustration shows the architecture of the Windows Service, called GuestBook, that you are going to build during this exercise .

Figure 1 GuestBook Application Architecture

A web role provides the front-end that enables the user to view the contents of the guest book and submit new entries. Each entry contains a name, a message, and an associated picture.
A worker role that generates thumbnails for the pictures submitted by the user.
When the user posts a new item, the web role uploads the picture to the blob storage and creates a new entry in the table storage. The entry contains the information entered by the user and a link to the blob with the picture. The web role renders this information through the browser so users can view the contents of the guest book.
After storing the image and creating the entry, the web role posts a work item to a queue to have the image processed in the back-end by the worker role.
The worker role fetches the work item from the queue, retrieves the image from the blob storage, and resizes it to create a thumbnail.

What we have described is a common pattern in cloud computing which enables the separation of compute-bound tasks from the front-end ones by using queues. The advantage of this approach is that front and back end can be scaled independently.

Prerequisites

The Windows Azure Tools for Microsoft Visual Studio are available on the Windows Azure Tools for Microsoft Visual Studio download page. The Windows Azure SDK is included with the installation, so there is no need to install the SDK separately.
You can also install the Windows Azure Tools using the Microsoft Web Platform Installer. The Web Platform Installer simplifies the process of installing and configuring IIS, the Windows Azure SDK, and the Windows Azure Tools.
The Windows Azure Tools can be used with these Microsoft products:
- Visual Studio 2010
- Visual Web Developer 2010 Express Edition
- Visual Studio 2008 with Service Pack 1
- Visual Web Developer 2008 Express Edition with Service Pack 1

For more information, see Windows Azure Tools for Microsoft Visual Studio.

For related topics, see the following posts.

Using Windows Azure Development Environment Essentials

michaelonmsdn — Wed, 01 Dec 2010 02:32:00 GMT

The Windows Azure development is a simulation environment which enables you to run and debug your applications (services) before deploying them. The development environment provides the following utilities:

The development fabric utility. The development fabric is a simulation environment for running your application (service) locally, for testing and debugging it before deploying it to the cloud. The fabric handles the lifecycle of your role instances, as well as providing access to simulated resources such as local storage resources.
The development storage utility. It simulates the Blob, Queue, and Table services available in the cloud. If you are building a hosted service that employs storage services or writing any external application that calls storage services, you can test locally against development storage.
The Windows Azure SDK also provides a set of utilities for packaging your service for either the development environment or for Windows Azure, and for running your service in the development fabric

For more information see Using the Windows Azure Development Environment.

Development Fabric

Before using the Windows Azure development environment, you must assure that it is activated. Usually this happens when you start debugging your application in Visual studio. You can verify the activation by checking that the related icon exists in the system tray as shown in the following illustration.

Figure 1 Windows Azure Development Environment Icon

Note. Using the CSRun command-line tool starts the development fabric if it is not yet running. You must run this tool as an administrator. For more information see CSRun Command-Line Tool.

You can right-click this icon to display the user interfaces for the development fabric and development storage and to start or shut down these services.

1. Right-click the icon and in the pop-up dialog click Show Development Fabric UI. A development fabric UI window is activated similar to the one shown in the following illustration. The development fabric UI shows your service deployments in an interactive format. You can examine the configuration of a service, its roles, and its role instances. From the UI, you can run, suspend, or restart a service. In this way, you can verify the basic functionality of your service.

Figure 2 Development Fabric UI

2. Right-click the icon and in the pop-up dialog click Show Development Storage UI. A development storage UI window is activated similar to the one shown in the following illustration. You can use the development storage UI to start or stop any of the services, or to reset them. Resetting a service stops the service, cleans all data for that service from the SQL database (including removing any existing blobs, queues, or tables), and restarts the service.

Figure 3 Development Storage UI

Development Storage

The development storage relies on a Microsoft SQL Server instance to simulate the storage servers. By default, the development storage is configured for Microsoft SQL Server Express versions 2005 or 2008. Also development storage uses Windows authentication to connect to the server.

Using the CSRun command-line tool automatically starts development storage. You can also use this command to stop development storage. The first time you run development storage, an initialization process runs to configure the environment. The initialization process creates a database in SQL Server Express and reserves HTTP ports for each local storage service.

Configuring Microsoft SQL Server

You can also configure the development storage to access a local instance of SQL Server different from the default SQL Server Express. You can do that by running the DSInit.exe command-line tool as shown next. Remember you must run this tool as an administrator. For more information see DSInit Tool.

1. In the Windows Azure SDK command prompt execute the following command as shown in the next illustration:

>dsinit /sqlinstance:.

Figure 4 Initializing Development Environment Storage

2. A dialog prompt is displayed similar to the one shown in the next illustration.

Figure 5 Confirming Development Environment Storage Initialization

The initialization process creates a database named DevelopmentStorageDb20090919 in your current SQL Server default instance and reserves HTTP ports for each local storage service.

3. Click OK.

You can view the created database by using Microsoft SQL Server Management Studio as shown in the following illustration. The tool can be downloaded from this location: Microsoft SQL Server 2008 Management Studio Express.

Figure 6 Displaying Development Environment Storage Database

Connecting to Microsoft SQL Server

This section shows you how to connect to your own Microsoft SQL server instance. To do that you need to configure the connection string that development storage can use. The following steps show how to do this.

The first thing you want to do is to obtain the actual connection string to use.

1. Activate Visual Studio as an administrator then select Server Explorer.

2. Right-click Data Connections and then select click Add Connection… as shown in the following illustration.

Figure 7 Creating Development Environment Storage Database Server Connection

3. In the displayed dialog window, in the Server name box enter the name of your SQL server (by default, it is the name of your machine).

4. In the Log on to the server, leave Use Windows Authentication selected. This is the authentication modality used by development storage.

5. In the Connect to a database check Select or enter a database name.

6. In the drop-down list select the development storage database DevelopmentStorageDb20090919. The following illustration is an example of these steps.

Figure 8 Specifying Development Environment Storage Database

7. Click Test Connection. If everything is correct, a successful pop-up dialog is displayed. Click OK.

8. Finally, Click OK in the main dialog window.

A new database connection, similar to the one shown in the following illustration, is created and displayed in Server Explorer.

Figure 9 Development Storage Database Connection

9. Right-click the data connection just created and in the pop-up dialog select Properties.

10. In the Properties window copy the Connection String property value that is similar to this:

Data Source=mmieleLAPTOP;Initial Catalog=DevelopmentStorageDb20090919;Integrated Security=True

Among other things, the string defines the name of the SQL server instance and the development storage database.

Now you need to instruct development storage to use this connection string to connect to the database. You do this by following the next steps.

11. In Visual Studio open the file C:\Program Files\Windows Azure SDK\v1.2\bin\devstore\dsservice.exe.config. Remember that you must activate Visual Studio as an administrator.

12. In the <configuration> element create a <connectionStrings> section.

13. In the section just created enter an <add> element.

14. To the name attribute assign the value DevelopmentStorageDbConnectionString.

15. To the connectionString attribute assign the connection string evaluated in the previous steps.

The following is an example of these connection string settings.

<connectionStrings>
    <add name="DevelopmentStorageDbConnectionString"
         connectionString="Data Source=mmielelaptop;Initial Catalog=DevelopmentStorageDb20090919;Integrated Security=True"
         providerName="System.Data.SqlClient" />
  </connectionStrings>

Notice that development storage expects the name attribute to be DevelopmentStorageDbConnectionString.

16. Save and close the file.

You have configured development storage to use your own instance of the SQL server instead of the default SQL Express server.

Getting Started With Silverlight

michaelonmsdn — Tue, 26 Oct 2010 14:40:00 GMT

Silverlight is a .NET Framework development platform for creating rich interactive applications (RIA) for web, desktop, and mobile platforms when online or offline. Silverlight also provides a free plug-in compatible with multiple browsers, devices and operating systems and supporting a new level of interactivity for applications.

For more information see:

Getting Started with Silverlight. Tools and background information to start learning and building Silverlight applications.
Silverlight. Conceptual and API documentation and many examples to help you understand and build your applications.

Silverlight Architecture

This topic describes Silverlight architecture and its components which create a powerful, lightweight platform for developing portable, cross-platform, networked applications that integrate data and services from many sources. Silverlight enables you to separate design and implementation concerns through a Model-View-ViewModel (MVVM) pattern. More specifically, you can separate your application view that is the User Interface (UI), from the business and data (back-end) logic. This model is supported by a set of tools specifically designed and integrated to support the life cycle of your application. For example:

To build a compelling and highly interactive UI, a web designer can use Expression Studio which includes four design and development tools for building rich desktop and Silverlight applications for standards based web sites and streaming video.
To build the business and data logic (back end), a developer can use Visual Studio 2010 or Visual Web Developer 2010 Express.

As we will describe later, the tools to build the UI and the tools to build the back-end logic work together in a seamless fashion.

While Silverlight offers a client-side runtime environment (browser plug-in) simple and compact in size, its development platform integrates a number of features and complex technologies. If you want to create effective Silverlight-based applications, you need a working knowledge of this platform architecture that is shown in the following illustration.

Fig.1 Silverlight Architecture

Presentation Core

This layer contains the following core components to allow for the creation of powerful, interactive user interface:

UI Core. It renders vector and bitmap graphics, animation and text.
Inputs. It handles inputs form devices such as keyboard, mouse and so on.
Media. It manages various audio and video files such as .WMP and .MP3 files.
DRM. It enables the management of media asset digital rights.
XAML. The eXtensible Application Markup Language is a language for declarative application programming. Silverlight uses a subset of the Windows Presentation Foundation (WPF) types that are implemented so that they can provide the required type backing for a XAML representation.

.NET Framework for Silverlight

This layer contains components that allow for the creation of the business and data elements or the back-end of your application.

Data. It supports Language Integrated Query (LINQ) and LINQ to XML features which make easier to work with different data sources. It also supports the use of XML and class serialization for data handling.
Windows Presentation Foundation (WPF). Silverlight WPF API extends the browser UI elements. This enables you to create graphics, animation, media and other rich client features. XAML is the declarative language to create these UI elements. WPF provides a parser implementation and language support for them. You can create the majority of your application UI in Extensible Application Markup Language (XAML) markup. That is why the previous illustration shows XAML extending over both presentation and .NET Framework layers.
Windows Communication Foundation (WCF). It provides features to simplify access to remote services and data that include: browser object, HTTP request and response object, cross-domain HTTP requests, RSS/Atom syndication feeds, support for JSON, POX and SOAP services.
Base Class Library (BCL). This is a set of .NET Framework libraries which provide essential programming support such as string handling, regular expressions, I/O, reflection, collections and globalization.
Dynamic Language Runtime (DLR). It supports the dynamic compilation and execution of scripting languages such as JavaScript and IronPython for Silverlight applications. It supports a pluggable model to allow for the addition of other languages.

Related Technologies

The following technologies augment Silverlight application capabilities.

JavaScript. Silverlight provides extensions to JavaScript to allow for controlling the browser UI and for scripting against WPF elements.
o Silverlight applications run on the client machine and do not require support on the server. However, when you create your own application you may find it useful to integrate server capabilities such as:
ASP.NET AJAX services. You can access most services that are used by AJAX from Silverlight applications. You do not have to change any code on the server, although you may have to change some configuration for the service on the server. These services are of two types:
WCF AJAX services: These are services based on the WCF technology. They are usually identified by the presence of a characteristic ".svc" extension in their URL. These services are usually created using the AJAX-enabled WCF Service item template in Visual Studio 2010.
ASP.NET AJAX services. These are services based on the ASP.NET Web Services technology. They are usually identified by the presence of a characteristic ".asmx" extension in their URL and by the use of the System.Web.Script.Services.ScriptServiceAttribute and System.Web.Script.Services.ScriptMethodAttribute attributes.
WCF RIA services. WCF RIA services bring together the ASP.NET and Silverlight platforms. RIA services provide a pattern to write application logic that runs on the mid-tier to control access to data for queries, changes and custom operations. It also provides support for common tasks such as data validation, authentication and roles by integrating with Silverlight components on the client and ASP.NET on the mid-tier.

For more information about how Silverlight access ASP.NET AJAX services, see Accessing ASP.NET AJAX Services.

Getting Started With Windows Azure

michaelonmsdn — Sun, 17 Oct 2010 18:05:00 GMT

Cloud Computing

Windows Azure Platform is Microsoft implementation of cloud computing. The National Institute of Standards and Technology defines cloud computing as follows:

Cloud computing is a model for enabling convenient on-demand network access to a shared pool of configurable computing resources (e.g., networks, servers, storage, applications and services) that can be rapidly provisioned and released with minimal management effort or service provider interaction. This cloud model promotes availability and is composed of five essential characteristics, three service models and four deployment models.

For more information see NIST Cloud Computing.

Fig. 1 Accessing Cloud Computing Resources

Cloud Characteristics

On demand-self-service is one of the cloud characteristics. It enables a consumer to provision computing resources as needed automatically, without intervention on the part of the cloud solution provider. From now on we will use the term cloud to mean cloud computing.

Also a broad network access allows for computing resources to be available through standard mechanisms such as HTTP and SOAP protocols. This is to enable access by a variety of clients such as laptops, mobile phones and other devices.

Another important characteristic is resource pooling. The cloud resources are pooled to serve multiple consumers using a multi-tenant model where resources are assigned based on consumer demand.

Cloud Service Models

The software as a service (SaaS) enables the consumer to use the provider applications that run in the cloud. The applications are accessible from various client devices through a thin interface such as a web browser. An example is a web-based e-mail application.

The consumer has the ability to deploy her own applications in the cloud as supported by the platform as a service (PaaS) model. These applications are created using programming languages and tools supported by the provider.

Finally, the infrastructure as a service (IaaS) enables the consumer to provision processing, storage, networks and other computing resources to deploy and run applications. The consumer cannot control the underlying physical infrastructure, though.

Fig.2 Service Models

Deployment Models

In the private cloud model the cloud is dedicated solely to an organization. It could be managed by the organization or a third party and may be located on premise or outside.

A community cloud model enables several organizations to share a cloud that supports a specific community with shared needs such as security requirements, policy and compliance considerations.

In the public cloud model the cloud is made available to the general public or a to a large industry group.

Cloud Ecosystem

The following community categories are involved in the cloud computing ecosystem:

Cloud Providers. They provide the hosting platform and cloud infrastructure services.
Cloud Consumers. They utilize the cloud platform and create applications and services for the users.
Cloud Users. They use the applications and services provided by the cloud consumers.

Fig. 3 Cloud Computing Ecosystem

Cloud Architecture

The cloud architecture is structured in layers. Each layer abstracts the one below it and exposes interfaces that layers above can build upon. The layers are loosely coupled and provide horizontal scalability (they can expand) if needed.

Fig. 4 Cloud Architecture

As shown in the previous illustration, the cloud architecture contains several subsystems that are described next.

Hosting Platform. This platform provides the physical, virtual and software components. These components include servers, operating system, network, storage devices and power control and virtualization software. All these resources are abstracted as virtual resources to the layer above.
Cloud Infrastructure Services. The important function of this layer is to abstract the hosting platform as a set of virtual resources and to manage them based on scalability and availability. The layer provides three types of abstract resources: compute, storage and network. It also exposes a set of APIs to access and manage these resources. This enables a user to gain access to the physical resources without knowing the details of the underlying hardware and software and to control these systems through configuration. Services provided by this layer are known as Infrastructure as a Service (IaaS).
Cloud Platform Services. This layer provides a set of services to help integrating on-premise software with services hosted in the cloud. For example in Windows Azure, Microsoft .NET Service Bus helps with discovery and access. Services provided by this layer are known as Platform as a Service (PaaS).
Cloud Applications. This layer contains applications built for cloud computing. They expose web interfaces and services and enable multitenant hosting. Services provided by this layer are known as Software as a Service (SaaS).

Windows Azure Platform

Windows Azure platform is the Microsoft implementation of cloud computing. The core of this platform is the Windows Azure operating system. The following illustration maps the Windows Azure platform to the cloud computing layers.

Fig. 5 Windows Azure Platform Architecture

From now on we will use the name Windows Azure to indicate the entire platform unless we want to specifically refer to the operating system. Windows Azure provides resources and services for consumers. For example, hardware is abstracted and exposed as compute resources. Physical storage is abstracted as storage resources and exposed through very well defined interfaces. A common Windows Fabric abstracts the hardware and the software and exposes virtual compute and storage resources. Each instance of an application is automatically managed and monitored for availability and scalability. If an application goes down, the Fabric is notified and a new instance of the application is created. Because virtualization is a key element in cloud computing, no assumption must be made on the state of the underlying hardware hosting the application. As matter of a fact Windows Azure follows a computing model where the Fabric controller maps service declarative specifications to available resources.

Technical Notes

Building Windows Azure Service Part7: Service Testing

Building Windows Azure Service Part6: Service Configuration

Handling Configuration Changes with Service Runtime Events

Changing Event

Configuration Related Exception

Building Windows Azure Service Part5: Worker Role Background Tasks Handler

To create the worker role

To configure the storage account used for worker role

Building Windows Azure Service Part4: Web Role UI Handler

To render the guest book

To store guest information in Table and Blob Storage

To configure the storage account for the web role

Building Windows Azure Service Part3: Table Storage

To create the data model project

To create the schema class

To create the context class

To create the data source class

Building Windows Azure Service Part2: Service Project

To create the Windows Azure service project

Building Windows Azure Service Part1: Introduction

Prerequisites

Using Windows Azure Development Environment Essentials

Development Fabric

Development Storage

Configuring Microsoft SQL Server

Connecting to Microsoft SQL Server

Getting Started With Silverlight

Silverlight Architecture

Presentation Core

.NET Framework for Silverlight

Related Technologies

Getting Started With Windows Azure

Cloud Computing

Cloud Characteristics

Cloud Service Models

Deployment Models

Cloud Ecosystem

Cloud Architecture

Windows Azure Platform