Suppose you have a simple list of objects:

   1: List<Object> list = new List<Object> { new Object(), new Object() };

And for some reasons you’d like to create a projection from this list using a wrapper class. One reason why you would do this is wrapping business objects into ViewModels.

   1: var enumerable = from o in list

   2:                  select new Wrapper(o);

The Wrapper class only adds the capability of being flagged to the whole story:

   1: public class Wrapper

   2: {

   3:     public bool IsFlagged { get; set; }

   4:  

   5:     private Object Obj;

   6:     public Wrapper(Object o)

   7:     {

   8:         Obj = o;

   9:     }

  10: }

So what you now have in enumerable is an IEnumerable<Wrapper>. Next, you’d like to use the wrapper functionality and flag the two elements in enumerable:

   1: foreach (var e in enumerable)

   2: {

   3:     e.IsFlagged = true;

   4: }

And then you go forth using your enumerable, only to discover that none of the contained elements are flagged.

What!? Why?

It’s because an IEnumerable is not a List. One needs to understand that prior to calling .ToList() or using foreach() to enumerate over it, no constructor of wrapper has been invoked. Put another way, only because we used this nifty LINQ projection, no Wrapper instances exist yet.

They came into life when we foreach’ed them and disappeared right after that. Whenever we try to use enumerable again, we are enumerating this LINQ expression again. Which means we call the constructors again and we get totally different instances of Wrapper.

For example, suppose we’d use this expression in order to check how many elements are actually selected as an effort to find out why the program doesn’t work as expected:

   1: int numberFlagged = enumerable.Count(e => e.IsFlagged);

This will return 0, as we already know. The best way to find out is to step through the provided code and put a breakpoint into the Wrapper constructor. Please find the whole source code ready for copy & paste at the end of this article.

Although i knew how an IEnumerable behaves, it took me 10 minutes today to find my error in a slightly more complicated example. I guess it’s the special case of using a linq projection together with an IEnumerable that got me.

class Program

{

    static void Main(string[] args)

    {

        List<Object> list = new List<Object> { new Object(), new Object() };

        var enumerable = from o in list

                            select new Wrapper(o);

        foreach (var e in enumerable)

        {

            e.IsFlagged = true;

        }

        int numberFlagged = enumerable.Count(e => e.IsFlagged);

    }

    public class Wrapper

    {

        public bool IsFlagged { get; set; }

        private Object Obj;

        public Wrapper(Object o)

        {

            Obj = o;

        }

    }

}

So the first thing I have done was reusing the parser logic. Clearly by far not the finest piece of code I’ve ever written, but we don’t even need to cover it here. The only thing worth mentioning is that it is responsible for issuing a HTTP GET to the HeavensAbove website with the coordinates your phone detected. All this scraping and parsing lives in the projects FlareParser and HeavensAboveParser. MobileFlares.Core is responsible for defining the interfaces and BusinessObjects the parsed, raw data gets transformed into.

I nearly forgot to mention the use of Async CTP features in the code, which greatly simplify working with asynchronous calls. Visual Studio Async CTP SP1 Refresh ships with assemblies for Windows Phone 7, which are included in the solution. Although the solution is self contained, you will still need to install the CTP should you want to build it yourself.

I’ve used the databound template for this project. This sets up your project with one page for master data and one page for detail data. For this step, we don’t even need the details page, we will only bind the data to a list on the master page (called MainPage.xaml)

MobileFlares/SampleData contains MainViewModelSampleData.xaml to throw design time data at the list on the master page. This is wired up in MainPage.xaml using this line:

d:DataContext="{d:DesignData SampleData/MainViewModelSampleData.xaml}"

The DataTemplate for visualizing flare data is called FlareOverviewTemplate and resides in App.xaml.

That’s it for the project layout. A bit more interesting is how the GeoCoordinateWatcher is set up. There is an initalization method in the code behind for MainPage.xaml:

private void InitGeoWatcher()
{
  geoWatcher = new GeoCoordinateWatcher(GeoPositionAccuracy.Default);
  geoWatcher.MovementThreshold = 1000; // Notify about new position every 1km travelled
  geoWatcher.PositionChanged += geoWatcher_PositionChanged;
  geoWatcher.Start();
}

