APPA Mundi

Windows Marketplace for Mobile 6.x to be Discontinued

Peter Foot — Wed, 02 May 2012 16:25:00 GMT

If you publish apps on the old Marketplace for Windows Mobile 6.x you should have received reminders that the service will be discontinued in two weeks. If you have been using our Mobile In The Hand product with a managed code app there are a couple of issues to be aware of. Our libraries contain the following two classes to provide programmatic access to the Marketplace client on Windows Mobile 6.x:-

InTheHand.Phone.Tasks.MarketplaceDetailTask
InTheHand.Phone.Tasks.MarketplaceLauncher

If these are called on a device with the Marketplace client installed they will launch the client application however once the service is discontinued no application details will be accessible so this may result in a confusing experience for your users. Consider these classes obsolete as they will no longer be supported and will be removed from the next release.

https://inthehand.uservoice.com/knowledgebase/articles/72785-windows-marketplace-for-mobile-6-x-to-be-discontin

Windows Phone User Group North West - Next meeting 29th May 2012 at MadLab Manchester

Pete Vickers — Wed, 25 Apr 2012 13:55:00 GMT

We have finally arranged the next meeting of the Windows Phone User Group North West.

It will again be at MadLab on the 29th May 2010 at 18:30 and you can register for it here.

We will be having 2 speakers - Chris Hardy will be talking about 'Cross Platform Mobile Application Development With C# and .Net' and our own Andy Wigley will be talking about 'MVVM and Unit Testing on Windows Phone'

Usual start at 18:30 and we will go on until 21:30 - probably across the road for 'refreshments'.

What happens to network calls when your WP7 app goes dormant?

Andy Wigley — Sun, 08 Apr 2012 19:29:00 GMT

Download sample code.

In my Windows Phone training courses and workshops, I explain how the application lifecycle works, and how when your app loses focus – because the lock screen comes up, because your app is interrupted by an incoming phone call, because your code has called a launcher or a chooser, or because the user has pressed the start button to go and run something else – the OS takes a copy of the working memory of your app, suspends all threads and at this moment, your app has become dormant. Since the OS has simply stuck this memory snapshot into a cache, once the user has finished with the interruption and returns to your app, the memory snapshot is quickly reloaded and your app continues from where it left off, as if it has never been away. If however, your user runs *lots* of apps after your app is made dormant, then the OSs cache may become exhausted, so the memory snapshot for your app may be discarded and in this case, your app becomes tombstoned.

When your app reactivates, you can find out whether it has come back from dormant or from the ‘deader’ state of tombstoned, by looking at the IsApplicationinstancePreserved property of the ActivatedEventArgs object in the Application_Activated event handler:

// Code to execute when the application is activated (brought to foreground)
// This code will not execute when the application is first launched
private void Application_Activated(object sender, ActivatedEventArgs e)
{
    if (e.IsApplicationInstancePreserved)
    {
        // Back from dormant – generally not a lot you need to do
    }
    else
    {
        // Back from Tombstoned – usually need to execute some logic to restore state
        …
    }
}

So I have always taught that in general, you don’t really have to write any special code to handle the case where we are coming back from dormant.

Except that is a bit of a simplification! It can almost continue exactly from where it left off, but you still have to think about two specific scenarios where you might need to run some logic to get everything truly back to where you left off:

- Time-dependent logic, where your app is waiting for something to happen on a specific timing, so you were using a timer object to trigger some action after some particular time interval. You will probably need to execute some logic on reactivation here to get everything straight.
- Networking calls. All networking calls are asynchronous, so what happens if your app becomes dormant when a networking request has been made, but the response hasn’t come back yet?

Networking Calls and Dormant State

Well, what actually happens is that when your app is reactivated from a dormant state, any calls that were in progress will complete in error. The network call will complete by reporting a WebException with a Status of Request Cancelled. For example, if your are using the WebClient API, the Request Cancelled status can be detected like this:

public class WebDataService
{
    private WebClient webClient = new WebClient();

    public WebDataService()
    {
        webClient.DownloadStringCompleted += new DownloadStringCompletedEventHandler(webClient_DownloadStringCompleted);
    }

    public void FetchUsingWebClient()
    {
         webClient.DownloadStringAsync(new Uri("http://localhost:8414/MyDataService.svc/DataObjects", UriKind.Absolute));
    }

    void webClient_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
    {
        if (e.Error != null)
        {
            if (e.Error is WebException)
            {
                var wEx = e.Error as WebException;
                if (wEx.Status == WebExceptionStatus.RequestCanceled)
                {
                    System.Diagnostics.Debug.WriteLine("Request was cancelled");
                }
                else
                {
                    // Some other WebException. Do something…
                }
            }
            else
            {
                System.Diagnostics.Debug.WriteLine("WebClient failed with " + e.Error.Message);

                // Some other Exception. Do something…
            }
        }
        else
        {
            System.Diagnostics.Debug.WriteLine("Request completed successfully");

            // Got response! Do something…
        }
    } 
}

Networking Calls and Tombstoned State

When your app is reactivated from a tombstoned state, any record or trace of networking calls that were in progress when the app was deactivated has disappeared. It is up to you to store some kind of state relating to any in progress networking calls – in persistent storage, or the Application or Page state dictionaries - when the app is deactivated. You can then retrieve that state data when the app reactivates from tombstoned and execute whatever logic you need to recover.

Creating a Networking Class that Recovers from Dormant and Tombstoned

Armed with the information above, we can now start thinking about how to create a class to use in our Windows Phone apps that can complete networking calls if the app is deactivated when a request has been made but the response has not come back yet. To do this, I developed a simple ODATA web service that returns a list of four dummy data objects. It’s included in the sample code for this post so I’m not going to waste time explaining how it works, but for those who are interested, I built it to serve some simple POCO objects (Plain Old CLR Objects) using excellent instructions I found in this post here.

In a browser, the output from this service looks like this:

However, the key feature of this service is that I’ve programmed in an artificial 5 second delay on any response, so this gives us time to deactivate our app after the request has been made and before the service sends the response back, so we can test our networking class.

It’s always a good idea to encapsulate related logic together into a single class, and in this case I have created a class called WebDataService which will contain the logic to make a request to the web service, return the results (or report an exception) to any clients of this class and it will – by the time we’ve finished – contain logic to recover from dormant or tombstoned state.

First Iteration – Basic Networking Class

My first iteration simply contains the logic to make the call, handle the response and return the received objects by firing a WebDataRequestCompleted event, or if an error is encountered fire a WebDataRequestException event. The client – which is MainForm in the sample app for this post – subscribes to these events so that it is notified when the request completes.

It includes a few nice embellishments: for one thing, it uses a BackgroundWorker to make the request and handle the deserialization of the response on a worker thread so that we keep all that processing off the UI thread, and it contains a private bool property called isRequestActive which is used to ensure this class can only handle one request at a time. It also uses Jeff Wilcox’s Global Progress Indicator solution to show a progress bar while a request is in progress.

