Part of the Developer Movement .NET Camp

Channel9 Page

Contents

• Introduction
• Azure Ecosystem
• Cloud Services Overview
• Why a Cloud Service?
• What is a Cloud Service? Web and Worker Roles
• What can it run? Languages and Frameworks
• Web Roles
• Worker Roles
• Role Lifecycle
• Roles and Instances
• Fault Domains
• Upgrade Domains
• Hello World Demo
• Packaging and Configuration
• Deployment
• Application Upgrade Strategies
• Service Management Demo
• Cloud Development Lifecycle
• Team Foundation Service integration
• TFS Online and Azure Demo
• Diagnostics Demo
• Closing

Part of the Developer Movement Web Camp

Channel9 Page

Contents

• Comparing Azure Virtual Machines, Cloud Services, and Websites
• Websites – start simple, code smart, go live
• Hello World Demo
• Modern Apps Demo – deploying from git and using the cross-platform command line interface
• Diagnostics and Scale Demo
• Shared Instances
• Reserved Instances
• Website Gallery and WordPress Demo
• Supported Frameworks – ASP, .NET, PHP, and Node.js
• Publishing Methods – FTP, TFS, WebDeploy, and git
• Partners
• Recap
• Closing

What we were trying to do

We created a custom activity which needed to send messages to possibly many other Workflow services (or Extensions). We thought that registering the services as workflow tracking participants would allow for this.

To send a message to the tracking participant we created a custom tracking record object.

using System.Activities.Tracking;

public class MyTrackingRecord : CustomTrackingRecord
{
    public MyTrackingRecord()
        : base("MyTrackingRecord")
    {
    }

    public string ExtraData { get; set; }
}

And a tracking participant

using System;
using System.Activities.Tracking;

public class MyTrackingParticipant : TrackingParticipant
{
    protected override void Track(TrackingRecord record, TimeSpan timeout)
    {
        var myRecord = record as MyTrackingRecord;

        if (myRecord != null)
        {
            //do something
        }
    }
}

This does not work

It seems like a simple solution but the record as MyTrackingRecord always returns null. In fact the only type that the record can be sucessfully cast to is a CustomTrackingRecord.

After decompiling the CustomTrackingRecord I noticed that class implements the Clone() method and returns a new record. My guess is that the tracking system clones all the record objects before sending them to each participant. I don’t know that for sure but it seems reasonable that one participant would not be able to change the object in memory and affect the operation of another participant.

The Solution

After adding a Clone() method the problem was resolved.

protected override TrackingRecord Clone()
{
    return new MyTrackingRecord { ExtraData = ExtraData };
}

There, now I was able to cast to a MyTrackingRecord type and my code executed properly. In the future I would just use the CustomTrackingRecord object which has a Name property to identify the record type and a key-value dictionary for added data. The reason we chose to go with a typed object was to reduce the use of “magic strings” that define functionality in the solution.

So by no means is this the only custom tracking solution it was just the path we were heading down.

I hope this helps you out of a jam and as always thanks for reading.

One of the apps that Kyle wrote is called the Animal Sounds Game. Its interface consists of buttons with pictures of animals and when you press the button it plays the sound. Simple I know, but it was a great Windows Store launching point for us.

I asked Kyle to write down some steps to create an app like this and any tips that he would like to share.

The following is written by Kyle Funk, a fellow Software Developer at Imaginet

Animal Sound Board – Windows Store C# app development and using the MediaElement control Asynchronously

- To start off, create a new Windows Store Blank App. As common practice, it’s good idea to replace the current MainPage with a new “BasicPage”. Delete the MainPage currently in your project. Once it’s deleted, set up a new BasicPage with the name “MainPage’. You will receive a Dialog Box to alter/add files that you need to accept. The Basic page acts as a good template to start your project. Including Preconfigured binding and a header inside of a grid ready for you to start adding controls. Microsoft also recommends these steps in their Store App tutorials.

