Rob Garfoot's Blog

Enabling UEFI booting on a BIOS installed Windows

Robert Garfoot — Fri, 29 Aug 2014 16:33:16 +0000

Just a short article this one. I just got a new motherboard that support UEFI after a long time with my old one. I didn’t want to reinstall Windows at this point and it did a great job of detecting all of the new devices and just booted no problems.

However I would like to take advantage of Windows’ ability to UEFI boot and use the Secure Boot feature on Windows 8. There is no supported way to migrate from BIOS booting to UEFI but it is possible to do it. This isn’t for the faint of heart and it’s always possible when messing around with things like this that it’ll leave you in an unsupported state or completely broken and require a rebuild.

It did work for me though. Check out this great article http://social.technet.microsoft.com/wiki/contents/articles/14286.converting-windows-bios-installation-to-uefi.aspx for the instructions.

Function lock for the Microsoft Wedge keyboard

Robert Garfoot — Sat, 05 Jul 2014 14:36:07 +0000

I’ve just purchased a Microsoft Wedge keyboard for my Dell Venue 8 Pro. It’s a really nice keyboard but it has one big flaw for my use, the F keys are on a function shift (Fn) which means when programming I have to hit Fn-F2 to get F2 and not volume mute.

Fortunately it’s a fairly easy fix thanks to a great bit of software called AutoHotkey. This software lets you remap keyboard keys to others, run macros, build basic UIs, hotstrings and much more, it’s rather nice.

In this case I built a script that has 3 modes, Media keys on, F keys on, programmer mode which just does F1-F8 and leave F9-F12 requiring Fn pressing. I did that last mode as Print Screen, Home, End and Page Up are on F9-F12 and I use Home/End/PgUp way more than F10 or F11 which I only use when debugging.

I can switch between the modes with Win-; as the hotkey I’ve set up. The last thing I did was drop this into MyDocuments as wedgekeyboard.ahk, added a #include %A_ScriptDir%\wedgekeyboard.ahk to the autohotkey.ahk in there and set AutoHotkey to run on login by dropping its shortcut into the startup folder for my user in explorer.

It’s not the prettiest script but here it is.

SetAllOff()

; Wedge keyboard remaps
Media_Play_Pause::F1
Volume_Mute::F2
Volume_Down::F3
Volume_Up::F4
<+#F21::F5
 2
  {
    Remap := 0
  }

  if Remap = 0
  {
    SetAllOff()
  }

  if Remap = 1
  {
    SetAllOn()
  }
  
  if Remap = 2
  {
    SetProgramming()
  }
}