The FetchUsingWebClient method sets the Accept header on the request to application/json to request the data from the ODATA service serialized as JSON, and in the webclient_DownloadStringCompleted method, I use the LINQ to JSON capability of the JSON.NET library (http://json.codeplex.com/) to deserialize the JSON and to create the List of DataObject types that is the retrieved data.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Net;
using NetworkingRecoveryOnReactivationSample.Misc;
using NetworkingRecoveryOnReactivationSample.MyDataServiceReference;
using System.Collections;

namespace NetworkingRecoveryOnReactivationSample
{
    public class WebDataService
    {
        private WebClient webClient = new WebClient();

        public event EventHandler<WebDataRequestCompletedEventArgs> WebDataRequestCompleted;
        public event EventHandler<WebDataRequestExceptionEventArgs> WebDataRequestException;

        private bool isRequestActive { set; get; }

        public WebDataService()
        {
            webClient.DownloadStringCompleted += new DownloadStringCompletedEventHandler(webClient_DownloadStringCompleted);
        }

        public void FetchUsingWebClient()
        {
            // WebClient instance only allows one request at a time
            if (!isRequestActive)
            {
                isRequestActive = true;
                System.Diagnostics.Debug.WriteLine("Starting new Request");

                // Let's do this properly and do our network calls and response processing on a worker thread
                var bgworker = new BackgroundWorker();
                bgworker.DoWork += ((s, e) =>
                    {
                        webClient.Headers["Accept"] = "application/json";
                        webClient.DownloadStringAsync(new Uri("http://localhost:8414/MyDataService.svc/DataObjects", UriKind.Absolute));
                    }
                );
                bgworker.RunWorkerAsync();

                ((App)App.Current).RootFrame.Dispatcher.BeginInvoke(() =>
                    GlobalLoading.Instance.IsLoading = true);
            }
        }

        void webClient_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
        {
            isRequestActive = false;

            ((App)App.Current).RootFrame.Dispatcher.BeginInvoke(()=>
                GlobalLoading.Instance.IsLoading = false);

            if (e.Error != null)
            {
                System.Diagnostics.Debug.WriteLine("WebClient failed with " + e.Error.Message);

                // report exception to client
                if (WebDataRequestException != null)
                    WebDataRequestException(this, new WebDataRequestExceptionEventArgs(e.Error));
            }
            else
            {
                System.Diagnostics.Debug.WriteLine("Request completed successfully");

                // Deserialize using LINQ to JSON
                Newtonsoft.Json.Linq.JObject jObject = Newtonsoft.Json.Linq.JObject.Parse(e.Result);

                var results = from item in jObject["d"]
                              select (new DataObject
                                        {
                                            Id = (int)item["Id"],
                                            Name = (string)item["Name"],
                                            Description = (string)item["Description"],
                                            ANumber1 = (int)item["ANumber1"],
                                            ANumber2 = (int)item["ANumber2"]
                                        });

                // Fire event to inform observers that results are ready
                if (WebDataRequestCompleted != null)
                {
                    WebDataRequestCompleted(this, new WebDataRequestCompletedEventArgs(results.ToList()));
                }
            }
        } 
    }

    public class WebDataRequestCompletedEventArgs : EventArgs
    {
        public WebDataRequestCompletedEventArgs(List<DataObject> objects)
        {
            Data = objects;
        }
        public List<DataObject> Data { get; set; }
    }

    public class WebDataRequestExceptionEventArgs : EventArgs
    {
        public WebDataRequestExceptionEventArgs(Exception exc)
        {
            Error = exc;
        }
        public Exception Error { get; set; }
    }
}

To use this class, I create it and expose an instance of this class through a property in App.xaml.cs:

public partial class App : Application
{
    private static WebDataService webDataService;

    public static WebDataService WebDataService
    {
        get
        {
            if (webDataService == null)
                webDataService = new WebDataService();

            return webDataService;
        }
    }

and in my MainPage.xaml.cs, I hook and unhook the events and make the call to the FetchUsingWebClient method to make the request. I’m not showing the XAML of the UI here, but if you download the sample, you’ll see that it has a button on it to make the request, and a ListBox to show the results:

public partial class MainPage : PhoneApplicationPage
{
    // Constructor
    public MainPage()
    {
        InitializeComponent();
    }

    protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
    {
        base.OnNavigatedTo(e);

        App.WebDataService.WebDataRequestCompleted += new EventHandler<WebDataRequestCompletedEventArgs>(WebDataService_WebDataRequestCompleted);
    }

    protected override void OnNavigatedFrom(System.Windows.Navigation.NavigationEventArgs e)
    {
        base.OnNavigatedFrom(e);

        App.WebDataService.WebDataRequestCompleted -= new EventHandler<WebDataRequestCompletedEventArgs>(WebDataService_WebDataRequestCompleted);
    }

    void WebDataService_WebDataRequestCompleted(object sender, WebDataRequestCompletedEventArgs e)
    {
        Dispatcher.BeginInvoke(()=>
            this.DataObjectsListBox.ItemsSource = e.Data
        );
    }

    private void btnWebClient_Click(object sender, RoutedEventArgs e)
    {
        // Clear context first
        this.DataObjectsListBox.ItemsSource = null;

        App.WebDataService.FetchUsingWebClient();
    }
}

Implementing Automatic Recovery when Reactivating from Dormant

If you run the app using the code as shown above, and press the button on the main page, you’ll see the progress indicator at the top of the page and after about 5 seconds, the web service returns the data and it shows up in the ListBox. So far, so good!

However, if you press the Windows ‘Start’ button on the phone after pressing the WebClient button and before the response comes back, then the app is deactivated and is dormant. Press the Back button on the phone and your app is reactivated but the data does not appear. The data service class fires the WebDataRequestException event to report that the request failed with a WebException.

We can easily update the WebDataService class to allow it to retry the request in this situation. A simple solution would simply be to implement an automatic retry when the request fails with a Request Cancelled status, but I’ve implemented a slightly more refined solution. I’ve added a public bool property called IsReactivatingFromDormant which we can set from our Application_Activating event handler if we are reactivating from dormant and is just a flag that the logic in webClient_DownloadStringCompleted can query the very next time it processes a response. If the flag is set, and the request fails with a Request cancelled status, then we just make the request again. Changes are shown here in italics:

/// <summary>
/// Property that can be set from Application_Activating to allow retry of incomplete requests
/// </summary>
public bool IsReactivatingFromDormant { set; private get;  }

…


void webClient_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
{
    isRequestActive = false;

    ((App)App.Current).RootFrame.Dispatcher.BeginInvoke(()=>
        GlobalLoading.Instance.IsLoading = false);

    if (e.Error != null)
    {
        if (e.Error is WebException)
        {
            var wEx = e.Error as WebException;
            if (wEx.Status == WebExceptionStatus.RequestCanceled)
            {
                System.Diagnostics.Debug.WriteLine("Request was cancelled");

                // Are we just restarting from dormant?
                if (this.IsReactivatingFromDormant)
                {
                    // Request was probably cancelled due to the app going dormant
                    this.IsReactivatingFromDormant = false;
                    // Retry
                    FetchUsingWebClient();
                }
            }
            else
            {
                System.Diagnostics.Debug.WriteLine("Request failed with WebException: " + wEx.Message);

                // report exception to client
                if (WebDataRequestException != null)
                    WebDataRequestException(this, new WebDataRequestExceptionEventArgs(e.Error));
            }
        }
        else
        {
            System.Diagnostics.Debug.WriteLine("WebClient failed with " + e.Error.Message);

            // report exception to client
            if (WebDataRequestException != null)
                WebDataRequestException(this, new WebDataRequestExceptionEventArgs(e.Error));
        }
    }
    else
    {
        System.Diagnostics.Debug.WriteLine("Request completed successfully");

        // Deserialize using LINQ to JSON
        …
    }

    this.IsReactivatingFromDormant = false;
}

You just set this flag from your Application_Activated event handler:

// Code to execute when the application is activated (brought to foreground)
// This code will not execute when the application is first launched
private void Application_Activated(object sender, ActivatedEventArgs e)
{
    if (e.IsApplicationInstancePreserved)
    {
        // Set flag on the data service to allow retry of requests that failed because we went dormant
        WebDataService.IsReactivatingFromDormant = true;
    }
}

With this enhancement, you can cause the app to be deactivated and then reactivated, and the request will be reissued without reporting an error.

Implementing Automatic Recovery when Reactivating from Tombstoned

If you now go into the Project Properties window and check the Tombstone upon Deactivation checkbox and repeat the exercise – deactivate and then reactivate – the app will be tombstoned instead of dormant when you deactivate it.

In this case no data is shown and no error is reported, because when the app is reactivated from a tombstoned state, a new instance of our WebDataService class is created and there is no record of the previous abandoned request. We must implement logic in our data service class to save its state on deactivation and record whether a request was in progress, and then to restore that state on reactivation and if that state tells us that a request *was* in progress, then reissue the request.

This logic can be implemented by a pair of methods: SaveState and RestoreState:

private const string WebDataServiceIsRequestActiveKey = "WebDataServiceIsRequestActive";

/// <summary>
/// Method called from Application_Deactivating to save state
/// </summary>
/// <param name="state">Application State Dictionary</param>
public void SaveState(IDictionary<string, object> state)
{
    // save data on whether we have an active request in the state
    state[WebDataServiceIsRequestActiveKey] = isRequestActive;
}

/// <summary>
/// Method called from Application_Activated if returning from Tombstoned
/// </summary>
/// <param name="state">Application State Dictionary</param>
public void RestoreState(IDictionary<string, object> state)
{
    // See if we have an incomplete request in the state
    if (state.ContainsKey(WebDataServiceIsRequestActiveKey))
    {
        if ((bool)state[WebDataServiceIsRequestActiveKey])
        {
            // Restart the request
            FetchUsingWebClient();
        }
    }            
}

Simply call these methods from Application_Deactivating and Application_Reactivating to implement this new functionality:

// Code to execute when the application is activated (brought to foreground)
// This code will not execute when the application is first launched
private void Application_Activated(object sender, ActivatedEventArgs e)
{
    if (e.IsApplicationInstancePreserved)
    {
        // Set flag on the data service to allow retry of requests that failed because we went dormant
        WebDataService.IsReactivatingFromDormant = true;
    }
    else
    {
        // Restore state of the service
        WebDataService.RestoreState(PhoneApplicationService.Current.State);
    }
}

// Code to execute when the application is deactivated (sent to background)
// This code will not execute when the application is closing
private void Application_Deactivated(object sender, DeactivatedEventArgs e)
{
    // Get the data service to save its state
    WebDataService.SaveState(PhoneApplicationService.Current.State);
}

Summary

This post has shown one technique for handling networking calls that can recover if the app is deactivated while a request is in progress. Every app has its own requirements, so this solution will not necessarily suit all situations. However, in many cases, the general approach shown here of placing your networking code into a dedicated class and implementing recovery logic will allow your apps to continue functioning correctly throughout the different stages of the application lifecycle.

Globalizing and Localizing a Windows Phone App

Andy Wigley — Fri, 06 Apr 2012 10:29:33 GMT

There’s a great post on the Windows Phone Developers Blog on Globalizing and Localizing a Windows Phone App. It’s a great summary of all the good advice that’s out there, but the standout info for me is how to handle different regional variations such as en-US and en-GB, or es-ES and es-MX. I’ve not seen this explained clearly anywhere before – until now!

Read the blog at Globalizing and Localizing a Windows Phone App

Nokia/Microsoft Windows Phone Camp - 31st March 2012

Pete Vickers — Mon, 02 Apr 2012 09:42:00 GMT

Just a quick note of thanks to everyone who came to the Windows Phone camp at LBi last Saturday - we had a great time and hope you did too.

Many thanks to John Cooper from Nokia for all his help, Riaz for his usual excellent help, and Lizzie and her team for all the great organisation.

Thanks to Scott, Dave and Matt for coming along just to help spread their knowledge on Windows Phone - thanks guys.

I have update the 'links' blog to include a couple of new links we discussed, including a link to the excellent presentation from Dave Crawford.

Registration is open for the next camps at LBi on the 12th May, and the Liverpool Arena on the 19th May. Stay tuned for news of any further camps.

Thanks

Pete & Andy

Free Windows Phone 7 training from Nokia/Microsoft/APPA Mundi

Pete Vickers — Tue, 20 Mar 2012 13:33:00 GMT

After the success, and over-subscription to the London Windows Phone 7 camps organised by Microsoft, Nokia have come to the aid of developers, and added more camps in conjunction with Microsoft, again taking place in London at LBi.

The first of these will be held on the 31st of March 2012, with myself and Andy Wigley in attendance from APPA Mundi. You can register now - but be quick - these events have filled up quickly in the past.

LBi is a great venue for these events, having a great 'workshop' area, as well as a great presentation area next to it. You can always play table tennis if you get fed up of listening to us.

Hope to see you on the 31st

Thanks

Pete

Windows Phone SDK 7.1.1

Peter Foot — Mon, 27 Feb 2012 16:49:00 GMT

At MWC today Nokia announced the Lumia 610 which is a lower spec device designed for emerging markets. This is running an updated Windows Phone OS which supports devices with just 256MB of RAM. To enable developers to create apps which support the new lower memory devices Microsoft are releasing an update to the Windows Phone SDK - 7.1.1.

At the moment a CTP has been released so that you can test your applications on a 256MB emulator but you should not install this to your main development machine as it doesn't have a Go-Live license. To try out the new SDK you can download the CTP here:-

http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=28962

There is just one API addition to support this change which is an additional property available from Microsoft.Phone.Info.DeviceExtendedProperties.GetValue - "ApplicationWorkingSetLimit" which will let you know whether you are running on a device with 256MB RAM. If your app/game is sufficiently resource heavy that you don't feel it will run on such a device you can opt out so that your app/game will not be available on these lower powered devices. This is done by adding the Requirements element to your WMAppManifest.xml:-

The other main difference for these devices is there is no support for Background tasks - either Periodic or ResourceIntensive and attempting to add a background task on one of these devices will throw an InvalidOperationException - so it's important to to check the capabilities first. Because of this limitation you need to design your app such that it doesn't rely on a background task and that whatever sync/processing the task normally performs can be done when the app is running in the foreground.

Microsoft have prepared some information on optimising apps for 256MB and it is available here:-

http://msdn.microsoft.com/en-us/library/hh855081(v=vs.92).aspx

Some of the suggestions including using the built in launchers and choosers rather than running functionality such as the WebBrowser control or Bing Maps control within your app. They also suggest avoiding using the page transitions provided by the Silverlight Toolkit but don't suggest an alternative - not sure if this means these devices don't have the smooth page transitions at all or if they are suggesting that doing them from managed code is too resource intensive. You may decide to implement multiple approaches and use different methods depending on the device capabilities. Obviously the trick here is the balance between providing the best possible experience on each platform and avoiding adding too much more code to maintain.

Tasks v1.19

Peter Foot — Wed, 22 Feb 2012 19:28:00 GMT

The latest update to Tasks is now available in the Marketplace. This release continues the improvements to the sync experience by providing more resilience in situations where the network drops out during a sync. It also improves the reminders feature in Windows 7.5 and improves the display of reminders for tasks with very long titles.

http://www.windowsphone.com/en-GB/apps/55fcf880-6b03-e011-9264-00237de2db9e

Follow Up from Windows Phone Camp Bristol

Peter Foot — Sun, 12 Feb 2012 10:58:00 GMT

A few of you who attended the Windows Phone Camp in Bristol asked about the slides and code from the Storing Data and Cloud/Networking session. I've uploaded the latest versions of these slides and the additional Sockets code project to the FTP site. All the links and resources mentioned during the day are on Pete's blog post:-

http://mobileworld.appamundi.com/blogs/petevickers/archive/2011/11/13/links-and-resources-from-windows-phone-camps.aspx

Happy Coding!

How to Databind SelectedItems of the ListPicker and RecurringDaysPicker

Andy Wigley — Thu, 02 Feb 2012 14:41:41 GMT

The ListPicker control from the Silverlight Toolkit is one of those Swiss Army Knife controls – very versatile and really useful. It wasn’t quite versatile enough for me though, as one thing it does *not* do is support setting the SelectedItems property when you have the control configured for multiple selections, which is something I wanted to do, and something you will certainly need to do if you ever want to pre-select some items from the list or you want to databind the SelectedItems property to a property in a data object. In this post, I will show you how to extend the ListPicker so that you can set the SelectedItems property. I will also show you how to do the same thing with the RecurringDaysPicker control from the Silverlight Toolkit, which it turns out, is just a ListPicker configured to allow selection from the days of the week.

ListPicker in Single Selection Mode

The ListPicker is a bit like a ComboBox, and to use it you set its ItemsSource property to say, a List<string> or a list of complex objects and if your list has five or fewer items, when the user taps on it, the list expands in-situ, (as shown with the background selector in the following picture), and if your list has more than five items (as with the accent color selector in the picture), then the control expands to what is called ‘Full Mode’, in other words it shows a new screen (right hand screenshot below) with all the items on it and the user can select from the list. And all that user experience is built into the control and comes for free!

In your code of course, you want to know which item the user selected, and the easy way to do this is to get the ListPicker’s SelectedItem or SelectedIndex property. More usually, you would use the SelectedIndex property particularly if you are using MVVM as it is easy to save the SelectedIndex when you serialize your viewmodel class and restore it when you deserialize the next time your user starts your app or the app returns from tombstoning. However, the SelectedIndex property is only useful when the ListPicker is in single selection mode, i.e. has its SelectionMode property set to Single, which is the default.

ListPicker in Multiple Selection Mode

The ListPicker also supports multiple selections from the user. To use it in this mode, you just set the SelectionMode property to Multiple and now when the user taps on the control, the full mode screen displays with checkboxes so the user can select more than one entry from the list. For example, the sample app for this post looks a bit like this, where the Football Teams control is a ListPicker in MultiSelect mode:

It’s quite simple to program the ListPicker for this kind of usage. First of all, you need to define the templates to use for the list displays, one to be used if the ListPicker items is less than or equal to 5, and one to be used for the full page display whn the number of items is more than that. I’ve defined them in the PhoneApplicationPage.Resources on MainPage.xaml:

    <phone:PhoneApplicationPage.Resources>
        <DataTemplate x:Name="PickerItemTemplate">
            <StackPanel Orientation="Horizontal">
                <TextBlock Text="{Binding Name}" Style="{StaticResource PhoneTextNormalStyle}"/>
            </StackPanel>
        </DataTemplate>
        <DataTemplate x:Name="PickerFullModeItemTemplate">
            <StackPanel Orientation="Horizontal">
                <TextBlock Text="{Binding Name}" Style="{StaticResource PhoneTextNormalStyle}"/>
                <TextBlock Text="{Binding League}" Margin="12 0 0 0" Style="{StaticResource PhoneTextSubtleStyle}"/>
            </StackPanel>
        </DataTemplate>
    </phone:PhoneApplicationPage.Resources>

And you then assign those templates where you declare the ListPicker control:

        <Grid x:Name="ContentPanel" Grid.Row="1" Margin="12,0,12,0">
            <TextBlock Height="30" HorizontalAlignment="Left" Margin="12,73,0,0" Name="textBlock1" Text="Multiselect ListPicker:" VerticalAlignment="Top" />             
            <toolkit:ListPicker Height="100" HorizontalAlignment="Left" Margin="9,109,0,0" x:Name="listPicker1" VerticalAlignment="Top" Width="441" 
                                SelectionMode="Multiple" ItemsSource="{Binding FootballTeams}"
                                Header="Football Teams" FullModeHeader="Football Teams" 
                                ItemTemplate="{StaticResource PickerItemTemplate}" FullModeItemTemplate="{StaticResource PickerFullModeItemTemplate}"/>
            <toolkit:RecurringDaysPicker x:Name="recurringDaysPicker1" Margin="198,259,0,0" HorizontalAlignment="Left" VerticalAlignment="Top" Width="212"/>
            <TextBlock Height="41" HorizontalAlignment="Left" Margin="12,275,0,0" Name="textBlock2" Text="Recurring Days:" VerticalAlignment="Top" Width="166" />
            <Button Content="Set ViewModel Props" Height="93" HorizontalAlignment="Left" Margin="71,433,0,0" Name="button1" VerticalAlignment="Top" Width="306" Click="button1_Click" />
        </Grid>

You’ll notice that the templates contain TextBlock controls that are databound to fields Name and League, and the ItemsSource for the ListPicker is bound to something called FootballTeams. FootballTeams is a property of type List<FootballTeam> on my MainViewModel class:

using System.Collections.Generic;
using System.ComponentModel;
using System.Collections.ObjectModel;

namespace SelectedItemsDataBindSample
{
    public class MainViewModel : INotifyPropertyChanged
    {
        public const string FootballTeamsPropertyName = "FootballTeams";
        private List<FootballTeam> _footballTeams = new List<FootballTeam>();

        public List<FootballTeam> FootballTeams
        {
            get
            {
                return _footballTeams;
            }
            set
            {
                if (_footballTeams == value)
                {
                    return;
                }

                _footballTeams = value;
                RaisePropertyChanged(SelectedTeamsPropertyName);
            }
        }

        public MainViewModel()
        {
        }

        public event PropertyChangedEventHandler PropertyChanged;

        private void RaisePropertyChanged(string propertyName)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            }
        }
    }
}