The UI for this application is very basic. Just a few buttons with Images in the content of the button. You can create it yourself in Visual Studio or use Expression Blend to assist in the design and photo resources.

I decided to use the MediaElement for our audio files. To see supported formats, click here – http://msdn.microsoft.com/en-us/library/cc189080(v=vs.95).aspx

- Once you find the Images and Audio you want to use, save them in your Assets folder.

Now let’s configure the URI’s in the fields we set up for each audio file. Make sure to prefix this protocol “ms-appx:///” to the URI. This allows us to access files within our app (Assets folder in this example). Notice the Third Backslash.

- Create 2 fields for each Audio you want to play. One will contain the Uri and the other will just be a “MediaElement” dedicated for that sound. You can only have 1 source set to a MediaElement.

We will set the audio source using the “MediaElement.SetSource” method which takes in RAS (Random access stream) and the MIME (Multipurpose Internet Mail Extensions) Type of the file. I will show you how to set up the Stream and retrieve the MIME type from the file loaded.

- Create a method (I named it SetAudio) and add the modifier “async”. We also need to add a parameter of type “Uri” (I named it audioUri). The methods used to set up the stream and access the StorageFile Class for retrieving the audio file can only be run by using the “await” operator.

- Set the return type as Task<MediaElement>. We must add Task<> to the Method declaration because our async method returns a value.

- First let’s load the Audio file using the “StorageFile.GetFileFromApplicationUriasync” and give it the audioUri parameter we passed into the “SetAudio” method. Remember to use the “await” operator in order to access this class.

- Next let’s set up the stream using the file we set up and passing in the AccessMode as Read. “File.OpenAsync(FileAccessMode.Read)”. This also requires the “await” operator.

- Now let’s new up the MediaElement that we will eventually return. In the example below, you’ll notice I have the “AutoPlay” property being set but commented out. This is handy when setting the source of the media element. In some cases, we don’t want the media to play automatically once the source is set. By default its “True”. We will leave it true since the first time the audio is loaded, we want it to play anyways. We won’t load it again after the first time and it will just call “Play” to initiate the sound afterwards.

- By using the “MediaElement.SetSource” method, pass in the Stream and the Content type of the file we loaded. This is simply done by the “ContentType” string property of the File you loaded. EX…LoadedFile.ContentType. See below.

- Now we return the MediaElement. Here is how the final method should look.

- At this point, we put some basic code into the click events of the button clicks. We check if the MediaElement Field we set up for this Button is null. If it is, we set the corresponding Field to our SetAudio method using the await operator and passing in the proper Uri field we set up. In case you forgot, remember to add the “async”modifier to the events. Repeat for every sound you want to play.

Optionally, you could load all the MediaElements on Initialize by setting each field and using the AutoPlay property I mentioned earlier to disable playing them all at once. Then you would just need to call “MediaElement.Play()” in the events.

And that is it. Now that you have an app (hopefully a bit different than this one) you can submit it to the windows store. As of today (Feb 15th) this application has been downloaded over 1,000 times! There is a huge market people that want good Windows Store apps, or even just fun ones like this.

If you have any questions about the app please post a comment.

Thanks for reading!

If you have used the version 1.x storage library you may have found the experience similar to Entity Repository in that you used a Context object and lots of LINQ. While this was fairly easy to grasp and understand it was difficult to figure out exactly when the code was making the query to the service. Also, it was a bit annoying that you could not use most of the LINQ functions, anything but “Where”, “First” and “Select” would not work and throw an unsupported exception at runtime.

Now in the new Version 2 you can use a TableQuery object which gives you more control over the query and exactly what you want to happen.

Filters

Table storage uses an ODATA interface which supports a few basic url query functions like filter, top, select, and orderby, plus a few more. The storage client library exposes these through the TableQuery class.