SetAllOff()
{
  TrayTip, Media keys on, Wedge keyboard, 1
  Hotkey, *Media_Play_Pause, off
  Hotkey, *Volume_Mute, off
  Hotkey, *Volume_Down, off
  Hotkey, *Volume_Up, off
  Hotkey, *<+#F21, off
  Hotkey, *

No related posts.

Using Grids with ItemsControl in XAML

Robert Garfoot — Tue, 17 Sep 2013 13:55:03 +0000

ItemsControl in XAML is a useful control that allows you to bind against multiple items and have them displayed using a repeating template (or templates). It forms the basis of the ListBox and other controls but can be used on its own where extra behaviour such as selection is not needed.

By default the ItemsControl uses a vertically aligned StackPanel as the layout panel for its items but you can override this by providing a template. It’s quite common to override this for example to use a VirtualizingStackPanel but in this instance I wanted to use a Grid for layout.

The Problem

I have a set of items that I want to arrange in a grid, I want the items to size to fill the available space after specifying the number of columns and rows I would like for display. This means I can’t use a WrapPanel but will ideally use a Grid.

The XAML for this would look something like this.

This should let me have a collection called “Data” with items that have X and Y properties that refer to the grid coordinates. The problem is that this doesn’t work. To understand why we need to look at how the Grid and ItemsControl work.

The ContentPresenter

During layout the Grid will look for attached properties Grid.Row and Grid.Column on child elements to place them in the correct cell. However, it only checks immediate children, this is important due to how the ItemsControl works.

When displaying items the ItemsControl will wrap the supplied item and its DataTemplate (if it has one) in a ContentPresenter. This means that if you add Grid.Row and Grid.Column attributes to the item in the DataTemplate then the Grid will not find them since the immediate child is a ContentPresenter, not the item in the DataTemplate.

Dynamic Rows and Columns

The other challenge we have is that the number of rows and columns cannot be databound, we have to specify them explicitly using RowDefinitions and ColumnDefinitions.

The Solution

After a bit of poking around on the internet I found a few solutions to the problem but having worked with the ItemsControl in the past I knew that there was probably a simpler solution than some of the ones I found.

I subclassed the ItemsControl into a GridAwareItemsControl and implemented the GetContainerForItemOverride method. This is the method that normally creates the container for the item, i.e. the ContentPresenter.

In this method I check to see if there is an ItemTemplate (DataTemplate) and then check to see if the content of it has Grid.Row and Grid.Column set. If they do I copy the bindings from them to the ContentPresenter. This code assumes there are bindings and not hardcoded values but hardcoding the values wouldn’t make sense for this.

public class GridAwareItemsControl : ItemsControl
{
    protected override DependencyObject GetContainerForItemOverride()
    {
        ContentPresenter container = (ContentPresenter) base.GetContainerForItemOverride();
        if (ItemTemplate == null)
        {
            return container;
        }

        FrameworkElement content = (FrameworkElement)ItemTemplate.LoadContent();
        BindingExpression rowBinding = content.GetBindingExpression(Grid.RowProperty);
        BindingExpression columnBinding = content.GetBindingExpression(Grid.ColumnProperty);

        if (rowBinding != null)
        {
            container.SetBinding(Grid.RowProperty, rowBinding.ParentBinding);
        }

        if (columnBinding != null)
        {
            container.SetBinding(Grid.ColumnProperty, columnBinding.ParentBinding);
        }

        return container;
    }
}

The second part of the solution, dynamically creating the rows and columns, was solved using a couple of attached properties. These take int values and then programmatically create the RowDefinition and ColumnDefinition items on the Grid.

public class GridAutoLayout
{
    public static int GetNumberOfColumns(DependencyObject obj)
    {
        return (int)obj.GetValue(NumberOfColumnsProperty);
    }

    public static void SetNumberOfColumns(DependencyObject obj, int value)
    {
        obj.SetValue(NumberOfColumnsProperty, value);
    }

    // Using a DependencyProperty as the backing store for NumberOfColumns.  This enables animation, styling, binding, etc...
    public static readonly DependencyProperty NumberOfColumnsProperty =
        DependencyProperty.RegisterAttached("NumberOfColumns", typeof(int), typeof(GridAutoLayout), new PropertyMetadata(1, NumberOfColumnsUpdated));

    public static int GetNumberOfRows(DependencyObject obj)
    {
        return (int)obj.GetValue(NumberOfRowsProperty);
    }

    public static void SetNumberOfRows(DependencyObject obj, int value)
    {
        obj.SetValue(NumberOfRowsProperty, value);
    }

    // Using a DependencyProperty as the backing store for NumberOfRows.  This enables animation, styling, binding, etc...
    public static readonly DependencyProperty NumberOfRowsProperty =
        DependencyProperty.RegisterAttached("NumberOfRows", typeof(int), typeof(GridAutoLayout), new PropertyMetadata(1, NumberOfRowsUpdated));

    private static void NumberOfRowsUpdated(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        Grid grid = (Grid) d;

        grid.RowDefinitions.Clear();
        for (int i = 0; i < (int)e.NewValue; i++)
        {
            grid.RowDefinitions.Add(new RowDefinition(){Height = new GridLength(1, GridUnitType.Star)});
        }
    }

    private static void NumberOfColumnsUpdated(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        Grid grid = (Grid)d;

        grid.ColumnDefinitions.Clear();
        for (int i = 0; i < (int)e.NewValue; i++)
        {
            grid.ColumnDefinitions.Add(new ColumnDefinition() { Width = new GridLength(1, GridUnitType.Star) });
        }
    }
}

In all this results in XAML that looks like this and I think is a reasonably simple solution.

Securely extending Surface RT with an SD card and BitLocker

Robert Garfoot — Wed, 21 Nov 2012 17:22:14 +0000

I bought myself a Surface RT the other day and I’m loving it however one thing that I wanted to do is expand the built in storage using a SD card. Unfortunately this is one area where the Surface is a little less than helpful, I can happily plug in a micro SD however getting my content to automatically use it is another matter.

Integrating SD cards with libraries

The first challenge is getting the SD card to be seen by Windows as the default location for things and to allow apps to find content on it. In theory you can do this by adding the SD card into the Windows libraries for music, pictures etc.

However, you can’t add removable media to libraries. This is quite easy to work around thankfully and has been documented elsewhere. To save you going looking here is my solution.

First I reformatted my SD card with NTFS, you’ll need to do this to set permissions later.

Next I created top level folders for Public and Rob (myself), remember this is a multi user device so I want document isolation.

Inside each of these I created the folders for music, pictures, documents and videos.

I set the ACLs on each of the top level public and user folders to match those on the system drive in C:\Users, this took a while but had to be done for security. You could looking into using robocopy to copy the original folders and ACLs, that might save time.

Next I ran disk management (from search or win-x -> computer management) and removed the drive letter from the SD card. I created a folder on C:\ called SD and then added a mount path to that location.

Once that was all done I was able to right click each library, go to properties and add the new locations to each library. I set the new public and rob folders as the defaults for public and current user respectively.

Job done, now I can move all my content from the C drive to the SD and apps will see it, since I changed the default any music I download etc. will save there by default. However, I’d suggest if you’re going to BitLocker the SD card you wait until after that before you start copying data over onto the SD, it’ll be quicker enabling BitLocker.

Security

I mentioned security above where I said I set up ACLs on the folders, however that’s only half of the story. This is a removable disk with my personal data on it, I really want it encrypted.

Luckily and mostly unknown to people the Surface has a TPM and comes with BitLocker enabled out of the box. Great, I can BitLocker by SD card.

Except Surface exposes no UI for it and as it turns out the manage-bde command won’t let you do it either, failing with the message that this version of the OS doesn’t support that when trying to encrypt. I have no idea why, it really should support encrypting removable (or in this case semi-permanent) storage, it has a TPM and seems quite arbitrary.

No worries though, I simply put the SD card into my desktop machine which is running Windows 8 Enterprise (or Pro will do), right clicked it and selected enable BitLocker. I set a password and backed up the key to a file.

Putting the SD back in the Surface didn’t auto unlock so I had to go the command line here.

I started an elevated command prompt (win-x) and then executed the following:

manage-bde -unlock c:\sd -password

I then entered my password and it was unlocked. Ideally though I want this to happen automatically at reboot.

Automatic unlocking

Again this is an area where things are missing, the -autounlock option on manage-bde doesn’t work on this version of Windows so I had to create an unlock script.

This was quite easy, I created a new .bat file on my C drive in my user documents folder on that disk, this script simply contains the above unlock command with a slight change, rather than using -password I use -rp to use a recovery password. This let’s you specify it in the command line. You ne to get the recovery password from the file saved out when you BitLockered the SD, its the big long number at the end of the text file. Just put that after the -rp option.

It looks something like this, where the xxxxxx-xxxxxx bit is your recovery key. Some people in the comments have had success with -rk instead of -rp but -rp works for me.

manage-bde -unlock c:\sd -rp xxxxxx-xxxxxx-xxxxxx-xxxxxx-xxxxxx

Next I used the Windows task scheduler which you can get to from computer management (win-x) to create a new task. This task was set to run as me, with max permissions (needs elevation) and triggered to run at startup. The action for the task was to run my .bat file.

Now when I reboot my machine automatically unlocks my SD but I’m safe in the knowledge that someone needs a logon to my Surface to access it and if they remove it they need the password for the SD to unlock it.

The final step

This one’s optional but if like me you’re not planning on removing the SD (which I’d really recommend once you’ve added it to your libraries, things gets upset if you do), then you might want to enable write caching on the SD.

Just run up device manager, again win-x is your friend, expand Disk Drives and go to Properties on the SD Memory Card. Select Policies and “Better performance”. Note that with write caching enabled you *must* use the safely remove hardware feature on the notification area on the desktop before ejecting the SD card. If you don’t you might lose data which hasn’t been flushed from memory to the SD.

Dynamic SQL scripting on Windows Phone 7 with LINQ

Robert Garfoot — Fri, 10 Feb 2012 12:13:41 +0000

I recently had cause to look into running dynamic SQL on WP7 for a customer. On a desktop this is easy, you just run some SQL statements through ADO.NET and you’re sorted. On Windows Phone 7 it’s a little trickier. This is because WP7 only exposes LINQ to SQL and it doesn’t support arbitrary SQL execution against your SQL CE databases.

So how to handle it when you have a corrupt DB and want to send a fix to a remote device or you just want to update the DB with some new data.

DB Operations

The first thing I decided was what operations I wanted to support, I limited this to supporting create, update and delete operations since those are the ones we are really look at here. I also limited it to each operation only operating against a single entity type at a time, it just made it easier and that covers most of the scenarios I needed at the time.

Command Serialization

The first problem I needed to tackle was getting the commands down to the phone application, how am I going to script this? I chose to create an object model of DatabaseInstruction objects which represent the serialized format of one of the above operations. I then used JSON as the format for my script as it’s nice and easy to then return that object model from a server to the client and it’s more compact than XML. Of course you can always change the serialization format by creating a new IDatabaseInstructionParser to process different serialization formats into the object model.

I used the excellent JSON.Net library to handle the serialization for me.

Database Commands

Once I’ve gotten a list of DatabaseInstruction objects I convert them into DbCommand objects, these are the objects that do the actual work of talking to the database using LINQ to SQL. That’s handled by calling CreateCommand against each instruction. If you’d like to reuse the same DatabaseInstruction classes in the server component to build the script then I suggest refactoring this to separate the command creation out. I started doing that with the CommandBuilder class but never finished it, currently that class is incomplete and unused.

Parsing

So far so simple. The next challenge was filtering the data in the instructions, in order to do that I needed to pass in predicates in my scripts to apply changes to certain rows or to delete specific items. I downloaded and slightly modified the Dynamic LINQ sample from Scott Guthrie’s blog. This almost worked on the phone out of the box but not quite, I had to chop out support for ‘new’ since the phone can’t do the dynamic code gen bits that the sample uses and I didn’t need the operator for what I was doing.

In the commands I then use the DynamicExpression.ParseLamba() method to create an Expression predicate from the predicate from the script. This can then be used in my command execution with a custom Where implementation that takes an Expression object.

And finally…

Using the library is fairly easy, I’ve put together a sample WP7 app that creates a database and then provides 2 buttons, one runs an JSON script to insert data, the other runs a JSON script to update the data and delete a row. The scripts are in the Content folder in the project and I just use the DatabaseInstructions.Execute() method to run the script. This can either take a TextReader or an IEnumerable if you’d prefer to handle parsing yourself.

As usual the normal disclaimers about demo code apply, use at your own risk. To build the sample just download the DynamicLinq sample code and load it in Visual Studio 2010. It uses NuGet to pull down the JSON.Net bits so just build the solution and it’ll do that automatically.

Enjoy.

Connecting to SharePoint on Office 365 with Windows Phone 7

Robert Garfoot — Sat, 21 Jan 2012 13:18:36 +0000

One of my colleagues recently asked me to look into connecting to a SharePoint site running on Office 365 from a Windows Phone 7 application. Now this is something that the phone has native support for but in this case he wanted to be able to build an application that had added functionality and then called into the SharePoint web service APIs to extract data from SharePoint.

Attempt number 1

At first I thought this would be really easy, add a reference to the web service, call the Logon API and then we’re away. Unfortunately that isn’t the case.

I found this blog article by Paul Stubbs which was a good starting point.

When I implemented this against Office 365 it all seemed good until I actually tried to logon, I kept getting a logon failure and couldn’t figure out why. Eventually I twigged, Office 365 uses federated identity. As a result the SharePoint logon APIs don’t recognise your credentials, it knows nothing about them.

Attempt number 2

I then traced out the flow of an actual logon and found that Office 365 uses login.microsoftonline.com to authenticate against. At least this is the case on my Office 365 site, if you federate with a different provider then you’ll have to adapt this solution appropriately.

Now the flow here is a fairly standard WS-Trust flow, you hit the SharePoint site, that redirects a couple of times internally and then goes off to microsoftonline.com passing it a bit of security information. This asks you for your username and password in a web page and then redirects you back to Office 365 with some more security information.

SharePoint then writes out a cookie with a security token in, as long as web service API requests pass this cookie they’ll work.

So this is simple, I pop up a web browser, hit SharePoint go through the logon flow, grab the cookie once it comes back to SharePoint and we’re good to go.

Except we’re not, the cookie gets written with HttpOnly which means that you cannot programatically get the cookie.

Enter the hack

The solution I came up with is a little brittle but it works ok for now for me. If you look at how the WS-Trust flow works as implemented by this secure token service (STS) after log on it writes out a form with POST data on it containing the WS-Trust security data, then it uses JavaScript to post this back to SharePoint.

So what I do is roughly this:

Check if not logged on
Pop up a web browser control
Navigate to the SharePoint site home page which will redirect to the STS
User enters credentials
I hook up navigation events from the browser control and when I spot a navigate to the page with the POST data from the STS…
Capture the security information from the form from the browser control
Programatically POST the form back to SharePoint using a new CookieContainer and HttpWebRequest
SharePoint completes the WS-Trust flow and issues the SP security cookie which goes into the new CookieContainer
Attach the new CookieContainer to all web service API calls and it’s sorted

Now as mentioned this is a little brittle as if the STS changes how it works a bit then it’ll break but most of the time that’s unlikely, especially if you are running you own STS to federate your corporate logons, you’ll control it’s appearance.

I’ve included some sample code that does this, usual caveats apply. The DefaultSettings class has the SharePoint site address and SSL settings in there, change this to point at your site.

I’ve wrapped the CookieContainer in a SharepointServerContext class to isolate the using code from this. This class also contains other information about the connection the server such as it’s address etc. All of the web service API calls are executed by my own ISharepointCommand classes, these commands all take a SharepointServerContext so they know which server to talk to and can get to the CookieContainer for authentication.

Most of the logon flow code is in the code behind for the LogonView since it needs access to the browser control.

Next steps

There are bugs in the code, things are not complete, this is a work in progress but it does demonstrate the flow mentioned above. Currently if you authenticate and tick remember me it’ll break the next time you run since the flow will be different, it doesn’t cache cookies yet as that’s something else I need to work out so this is not a perfect approach. But hopefully it’ll help as a starting point for people looking at this.

You can download the sample project from here SharePointConnector. Good luck.

Update

After a little bit of investigation with the help of Rob de Beir (see comments below) we’ve discovered that the solution as posted only actually works on E1 Office 365 deployments, if you’re running P1 then it doesn’t work.

This is down to 4 things;

P1 SOAP APIs only work over HTTP, E1 work over HTTPS
There was a bug in the code (gasp) that meant setting SSL = false didn’t work
The logon view didn’t process the POST address from the STS, it was hardcoded
P1 sites have a path

Fortunately this is an easy fix, disable SSL in the DefaultSettings.cs, fix the bug (shown below) and make sure you set the host in the DefaultSettings.cs to have the path too e.g. mysite.sharepoint.com/teamsite.

To fix the bug simply find the line of code in GetListItems.cs where the BasicHttpBinding is created and change it to read;

new BasicHttpBinding(ServerContext.UseSsl ?
 BasicHttpSecurityMode.Transport :
 BasicHttpSecurityMode.None),

There is another bit that needs to change in the LogonView.xaml.cs file too. Replace the OnBrowserNavigated method with this one in order to correctly parse out the return address from the STS.

private void OnBrowserNavigated(object sender, NavigationEventArgs e)
{
    if (!IsLastPage(e.Uri))
        return;

    string content = Browser.SaveToString();
    Regex actionRegex = new Regex("
Add a backing field for the action.
private string _action;

And finally update Logon() to use the new action.
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(_action);

That should fix it all to work on E1 as well as P1. Thanks to Rob for his help in debugging this, I’ll try and get updated source up soon.


No related posts.

TechEd GadgetVote source code

Robert Garfoot — Fri, 12 Nov 2010 10:48:07 +0000

For those people that attended my TechEd Europe session on end to end development in WP7, here is the source code for my demos.

In order to run the demo code you will need VS2010, WP7 SDK, Azure SDK.

Running for the first time

Run VS2010 elevated (needed for Azure) and build the project. Run using the GadgetVote.Client and GadgetVote.Server projects as startup projects.

Once running you will need to go to settings in the client and change the address of the server to localhost:81 (or whatever port your Azure service is running on in DevFabric). You can also choose to use the proper WP7 push notifications service by leaving the check box ticked or use the Azure based stub service by unticking the box. You will need to restart the client app after changing this setting.

It’s a demo project!

It’s a demo project, it will crash and break if you don’t do things just right. If the Azure service hasn’t started by the time the phone app starts then you’ll get an exception from the client app. Just hit F5 and carry on, once the Azure services have started you can go to settings and hit OK and it should register again with the Azure service and work.

Who am I?

You will want to go to settings and add a username for yourself, this is name@domain, I usually use something like rob@emulator or rob@phone1 etc.

I do have friends, honest

Next you’ll need to hit the + button and add a friend, you can just add yourself for now, the name doesn’t matter but the second field must match the name entered in settings.

Adding a gadget

You can then add a gadget by clicking the camera. Check the table storage on your Azure instance though first, the clients must all have registered themselves with push notification endpoints before doing this or you’ll get a crash! You can goto settings and hit OK to force it to re-register.

Multiple clients

You will need to run multiple machines to do this with an emulator on each. If you have phones then you can use those. Azure DevFabric only allows connections from the local machine though, to get around this I run a reverse proxy using IIS and the ARR plugin. Configure a proxy with a URL rewrite rule for something like /azure to map to localhost:81. Then you can use ip/azure for the host name in the client settings on the WP7 app and it’ll work remotely.

Usual caveats apply, this is demo code, it’ll explode if you prod it wrong and don’t use in production.

Enjoy!!

TechEd code coming soon

Robert Garfoot — Fri, 12 Nov 2010 09:27:04 +0000

Just a quick note to say I’ll get the code from my TechEd session uploaded within the next few days so check back next week.

Simulated Push Notifications on Windows Phone 7

Robert Garfoot — Tue, 05 Oct 2010 15:07:00 +0000

I’m currently prepping for my TechEd Europe WP7 session and I like to prepare for the worst. My demo relies on some cloud services and also on WP7 push notifications. Push notifications are nice but they have one drawback for demos, I need an internet connection.

Now in the real world my application would indeed need an internet connection or it would actually be kind of useless, but in demoland I don’t need one as I can run the cloud services portion in the Azure DevFabric which is nice in case the internet connectivity in the demo room goes down, I have a backup.

The same isn’t true of push notifications, they are managed by Microsoft and if I can’t get to them I can run my demo even though my own cloud services are running locally. In order to get around this I wrote a simple WCF service that also runs in my Azure DevFabric along with my other services that can act as a push notification endpoint. It’s not totally seamless but it works quite nicely for me as I now have a fallback for push notifications as well as for my own cloud services.

The Service

The service is a REST based WCF service that has two methods on it’s rather simple interface.

[ServiceContract]
public interface INotifications
{
    [OperationContract]
    [WebInvoke(Method="POST", UriTemplate = "Notify",
        BodyStyle = WebMessageBodyStyle.Bare, RequestFormat = WebMessageFormat.Xml)]
    void Notify(Message message);

    [OperationContract]
    [WebInvoke(Method = "GET", UriTemplate = "Notifications/{id}")]
    Message GetNotifications(string id);
}

The service then queues any incoming messages until the client gets them. The notify endpoint will quite happily take push notification requests from my existing Azure services without modification.

[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single,
                    ConcurrencyMode = ConcurrencyMode.Multiple)]
public class NotificationsService : INotifications
{
    private class NotificationMessage
    {
        public string MessageContentBase64 { get; set; }
    }

    private ConcurrentDictionary> _messages;

    public NotificationsService()
    {
        _messages = new ConcurrentDictionary>();
    }

    public void Notify(Message message)
    {
        // Grab the notification from the message body
        var queryParams = ParseQueryString(message.Headers.To.Query);
        var body = message.GetReaderAtBodyContents();

        XElement data = XElement.Load(body);

        var queue = _messages.GetOrAdd(queryParams["id"], key => new ConcurrentQueue());

        queue.Enqueue(new NotificationMessage
                        {
                            MessageContentBase64 = (string)data,
                        });

        Log.Default.TraceInformation("Notification from: {0}", queryParams["id"]);
    }

    private static IDictionary ParseQueryString(string queryString)
    {
        var queryItems = new Dictionary(StringComparer.InvariantCultureIgnoreCase);

        queryString = queryString.TrimStart('?');
        string[] strings = queryString.Split('&');

        foreach(string queryItem in strings)
        {
            int equalsIndex = queryItem.IndexOf('=');
            if (equalsIndex >= 0)
            {
                queryItems.Add(queryItem.Substring(0, equalsIndex),
                                queryItem.Substring(equalsIndex + 1));
            }
            else
            {
                queryItems.Add(queryItem, null);
            }
        }

        return queryItems;
    }

    public Message GetNotifications(string id)
    {
        XElement response = new XElement("notifications");
        ConcurrentQueue queue;

        Log.Default.TraceInformation("Checking notifications for: {0}", id);

        if (_messages.TryGetValue(id, out queue))
        {
            NotificationMessage message;
            while (queue.TryDequeue(out message))
            {
                response.Add(new XElement("notification", message.MessageContentBase64));

                Log.Default.TraceInformation("De-queued notification for: {0}", id);
            }
        }

        WebOperationContext.Current.OutgoingResponse.Headers[HttpResponseHeader.CacheControl] = "no-cache";
        return WebOperationContext.Current.CreateXmlResponse(response);
    }
}

The Client

The WP7 application isn’t quite as lucky. I could probably have done something that faked getting the notifications a little better but the simplest solution was to just have a background timer that polls my service and gets the notifications. It then processes these using the normal code path for push notifications in my application.

I really should probably use the reactive extensions (RX) to manage my push notifications in the client as that would make them nice and mockable too but for now this works as a solution and keeps the client code reasonably understandable for demo purposes.

All in all it works quite nicely and means I don’t have to have an internet connection to now demo my application, even with push notifications.

Silverlight Navigation With the MVVM Pattern

Robert Garfoot — Wed, 08 Sep 2010 14:36:28 +0000

I recently had a query from a customer that was one of those ones that you think “Aha! That’s easy, you just do this”. Then you think a bit more about it and realise that if you want to do it properly it’s not quite as simple as you first thought.

This particular query related to how to use the navigation framework introduced in Silverlight 3 with the MVVM pattern. For those that don’t know the Model-View-ViewModel pattern is a common pattern often used to build Silverlight and WPF applications since it has strong support for databound UIs and provides good abstraction for unit testing and keeping your view logic separate from the view and the model.

Enter the Silverlight Navigation Framework

Handling the page style navigation that we’ve all become used to on the web can be a real pain in RIAs written using Silverlight, Flash or AJAX involving lots of tracking of page clicks using HTML bookmarks and some liberal use of JavaScript. Fortunately Silverlight 3 added a navigation framework to help with this.

This framework works by you adding a Frame element to your root XAML and then creating many Page derived classes. These classes can then navigate between each other by calling into a NavigationService instance that each page inherits from it’s base class.

The issue with MVVM is that page navigation is a view logic, that means that it should sit inside the ViewModel, however the NavigationService is only on the Page class which the ViewModel doesn’t have access to.

Solving this problem is simple, just pass the NavigationService instance to the ViewModel, job done! Well ok, that works if you hate unit testing. If you like unit testing though you may find you have problems then when it comes to testing your ViewModel as you won’t have a NavigationService instance to pass it.

Additionally since many pages are likely to want to do this I’d like to have a reusable approach that doesn’t take much code to reuse.

The Solution

The solution I came up with is one of a few different ways you could implement this but this works for me at the moment. Feel free to point out any glaring errors in my design though.

Wrapping the NavigationService

First I need to make the NavigationService mockable so I can use it in unit tests. To do this I created a new interface INavigationService that exposes the methods and properties of the NavigationService. This sample version only exposes Navigate() but you could easily expose more as needed.

    public interface INavigationService
    {
        void Navigate(string url);
    }

Not the most complex interface ever devised you’ll agree.

Next I created a class that implemented the interface and took a reference to a System.Windows.Navigation.NavigationService on it’s constructor.

    public class NavigationService : INavigationService
    {
        private readonly System.Windows.Navigation.NavigationService _navigationService;

        public NavigationService(System.Windows.Navigation.NavigationService navigationService)
        {
            _navigationService = navigationService;
        }

        public void Navigate(string url)
        {
            _navigationService.Navigate(new Uri(url, UriKind.RelativeOrAbsolute));
        }
    }

Supporting INavigationService in the ViewModel

Now I had an abstraction I needed to pass the INavigationService to the ViewModel. I wanted to do this in a standard way. I could have made it a constructor argument but I couldn’t always guarantee I’d be there at construction. The best way seemed to be to add a property. I decided to put that property on an interface so I had a defined contract that ViewModels could support.

INavigable.

    public interface INavigable
    {
        INavigationService NavigationService { get; set; }
    }

This interface provides a single property that a ViewModel can implement that will contain a reference to the INavigationService that the ViewModel should use to perform navigation when it needs to.

Passing the INavigationService to the ViewModel

Next I need to create an instance of the NavigationService that wraps the System.Windows.Navigation.NavigationService in the Page class and pass that to the ViewModel. I’d like this to be reusable code and if possible I don’t want any code behind in my View.

This is a perfect use for an attached behaviour. What’s one of those? It’s simply an attached property with a property changed handler on it that hooks up code to the DependencyObject that the property gets attached to. It’s simpler than it sounds and is a nice way of making reusable logic that you want to attach to objects in XAML.

The Navigator.

    public static class Navigator
    {
        public static INavigable GetSource(DependencyObject obj)
        {
            return (INavigable)obj.GetValue(SourceProperty);
        }

        public static void SetSource(DependencyObject obj, INavigable value)
        {
            obj.SetValue(SourceProperty, value);
        }

       public static readonly DependencyProperty SourceProperty =
            DependencyProperty.RegisterAttached("Source", typeof(INavigable), typeof(Navigator), new PropertyMetadata(OnSourceChanged));

        private static void OnSourceChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            Page page = (Page) d;

            page.Loaded += PageLoaded;
        }

        private static void PageLoaded(object sender, RoutedEventArgs e)
        {
            Page page = (Page)sender;

            INavigable navSource = GetSource(page);

            if (navSource != null)
            {
                navSource.NavigationService = new NavigationService(page.NavigationService);
            }
        }
    }

This class provides a single attached property definition of the type INavigable. This property has a handler that when invoked grabs the DependencyObject you are attaching the property to and hooks up it’s Loaded event.

So when you attach this property to a Page instance in XAML it will fire off the PageLoaded method when the Page you attach it to loads. In the page load handler I then query the Page instance for the Source attached property. Remember that this property is of type INavigable. If the source supports INavigable I then create a new instance of the NavigationService, wrapping the Page’s instance and set it on the source using the INavigable.NavigationService property.

And there we have it, a reusable way of attaching the navigation service instance for a Page to the Page’s view model.

The View XAML

And finally using the attached property is a case of assigning the ViewModel to the DataContext of the Page as normal and then doing this.

Summary

So that’s it, my solution. I think it’s reasonable, it minimised the amount of code needed in the View code behind to nil, makes the only code you need on the ViewModel is to derive from and implement INavigable which is one property and to put an attached property on the Page in the XAML. It keeps a good separate of concerns as the ViewModel is still unit testable but it can now support navigation.

Let me know what you think.

Sample code: NavigationSample

*edit* Added a sample