The FootballTeam class looks like this:

public class FootballTeam
{
    public string Name { get; set; }
    public string League { get; set; }

    public FootballTeam()
    {  }

    public FootballTeam(string name, string league)
    {
        Name = name;
        League = league;
    }
}

The sample app creates an instance of MainViewModel in my App.Xaml.cs, and exposes it via a property called ViewModel:

public partial class App : Application
{
    private static MainViewModel viewModel = null;

    /// <summary>
    /// A static ViewModel used by the views to bind against.
    /// </summary>
    /// <returns>The MainViewModel object.</returns>
    public static MainViewModel ViewModel
    {
        get
        {
            // Delay creation of the view model until necessary
            if (viewModel == null)
            {
                viewModel = new MainViewModel();
                viewModel.FootballTeams = new List<FootballTeam>()
                                            {
                                                new FootballTeam("Leeds", "Championship"),
                                                new FootballTeam("Man U", "Premiership"),
                                                new FootballTeam("Man C", "Premiership"),
                                                new FootballTeam("Chelsea", "Premiership"),
                                                new FootballTeam("Liverpool", "Premiership"),
                                                new FootballTeam("Spurs", "Premiership"),
                                            };
            }

            return viewModel;
        }
    }
}

and the final piece of the jigsaw is to set this instance of MainViewModel to be the DataContext for MainPage.xaml. Notice also that I have set the SummaryForSelectedItemsDelegate property to a method I have written called SummarizeTeams. This is how you provide the ‘summary text’ representation of the users’ selections which is displayed on the MainPage, on the ‘normal’ rendering of the ListPicker before the user interacts with it, by providing a method like this that takes an IList parameter and returns a string:

public partial class MainPage : PhoneApplicationPage
{
    // Constructor
    public MainPage()
    {
        InitializeComponent();
        this.DataContext = App.ViewModel;

        this.listPicker1.SummaryForSelectedItemsDelegate = SummarizeTeams;
    }

    protected string SummarizeTeams(IList selection)
    {
        string str = "*None Selected*";

        if (null != selection && selection.Count > 0)
        {
            StringBuilder contents = new StringBuilder();
            int idx = 0;
            foreach (object o in selection)
            {
                if (idx > 0) contents.Append(", ");
                contents.Append(((FootballTeam)o).Name);
                idx++;
            }
            str = contents.ToString();
        }

        return str;
    }
}

Getting – and Setting – the SelectedItems

After a user has selected items from the ListPicker, you can easily find out what the selected items are by hooking the SelectionChanged event and in the event handler, enumerate the SelectedItems collection. For example:

private void listPicker1_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)
{
    StringBuilder msg = new StringBuilder();
    msg.Append("Selected Teams:");

    if (listPicker1.SelectedItems != null)
    {
        foreach (var item in listPicker1.SelectedItems)
        {
            var team = item as FootballTeam;
            msg.Append(" " + team.Name);
        }
    }

    System.Diagnostics.Debug.WriteLine(msg.ToString());
}

Extending the ListPicker to Support Setting of SelectedItems

Using the standard control, there’s no way to programmatically set the SelectedItems, either by setting the SelectedItems property directly, or by exposing a collection of selected objects through a property of a ViewModel class and using databinding. This is because the SelectedItems property is a read-only property, as revealed if you browse the control class in the Object Browser:

So if you want to set the SelectedItems, we must change the implementation of this property and add a setter to it as well.

There are two ways to do this:

Download the source for the silverlight toolkit from http://silverlight.codeplex.com and modify it yourself so you run with a customised version
Create your own custom control that inherits from ListPicker and implement the altered SelectedItems property in there.

I prefer option 2, as it turns out the code you need to write is pretty simple, and it’s a simpler solution – you can just add your reference to the Silverlight Toolkit assembly through NuGet or directly, and then inherit from the standard ListPicker in your custom control.

The code you need to add a setter to the SelectedItems property looks like this:

using Microsoft.Phone.Controls;
using System.Collections;

namespace SelectedItemsDataBindSample
{
    public class ListPickerEx : ListPicker
    {
        /// <summary>
        /// Gets or sets the selected items.
        /// </summary>
        public new IList SelectedItems
        {
            get
            {
                return (IList)GetValue(SelectedItemsProperty);
            }
            set
            {
                base.SetValue(SelectedItemsProperty, value);
            }
        }
    }
}

That’s it! You can do the same for the RecurringDaysPicker with identical code, and this is demonstrated as well in the sample code for this post.

To use your custom control, first declare the namespace for your custom controls in the Xaml at the top of your page (in this example, these controls are just in the SelectedItemsDataBindSample namespace, in the project assembly):

<phone:PhoneApplicationPage 
    x:Class="SelectedItemsDataBindSample.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"
    xmlns:shell="clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    xmlns:toolkit="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone.Controls.Toolkit"
    xmlns:local="clr-namespace:SelectedItemsDataBindSample"
    mc:Ignorable="d" d:DesignWidth="480" d:DesignHeight="768"
    FontFamily="{StaticResource PhoneFontFamilyNormal}"
    FontSize="{StaticResource PhoneFontSizeNormal}"
    Foreground="{StaticResource PhoneForegroundBrush}"
    SupportedOrientations="Portrait" Orientation="Portrait"
    shell:SystemTray.IsVisible="True" 
    >