In the previous post I demonstrated how to retrieve a single entity using a RowKey/PartitionKey combination. The TableQuery class can be used for more complex data queries like the following.

using Microsoft.WindowsAzure.Storage;
using Microsoft.WindowsAzure.Storage.Table;

TableQuery query = new TableQuery().Where(TableQuery.GenerateFilterCondition("Name", QueryComparisons.Equal, "Tyler"));

There are 2 main elements to that statement, GenerateFilterCondition and QueryComparisons. You can use a few variations of these components to get the desired query.

GenerateFilterConditionForGuid
GenerateFilterConditionForLong
GenerateFilterConditionForDouble
GenerateFilterConditionForInt
GenerateFilterConditionForDate
GenerateFilterConditionForBool
GenerateFilterConditionForBinary

QueryComparisons.Equal
QueryComparisons.NotEqual
QueryComparisons.GreaterThan
QueryComparisons.LessThan
QueryComparisons.GreaterThanOrEqual
QueryComparisons.LessThanOrEqual


If you need to combine multiple filters you the TableQuery.CombineFilters() method.

string filterA = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, "Winnipeg");
string filterB = TableQuery.GenerateFilterCondition("Name", QueryComparisons.Equal, "Tyler");
string combined = TableQuery.CombineFilters(filterA, TableOperators.And, filterB);
TableQuery query = new TableQuery().Where(combined);

Here are the operators you can use.

TableOperators.And
TableOperators.Or
TableOperators.Not

This may seem long-winded but the usage is much more explicit than previous versions.

Selects

The other feature I want to quickly go over is the Select function. With this you can retrieve only the data that you need without excessive network access. This may be important for those using this library on WinRT devices.

CloudTable customerTable = tableClient.GetTableReference("customer");
TableQuery query = new TableQuery().Select(new string[] { "Name" });
customerTable.ExecuteQuery(query);

This will retrieve the names of all the customers in the table.

Take

Very simply

query.Take(10);


All Together

TableQuery query = new TableQuery().Where(TableQuery.GenerateFilterCondition("Name", QueryComparisons.Equal, "Tyler")).Select(new string[] { "Email" }).Take(5);


Take this as a quick introduction to the query syntax. There is so much more that I won’t go into right now. All of the examples are using Dynamic entities but the TableQuery object can also be created with typed entities (TableQuery<Customer>)

I hope this was helpful, as always thanks for reading!

You can still get the storage SDK on NuGet, or browse/fork the source code on GitHub.

Whats new in 2.0

New Dependencies: The previous version required a reference to the System.Data.Client assembly but now has dependencies on the ODataLib NuGet projects (Microsoft.Data.OData, Microsoft.Data.Edm, System.Spatial)

New Namespace: The namespace has changed from Microsoft.WindowsAzure.StorageClient to Microsoft.WindowsAzure.Storage and the different services are under .Blob .Queue .Table namespaces.

For more information checkout the overview, and migration guide articles.

Table Storage API in 2.0

Lets get down to it. You can continue to use the API in the standard way with context objects and LINQ but I wanted to show off the new object structure which improves on the clarity of the API.

CloudTable

Rather than instantiating a context class, you can just use the CloudTableClient similar to blobs and queues.

CloudTableClient tableClient = storageAccount.CreateCloudTableClient();
CloudTable customers = tableClient.GetTableReference("customers");

Once you have a CloudTable object you can start creating objects and performing operations.

public class Customer:TableEntity
{
public string FirstName { get; set; }
public string LastName { get; set; }
}

Customer newCustomer = new Customer();
newCustomer.RowKey = "tylergd";
newCustomer.PartitionKey = "Manitoba";
newCustomer.FirstName = "Tyler";
newCustomer.LastName = "Doerksen";

TableOperation insertOp = TableOperation.Insert(newCustomer);
customers.Execute(insertOp);

TableOperation and TableBatchOperation