By specifying GeoPositionAccuracy.Default we tell the watcher that we don’t need GPS accuracy and are happy to use coordinates that have been determined through cell tower triangulation. This cuts down power consumption because the GPS sensor does not need to get activated.

Movement threshold is another option for reducing both power consumption and the number of calls to the website. As long as the app is running, the PositionChanged event will only fire if the position has changed more than 1km. This is still good enough for accurate flare predictions.

There is also a LogPage implementation that can be hooked up to attach itself to the ApplicationBar. Up to this point, it has only been used to check when the GeoCoordinateWatcher fires its PositionChanged event.

So this is what happened up to revision 3: The app will get the location from your device, use the coordinates to fire a request to the website, parse the response into business objects and bind it through MainViewModel to a list on the screen.

The next step will already contain the upgrade to Mango tools and using the Compass API to implement what I called guidance.

Some ideas are more or less useless, but also just as timeless. Some time ago, I started to implement a project called Mobile Flares for Windows Mobile 6.5. It was a small app for getting flare predictions for Iridium Flares.

After I got myself a brand new Windows Phone I thought about revisiting the project to make it work on the new platform. But it was only when the new Windows Phone Mango features were announced that I eventually got into it. Mango has interesting new APIs this small application can benefit from, which is why I’d like to shine some light on implementation details in order to turn the project into a Mango tutorial.

In the following posts, I will describe the implementation progress in steps and also point to the corresponding code revision. All the code is available on Codeplex, I am using Mercurial as version control software. I have to apologize for my random switching between german and english commit comments, I will restrict it to english from now on.

Even though the main use case of Mobile Flares is extremely simple (get predictions for the current location) there are a lot of sub-usecases revolving around this, which is why the application uses, among other APIs:

• Location API
• Compass API
• Background Agents
• Live Tiles
• Local Database
• Reminders

It also uses Visual Studio Async CTP (SP1 Refresh) and MVVM Light.

What I like about Windows Phone development is that it’s only a special flavor of Silverlight development, and Silverlight will look familiar to anyone who has done some WPF, which is, as it happens, exactly what I have done. I will not cover the basics of XAML, data binding etc for this is not a Silverlight tutorial.

Instead, I will show how to achieve this with LiveTiles:

and this using reminders

and this using compass data

But your phone just never tells you about the update, and there is nothing to be installed, and some friends of yours already got the update while you are still unable to thoroughly test your app. Then you realize the difference: You bought the phone from a different carrier.

Some carriers hold back new updates for WP7 for quite some time, which – from a developer’s point of view – might be unacceptable.

And then someone tells you that flashing your phone with an original (unbranded) ROM might do the trick, but this means that you are losing all your messages and settings and so on – almost everything in fact, since the device will be completely reset, just like after doing a fresh reinstall of you favorite OS on your PC. But at least for a PC there are a lot of backup solutions available that will bring all your data back.

At the time of writing, this is not true for WP7 devices – the only backup solution worth mentioning I know of will do a complete backup of the phone – including the device’s current ROM which means that this is only applicable if you do NOT want do upgrade the ROM. But this is precisely what debranding is about.

If your only goal is to unlock the updates for your phone so that it uses MS updates directly instead of waiting for your carrier to release them, then there is another solution. Essentially, it will only flick a switch telling your phone not to receive the updates from your carrier but directly from MS. It will not alter your branded boot screen nor any other settings on your phone. Most importantly, it will not do anything to your precious data.

This is a short outline of what I did for my Samsung Omnia 7:

1. (Optional) Create a complete backup of your phone so you could roll back in case of failure. This might be a good idea anyway.
1. Install the support tool for WP7
2. Install this wrapper for the support tool (this is the backup solution I mentioned previously)
3. Perform a backup of the phone. For me, it was ok to remove the USB cable when the app told me to even though the phone was displaying an image at that time strongly advising me not to do so
2. Follow the instructions on this site. For me this meant:
1. Installing the registry editor for Samsung devices. This editor comes as an XAP file which must be deployed to the phone via the Windows Phone SDK Application Deployment tool
2. After that I had to edit one registry value and
3. Reboot the phone
3. This should be it. My phone announced available updates and I installed them after Zune was finished updating itself to a new version.