and where you declare the ListPicker, simply substitute local:ListPickerEx for toolkit:ListPicker:

        <!--ContentPanel - place additional content here-->
        <Grid x:Name="ContentPanel" Grid.Row="1" Margin="12,0,12,0">
            <local:ListPickerEx Height="100" HorizontalAlignment="Left" Margin="9,109,0,0" x:Name="listPicker1" VerticalAlignment="Top" Width="441" 
                                SelectionMode="Multiple" ItemsSource="{Binding FootballTeams}"
                                SelectedItems="{Binding SelectedTeams, Mode=TwoWay}"
                                SelectionChanged="listPicker1_SelectionChanged"
                                Header="Football Teams" FullModeHeader="Football Teams" 
                                ItemTemplate="{StaticResource PickerItemTemplate}" FullModeItemTemplate="{StaticResource PickerFullModeItemTemplate}"/>
            <TextBlock Height="30" HorizontalAlignment="Left" Margin="12,73,0,0" Name="textBlock1" Text="Multiselect ListPicker:" VerticalAlignment="Top" />
            <local:RecurringDaysPickerEx x:Name="recurringDaysPicker1" Margin="198,259,0,0" HorizontalAlignment="Left" VerticalAlignment="Top" Width="212" 
                                         SelectedItems="{Binding SelectedDays, Mode=TwoWay}" />
            <TextBlock Height="41" HorizontalAlignment="Left" Margin="12,275,0,0" Name="textBlock2" Text="Recurring Days:" VerticalAlignment="Top" Width="166" />
            <Button Content="Set ViewModel Props" Height="93" HorizontalAlignment="Left" Margin="71,433,0,0" Name="button1" VerticalAlignment="Top" Width="306" Click="button1_Click" />
            <Button Content="Set SelectedItems" Height="93" HorizontalAlignment="Left" Margin="71,514,0,0" Name="button2" VerticalAlignment="Top" Width="306" Click="button2_Click" />
        </Grid>

Now you could have code similar to the following to programmatically set the SelectedItems:

// Get the full collection of items:
List<FootballTeam> allItems = listPicker1.ItemsSource as List<FootballTeam>;

// Set the SelectedItems to the 5th and 6th teams
listPicker1.SelectedItems = new ObservableCollection<object>() { allItems[4], allItems[5] };

The key thing to remember here is that the collection of items you set the SelectedItems property to must be a collection containing zero, 1 or more of the exact same objects that are in the main list of items that you supplied for the ItemsSource. The only qualification here is that if your data objects are just simple strings, as is the case with a RecurringDaysPicker for example, then you can just supply a collection of strings for SelectedItems as well – as long as the supplied strings exist in the ItemsSource as well of course.

Using Two-Way DataBinding with SelectedItems

You can also databind the SelectedItems property to a property in a View Model class. The trick here is to declare the property in your view model as type ObservableCollection<object>. In my sample code for this post, I started out by doing the obvious thing of defining a property of type ObservableCollection<FootballTeam>, but it turns out that doesn’t work. Internally the control expresses its list of selected items as an ObservableCollection<object> so when you declare two-way data binding and the control tries to set the bound property in the View Model, it doesn’t know how to convert between an ObservableCollection<object> and an ObservableCollection<FootballTeam> – so just declare the bindable property in your ViewModel as ObservableCollection<object> and everything works fine.

In the FootballTeam sample, the ViewModel class now has a new public property called SelectedTeams:

public class MainViewModel : INotifyPropertyChanged
{
    ...


    /// <summary>
    /// The <see cref="SelectedDays" /> property's name.
    /// </summary>
    public const string SelectedTeamsPropertyName = "SelectedTeams";

    private ObservableCollection<object> _mySelectedTeams = new ObservableCollection<object>();

    /// <summary>
    /// Sets and gets the SelectedTeams property.
    /// Changes to that property's value raise the PropertyChanged event. 
    /// </summary>
    public ObservableCollection<object> SelectedTeams
    {
        get
        {
            return _mySelectedTeams;
        }
        set
        {
            if (_mySelectedTeams == value)
            {
                return;
            }

            _mySelectedTeams = value;
            RaisePropertyChanged(SelectedTeamsPropertyName);
        }
    }
    
    ...

And in the MainPage.xaml, the SelectedItems property is databound to the new property:

        <Grid x:Name="ContentPanel" Grid.Row="1" Margin="12,0,12,0">
            <local:ListPickerEx Height="100" HorizontalAlignment="Left" Margin="9,109,0,0" x:Name="listPicker1" VerticalAlignment="Top" Width="441" 
                                SelectionMode="Multiple" ItemsSource="{Binding FootballTeams}"
                                SelectedItems="{Binding SelectedTeams, Mode=TwoWay}"
                                SelectionChanged="listPicker1_SelectionChanged"
                                Header="Football Teams" FullModeHeader="Football Teams" 
                                ItemTemplate="{StaticResource PickerItemTemplate}" FullModeItemTemplate="{StaticResource PickerFullModeItemTemplate}"/>
           ...
        </Grid>

If you run this sample and tap on the ListPickerEx on the screen and then select some teams, the control sets the SelectedTeams property of the underlying MainViewModel instance. If you tap on the Set ViewModel Props button, the code behind directly sets the SelectedTeams property of the MainViewModel object, and through the magic of databinding, the UI updates. The sample also does the same thing for a RecurringDaysPicker for which the solution is virtually identical.

This sample also implements proper support for tombstoning and saving and restoring state when closed and later re-opened. To do this, it (de)serializes the MainViewModel object to and from isolated storage. This raises more interesting questions on how best to serialize an object that has a property (SelectedTeams) that exposes a list of object references rather than actual object instances. This is demonstrated in the sample code, but the explanation will be the subject for my next post…

Download the sample code

Review of Windows Phone 7.5 Data Cookbook

Pete Vickers — Tue, 24 Jan 2012 20:10:00 GMT

I was recently sent an 'ebook' of the Windows Phone 7.5 Data Cookbook by Ramsh Thalli.

It seems a good time to look at a book on data access for Windows Phone, as Mango introduced local database support using SQL Ce. The book covers:-

Data binding, including element binding, DataContext, data templates, converters.
Isolated storage
Using XML files
Consuming OData, and performing CRUD against OData sources
Using on-device databases, including Perst, SQLite and SQL Server Compact with LINQ to SQL
Consuming REST feeds, and creating a REST service
WCF Data Services
MVVM

Starting with 'Data binding', the book leads you through the various methods of data access available to the Windows Phone developer. Having been involved in the Windows Phone camps over the last few months, I know what a hot topic data access is. The Windows Phone Databound Application is a great way to learn about data binding, but the Data binding chapter of the book explain in very simple terms the art of data binding. You start with simple data binding of text blocks to your text boxes, progress through converters, and end with how to bind data classes to your forms. Each step contains example code, and it all builds together to create a data bound project.

The chapter on Isolated Storage takes you through file manipulation and application settings. This is available here as a downloadable sample chapter. If you follow the samples, you can use our GUI Isolated Storage Explorer to check your output.

XML access was until Mango probably the main data access method used. XML access is covered in depth, including remote XML file access, and builds on the lessons learnt in Data binding and Isolated Storage to bring them all into one project.

Chapter 4 covers Odata, and shows you how to build a data driven project, using Odata from Netflix. Following the pattern already set, the project starts simply, and gradually builds up to use all the features of Odata.

Chapter 5 takes you through database access on the device, starting with SQLite, moving through SQL Ce, and covering Perst from McObject, first ported by our very own Andy Wigley. Personally, I would have preferred more about SQL Ce, but that is more my interest. For those of you using SQL Ce, SQL Server Compact Toolbox from fellow MVP ErikEJ is a 'must have'.

The final 3 chapters get heavy, covering in great detail, REST, WCF and MVVM. Following the pattern already established, all 3 chapters contain detailed explanations, and sample code, beginning with simple examples, gradually getting more complex.

I think this is a book for 'dipping' into, and is a great help when you are looking to solve a particular problem. There are over 30 'recipes' for working with data. This book covers a wide subject, data access, but covers it in depth. As shown by questions on the forums and events, data access on Windows Phone is a hot topic, and this books really helps in explaining the options available to you, and sample projects to guide you. For anyone wanting to know the detail behind the acronyms, this is a great choice.

Review: Making Embedded Systems (Elecia White)

Peter Foot — Thu, 19 Jan 2012 19:53:00 GMT

This title takes a traditional software programmer into the world of embedded system. It covers the process of designing and implementing an embedded system from a sketch through to optimising performance and power consumption.

As an interesting addition, at the end of each chapter, there is a potential interview question for an embedded developer position. It’s an unusual idea but is a way of tying up the topics covered in the chapter. Because the book is written for developers it applies patterns and techniques which the reader will already be familiar with and how they apply to embedded systems.

It emphasises the need to be aware of the limited resources available and how to pare down operations to a minimum to make best use of them. It also talks about various options for input and output for a variety of peripherals and sensors.

The book offers a useful introduction to the world of embedded development to a developer with existing C (or similar) experience. More experienced embedded developers will probably want to delve into more detail on the specific areas, but this is a great starting point.

4/5

Silverlight Toolkit ToggleSwitch Databinding Bug

Andy Wigley — Wed, 18 Jan 2012 20:23:00 GMT

Are you using MVVM? Are you using the ToggleSwitch from the Silverlight Toolkit? Have you got a weird bug where a ToggleSwitch that has its IsChecked property databound to a bool or a bool? property of a ViewModel doesn’t always seem to display the correct ON or OFF value? It may be you have encountered a rather subtle bug in the ToggleButton control.

I have just been developing an app using MVVM and noticed a problem with the ToggleSwitch control from the Silverlight Toolkit for Windows Phone (November 2011 release). I noticed that a ToggleSwitch that had its IsChecked property databound to a ViewModel class did not update the ToggleSwitch UI as expected – but only when the bound property on the viewmodel is changed from true to false and only when the ToggleSwitch is not visible. Puzzled? Let me explain…

This can be easily demonstrated by a slight variant on the well-known Databound App that you can create using the standard project templates. I added an additional property to the ItemViewModel class so alongside the existing LineOne, LineTwo and LineThree properties, it now has an additional property of type bool? called IsActive:

public class ItemViewModel : INotifyPropertyChanged
{
    public string LineOne  { ... }

    public string LineTwo  { ... }

    public string LineThree { ... }
    
    private bool? _isActive;