There are a number of static methods to create TableOperation objects like .Insert .Delete .Merge .Replace and a few more variations like .InsertOrMerge all the methods take an ITableEntity interface instance, which the TableEntity base class implements.

To me this is a crucial addition to the API because it allows the user to specifically define the storage operations, giving much more control than the previous data context abstraction.

If you want to perform batched operations you need only use a TableBatchOperation object.

TableBatchOperation batch = new TableBatchOperation();
batch.Add(TableOperation.Insert(newCustomer));
customers.ExecuteBatch(batch);

Or slightly cleaner…

TableBatchOperation batch = new TableBatchOperation();
batch.Insert(newCustomer);
customers.ExecuteBatch(batch);

This operation object structure is also used for read requests, which I will cover in a following post.

This is all the time I have right now. Please look out for the upcoming Table Storage 2.0 posts

• Read Operations
• Dynamic Model Objects
• Building Advanced Queries

As always thanks for reading!

P.S. – Right now I am participating in a blog challenge with a few other western Canada software professionals. We have all entered a pool in which you are eliminated if you do not write a post every two weeks. So far everyone is still in and it has produced a number of excellent blog posts! Check out the links below.

• Aaron Kowall: http://www.geekswithblogs.net/caffeinatedgeek
• Dave White: http://www.agileramblings.com
• David Alpert: http://www.spinthemoose.com
• Dylan Smith: http://geekswithblogs.net/Optikal/
• Steve Rogalsky: http://winnipegagilist.blogspot.ca

My blog is a bit sparse these days, mainly because I have been involved in so many events in October-November and that steady stream is not slowing down in December.

VS 2012 Launch Event @ Winnipeg IMAX – December 6

Register Here (eventbrite.ca)

Event Details

• When: Thursday, Decemer 6th from 8:00 AM – 4:00 PM
• Where: IMAX Theatre, Portage Place
• Cost: *FREE!*

Agenda

8:00 – 9:00	Continental Breakfast and Registration
9:00 – 9:15	Welcome
9:15 – 10:30	End-To-End Application Lifecycle Management with TFS 2012
10:30 – 10:45	Break
10:45 – 12:00	Improving Developer Productivity with Visual Studio 2012
12:00 – 1:00	Lunch Break (Lunch Not Provided)
1:00 – 2:15	Web Development in Visual Studio 2012 and .NET 4.5
2:15 – 2:30	Break
2:30 – 3:45	Microsoft Cloud Development with Azure and Visual Studio 2012
3:45 – 4:00	Prizes and Thanks

Here is the abstract for my talk at 2:30

Microsoft Cloud Development with Azure and Visual Studio 2012
Tyler Doerksen, Imaginet

Microsoft’s public cloud platform is nearing its third year of public availability, supporting web site/service hosting, storage, relational databases, virtual machines, virtual networks and much more. Windows Azure provides both power and flexibility. But to capture this power you need to have the right tools! This session will demonstrate the primary ways you can harness Windows Azure with the .NET platform. We’ll explain cloud service development, packaging, deployment, testing and show how Visual Studio 2012 with the Windows Azure SDK and other Microsoft tools can be used to develop for and manage Windows Azure.Harness the power of the cloud from the comfort of Visual Studio 2012

Also don’t forget…

Vancouver Web Camp – Online – December 4

Register Online Here

I will be taking questions in the chat online.

Be sure to attend these great events this week! And stay tuned for more coming up in the new year!

Thanks for reading

The name of the game is building beautiful, interactive, and fast web sites! On December 4th join Brady Gaster, Jon Galloway, and Xinyang Qiu direct from Redmond as they show you how to build sites using:

• ASP.NET
• HTML5
• jQuery
• WebAPI
• SignalR
• and of course Windows Azure

If you cannot make it in person to Vancouver you can join me online for the virtual event stream. Register Here…

Check out this list of great topics:

• What’s new in ASP.NET 4.5
• Building and deploying websites with ASP.NET MVC 4
• Creating HTML5 Applications with jQuery
• Building a service layer with ASP.NET Web API
• Leveraging your ASP.NET development skills to build Office Apps
• Building and leveraging social services in ASP.NET
• Building for the mobile web
• Realtime communications with SignalR
• Using Cloud Application Services

In-Person Registration

Online Registration

See you there!

As an example (because I cannot use my real solution) I will be downloading and upgrading the BlobShare sample solution from http://blobshare.codeplex.com. This is a fairly complex solution published about a year ago. To build it requires the WIF (Windows Identity Framework SDK) and Azure SDK installed on your machine.

Opening the solution for the first time in VS2012

The first message is from Visual Studio saying that one of the projects requires a “One-way Upgrade”. In this case the project is the Azure BlobShare.ccproj. Once the solution is open you can look at the properties of the Azure project and see that it has been upgraded to October 2012.

At first you may be thinking “Great!” but then you try and compile and get a bunch of errors.

Missing the ServiceRuntime namespace

So once you compile you may get a number of reference missing warnings and compilation errors like this.

Could not resolve this reference. Could not locate the assembly “Microsoft.WindowsAzure.ServiceRuntime, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL”. Check to make sure the assembly exists on disk. If this reference is required by your code, you may get compilation errors.

The resolution to this is to remove and re-add the ServiceRuntime reference. The new reference should show Version 1.8.0.0

There are a few Azure libraries that have been added to NuGet but the Service Runtime assembly is not one of them.

Azure Storage Client Version 2.0

Occasionally when Visual Studio upgrades the projects it may add version 2.0 of the Storage Client library to the project. If that happens you will know from a large amount of errors. After version 1.7, 2.0 introduced a number of breaking changes to the framework.

To re-add version 1.7 to your projects, just use the NuGet package manager console.

Install-Package WindowsAzure.Storage -Version 1.7.0.0

After running that command in the package manager, you should not get any more storage API errors. I do recommend upgrading to the newest version of the storage library. Here is an article about the significant breaking changes in the library. Windows Azure Storage Team Blog

Once you get all of those straightened out you should have a successful compilation.

If you have any other problems with your solution upgrades, feel free to comment below or drop me a line at tylergd@outlook.com

Thanks for reading.

Previously all Shared hosted sites were free but now you can choose between Free, Shared, or Reserved. Here is a brief summary of the functionality of each.

Free: You know what they say “Free is the new Shared” well in this case that’s right. Free is like shared in that your site could be hosted on the same VM as other sites but you cannot assign a different domain name to the site. With Free the site will always be <something>.azurewebsites.net

Shared: The same hosting as free in that the site is not on a dedicated VM, however with this option you pay for the ability to assign your own domain to the site, even without a subdomain or what is called a “naked domain”.

Reserved: With this option you can assign the domain like shared but all of your sites in that datacenter are hosted on a reserved instance. The key point here is that all your websites are hosted by the same reserved instance. So if you have a high traffic site that requires 2 VMs and another small site, both will gain the 2nd VM if they are in the same datacenter.

Pricing

Also before this change the only option that would show up on your bill was the reserved instance but now that there is a cost for the Shared instance, you may need to make some decisions on how you are hosting your sites.

Since all of your Reserved instance sites share one cost for the machine, you may want to go to reserved if you have a number of small traffic sites to host. However, at what point would you switch from Shared to Reserved? Take a look at these screenshots from the Azure pricing calculator.

So Reserved you are paying per VM and Shared you are paying per site it would take about 6 sites to reach the cost of a single small VM. I don’t know what the performance gains are for Reserved vs Shared but this gives you an idea as to what the cost of a Shared site would be compared to a Reserved instance.

If you are planning on deploying multiple sites or any services to Azure I suggest playing around with the pricing calculator for a while. https://www.windowsazure.com/en-us/pricing/calculator/

Thanks for reading!

Tyler Doerksen