Some forum members claimed that this took more than one attempt for them. While it worked for me at once, some had to try 20 times.

HTH

At this point I discovered the WCF Data Services Toolkit on Codeplex which circumvents the need to write your own LINQ provider by using a repository pattern architecture for you to hook into. I also found documentation to get me started, however I discovered later that the documentation does not match the current (beta) release of the toolkit.

As a prerequisite, please read the author’s blog post about updating resources with the toolkit. Here he describes the IWriteableRepository interface. Please note that this documentation is partly out of date as with the april update:

IWriteableRepository interface is gone

But fear not. It is a breaking change, but simply removing it from the class declaration will do the trick. This is because methods on your repository will be called by convention (hence by reflection). This has multiple advantages which the author mentions at the end of the updating resources post.

CreateDefaultEntity has been renamed to CreateResource

While the previous change might have been obvious, this one is not. But again, this is easy to solve, just rename the method.

This is it for the changes. Some random things I discovered while using the Toolkit:

Make sure to implement CreateResource. In there, simply new up a new instance of your entity (or do more advanced stuff if necessary). Otherwise, the toolkit will try to use Activator.CreateInstance() to create an entity instance, which did not work for me because the type to create an instance from was in a different assembly. This is a known issue (#12 on Codeplex) and I sent a patch for this to the author.

Just for reference: The list of methods one can implement in the repository:

1. public void Save(<YourType> entity)
2. public void Remove(<YourType> entity)
3. public void CreateRelation(<YourType> entity, <YourOtherType> relatedEntity)
4. public object CreateResource()

So far, I really like the toolkit and how it helped me to work with Azure Storage. Keep up the good work!

1. Using WIF to authenticate the Silverlight client against a server relies on security tokens being sent from client to server. These tokens are sent as cookies
2. Sending cookies from a Silverlight application means you have to use the BrowserHTTP network stack since the other option for silverlight (ClientHTTP stack) is incapable of sending cookies
3. BrowserHTTP in turn is limited to sending GET and POST requests. But REST web service methods often use other HTTP verbs as well, such as PUT and DELETE
4. So this means we can’t use WIF with Silverlight AND call web service methods by HTTP verbs other than GET and POST, right?

Right, not as it is. But in certain circumstances, one is able to get over this limitation.

These are the moving parts:

• I’ve been using the Silverlight in Browser WIF Example of the Identity Developer Training Kit March 2010 update
• Silverlight Version 4
• My REST web service has been implemented in ASP.NET MVC 1

So what is needed for our workaround? The web service has to understand and handle a request header that you can set in your Silverlight App and that is being used to tunnel the actual verb.

I chose to use X-HTTP-Method-Override as header. If you are responsible for the implementation of the web service, you could of course use every spare header you’d like, but I think X-HTTP-Method-Override pretty much sticks to the standards.

The solution can be outlined as follows:

1. You still use the BrowserHTTP stack, which lets WIF do its magic.
2. Whenever you want to send, lets say a PUT request, you set a header in the Silverlight app on this request which contains the actual verb you want to use (in this example, PUT) and let the stack issue a POST request to the resource.
3. The web service recognizes the header and uses the contained verb to handle the requests as opposed to the verb the stack reported.

Here is some code to tunnel the verb by setting a header:

var request = (HttpWebRequest)System.Net.Browser.WebRequestCreator.BrowserHttp.Create(new Uri(fullUri));
request.Headers["X-HTTP-Method-Override"] = "PUT";
request.Method = "POST";

Next, here is what is necessary to make the web service understand this header.

ASP.NET MVC offers the [Authorize] attribute to make sure incoming calls to a method are authenticated. 

This attribute uses the actual verb and does not recognize our custom header, so we will need to provide another implementation for that. Luckily, that one is easy. Below is the full sample implementation of an attribute that uses the custom header if present, otherwise it will use the real verb. This implementation is mostly based on the ASP.NET MVC version of the Authorize attribute.

[AspNetHostingPermission(System.Security.Permissions.SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
public class AcceptTunneledVerbsAttribute : ActionMethodSelectorAttribute
{
   public AcceptTunneledVerbsAttribute(HttpVerbs verbs)
       : this(EnumToArray(verbs))
   {
   }

   public AcceptTunneledVerbsAttribute(params string[] verbs)
   {
       if (verbs == null || verbs.Length == 0)
       {
           throw new ArgumentException("Argument was null or empty", "verbs");
       }

       Verbs = new ReadOnlyCollection<string>(verbs);
   }

   public ICollection<string> Verbs
   {
       get;
       private set;
   }

   private static void AddEntryToList(HttpVerbs verbs, HttpVerbs match, List<string> verbList, string entryText)
   {
       if ((verbs & match) != 0)
       {
           verbList.Add(entryText);
       }
   }

   internal static string[] EnumToArray(HttpVerbs verbs)
   {
       List<string> verbList = new List<string>();

       AddEntryToList(verbs, HttpVerbs.Get, verbList, "GET");
       AddEntryToList(verbs, HttpVerbs.Post, verbList, "POST");
       AddEntryToList(verbs, HttpVerbs.Put, verbList, "PUT");
       AddEntryToList(verbs, HttpVerbs.Delete, verbList, "DELETE");
       AddEntryToList(verbs, HttpVerbs.Head, verbList, "HEAD");

       return verbList.ToArray();
   }

   public override bool IsValidForRequest(ControllerContext controllerContext, MethodInfo methodInfo)
   {
       if (controllerContext == null)
       {
           throw new ArgumentNullException("controllerContext");
       }

       string incomingVerb = controllerContext.HttpContext.Request.Headers["X-HTTP-Method-Override"] ?? controllerContext.HttpContext.Request.HttpMethod;
       return Verbs.Contains(incomingVerb, StringComparer.OrdinalIgnoreCase);
   }
}

Credit to whom credit is due: These have been my sources

Golo Roden: Hint for tunneling the verb (german) http://www.des-eisbaeren-blog.de/post/2009/07/13/ClientHttpStack-in-Silverlight-3.aspx

Jeff Prosise: Differences between Silverlight network stacks http://www.wintellect.com/CS/blogs/jprosise/archive/2009/10/14/silverlight-3-s-new-client-networking-stack.aspx

stackoverflow user Levi pointed into the right direction for handling the header in ASP.NET MVC. Make sure to read the comments, subclassing the Attribute does not work. http://stackoverflow.com/questions/467535/is-it-possible-to-implement-x-http-method-override-in-asp-net-mvc

Extra Small Instances

This is one of the features I was really waiting for. Before this announcement, the smallest instance size was Small, having a price tag of $0.12 per hour. Now there is an Extra Small instance size with $0.05 / hour.

I went ahead and replicated the table from this Microsoft web site to have the most current overview on my blog. This should come in handy, at least for me because I will keep forgetting this stuff.

As explained in this video, Extra Small Instances share resources (CPU, memory) with other VMs on the same node. Furthermore, the network bandwidth is capped at around 5 Mbps. This is not the case with larger instance sizes, where CPU and memory are not shared and your service can leverage unused bandwidth.

I believe this is a very good idea. Amazon’s smallest Windows instance (Micro Instance) is available at a cut-price $0.03 per hour, but we can’t compare these offerings 1:1 because Azure offers more functionality. We don’t have to pay extra for load balancing services and we don’t have to worry about OS updates etc. Besides, Azure’s Extra Small instance has 155MB more RAM, which could make a lot of difference.

This is why I like this new instance size so much: It means that it just got easier to get a small service running without downtime. By that I mean that I can now pay 2 extra small instances for a small service which gives me the ability to enable rolling upgrades without downtime. This includes automatic OS updates as well as my own updates to my service when delivering new features. This is still cheaper than having one small instance without all these benefits. I would expect this to activate the SLAs also, but I’m not sure about that. This won’t be the case while this feature is still in beta.

Some missing features require workarounds, others are simply showstoppers. For example, this week I hit a wall with Table Storage. Ouch. I was really happy about the approach I used with it and had even already applied some workarounds to my solution when, suddenly and sadly, I had to realize that Table Storage just doesn’t support case insensitive search.

Without going into much detail, let me put all this into a list. While it may seem that this post is essentially a rant about Windows Azure, that is not true. The rant is really only about documentation, see below. Everything else are just features I want to have and I believe the Azure platform needs to have ASAP if MS doesn’t want to get left behind. Some other big players in Cloud Computing are doing a splendid job of throwing new features at developers almost monthly and letting them know as soon as possible.

So all this boils down to: Deliver crucial new features. Do it fast. Let everyone know about it.

Table Storage

There is no support for secondary indexes. Amazon SimpleDB has it. Missing this kind of feature means we will have to store information redundantly, just to be able to query efficiently for them. This results in additional development effort as well as increased storage costs. Since storage is cheap, this is ok. Since when done properly, Table Storage can do an enormous scale out, I am even willing to invest some more time to get this right. So this is not necessarily a showstopper.

There is no support for case insensitive search. This means that I would have to store a lowercase version of whatever I need to search for, together with the version containing the correct spelling.

There is also no way for doing full text searches on the storage. There is a workaround for StartsWith() but none for EndsWith() or Contains(). And I’m not talking about not being able to do that efficiently. I’m talking about not being able to do that. Because the LINQ provider just doesn’t support these kinds of queries. And no, doing that on the client side is not always an option.

So MS, please, don’t tell me that Table Storage is missing all those features by design and that it was always intended to be only a very simple way of storing data. Just don’t. Give it a few more features and make it a powerful No-SQL storage. I’m not asking for making it support all the relational stuff like cascading deletes and the like. I understand that it is non-relational. But don’t stop on half the way. Continue, quickly.

Hosting

Yes I know this one is probably just for devs trying to grok the way Azure works or maybe small startups, but still … hosting a small service on Azure is just too expensive. As already mentioned, this is not a problem when you put your virtual machine’s power to good use, but the pay-as-you-grow model has a flaw here – the inital price might be too high if your needs are too low. Ah yes, Amazon has that, too.

Sending Emails

Did I mention that Amazon has a feature called SNS? This is not sufficient for sending emails to your customers, but it is perfectly acceptable for anything else, including email messaging in case of failure etc. There are solutions for that, but these are merely workarounds.

Caching

While I am happy that there are projects like CloudCache that are based on Memcached, I really hope that support for Velocity a.k.a. AppFabric Cache is coming soon. And by soon I do not mean PDC 2011. If there is no announcement (with specific date) at PDC 2010, I will go with Memcached.

Fixed IPs

IPs seem to remain fixed over the lifetime of a deployment. While this may be true, there is no official statement from Microsoft saying that this behavior is supported. To some, that might seem fair enough since you don’t have to bother about that anyway, right? Well, say you’d have to communicate with some other service that requires your IP to be whitelisted. Not your domain but your IP. Then assume that it will take some time to get another whitelist entry in case something happens to your first IP. You could try to get a ‘backup IP’ whitelisted parallel to your real IP, but this would require another deployment to run on a different production slot, so this is also a clumsy workaround.

And Amazon has the concept of – ah, never mind.

Documentation

Honestly. This is just too hard. Its not surprising the Azure community keeps on providing link lists and compilations of Azure resources. Information is scattered, insufficient and sometimes out-dated.

And I’m getting tired of saying this, but compared to Microsoft’s approach, Amazon’s is really centralized. You find a long list of documentation for every feature AWS offers on the starting page for that feature and from there on, you can follow links to complementary information.

There is a monthly AWS newsletter saying “we are happy to announce”. Well, I am happy if there is ANY way for me to figure out what Microsoft is up to in the next few months with regard to Azure. Why is communication so bad on this topic?

Last time I checked, the official voting forum for Windows Azure Feature Requests lists 8 completed requests and 1 accepted request (secondary indexes for Table Storage). Even then, there has been no further information on secondary indexes since like 11 months. No, let me check that again, this can’t be true … aargg, it is true. There are a lot of other very important requests but none of them made it to ‘accepted’. Does this mean the Azure team is not currently working on any of these feature requests? I hope not! Really, I hope not.

I would like to see that Microsoft uses this platform (or any other means, just DO it) to communicate upcoming changes to developers and decision makers. That way, everybody would be able to plan ahead and be less frustrated. Developers like me would have a central way of being kept in the loop and appreciate new features instead of being angry for not being told.

Only they don’t. So they won’t. So they are not. And we haven’t. So I am not (at least to a certain degree).

And I definitely believe it is not a good idea for MS to keep roadmaps and timelines as secret as possible, wait a whole year until next PDC and only then make information about all that publicly available. That being said, I really hope there will be some interesting announcements at PDC 2010. I need certain new features to make it easier for me to get customers adopt Azure. Otherwise they will rather go with Amazon.

1. Downloaded the installer from here and executed it
2. This failed with a well-known error which I discovered just after step 3
3. So I tried to uninstall SQL Server 2008 R2 November CTP because I thought these errors were related
4. This is when I discovered that trying to do this via Add/Remove programs is pretty useless, these installers are getting in each other’s way because they all fail to uninstall dependent objects and these very objects just won’t show up in Add/Remove
5. But then I found this post that said I had to run a tool mentioned here to get a list of installed software I could search for product ids and get rid of them using this smart uninstaller
6. I was then able to use the Web Platform Installer to get SQL Server Express and Management Studio installed.

I wrote this post to thank Aaron Stebner for his blog posts and tools, to thank the guys responsible for the Web Platform installer for being the only reliable way to install anything that has ‘SQL Server’ in it and to blame the guys from SQL Server because of the same reason.

Why, oh why does it always have to be this way with SQL Server, I NEVER experience NO trouble.

Whitepapers

Whitepapers are also some sort of resources, but I thought I’d give them some extra attention here instead of just adding them to the resources link list, otherwise no one including me would know what’s inside them.

Implementation Whitepapers

• Programming Blob Storage Describes the Blob Storage hierarchy, how to work with blobs, use pagination and handle errors.
• Programming Table Storage Learn the basics about Partition Keys, CRUD operations on Entities via LINQ, supported data types, Best Practices and Known Issues. This will also give you an idea about the difference between Relational Databases and the Table Storage Model.
• Programming Queue Storage This is about connecting and sharing information between different application blocks in a loosely coupled way a.k.a. “the way it’s meant to be”. This is done by pushing messages (processing orders) into a queue and let some other part of the application deal with it.
• SQL Azure
  The best way to get started with SQL Azure is probably to already have a basic understanding of SQL Server 2008. If you want to build your tables from scratch, you might want to know about the similarities and differences between SQL Server and SQL Azure. Due to the lack of designer support on SQL Azure (you can use SSMS to get access to your SQL Azure databases, but you can only manipulate table structures by scripts) I prefer to create and test tables on my local dev machine, then use the SQL Azure Migration Wizard to create these tables on my SQL Azure database.
• Project Houston can do what SSMS doesn’t do for you – provide design capabilities for SQL Azure. This is implemented as Silverlight Client.
• You know how Skype is able to communicate with other Skype instances running on different machines, all sitting behind firewalls? No? Well that’s exactly what AppFabric Service Bus does. Its primary goal is to bridge on-premise and off-premise solutions.

Tools

Azure Storage Explorer Have a look at and manipulate your Azure Tables, Blobs and Queues.

SQL Azure Migration Wizard Set up a local database and load it into your SQL Azure database. Or the other way round: Back up your SQL Azure to a local machine. Or to another SQL Azure instance if you feel like it.

Azure Services Management Tools Manage Azure Services such as .NET Access Control Services and the .NET Workflow Service. Please note that these tools are out of date as of 06.08.2010

Windows Azure Service Management CmdLets Use PowerShell to script your deployments, upgrades, and scaling of Windows Azure Applications

Resources

• Pricing Overview
• MSDN Subscription Benefits
• Microsoft Online Customer Portal

Videos, Frameworks?

• Videos of the Windows Azure Sessions at MIX10
• “How Do I?” Videos for Windows Azure Platform
• Windows Azure Storage Videos

As of 06.08.2010, the Windows Azure Storage Videos are offline but should have been replaced by 15.02.2010. Right. Maybe it’s a typo.

English Blogs

• Blog of Steve Marx (Windows Azure Team Member)
• Windows Azure Blogs

German blogs

• Holger Sirtl
  • Änderungen an der Windows Azure Platform seit CTP
• Windows Azure Tutorial Serie

Some other resources

• Windows Azure Code Samples
• Windows Azure FAQs

[Update] I believe this to be a quite comprehensive list of Windows Azure resources