    public bool? IsActive
    {
        get
        {
            return _isActive;
        }
        set
        {
            if (value != _isActive)
            {
                _isActive = value;
                NotifyPropertyChanged("IsActive");
            }
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;
    ...

Next, I changed the DataTemplate for the ListBox on the main page so that it displays a ToggleSwitch with its IsChecked property databound to the new IsActive property of my ViewModel. For interest, I also added a Checkbox databound in a similar way because ToggleSwitch inherits from CheckBox and I wanted to see if the problem existed with the CheckBox as well. So the DataTemplate looks like this:

            <ListBox x:Name="MainListBox" Margin="0,0,-12,0" ItemsSource="{Binding Items}" SelectionChanged="MainListBox_SelectionChanged">
                <ListBox.ItemTemplate>
                    <DataTemplate>
                      <StackPanel Margin="0,0,0,17" Width="432">
                          <TextBlock Text="{Binding LineOne}" TextWrapping="Wrap" Style="{StaticResource PhoneTextExtraLargeStyle}"/>
                          <TextBlock Text="{Binding LineTwo}" TextWrapping="Wrap" Margin="12,-6,12,0" Style="{StaticResource PhoneTextSubtleStyle}"/>
                          <CheckBox  Content="Is Active" IsChecked="{Binding IsActive}" IsEnabled="False" Margin="0,-6,0,0"/>
                          <toolkit:ToggleSwitch Margin="0,-36,0,0" IsChecked="{Binding IsActive}" IsEnabled="False"/>
                        </StackPanel>
                    </DataTemplate>
                </ListBox.ItemTemplate>
            </ListBox>

Next i updated the code in the constructor of MainViewModel so that it sets ‘runtime one’ IsActive to false, ‘runtime two’ IsActive to true and ‘runtime three’ IsActive to null. When running the List looks like this, just as you would expect:

The CheckBox and the ToggleSwitch controls in the template display the UI you would expect, Unchecked/Off for runtime one, Checked/On for runtime two and Indeterminate/Off for Runtime three.

When you tap on an item in the ListBox, the standard Databound App navigates to DetailsPage.xaml, and in my version, I have added a ToggleSwitch to that page with its IsChecked property databound to the IsActive property. I also added an ApplicationBar to that page with an ‘Edit’ button on it that when pressed navigates to another page called EditDetailsPage.xaml which is similar to DetailsPage.xaml but uses two-way databinding to allow you to edit the fields of the underlying data item. It looks like this:

[I won’t go into the simple code behind this – download the sample code that accompanies this post to see how this is implemented ].

Remember that when the app starts up, the ‘runtime one’ object has IsActive set to false, so the checkbox and ToggleSwitch in the full list on MainPage.xaml are ‘Off’. If you then tap on the Runtime One record in the ListBox, the app navigates to DetailsPage.xaml to show the details of that record. If I then tap on the application bar Edit button, the app navigates to EditDetailsPage.xaml. On that edit page, I have checked the CheckBox so thanks to two-way databinding, the IsActive property of ‘runtime one’ is now set to true. So of course, as we navigate back through the pages, the ToggleSwitch and Checkbox controls that are bound to that property will be checked, correct?

Correct. Everything is as it should be:

So, no problem there. The ToggleSwitch on DetailsPage.xaml is correctly shown as ‘On’ (the left hand screenshot), and on MainPage.xaml, the CheckBox and the ToggleSwitch in the list for runtime one have correctly detected that IsActive property is now true, so are showing as Checked and On respectively.

Now we‘ll reverse that and set IsActive to false again. So tap on runtime one in the list and we navigate to the DetailsPage.xaml, then tap on the edit button in the appbar and we navigate to EditDetailspage.xaml. Tap the checkbox to clear it and then tap Save. This is where things go wrong . The ToggleSwitch controls both on DetailsPage.xaml and in the DataTemplate for the ListBox on MainPage.xaml do not pick up the fact that IsActive is now false – though the CheckBox controls *do* pick it up and display unchecked:

As you can see, the Checkbox has been cleared on the first edit screen – this causes the IsActive property of the viewmodel to be set to false. Pressing the save button on that screen causes a navigation back to the View Details screen (middle screen shot) and as you can see, the ToggleSwitch on that screen hasn’t picked up the fact that the viewmodel has changed since it is still set to On. Another press of the Back key puts you back on the main page, where the ListBox displays both a CheckBox and a ToggleSwitch databound to the IsActive property and here the CheckBox is unset but the ToggleSwitch is still On.

Note that this problem only occurs when the databound ToggleSwitches are not visible. When the IsActive property of the viewmodel class is set, it fires PropertyChanged events in the normal way. In Windows Phone, as you navigate through pages, the control objects that are on the parent screens (such as MainPage.xaml and DetailsPage.xaml in this example) stay in memory but are not rendered to the screen. Although the TextBox and CheckBox controls respond correctly to changes in a databound property of an underlying viewmodel class, the ToggleSwitch does not – well at least not when a bool? type is changed from true to false!

In the download for this post, I’ve included another simple project that shows that there is no problem with a databound ToggleButton as long as it is visible.

The workaround for this? You have to force the ToggleButton to refresh its binding and this is best done in OnNavigatedTo. For example, in OnNavigatedTo on DetailsPage.xaml, add code such as:

protected override void OnNavigatedTo(NavigationEventArgs e)
{

    ...


    // Force the ToggleButton to refresh its binding
    ItemViewModel vm = this.DataContext as ItemViewModel;
    this.ToggleSwitch1.IsChecked = vm.IsActive;
}

For the ListBox on MainPage.xaml, you could use a blunt stick approach and simply toggle the setting of the ItemsSource to force it to renew all its bindings:

protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
{
    base.OnNavigatedTo(e);

    // Toggle the ItemsSource setting to force the ToggleSwitches to rebind
    this.MainListBox.ItemsSource = null;
    this.MainListBox.ItemsSource = App.ViewModel.Items;
}

It’s ugly but effective. More elegant solutions would be possible using the VisualTreeHelper to identify the ToggleButton instances and to refresh them individually, but I leave that as an exercise for the reader

Windows Phone Update Due Shortly

Peter Foot — Fri, 06 Jan 2012 01:32:00 GMT

Microsoft have published details of a new update (7.10.8107.79) which adds a number of fixes to the Mango release. It fixes the issue where the on screen keyboard will randomly hide itself which I've been finding frustrating recently and also a fix for the SMS bug which could disable messaging. It also hopefully finally resolves the issue when forwarding Exchange messages where the original message body would disappear. It hasn't shown up yet but expect it over the next couple of weeks. Full details on all the updates and fixes are published here:-

http://www.microsoft.com/windowsphone/en-us/howto/wp7/basics/update-history.aspx

Developer Unlock Expiry

Peter Foot — Wed, 21 Dec 2011 23:35:00 GMT

When you've developer unlocked your Windows Phone you can merrily deploy and debug on it and everything is great. If you've upgraded to Mango you had to run the Unlock tool again but this is fairly painless. What is not obvious is that the developer unlock has a 12 month expiry from when you first register the device and even when you subsequently use the unlock tool on the same device this never gets extended.

So one day you'll be developing as normal and get the error "Failed to connect to device as it is developer locked. For details on developer unlock, visit http://go.microsoft.com/fwlink/?LinkId=195284.". Instictively you launch the developer unlock tool, enter your App Hub credentials and unlock the phone. This completes with no errors but you'll soon find that it hasn't helped despite the fact you entered valid credentials and your App Hub account is valid.

The solution to this problem is to log into App Hub on the web and go to your account profile, select devices and remove the offending device from the list (here you'll see that the expiry date is shown). After doing this you can run the unlock tool again and successfully unlock the device.

Microsoft could certainly improve this process in the future by using a more descriptive error message and also by improving the unlock tool so that when you try to unlock a device that has expired it refreshed the registration and provide 12 more months of use (just like the manual process described above does).

Merry Christmas, and here's to a wonderful 2012 filled with Windows Phone goodness!

Windows Phone LINQ to SQL and Data Virtualization

Andy Wigley — Wed, 14 Dec 2011 17:05:01 GMT

How to work with large tables in LINQ to SQL on Windows Phone

Introduction to Data Virtualization

Data Virtualization is a technique you use to expose a subset of the data from a large data collection so that only the actual data you need is fetched into memory. To implement data virtualization, you take your data collection which could contain any number of rows – even a million rows or more! – and you create a custom class for your virtualized data collection that implements IList<T> and acts as a facade to the underlying data collection.

IList<T> has a great many methods, but fortunately the only methods you have to implement are:

public int Count

T IList<T>.this[int index]

The count property just returns the number of items in the underlying data collection, while the second is just the indexer and allows you to retrieve the ‘nth’ item from the underlying collection. The rest of the methods of IList<T> must of course be implemented in your virtualized data collection class, but you can just throw the NotImplemented exception – in most usages, they will not be called. The only other method of IList<T> that you might choose to implement is public int IndexOf(Titem) which returns the position of an item in the underlying collection. This becomes useful when you want to do lookups in the collection.

In Windows Phone apps, this is beneficial when you want to display a long list of items in a ListBox. Just set your ListBox ItemsSource property to an instance of your virtualized data collection class, and the ListBox will only fetch the visible items and a few either side (to assist with scrolling up and down the list). You can read more about this technique in Shawn Oster’s blog: Improving ListBox Performance in Silverlight for Windows Phone 7: Data Virtualization or in Peter Torr’s blog: Virtualizing Data in Windows Phone 7 Silverlight Applications.

Data Virtualization with LINQ to SQL

So, on to the purpose of this post. I wondered how to implement data virtualization using LINQ to SQL in Windows Phone Mango. For my test database, I created a database with a single table in it which could be used in a dictionary application. It has 200000 entries in it, and the the Word table looks like this:

Ignore the Sequence column for now – we’ll come back to that at the end. The WordTxt column is up to 128 characters in length and is the Primary Key, while the WordDescription column is up to 1024 characters and holds the description of the word. I’ve filled the table with randomly generated data (using a contorted process – see footnote ) and now we can try to bind the data in this table to a ListBox.

You can download the sample project here (it’s nearly 50MB since it contains a database that is 107MB when decompressed). Compile the project and deploy it onto your target emulator or device.

IMPORTANT: The database is included in the project, but its Build Action is set to ‘None’ and Copy to Output Directory set to ‘Do not copy’ – so you’ll have to manually copy the database onto the target. I’ve done it this way because if you include the database as Content it takes around 5 minutes to build and deploy the app which is tedious when you’re playing with the code. So to deploy the database, either change its Build Action to Embedded Resource and then go away and have a cup of tea while it’s deploying, or use the Isolated Storage Explorer Tool to copy it to the target, or better still the nice tools at http://wptools.codeplex.com .

In the project, in the App.xaml.cs I initialize the data context appropriately for a read only database:

public DictionaryDatabaseContext DbDC;

// Code to execute when the application is launching (eg, from Start)
// This code will not execute when the application is reactivated
private void Application_Launching(object sender, LaunchingEventArgs e)
{
    DbDC = new DictionaryDatabaseContext(
        "Data Source=isostore:/DictionaryDatabase.sdf;Max Database Size=180;File Mode=Read Only;");
    DbDC.ObjectTrackingEnabled = false;
}

// Code to execute when the application is activated (brought to foreground)
// This code will not execute when the application is first launched
private void Application_Activated(object sender, ActivatedEventArgs e)
{
    if (!e.IsApplicationInstancePreserved)
    {
        DbDC = new DictionaryDatabaseContext(
            "Data Source=isostore:/DictionaryDatabase.sdf;Max Database Size=180;File Mode=Read Only;");
        DbDC.ObjectTrackingEnabled = false;
    }
}

The main page just has four buttons on it which navigate to four different pages which use differing ways of binding to the data:

Every page has a ListBox on it which uses the following DataTemplate to format the display of items in the list:

        <DataTemplate x:Key="WordTemplate">
            <StackPanel>
                <TextBlock Text="{Binding WordTxt}" 
                           Style="{StaticResource PhoneTextAccentStyle}"/>
                <TextBlock Text="{Binding WordDescription}" 
                           Style="{StaticResource PhoneTextSmallStyle}" 
                           Width="436" TextWrapping="Wrap" Margin="12,0,12,12" Height="75"/>
            </StackPanel>
        </DataTemplate>

Option 1: Bind directly to the database table

This is just to prove the point. The ‘Load All’ button navigates to a page that just binds the ListBox directly to the database table:

using Microsoft.Phone.Controls;

namespace LargeDBAppSample.Views
{
    public partial class LoadAllPage : PhoneApplicationPage
    {
        public LoadAllPage()
        {
            InitializeComponent();
            this.Loaded += ((s, e) =>
            {
                DictionaryDatabaseContext dc = ((App)App.Current).DbDC;
                listBox1.ItemsSource = dc.Words;
            }
           );
        }
    }
}

When you try this option, the result is predictable. I’m using Peter Torr’s very helpful MemoryDiagnosticsHelper which writes the memory usage alongside the Framerate counters. This throws a debug assert when memory exceeds 90MB, and in this case we hit 104MB:

Option 2: Data Virtualization – Bad Implementation

The second button on the main page takes you to a page that uses data virtualization. In this case, we also have a textbox where the user can enter a search string – because let’s face it, a ListBox that contains 200000 items is not going to give a good user experience. Scroll down to the bottom to find the ‘Y’s?? – I don’t think so .

So the code for the page here looks like this:

public partial class BadDataVirtualizationPage : PhoneApplicationPage
{
    public BadDataVirtualizationPage()
    {
        InitializeComponent();

        this.Loaded += ((s, e) =>
            {
                listBox1.ItemsSource = new BadVirtualizedDataModel();
            }
        );
    }

    private void txtSearch_TextChanged(object sender, TextChangedEventArgs e)
    {
        DictionaryDatabaseContext dc = ((App)App.Current).DbDC;

        var words = from w in dc.Words
                    where w.WordTxt.StartsWith(txtSearch.Text)
                    select w;

        if (words.Count() == 0)
            MessageBox.Show("No matches");
        else
            listBox1.ScrollIntoView(words.First<Word>());
    }
}

As you can see, the ListBox is bound to an instance of BadVirtualizedDataModel. Why is it bad? I’ll explain shortly….

The class implements IList<Word> and as you can see below, it returns the count (which is cached since for some reason the ListBox asks for it multiple times). The indexer property uses some LINQ to SQL to fetch the item in the table at a particular index, and I write the time taken to the Debug Output window. The whole class looks like this:

using System;
using System.Linq;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;

namespace LargeDBAppSample.Model
{
    public class BadVirtualizedDataModel : IList<Word>
    {
        private DictionaryDatabaseContext dc = ((App)App.Current).DbDC;
        int? cachedCount = null;

        public int Count
        {
            get {
                if (!cachedCount.HasValue)
                {
                    var wordcount = dc.Words.Count();
                    cachedCount = wordcount;
                }
                return cachedCount.Value; 
            }
        }

        Word IList<Word>.this[int index]
        {
            get
            {
                Stopwatch sw = Stopwatch.StartNew();

                var word = (from w in dc.Words
                            orderby w.WordTxt
                            select w).Skip(index).Take(1).First();
                
                Debug.WriteLine("Fetched {0} in {1}ms", new object[] { index, sw.ElapsedMilliseconds });
                return word;
            }
            set
            {
                throw new NotImplementedException();
            }
        }

        public int IndexOf(Word item)
        {
            Stopwatch sw = Stopwatch.StartNew();

            var matches = (from w in dc.Words select w).AsEnumerable()
                .Select((matchItem, index) => new { Item = matchItem, Position = index })
                            .Where(x => x.Item.WordTxt == item.WordTxt);

            int position = matches.First().Position;

            Debug.WriteLine("Found position of {0} in {1}ms", new object[] { item.WordTxt, sw.ElapsedMilliseconds });

            return position;
        }

        #region NotRequired

        public int Add(object value)
        {
            throw new NotImplementedException();
        }

        public void Clear()
        {
            throw new NotImplementedException();
        }

        public bool Contains(object value)
        {
            throw new NotImplementedException();
        }

        public void Insert(int index, object value)
        {
            throw new NotImplementedException();
        }

        public bool IsFixedSize
        {
            get { throw new NotImplementedException(); }
        }

        public bool IsReadOnly
        {
            get { throw new NotImplementedException(); }
        }

        public void RemoveAt(int index)
        {
            throw new NotImplementedException();
        }

        public bool IsSynchronized
        {
            get { throw new NotImplementedException(); }
        }

        public object SyncRoot
        {
            get { throw new NotImplementedException(); }
        }

        public void Insert(int index, Word item)
        {
            throw new NotImplementedException();
        }

        public void Add(Word item)
        {
            throw new NotImplementedException();
        }

        public bool Contains(Word item)
        {
            throw new NotImplementedException();
        }

        public void CopyTo(Word[] array, int arrayIndex)
        {
            throw new NotImplementedException();
        }

        public bool Remove(Word item)
        {
            throw new NotImplementedException();
        }

        public IEnumerator GetEnumerator()
        {
            throw new NotImplementedException();
        }

        IEnumerator<Word> IEnumerable<Word>.GetEnumerator()
        {
            throw new NotImplementedException();
        }

        #endregion
    }
}

So when you run this, first impressions are very favorable. The list appears in no time at all, scrolling up and down the list is really fast, and memory usage is only about 24MB. Looks great!

However, everything is not as good as it seems. This is illustrated if you type a letter from later in the alphabet, such as ‘t’ into the Search box. Look at what is reported in the output window now:

There are two lines starting ‘Found Position…’ each taking over 4.3 seconds, and further down the ‘Fetched…’ lines report how long it takes to get an item from the collection at a particular index are now taking over 370ms each. From this point on, scroll performance of the ListBox is terrible. What is going on?

The code that is executing here is firstly the TextChanged event handler finds the first word in the table that begins with the letters entered into the Search textbox:

private void txtSearch_TextChanged(object sender, TextChangedEventArgs e)
{
    DictionaryDatabaseContext dc = ((App)App.Current).DbDC;

    var words = from w in dc.Words
                where w.WordTxt.StartsWith(txtSearch.Text)
                select w;

    if (words.Count() == 0)
        MessageBox.Show("No matches");
    else
        listBox1.ScrollIntoView(words.First<Word>());
}

The lookup is really fast because it is doing a lookup on the WordTxt field which is the primary key.

However, once we have found our word, we call the ListBox.ScrollIntoView(object) method to cause the ListBox to scroll to display the first matching word. The way the ListBox does this is to first call the IndexOf(Word item) method of the data collection to find the index in the collection of the desired item (which it does twice for some reason), and then to call the indexer as normal to pull the required items out of the collection. It is the IndexOf() method that is reporting the 4.3 second search times and the indexer that is reporting times of over 370ms.

The problem here is that an index in a SQL Server Compact Edition database (the underlying database for LINQ to SQL on Windows Phone) is not optimised for random access. There is no efficient way of getting the 109,456th item out of an index. The code used in the indexer is actually an adaptation of what is in the MSDN Windows Phone documentation, topic Local Database Best Practices for Windows Phone, which states:

Use of Data Virtualization and Skip/Take

With ListBox controls, you can use the Skip and Take methods to enable fetching of the appropriate batches of items as the user scrolls through the list. For more information about enabling data virtualization on data-bound ListBox controls, see Improving ListBox Performance in Silverlight for Windows Phone 7: Data Virtualization.

Using the Skip and Take methods ensures that data will not be loaded from the database into memory until it is needed for display in the ListBox control. For example, the following code shows how to retrieve records 501 to 550 from the database.

return
(from f in App.FeedsDB.Feeds                    
select f).Skip(500).Take(50);

Because there is cost to performing this load operation as the user scrolls through the list, this technique should be limited to scenarios where the data set is large (greater than 150 items). For smaller data sets, loading the entire collection into memory and binding to it there is likely to yield better performance.

In actual fact, this best practice advice should be qualified by saying that it should not be used for collections of greater than perhaps 1000. What is actually happening here is that internally, the database engine is having to walk the record collection to implement the Skip(n) part of it. So while it is true to say that the skipped records are not loaded from the database into memory, the database engine is still having to do a great deal of work to identify the record(s) it does need to materialize into memory.

Our indexer looks like this:

var word = (from w in dc.Words orderby w.WordTxt select w).Skip(index).Take(1).First();

However the real damage is being done by the IndexOf() method implementation:

public int IndexOf(Word item)
{
    Stopwatch sw = Stopwatch.StartNew();

    var matches = (from w in dc.Words select w).AsEnumerable()
        .Select((matchItem, index) => new { Item = matchItem, Position = index })
                    .Where(x => x.Item.WordTxt == item.WordTxt);

    int position = matches.First().Position;

    Debug.WriteLine("Found position of {0} in {1}ms", new object[] { item.WordTxt, sw.ElapsedMilliseconds });

    return position;
}

This code was taken from a number of posts found in searches on the internet and while it works well enough, it also causes the database engine to work very hard to give us our result. The only good news with all of this is that memory utilisation remains low at 24MB but that’s no substitute for the terrible performance which makes this solution unusable.

Option 3: Data Virtualization – Better Implementation

The second and third buttons on the main page takes you to two different pages that use a workable implementation of data virtualization. Each shows a different solution to this problem of needing a random access index to a database table. The Good virtualization button takes you to a page that is the same as the one we have just used in the previous example, with the exception that when the page loads, the page calls the BeginInitialize() method on our GoodVirtualizedDataModel class which builds an in-memory lookup table to allow us to easily find the index of a word in the collection. In the form, the page initialization logic looks like this:

public partial class GoodDataVirtualizationPage : PhoneApplicationPage
{
    public GoodDataVirtualizationPage()
    {
        InitializeComponent();

        this.Loaded += ((s, e) =>
        {
            listBox1.ItemsSource = null;

            var vDM = new GoodVirtualizedDataModel();
            vDM.InitializeCompleted += (ss, ee) =>
                {
                    listBox1.ItemsSource = vDM;
                    SystemTray.ProgressIndicator.IsVisible = false;
                };

            vDM.BeginInitialize();
            var pi = new ProgressIndicator();
            pi.IsIndeterminate = true;
            pi.Text = "Initializing..";
            pi.IsVisible = true;
            SystemTray.ProgressIndicator = pi;
        }
        );
    }

…

The GoodVirtualizedDataModel class has a private List<string> field called inMemoryLookup and this is what is initialized by the BeginInitialize() method. That uses a BackgroundWorker to do the work on a background thread, but all it is doing is extracting just the WordTxt field (which is the primary key field) from every Word object in the database and inserting it into the List<string>:

inMemoryLookup = (from w in dc.Words
                   orderby w.WordTxt
                   select w.WordTxt).ToList<string>();

Then in the indexer, instead of the costly .Skip(n).Take(1) operation, the code simply takes the index of the item that is passed in, uses it to fetch the object at that index from the inMemoryLookup collection and that gives it the primary key (the WordTxt) at that index which it uses to do an efficient primary key lookup for the required word:

Word IList<Word>.this[int index]
{
    get
    {
        var word = from w in dc.Words
                   where w.WordTxt == inMemoryLookup[index]
                   select w;
        return word.First<Word>();
    }
    set
    {
        throw new NotImplementedException();
    }
}

In actual fact, as a further optimisation, instead of executing the same query every time the indexer Getter is called, the implementation in the sample uses a Compiled Query to avoid the overhead of the query processor doing the same query analysis on every call. This is the full class:

using System;
using System.Linq;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.ComponentModel;

namespace LargeDBAppSample.Model
{
    public class GoodVirtualizedDataModel : IList<Word>
    {
        private DictionaryDatabaseContext dc = ((App)App.Current).DbDC;
        int? cachedCount = null;
        private List<string> inMemoryLookup;
        private Dictionary<string, int> cachedPositions = new Dictionary<string,int>();

        public event EventHandler InitializeCompleted;

        public void BeginInitialize()
        {
            BackgroundWorker worker = new BackgroundWorker();
            worker.DoWork += (s, e) =>
            {
                inMemoryLookup = (from w in dc.Words
                                  orderby w.WordTxt
                                  select w.WordTxt).ToList<string>();

            };
            worker.RunWorkerCompleted += (s, e) =>
            {
                if (InitializeCompleted != null)
                {
                    InitializeCompleted(this, new EventArgs());
                }
            };
            worker.RunWorkerAsync();
        }

        public int Count
        {
            get {
                if (!cachedCount.HasValue)
                {
                    var wordcount = dc.Words.Count();
                    cachedCount = wordcount;
                }
                return cachedCount.Value; 
            }
        }

        // Prepare a compiled query for optimum performance
        public static Func<DictionaryDatabaseContext, string, IQueryable<Word>> SelectedByIndexWordResult =
            System.Data.Linq.CompiledQuery.Compile(
            (DictionaryDatabaseContext dc, string theWord) =>
                 from w in dc.Words
                 where w.WordTxt == theWord
                 select w
                 );

        Word IList<Word>.this[int index]
        {
            get
            {
                //var word = from w in dc.Words
                //           where w.WordTxt == inMemoryLookup[index]
                //           select w;
                //return word.First<Word>();

                Stopwatch sw = Stopwatch.StartNew();
                var word = SelectedByIndexWordResult(dc, inMemoryLookup[index]).First<Word>();
                Debug.WriteLine("Fetched {0} in {1}ms", new object[] { index, sw.ElapsedMilliseconds });

                return word;
            }
            set
            {
                throw new NotImplementedException();
            }
        }

        public int IndexOf(Word item)
        {
            Stopwatch sw = Stopwatch.StartNew();
            int position;

            if (cachedPositions.ContainsKey(item.WordTxt))
            {
                position = cachedPositions[item.WordTxt];
            }
            else
            {
                var matches = inMemoryLookup
                    .Select((matchItem, index) => new { theWord = matchItem, Position = index })
                                .Where(x => x.theWord == item.WordTxt);

                position = matches.First().Position;

                cachedPositions[item.WordTxt] = position;
            }

            Debug.WriteLine("Found position of {0} in {1}ms", new object[] { item.WordTxt, sw.ElapsedMilliseconds });

            return position;
        }

        #region NotRequired

        ...

        #endregion
    }
}

Using this in-memory lookup table, the results are impressive:

Of course, everything comes with a price. Using this in memory lookup, the building of the in-memory lookup takes 10-15 seconds on a device so you’ll have to show some ‘Please wait’ UI (I use a progress bar) or do it on a background thread while your user is still in the opening screens of your app. The lookup table also takes quite a lot of memory – up to 54MB with this sample set, which is not so bad, but in some earlier tests I did with 500000 items, my in-memory lookup was causing me to exceed the 90MB memory threshold. On the plus side, because the in-memory lookup is well – in memory – it’s easily updated if your app allows items to be added, edited or deleted from the main table.

Option 3: Data Virtualization – Best Implementation

So what do you do if you don’t want to have your users wait while you build the in-memory lookup index? Or you can’t afford the memory that the lookup table requires?

Well, one solution is to let the database do the work for you, and this is what the final option demonstrates. Remember that third column, Sequence, that I said I would come back to? That is performing the same role as an in-memory lookup but instead it’s stored in the data base as well. I wrote a desktop utility program that prepared this database by fetching all the records using the primary key – in other words giving me the Words in alphabetical order – and then sets the Sequence field of each to its position in the collection. I then created a secondary key on the Sequence field (again before including the database in this project), so now I have a fast lookup of words both by WordTxt (the primary key) and by index (the secondary key).

Using this, the final version of my virtualized data model looks like this:

using System;
using System.Linq;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;

namespace LargeDBAppSample.Model
{
    public class BestVirtualizedDataModel : IList<Word>
    {
        private DictionaryDatabaseContext dc = ((App)App.Current).DbDC;
        int? cachedCount = null;
        private Dictionary<string, int> cachedPositions = new Dictionary<string,int>();

        public int Count
        {
            get {
                if (!cachedCount.HasValue)
                {
                    var wordcount = dc.Words.Count();
                    cachedCount = wordcount;
                }
                return cachedCount.Value; 
            }
        }

        // Prepare a compiled query for optimum performance
        public static Func<DictionaryDatabaseContext, int, IQueryable<Word>> SelectedBySecondaryIndexWordResult =
            System.Data.Linq.CompiledQuery.Compile(
            (DictionaryDatabaseContext dc, int theIndex) =>
                 from w in dc.Words
                           where w.Sequence == theIndex
                           select w
                 );

        Word IList<Word>.this[int index]
        {
            get
            {
                Stopwatch sw = Stopwatch.StartNew();

                //var word = from w in dc.Words
                //           where w.Sequence == index
                //           select w;
                //return word.First<Word>();

                var word = SelectedBySecondaryIndexWordResult(dc, index).First<Word>();
                Debug.WriteLine("Fetched {0} in {1}ms", new object[] { index, sw.ElapsedMilliseconds });

                return word;
            }
            set
            {
                throw new NotImplementedException();
            }
        }

        public int IndexOf(Word item)
        {
            Stopwatch sw = Stopwatch.StartNew();
            int position;

            if (cachedPositions.ContainsKey(item.WordTxt))
            {
                position = cachedPositions[item.WordTxt];
            }
            else
            {
                position = (from w in dc.Words
                           where w.WordTxt == item.WordTxt
                           select w.Sequence).First();

                cachedPositions[item.WordTxt] = position;
            }

            Debug.WriteLine("Found position of {0} in {1}ms", new object[] { item.WordTxt, sw.ElapsedMilliseconds });

            return position;
        }

        #region NotRequired

        ...

        #endregion
    }
}

The results speak for themselves:

Memory usage here is around 23MB.

So when not to use this option? Well, this only really works with read-only collections where you can get the Sequence numbers correct in the table before transferring to the device. It won’t work if you start inserting or removing records or changing the ordering – not without having to do massive data updates that would negate the benefit of the approach.

Summary

These examples have shown how to bind a very large collection of records from a local database table to a ListBox. This is rarely a great idea from a user experience point of view, unless you implement some kind of search as I have done in these examples. [An aside: my original intention had been to show a sample using the LongListSelector from the Silverlight Toolkit, configured as a JumpList, but that control does not support data virtualization, despite claims in a few blogs from the team to the contrary .] Nonetheless, a virtualized data source can be used in other situations where you want to avoid materializing all the records from a large table into memory.

So if you are going to implement a virtualized data source, beware of the .Skip(n).Take(n1) syntax recommended by the MSDN docs – that does not work with large collections as it makes the database engine struggle as you get down towards the bottom of the list.

Instead, implement your own way of efficiently determining the position of an item in the list, either by an in-memory lookup collection, or if your data is read-only by embedding positional information into a column in the database table and configuring it as a secondary index.

Download the sample project (around 50MB)

Footnote:

I built this sample database using some excellent tools that deserve calling out. Firstly, I created a ‘big SQL’ database in SQL Express and designed my Word table. I then generated the random data using Red Gate’s excellent SQL Data Generator, part of their SQL Toolbelt product set. They have a 14 day free trial, which was just long enough while I was working on this post!

I then scripted all the data and schema suitable for loading into a SQL Server Compact Edition 3.5 database using the free SQL export and script utility called Export2SQLCE, available here on Codeplex. Thanks Erik for these amazing (and free!) tools. Then it was back to SQL Server Management Studio to create an empty SQL Server Compact Edition 3.5 database and to execute all the scripts that Export2SQLCE had created for me. After this I had a database I could use on Windows Phone. I ran a small console app to set the sequence number in the table.

Last part of the jigsaw was to generate the DataContext. I could have used SQLMetal utility for that, but I prefer to use another of Erik’s free tools, this time the SQL Server Compact Toolbox which allows you to create a data context (amongst many other things).

Thanks guys for these tools!

Submitting Apps to Marketplace with Background Tasks

Peter Foot — Thu, 08 Dec 2011 11:38:00 GMT

I've been working on an update to the Tasks application which adds in background synchronisation using the new background task support in Windows Phone 7.5. As with any app when you submit your XAP static analysis is performed on it to check, for example, that you have declared the correct capabilities based on the functionality in your app. Within a background agent you are only allow to call a subset of APIs - as you would expect you can't play sound effects or draw to the UI (with the exception of toast notifications and tile updates). Because the main app has to include a reference to the dll which provides the background task, and the functionality within the dll is used in both the background task and the main app it made sense to move all of the logic into the background dll. This meant including a number of third-party references. I was very careful to ensure that nowhere in the background task was any restricted API called and it worked perfectly in testing.

The first problem is that upon submitting the static anaylsis looks at all of the referenced dlls and sees that they contain APIs not permitted in a background task and blocks the XAP. One of the culprits was InTheHand.Phone.dll (Part of Mobile In The Hand) because it provides a mixture of helper classes for logic and for UI. As I've been working on the 7.1 version in tandem I've now split this into two assemblies for Windows Phone 7.1 SDK projects. This means we can continue to use InTheHand.Phone in background tasks and add a reference to the second assembly in the main application only.

The second problem is that code within the sync logic calls ScheduledActionService.Add which is disallowed within a background task. This API is used within Tasks to add system-wide reminders (Another new feature for this version) for new task items. The code also has the ability to update and delete reminders based on modified or deleted tasks but these do not seem to have been flagged up as errors. This is a pain because it means that if the device syncs a new task with a reminder set to show before you next open the foreground app we won't have had a chance to register it.

The other issue with the NeutralResourceLanguage is an issue with projects originally created with an older version of the development tools. You can add this setting from the projects properties, Application tab and click "Assembly Information...".

This has been an interesting learning experience and shows that the validation picks up not just APIs used in the background agent code-path but also in referenced assemblies.

Syncing Windows Phone database with backend SQL Server

Andy Wigley — Wed, 07 Dec 2011 17:47:45 GMT

Windows Phone 7 was first released without any local database support which caused raised eyebrows from me and other MVPs who had a background in building Line of Business apps. Over a year ago, I posted about a port of the Perst C# database which had been developed by McObject for a number of clients including desktop Silverlight. I’m pleased to say that McObject were inspired enough by my efforts to add proper support for Windows Phone 7 into their official download which you can get here.

At APPA Mundi, we built and deployed what I’m pretty sure was the first ‘proper’ line of business app for a commercial client in the U.S. in which we populated Perst databases on the server and then copied the database file down to the client. The database has many tens of thousands of records in it, and the app worked – and still works – well. I won’t tell you the name, as you will not be able to find it in marketplace as it is a private distribution.

Since then, Microsoft has released Windows Phone 7.1 SDK, better known as ‘Mango’, which includes support for LINQ to SQL which you can use to access SQL Server Compact databases on the client. Nonetheless, Perst remains a valuable alternative to L2S and can outperform it in many situations.

So, now that we have a choice of databases we can use on the client side, the new ‘ask’ that has gone straight to the top of the ‘Requested New Features’ lists is the ability to sync a local database with a backend database. There’s no solution been announced for LINQ to SQL, but last week McObject announced that the MediFox company have developed a Perst Sync provider which implements the client-side plumbing for a sync solution built around the Microsoft Sync Framework Toolkit. The PerstSyncProvider synchronization code may be downloaded for free at perstsyncprovider.codeplex.com.

The download includes the code for the sync provider and also a simple demo app that shows how you can sync with the sample ListService that you can build from the Microsoft Sync Framework Toolkit. It doesn’t show much in the way of UI, but the code underneath illustrates how easy it is to work with:

Read more about the Perst Sync provider here at Windows for Devices.

The Microsoft Sync Framework Toolkit allows you to create your own sync solutions by provisioning a database with the required sync tracking tables and columns and then exposing a WCF sync service to clients. The server side works with SQL Server out of the box, but it should be simple enough to extend to other databases. On the wire, sync is handled by extensions to the OData protocols. Don’t be fooled into thinking it’s a simple click and deploy solution though: this is a *framework* so be prepared to invest some time into this reading the documentation and studying the samples if you want to build your own sync solution. The toolkit comes with sample clients for HTML5, desktop Silverlight, Windows Phone 7 (synchronizing to flat files in Isolated Storage) and Windows Mobile 6.5.

Links and Resources from Windows Phone Camps

Pete Vickers — Sun, 13 Nov 2011 17:00:00 GMT

We have been running, and are continue to run Windows Phone Camps in the UK.

During the presentations, we include many links to articles, resources etc. - so we decided to put them all in one place

The slides and Hand On Lab files are availble on our server - appmundi.com with a user of wp7camps and the same password

If we mentioned any and didn't put them in the list, please let us know

Thanks

Pete

Windows Phone 7.1 SDK
http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=27570

App Hub
http://create.msdn.com

Windows Silverlight Toolkit
http://silverlight.codeplex.com/

Silverlight for Windows Phone Toolkit in depth
http://windowsphonegeek.com/upload/ebooks/Windows%20Phone%20Toolkit%20Aug%202011%20in%20depth-v1.pdf

Coding4Fun
http://coding4fun.codeplex.com/

Jump Start Training
http://channel9.msdn.com/posts/Mango-Jump-Start-01-Building-Windows-Phone-Apps-with-Visual-Studio-2010

Windows Phone 7 Resource Locator
http://forums.create.msdn.com/forums/t/93178.aspx

Application certification guidelines
http://msdn.microsoft.com/en-us/library/hh184843(v=VS.92).aspx

Marketing resources
http ://create.msdn.com/en-us/education/basics/marketing

Application Submission Walkthrough
http://create.msdn.com/en-US/home/about/app_submission_walkthrough

Screenshot Tool
http://www.innovativetechguy.com/?p=13&nbsp#awp::?p=13

XNA-UK XAP test service
http://xna-uk.net/groups/xnaukxap/default.aspx

Windows Phone 7 Screen Shot Tool
http://www.innovativetechguy.com/?p=164#awp::?p=164

Mike Ormond’s Templates for Paint.net
http://blogs.msdn.com/b/mikeormond/archive/2011/03/21/windows-phone-7-iconography.aspx?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%3A+mikeormond+%28Mike+Ormond%27s+Blog%29

GUI Interface for Capability Detection
http://appamundi.com/software/CapDetect.1.0.zip

GUI Interface for Isolated Storage Explorer Tool
http://appamundi.com/software/GUI_Iset.1.1.zip

Creating a Windows Phone 7 Trial Application: Implementation and Best Practices
http://www.windowsphonegeek.com/articles/Creating-a-Windows-Phone-7-Trial-Application-Implementation-and-Best-Practices

Beginning C# - Robe Miles C Sharp Yellow Book
http://www.robmiles.com/c-yellow-book/ or http://www.robmiles.com/c-yellow-book/Rob%20Miles%20CSharp%20Yellow%20Book%202010.pdf

Rob Miles - Writing Silverlight and XNA apps for Windows Phone
http://www.robmiles.com/c-yellow-book/Rob%20Miles%20Windows%20Phone%20Blue%20Book.pdf

APPA Mundi Blogs
http://mobileworld.appamundi.com/blogs/

Windows Phone SDK 7.1 RC
http://go.microsoft.com/?linkid=9772716

Obfuscation and Analytics
http://www.preemptive.com/windowsphone7.html

Windows Phone Developer Support
http://create.msdn.com/en-us/home/feedback

Windows Phone User Group
www.wpug.net

Community Windows 7 Development book
http://www.lulu.com/product/file-download/building-windows-phone-apps-a-developer%e2%80%99s-guide/17266976

Jeff Blankenberg - 31 days of Mango
http://www.jeffblankenburg.com/2011/10/31/31-days-of-mango/

Jeff Wilcox - Unit Testing
http://www.jeff.wilcox.name/2010/05/sl3-utf-bits/

Jeff Wilcox - Metro Grid Helper
http://www.wpcentral.com/metrogridhelper-visual-aid-designers-and-developers

SQL Compact Toolbox including GUI Interface for SQLMetal
http://visualstudiogallery.msdn.microsoft.com/0e313dfd-be80-4afb-b5e9-6e74d369f7a1/

Mike Ormonds Blog
http://blogs.msdn.com/b/mikeormond/

Windows Phone Developer Blog
http://windowsteamblog.com/windows_phone/b/wpdev/

Ad Monetization - Best Practices
http://advertising.microsoft.com/wwdocs/user/en-us/forpublishers/Ad-in-Apps-Monetization%20Best%20Practices_3-1-2011.pdf

XNA - UK XAP Test service
http://xna-uk.net/groups/xnaukxap/default.aspx

Windows Azure Toolkit For Windows Phone
http://watwp.codeplex.com/

Windows Phone Metro Design - Channel 9 from Techdays of Dave Crawfords excellent presentation
http://channel9.msdn.com/Events/TechDays/Techdays-2012-the-Netherlands/2289

Slides and HOLS
ftp://apamundi.com

user and password wp7camps

To receive a developer phone you will need to be provide:

App Hub Publisher Name
Live ID
Screenshots of a new app that you will publish in the next 30 days.
Full Name
Address
Telephone Number

Requests can be sent to UKWPrequests@microsoft.com

Only one handset per developer

Windows Phone Workshop–Manchester

Andy Wigley — Mon, 26 Sep 2011 06:35:07 GMT

Just a very brief note as I’m about to start giving a Windows Phone workshop to Nokia developers in Milan

Big thank you to everyone who came to the workshop in Manchester on Saturday 24th September. You were a great and enthusiastic crowd!

I have started posting up the slides and code at this Skydrive share. Three of the sessions are up there now, and the rest will follow before the end of today.

Thanks for coming to the Workshop!!

Showing Mango Features on Marketplace

Peter Foot — Tue, 20 Sep 2011 20:30:00 GMT

The Windows Phone team have posted to their blog about application updates with a couple of useful points:-

From October you will again be able to publish updates to your 7.0 apps independently from 7.5 (previously once you had published a Mango update your 7.0 app would be locked). It does mean potentially being in limbo for a month but at least you are not stuck completely with no way of updating a 7.0 app. This is important as it will take some time before many users will have the opportunity of upgrading to Mango.

When submitting apps there is only one description for both versions of your app so you must describe which features are for Mango only. For the purposes of Screenshots there is now an officially accepted overlay which can be used to indicate Mango-only functionality. You can download a ZIP containing the overlay and examples here:-

http://create.msdn.com/downloads/?id=882&filename=Marketplace_7.5_Badges.zip

The full blog post is here:-

http://windowsteamblog.com/windows_phone/b/wpdev/archive/2011/09/20/submit-windows-phone-7-5-apps-today-update-7-0-apps-in-october.aspx?utm_source=twitterfeed&utm_medium=twitter

Inaugural meeting of Windows Phone User Group (North West)

Pete Vickers — Sat, 17 Sep 2011 06:40:00 GMT

On Tuesday the 13th of September, we finally held the first meeting (hopefully of many) of the WPUG in Manchester. Matt Lacey has been running the WPUG in London for over a year, and a northern meeting has been mooted for a while.

This finally came about due to the efforts of Rick Garner, Chris Hardy and a bit of input from myself.

The meeting was held at the Manchester Digital Laboratory (MadLab), a centrally located, but well hidden venue in Manchester's 'northern quarter'. Once you worked out that MadLab was the abbreviation for Manchester Digital Laboratory, the task was a little easier, although with the closed shutters, and just a faded sign over the intercom, it was still a challenge. MadLab is ideally placed though, and the room was just right for our needs. We were well looked after - so thanks again to MadLab.

We started around 6:30 with a smaller audience than the registrations indicated, so thanks to everyone who made the effort. We had attendees who had traveled on the day from Birmingham, Sheffield and Liverpool to name but 3, and Ben who is based in Durham but was working in Manchester.

After the introductions, and we found out why everyone was there, I did a presentation on Marketplace submission - tips and tricks. This simulated a wide ranging discussion from development to submission, with everyone contributing. Special thanks to Simon Jackson for highlighting the testing service provided by the the XNA-UK XAP test service. They support testing of all apps / games in either Silverlight or XNA on the service and provide a wealth of testing capabilities from marketplace testing to UI/UX guidance and support. All for free.

We had a short discussion about what we wanted to see in the future (Expression Blend, Mono, data binding), and who we could 'press gang' into speaking at the meetings.

Thanks to Paul Lo from Microsoft, we raffled off some swag, including a very nice Windows Phone laptop bag, and then retired across the road to a very nice bar for some socialising and geek talk.

We are HOPING to run the next meeting on Tuesday 8th November at the same place - so stay tuned for more details.

Again, thanks to Rick, Chris and Matt - and here are some photograhs from the event.

Working with Marketplace Exported Reports

Peter Foot — Mon, 12 Sep 2011 13:14:00 GMT

When Microsoft refreshed the Windows Phone developer portal in advance of the Mango refresh they added various improvements to reporting, an important one being export to file (XLSX). When you open the exported payout detail reports in Excel and enable editing you'll see a number of warnings against a couple of columns. This is because the data is formatted as text but Excel recognises that the contents are numbers. In order to use these values in formulas or graphs you'll need to convert them to numerical values.

The easiest way I found to do this was to select an empty cell and Copy it, then select the entire columns of "Units Sold" and "Royalty", right click and select "Paste Special". From the popup select "Add" as the operation and click "Ok". Now all your number columns are really numbers (you'll see the formatting change to right alignment).

Mango Jump Start Videos–Just Released!

Andy Wigley — Thu, 08 Sep 2011 13:48:05 GMT

Microsoft have announced availability of the HD-quality video recordings – FREE – on Channel 9!

· The 14-hour course covers all aspects of Windows Phone development Visual Studio 2010, Silverlight, Expression, data storage, networks, user interface, XNA and the Marketplace.

· “Team-teaching” approach led by MVPs Rob Miles and Andy Wigley

· Every module is an engaging discussion, packed with best practices and real-world demonstrations

Home page for the entire course on Channel 9: “Building Applications for Windows Phone Mango Jump Start”

· Links directly to specific modules:

o Mango Jump Start (01): Building Windows Phone Apps with Visual Studio 2010

o Mango Jump Start (02): Silverlight on Windows Phone—Introduction

o Mango Jump Start (03): Silverlight on Windows Phone—Advanced

o Mango Jump Start (04): Using Expression to Build Windows Phone Interfaces

o Mango Jump Start (05): Windows Phone Fast Application Switching

o Mango Jump Start (06): Windows Phone Multi-tasking & Background Tasks

o Mango Jump Start (07): Using Windows Phone Resources (Bing Maps, Camera, etc.)

o Mango Jump Start (08a): Application Data Storage on Windows Phone | Part 1

o Mango Jump Start (08b): Application Data Storage on Windows Phone | Part 2

o Mango Jump Start (09): Using Networks with Windows Phone

o Mango Jump Start (10): Tiles & Notifications on Windows Phone

o Mango Jump Start (11a): XNA for Windows Phone | Part 1

o Mango Jump Start (11b): XNA for Windows Phone | Part 2

o Mango Jump Start (12): Selling a Windows Phone Application

· Links to course materials on Born to Learn

FREE GUI add-on for Isolated Storage Explorer

Andy Wigley — Fri, 02 Sep 2011 09:08:19 GMT

Last week in the JumpStart video webcasts, I showed how you use a new tool that is included in the Windows Phone 7.1 SDK – the Isolated Storage Explorer Tool. This handy tool allows you to list the files in Isolated Storage on the emulator or a develop-unlocked device for an app you are developing, or to copy the files to and from your development PC. It’s very useful but is a command line tool.

But we all prefer a graphical user interface, don’t we? So here at Appamundi, we’ve built one. My colleague Pete Vickers has already blogged a detailed post all about it, so if you want to learn more, go to Pete's' post on GUI-ISET where Pete explains how to get it and how it works.

Enjoy!