What is the difference between the following two commands?

powershell.exe -Command "& {invoke-command {throw 'error'}}"

powershell.exe -Command "& invoke-command {throw 'error'}"

As it turns out, the first one will exit with error code 0, the second one will exit with error code 1. This in turn is very important if you want to integrate some powershell command into your build process, and want to make sure that the build does or does not fail if the invoked command fails. An example from real life would be stopping and starting a web server, such as

powershell.exe -Command "& invoke-command -ComputerName MYSERVER {Import-Module WebAdministration; Stop-Website Default}"

In my case I needed to do automatic deploy to a web server from a CI system, and thus it was important to mark the build as failed if my commands to the web server didn't get through. Since I am somewhat of a beginner to powershell, it took a while to find that wrapping the command in curly braces was the cause.

I hope this is of some use if you find your build succeeding even though your powershell commands failed.

This time was no different, so when I finally reached some sort of understanding I ended up with this blog post. I’ll try to explain charms and contracts. I also want to show how you can use a charm, more specifically the search charm, to extend your application into Windows 8.

Charms and contract - no comprende?

Let’s start with charms. As it is, you get five charms in Windows 8. You have Search, Share, Start (you can’t really do anything with this one, it just shows the home screen), Devices and Settings. They can either be accessed by sliding in from the right hand side or, if you are using a mouse, you can find them in the bottom left. You can think of charms as a more powerful version of the traditional start menu. A start menu that you can use to extend your application into the operating system.

What about contracts then? Contracts are what connect your application to the charms. You just select the required contract in your appmanifest and then voilà. You can write all of your code without doing this, but then will get an AccessViolationException when running your code - which tends to go against best practice.

Implementing the search charm

So, I started with a basic implementation of the search charm. As a test application I had my conference application that I wrote for Øredev. First up, declare the contract in order to avoid that nagging exception. Just open up your Package.appxmanifest file and declare your application as one that can interact with the search charm.

If we start our application now and then press the search charm we will see our own little Øredev application, at the very top with the ugly icon, in the list for applications implementing the search contract. That’s basically all one need to know about contracts.

Now we’re all set up to start coding. In App.xaml.cs, add the following code.

protected override void OnLaunched(LaunchActivatedEventArgs args)
{
    ActivateSearchCharm();
    ShowCollection();
    Window.Current.Activate();
}

private void ActivateSearchCharm()
{
    var pane = SearchPane.GetForCurrentView();
    pane.QuerySubmitted += QuerySubmitted;
    pane.SuggestionsRequested += SuggestionsRequested;
    pane.ResultSuggestionChosen += ResultSuggestionChosen;
}

protected override void OnSearchActivated(SearchActivatedEventArgs args)
{
    // the first page in a collection of many - just for testing
    ShowSplit(_sampleData.GroupedCollections.First(), args.QueryText);
}

What we get here is basically three different events and one override that you should handle in order to implement the search charm.

• Event – QuerySubmitted
• Event – SuggestionsRequested
• Event – ResultSuggestionChosen
• Override – OnSearchActivated

We start with the override of OnSearchActivated. This will trigger if our application is not in the foreground and you swipe out the right pane, press the search charm and then tap the application. In the screenshot below you can see what happened when I did just that. In this case I just show a plain view containing all the talks for the Agile track, naturally, one should navigate to something more suitable in a real application.

We continue with the implementation of QuerySubmitted. This event will fire when the user enters a query and then press enter. I to remind any and all that this code is only intended to make my example work, I would not implement any real search functionality this way.

private void QuerySubmitted(SearchPane sender, SearchPaneQuerySubmittedEventArgs args)
{
    var items = page.Items as SampleDataCollection;
    page.Items = items.OfType<SampleDataItem>()
                      .Where(a => a.Description.Contains(args.QueryText));
}

Right, so we pick out all the items bound to the page. Then we pick out any item that has a description that contains the query string. To test my code I simply entered “someone” and tapped enter.

As you can see, all other sessions, not containing the word “someone” are removed, only showing the session that match the search criteria.

This was basically all that I expected from the search charm. But there’s actually one more thing to the it that can really make your application shine. The secret sauce? SuggestionsRequested and ResultSuggestionChosen.

private void SuggestionsRequested(SearchPane sender, SearchPaneSuggestionsRequestedEventArgs args)
{
    var suggestions = args.Request.SearchSuggestionCollection;
    var items = page.Items
                    .OfType<SampleDataItem>()
                    .Where(i => i.Category.StartsWith(args.QueryText, StringComparison.OrdinalIgnoreCase));

    foreach (var item in items)
    {
        suggestions.AppendResultSuggestion(

                    item.Category,
                    item.Title,
                    item.Title,
                    StreamReference.CreateFromUri(new Uri(item.ImagePath)),
                    item.Title);
    }
}

private void ResultSuggestionChosen(SearchPane sender, SearchPaneResultSuggestionChosenEventArgs args)
{
    var items = page.Items as SampleDataCollection;
    page.Items = items.OfType<SampleDataItem>()
                      .Where(a => a.Title == args.Tag));
}

So, this is what happens. When the user start to write in the search field, SuggestionsRequested is called, once called we can find any partial matches for the query string. In my case I match against everything that is the start of Category. Then I add those results to the search charm with AppendResultSuggestion(string text, string detailText, string tag, StreamReference image, string imageAlternateText). This will give us this very neat behavior.

If the user starts writing a word we can send suggested items to the search charm. If the user taps on one of them it will trigger ResultSuggestionChosen where we will get the Tag for the selected item allowing us to display it. Also notice that “Joha” gets highlighted in the suggestion list; this is done automagically by Windows 8.

Possibilities

Personally - I’m very excited about this. Charms really take one step closer to really erase the borders between the OS and your application. Much like what Microsoft has done with Windows Phone. I believe that this is the right way to go and I look forward to see it evolve.

But - there’s always a but. Don’t implement it if your application doesn’t have the need for it. It can be pretty annoying to have several applications taking up space in the search pane without having any real reason for doing so.

The working title was actually “Allowing Windows 8 Metro applications to access files”, but I think that this one has more Omph! to it.

Someone moved my cheese!

If this was a normal application and I wanted to load a xml file from disk, I would probably do something like this.

XDocument xDocument = null;
using(var fileStream = File.OpenRead(@"C:\data.xml"))
{
    xDocument = XDocument.Load(fileStream);
} 

But .NET Framework 4.5 and WinRT is something new and really different. Reading files from disk just are not what it used to be. Just start to write System.IO. and you get – well, not much.

With WinRT, any operation that potentially can run longer than 50 ms has been converted to an async method. So, when it comes to reading a file you get a bunch of them. After some frantic googling and experimentation (without ReSharper and with an American keyboard) I managed to create this async file reading method.

private async Task<XDocument> ReadFileAsync(string fileName)
{
    var file = await KnownFolders.DocumentsLibrary.GetFileAsync(fileName);
    var readable = await file.OpenAsync(FileAccessMode.Read);
    uint size = (uint)readable.Size - 1;
    var stream = readable.GetInputStreamAt(0);
    var reader = new DataReader(stream);
    await reader.LoadAsync(size);
    var result = reader.ReadString(size);
    return XDocument.Parse(result);
}

Not quite as streamlined is it? I don’t know about you, but when I look at this, I certainly feel that I have a lot of new stuff to learn. So, did it work?

No. It did not.

May I please access a file?

To be a little more precise, nothing happened at all. Well, something did happen. An exception was thrown when I tried to read a file. But since Visual Studio 2011 is not by default set to always break for any thrown CLR exception I only got a line in my output window. With hindsight I probably should have looked there directly, but I didn’t. So I noticed this after quite some time.

WinRT information: Access to this location requires a corresponding capability.
A first chance exception of type 'System.UnauthorizedAccessException' occurred in mscorlib.dll

What it basically means is that you need to ask nicely before accessing any file. Also, you need to specify which kind of files you want to access and where you would like to access them. You can do this by opening your Package.appxmanifest found in your solution directory.

Since I had placed my xml files in “My Documents”, I first needed to add the capability to read from that folder. (click on the image to see a bigger version)

The next step was to declare my application association with xml files. In the tab Declarations you first chose to add File Type Associations.

Now you need to specify that it is a xml file that you want to read.

You can enter any name that you want and as file type I just entered “.xml”. Pressed F5 and launched my application. So did it work?

Yes. Yes it did.

To be perfectly honest

I’m not still not happy with my lack of understanding with how file access actually works. Right now it just seems overly complex to me. Important to note is that both Windows 8 Metro application development and WinRT is in an extremely early stage. A lot can still change.

Also - thanks to Håkan that helped me out with the application design.

The previous entry, where I demonstrated how to use databound controls in xaml based webservice is available here.

The purpose of this post is to provide an overview of methods that will allow your application to seem to "run in the background" eventhough Windows Phone doesn't actually allow it.

These methods are not hacks, they are well-documented and intended for the purpose that I describe here. I just couldn't find a good overview for this purpose anywhere else, so I decided to try to summarize the documentation from msdn.

Overview

There are a number of techniques that can be used to make your application (seem to) do stuff, eventhough it is in the background:

• Tiles
• Tile schedule
• Push notifications
• Alarms and reminders
• Scheduled tasks
• Background audio
• Background file transfer

Tiles

Tiles are the big squares that make up the start-page.

An application can have to kinds of tiles:

• Application tile
  Created by user when he "pins" the application to the start screen.
  Each application can have exactly 1 application tile on the start screen.
  When the users taps the application tile, the application is launched to the normal startpage.
• Secondary tiles
  Created in code from the application.
  Each application can have any number of secondary tiles.
  A secondary tile can act as a deep link into the application, so it can bypass the normal startpage.

If you set one or more of the properties on the back of the tile, Windows Phone will flip back and forth between the front and back of the tile with a nice animation, making your app look alive.

In project settings you can set the title and background image of your application tile. If you want to set the count or any of the back content, you can do this programmatically when the application runs or by editing /Properties/WMAppManifest.xml in your project.

All properties of secondary tiles are set programmatically.

Fore more information on tiles see Tiles for Windows Phone 7.

 Tile schedule

You can create a(ny number of) ShellTileSchedule that will update your application tile or any of your secondary tiles.

The schedule can run once, a number of times or indefinitely.

The schedule can run hourly, daily, weekly or monthly.

When you create the schedule, you supply a RemoteImageUri, from which the phone will attempt to fetch a new background image for the frontpage of the tile.

You can not change anything else on the tile.

For more information on tile schedules see How to: Schedule Tile Updates for Windows Phone

Push notifications agents

Push notifications provide a way for a third party developers to push messages to the phone.

Types of push notifications:

• Toast
  a toast message is shown on the top of the screen. If the user taps the toast, the application is launched.
  
  Toast messages are not shown if the application is running.
• Tile
  Updates the application tile or any of the secondary tiles, with the supplied values. This could include (but is not limited to) a new count, or urls to new images.
• Raw
  Raw messages do not in themselves trigger any UI and are only delivered if the application is running.

Push notifications cannot start your application or trigger any processing except for download of images for the tiles.

For more information about push notifications see Push Notifications for Windows Phone

Alarms and reminders

By setting alarms and reminders, you can launch the phones default UI for alarm or reminder at a specified time (accuracy < 1 minute).

In short, alarms are meant to be loud and insisting (like an alarm clock) and reminders are more discreet (like the reminder for a calendar appointment).

For more information about alarms and reminders see Alarms and reminders overview for Windows Phone

Background agents

Scheduled task

Scheduled tasks associated to your application, allow you to execute code eventhough your application is not running. Scheduled tasks cannot have UI or launch applications, but may trigger tile update or toast notifications.

Scheduled tasks are restricted by requirements for memory usage, time until completion, available APIs, battery level, device limit on total allowed scheduled tasks etc.

If these restrictions are not met the task will not run or be terminated.

You have the choise between two types of tasks

• Periodic task
  - Runs regularly (every 30 minutes +- 10 minutes)
  - May only run for 25 seconds
• Ressource intensive task
  - Runs when certain conditions are met: external power+high battery, wifi, screen lock, no call etc
  - May run for 10 minutes

Tasks need to be rescheduled by the application every 2 weeks. They cannot reschedule themselves. If a task fails two consecutive times it will be be unscheduled.

The restrictions may cause a scheduled task to never be run.

For more information about scheduled tasks see Background agents for Windows Phone.

Background audio

An AudioPlayerAgent is a specialized background agent, that allows you to control playback of local or streamed audio through the Zune Media Queue eventhough your application is not running.

The restrictions listed for scheduled tasks do not apply to AudioPlayerAgents.

For more information about background audio see Background Audio Overview for Windows Phone

Background file transfer

Background file transfer allows your application to queue a number of up- or downloads that will be executed in the background, regardless of wether the application is running in the foreground. The system manages the queue and decides wether it will process the queued items.

There are restrictions on the number of requests per application and per device as well as the size of the files.

Upload files must not exceed 5 MB.

Download file size limits range from 20 MB to unlimited.  The limits are determined by the TransferPreferences property, which indicates the conditions that should be met, for the transfer to take place. The conditions are a combination of external power and/or wifi connection.

Background file transfers are automatically suspended and resumed based on wether the conditions are met.

For more information about background file transer see Background File Transfers for Windows Phone.

I was adding a transformation to adapt our NLog configuration for the various environments, when I ran into a problem. I'd added the following transformation, intended to set the log level to Warning on the given deloyment:

<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd">
  <rules>
    <logger name="*" minlevel="Warn"
      xdt:Transform="SetAttributes(minlevel)" xdt:Locator="Match(name)"
    />
  </rules>
</nlog>

However, the original fragment kept being passed through without modification. I tried various modes of matching (incidentally, the online Web Config Transformation Tester is a good tool for such tinkering with transformations) to no avail, until I decided to try and remove the NLog namespace from the transformation:

<nlog>
  <rules>
    <logger name="*" minlevel="Warn"
      xdt:Transform="SetAttributes(minlevel)" xdt:Locator="Match(name)"
    />
  </rules>
</nlog>

And lo and behold; it worked.

That could have been the end of it, but I decided to dig a bit deeper, since we have the NLog schema in our solution and properly referencing it allows us to have IntelliSense within the web.config.

Eventually, as an experiment, I tried associating a namespace prefix with the NLog namespace at the top level, and then explicitly qualify the NLog elements with that prefix, rather than relying on specifying a default namespace on the NLog element:

<configuration xmlns:xdt="http://schemas.microsoft.com/XML-Document-Transform"
  xmlns:nlog="http://www.nlog-project.org/schemas/NLog.xsd"
>

  <nlog:nlog>
    <nlog:rules>
      <nlog:logger name="*" minlevel="Warn"
        xdt:Transform="SetAttributes(minlevel)" xdt:Locator="Match(name)"
      />
    </nlog:rules>
  </nlog:nlog>

</configuration>

Success!

Conclusion

Explicitly prefixing elements from foreign XML namespaces in config transformations must be described as a workaround, since semantically the first and the third NLog fragments are equivalent.

In spite of this flaw in the web.config transformations implementation, this workaround allows you to get the benefits of IntelliSense and better validation when you have the schema for NLog or any other foreign fragment available.

The problem

An app created before July 18th 2011 will not have the AssemblyInfo attribute NeutralResourcesLanguage and submitting an update to this app will give you the error:

Error 2003: The [NeutralResourceLanguage] attribute is missing on the entry assembly.

The fix

So, the fix for this is simple – add the attribute in AssemblyInfo.cs. (can also be done through selecting in a drop down in app properties)

[assembly: NeutralResourcesLanguage("en-us")]

The quirk

English it not always English. There is something called location groups. If you’re lucky – you’ll now pass through submission. If you’re not, you’ll end up with:

Error 1047: An update cannot support fewer languages than the previous app instance supported.

Whoah, what is this? For me, this was because I had stated the language as English (International) when submitting the first time. The rules are:

I learned this from the MSDN forum page helpful tips on language processes during app submission. To quote: If the parent instance was marked as “English (International)”, you need to use [NeutralResourcesLanguage(“en”)], if it was “English”, use [NeutralResourcesLanguage(“en-US”)] or [NeutralResourcesLanguage(“en-CA”)], in other cases use two-letter language name.

Summary

My final statement ended up as:

[assembly: NeutralResourcesLanguage("en-us")]

This bit me when submitting updates – I really hope this helps you avoid or find the problem quickly

Bye!

The previous entry, where I demonstrated how to retrieve and data from a REST based webservice is available here.

In that blog post I created a fairly naive application, which retrieves som Json data and manually assigns values to some labels on screen.

In this post I will demonstrate how to use Visual Studios databound application template to create an application, that can display the contents of an RSS feed.

Background

If, like me, you suddenly have a profound interest in the subject of having twins, you might create an application that displays all the latest stories from http://www.having-twins.com/.

A more likely example could be that you have an existing website/community or similar and would like to create a simple mobile app from it. You could then create an RSS feed on your site and then create an RSS driven application.

Fortunately for the lazy programmer, Microsoft has created a couple of project templates, that make it simple to get started.

Simple Datebound Application

Since this is going to be an app that displays a list of news entries drawn from a single source, I will use the template "Windows Phone Databound Application".

Lets examine the project that was created for us. The main application screen has the basic Windows Phone 7 application layout, with the top third of the screen reserved for application and page name, and below there is a list of items, each with a title and a summary. When the users taps on an item, he is taken to the details screen.

Design datasource

First thing you might notice is, that the design view of the template application is filled with example data already:

Now, where did that come from? Well, if we examine the xaml for the view, we'll find that Visual Studio has added a d:DataContext declaration, that points to the file MainViewModelSampleData.

<phone:PhoneApplicationPage
    (...)
    d:DataContext="{d:DesignData SampleData/MainViewModelSampleData.xaml}"
    (...)
>

This sample data corresponds to the example viewmodels MainViewModel and MainViewModel.Items.
Using this metod you can define your own example data or use the autogenerated data to see what your views will look like when you design them in Visual Studio or Expression Blend. Expression blend even has the ability to generate data for you, once you have defined your custom ViewModel.

Secondly, the controls are bound to properties in the datamodel using standard xaml-based databinding syntax {Binding PropertyName}.

    <!--Data context is set to sample data above and LayoutRoot contains the root grid where all other page content is placed-->
    <Grid x:Name="LayoutRoot">
        (...)
        <Grid>
            <ListBox ItemsSource="{Binding Items}">
                <ListBox.ItemTemplate>
                    <DataTemplate>
                      <StackPanel>
                          <TextBlock Text="{Binding LineOne}" TextWrapping="NoWrap" />
                          <TextBlock Text="{Binding LineTwo}" TextWrapping="NoWrap" />
                      </StackPanel>
                    </DataTemplate>
                </ListBox.ItemTemplate>
            </ListBox>
        </Grid>
    </Grid>

Notice that the ListBox binds to Items, which is an ObservableCollection<ItemViewModel> on MainViewModel and each <TextBlock> within the <ListBox.ItemTemplate> then binds to properties LineOne and LineTwo on the ItemViewModel.

Runtime datasource

When you run your application, you'll notice that the running app displays another set of  data:

The "runtime one", "runtime two", etc data is default template data generated in MainViewModel.LoadData, which is called from MainPage.MainPage_Loaded.

/// <summary>
/// Creates and adds a few ItemViewModel objects into the Items collection.
/// </summary>
public void LoadData()
{
    // Sample data; replace with real data
    this.Items.Add(new ItemViewModel() { LineOne = "runtime one", LineTwo = "Maecenas praesent accumsan bibendum", LineThree = "Facilisi faucibus habitant inceptos interdum lobortis nascetur pharetra placerat pulvinar sagittis senectus sociosqu" });
    (...)
    this.Items.Add(new ItemViewModel() { LineOne = "runtime sixteen", LineTwo = "Nascetur pharetra placerat pulvinar", LineThree = "Pulvinar sagittis senectus sociosqu suscipit torquent ultrices vehicula volutpat maecenas praesent accumsan bibendum" });

    this.IsDataLoaded = true;
}

To keep this example as simple as possible, the only thing I'll change is which data we put into the items collection, so to download the RSS feed and use that data instead, the above lines are changed into.

/// <summary>
/// Creates and adds a few ItemViewModel objects into the Items collection.
/// </summary>
public void LoadData()
{
    var webClient = new WebClient();
    webClient.DownloadStringCompleted += webClient_DownloadStringCompleted;
    webClient.DownloadStringAsync(new Uri("http://www.having-twins.com/Twins.xml"));
}

private void webClient_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
{
    if (e.Error != null) return;

    var reader = XmlReader.Create(new StringReader(e.Result));
    SyndicationFeed feed = SyndicationFeed.Load(reader);

    foreach (var item in feed.Items)
    {
        Items.Add(new ItemViewModel(){LineOne = item.Title.Text.Trim(), LineTwo = item.Summary.Text.Trim()});
    }
    this.IsDataLoaded = true;
}

This code downloads the rss-feed from http://www.having-twins.com/Twins.xml, parses it using SyndicationFeed (you must manually reference it from \Program Files\Microsoft SDKs\Silverlight\v4.0\Libraries\Client\System.ServiceModel.Syndication.dll) and uses the Title and Summary texts from that feed to populate the LineOne and LineTwo properties of the ItemViewModel.

When you run the app in the emulator, you'll get a nice view like this (you'll need to set TextWrapping to NoWrap on the TextBlocks):

Starting a browser

Finally, the feed from having-twins.com provides a link to the article and not the actual article, so when you click on an item in the list, we should start a webbrowser and go directly to the article on the website.

First we need to add a property to store the item url on the ItemViewModel:

private Uri _uri;
public Uri Uri
{
    get
    {
        return _uri;
    }
    set
    {
        if (value != _uri)
        {
            _uri = value;
            NotifyPropertyChanged("Uri");
        }
    }
}

Next we need to extract the url and store it per item, so we'll change the line of code in webClient_DownloadStringCompleted to:

Items.Add(new ItemViewModel(){LineOne = item.Title.Text.Trim(), LineTwo = item.Summary.Text.Trim(), Uri = item.Links.First().Uri});

The final step is to start the webbrowser. This is done in MainListBox_SelectionChanged, where we replace the code that opens the details view:

// Navigate to the new page
NavigationService.Navigate(new Uri("/DetailsPage.xaml?selectedItem=" + MainListBox.SelectedIndex, UriKind.Relative));

with code that opens a browser:

var webBrowserTask = new WebBrowserTask {Uri = ((ItemViewModel) MainListBox.SelectedItem).Uri};
webBrowserTask.Show();

So now, when you tap on an item in the list, the browser will open and go directly to the article mentioned in the rss-feed.

Naturally, you could error handling, offline caching of content, splash screen etc. but that is beyond the scope of this demonstration.

This concludes this example of how to use the standard databound template to create an app that displays latest news (in form of an rss-feed) from a website.

The previous entry, where I demonstrated how to store and retrieve view states between application deactivation and activation is available here.

In this blog post I will demonstrate how to fetch data from a simple REST based web service and use it in an application, that many, many people have been waiting for.

Background

In Copenhagen there is a famous neon billboard from 1953 showing a hen laying eggs.

It just so happens that there is a REST api available, where one can query the status of the egglaying.

If you load

http://sevengoslings.net/~fangel/hvormangeaeg/eggs_laid/json

You will get the status in json format

{"eggs":105300654,"on":902667014,"currently_laying_eggs":false}

When I made the request,  the hen had been working for 902667014 seconds, it had layd 105.300.654 eggs and was not currently laying any eggs (it was not dark outsite).

The status is also available in xml, php-serialized and LOL (don't ask). The complete developers api is documented at http://sevengoslings.net/~fangel/hvormangeaeg/developers.

 The application

In the following, I'm assuming that you have either read the previous posts or have sufficient knowledge of how to create a new Windows Phone 7 based application.

I have created a new Windows Phone project using the simple "Windows Phone Application" template.

In the grid called ContentPanel, I've added a few TextBlocks to display the status and Rectangles to serve as dividers between the TextBlocks.

<!--ContentPanel - place additional content here-->
<Grid x:Name="ContentPanel" Grid.Row="1" Margin="12,0,12,0">
    <Grid.RowDefinitions>
        <RowDefinition Height="Auto"></RowDefinition>
        <RowDefinition Height="20"></RowDefinition>
        <RowDefinition Height="Auto"></RowDefinition>
        <RowDefinition Height="20"></RowDefinition>
        <RowDefinition Height="Auto"></RowDefinition>
    </Grid.RowDefinitions>
    <TextBlock Grid.Row="0" x:Name="txbHenAge" TextWrapping="Wrap"></TextBlock>
    <Rectangle Grid.Row="1" Width="300" Height="2" Stroke="White" Fill="White"></Rectangle>
    <TextBlock Grid.Row="2" x:Name="txbEggCount" TextWrapping="Wrap"></TextBlock>
    <Rectangle Grid.Row="3" Width="300" Height="2" Stroke="White" Fill="White"></Rectangle>
    <TextBlock Grid.Row="4" x:Name="txbEggLayingStatus" TextWrapping="Wrap"></TextBlock>
</Grid>

To retrieve the egg-laying status, I'll use the WebClient class, which uses a simple event -based system to make requests and receive responses. For more details on how to use the WebClient class, you might check out Accessing a REST web service quick start on create.msdn.com.

Sending the request

In my page constructor I'll add:

_webClient = new WebClient();
_webClient.DownloadStringCompleted += _webClient_DownloadStringCompleted;
_webClient.DownloadStringAsync(new Uri("http://sevengoslings.net/~fangel/hvormangeaeg/eggs_laid/json"));

First I create a new instance of WebClient. Then I provide a method to handle the DownloadStringCompleted event, and finally I call DownloadStringAsync with the URI that I want to load.

Handling the response

In the method handling the DownloadStringCompleted event I have to parse the received Json. For that purpose I'm using Json.NET.

First I create class to model the data I expect to receive:

public class IrmaHenStatus
{
    public int eggs { get; set; }
    public long on { get; set; }
    public bool currently_laying_eggs { get; set; }
}

Then I apply JsonConvert.DeserializeObject to the received Json:

void _webClient_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
{
    IrmaHenStatus result = JsonConvert.DeserializeObject<IrmaHenStatus>(e.Result);
    ...

Add a bit of error handling:

if (e.Error != null)
{
    // Do something meaningfull if the response was not OK

Add strings and a helper method to turn the number of seconds into human readable format:

string HenAgeText= "The hen has been laying eggs for {0}.";
string EggCountText = "During that time, the hen has layed {0} eggs.";
string NetworkErrorText = "A network error occured!";
string EggLayingOngoing = "The hen is currently laying eggs";
string EggLayingPaused = "The hen is currently not laying any eggs";

private string FormatEggLayingTime(long time)
{
    var seconds = time;
    var elapsedDays = (int) (seconds/(60*60*24));
    seconds = seconds % (60*60*24);

    var elapsedHours = (int) (seconds/(60*60));
    seconds = seconds%(60*60);

    var elapsedMinutes = (int) (seconds/60);
    var elapsedSeconds = seconds%60;

    string returnValue = string.Format("{0} days, {1} hours, {2} minutes and {3} seconds", elapsedDays, elapsedHours, elapsedMinutes, elapsedSeconds);
    return returnValue;
}

And we are now ready to update the UI

txbEggCount.Text = string.Format(EggCountText, result.eggs.ToString("N"));
txbHenAge.Text = string.Format(HenAgeText, FormatEggLayingTime(result.on));
txbEggLayingStatus.Text = result.currently_laying_eggs ? EggLayingOngoing : EggLayingPaused;

The final result may not be very impressive, but it does illustrate quite nicely how an app can display data retrieved from a REST based webservice.

Now, onto the topic of the hour: Beta submission.

Empirical timing results

I have during the past months submitted numerous apps to the Marketplace as beta – and come to the conclusion: (this probably will just be true for the near future AND the region I’m in – Sweden)

1) Beta submission takes 4 hours to complete – the app then becomes “published”

2) It takes another 8 hours before the app becomes available for download!

Error when trying to download right after submission completed

Before the 8 hours, hitting the deep link gives Marketplace error: 805a0194. An explanation of the error can be found in this StackOverflow response: it’s a 404 – not found.

Why is it like this? I don’t know. Probably propagation of the xap package onto download servers. Annoying – but more bearable once you see the system in it.

Go publish those apps!

The previous entry, where I created a simple app for collecting feedback on how a presentation went is available here.

Application life cycle

An obvious problem with the app created in the previous post is that it reset the counters every time the app is started.

This means that the counters are reset if the phone receives an incoming call, if it goes to sleep or if somebody accidentally presses the Start button. This is of course very inconvenient.

To address this problem, we need to look at application life cycle management. Here is a good throrough description.

The issue at hand is called tombstoning. Since Windows Phone doesn't allow apps to run in the background, our application process gets killed, when the application doesn't occupy the UI.

The user can then either start a new instance of the application (in which case the counters SHOULD be reset) or navigate "back" into the application (in which case the counters should NOT be reset).

So to resume at the point, where we left off, we have to save our state information, so it can be reloaded if the application gets reactivated.

There are two ways to save information, application state and page state.

Application state

Application state is the state of the application that is not related to a specific page in the application. It could e.g. be login information.

The application has a set of events that can be used to handle/save/restore application state:

// 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)
{
}

// 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)
{
}

// 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)
{
}

// Code to execute when the application is closing (eg, user hit Back)
// This code will not execute when the application is deactivated
private void Application_Closing(object sender, ClosingEventArgs e)
{
}

Page state

Page state is the state of a single page, typically UI-related such as content of textboxes or scroll-position of a scroll view.

protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
{
    // this.State is a dictionary, where one can store page state information
    base.OnNavigatedTo(e);
}

protected override void OnNavigatedFrom(System.Windows.Navigation.NavigationEventArgs e)
{
    // this.State is a dictionary, containing previously stored page state information
    base.OnNavigatedFrom(e);
}

These methods are called every time a page is navigated to or from, so if the application gets deactivated, you can store page state information in OnNavigatedFrom and restore it in OnNavigatedTo.

 Using Page state to save counters

In this case the counters are page-specific, so they will be treated as page-state information for now.

The following code will save the counter values during deactivation and restore them during reactivation. You might notice that there is room for some improvement here, if one were to refactor the code a bit, but I choose not to in order to keep the example as simple and illustrative as possible.

private const string StateHappyCount = "happyCount";
private const string StateNeitherCount = "neitherCount";
private const string StateSadCount = "sadCount";

protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
{
    _happyCount = (int)(State.ContainsKey(StateHappyCount) ? State[StateHappyCount] : 0);
    _neitherCount = (int)(State.ContainsKey(StateNeitherCount) ? State[StateNeitherCount] : 0);
    _sadCount = (int)(State.ContainsKey(StateSadCount) ? State[StateSadCount] : 0);

    base.OnNavigatedTo(e);
}

protected override void OnNavigatedFrom(System.Windows.Navigation.NavigationEventArgs e)
{
    State[StateHappyCount] = _happyCount;
    State[StateNeitherCount] = _neitherCount;
    State[StateSadCount] = _sadCount;

    base.OnNavigatedFrom(e);
}

When you test the application, be sure to distinguish between wether the app is deactivated or closed and wether it is reactivated or launched.

An app is closed, when the user backs out from the main screen with the back button. Otherwise it is deactivated (tombstoned).

An app is launched, when it is started from the start screen (regardless of wether it was previously deactivated), otherwise it is activated. The State dictionary is empty, when an application is launched.

The previous entry about installing the tools is available here.

 Idea for an app

The app I'd like to create is a simple tool, that one might use if one was conducting a course on, say, Windows Phone development.

The idea is that as people leave the room, the can indicate if they were satisfied with the presentation they just witnessed by simple pressing a red or green smiley on the screen of a phone, held by a person in the doorway.

The user interface would look something like this drawing:

Below each smiley is a number indicating how many people pressed each smiley.

Creating the UI

Unless you are creating games using XNA, you will be creating your userinterface using XAML. If you do not know XAML, then this is a good introduction to XAML on Windows Phone.

The following is the definition of the UI:

The top half of the screen is a graphical editor, while the botttom half is the XAML editor.

The UI of this application consists of three buttons filling the entire screen. Each button has a smiley (a character from the windings character set) and a count.

The buttons are arranged using a StackPanel with orientation=Horizontal, so they line up next to each other.

Below is shown the complete XAML code for this application:

<phone:PhoneApplicationPage
    x:Class="PhoneApp1.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"
    mc:Ignorable="d" d:DesignWidth="728" d:DesignHeight="480"
    FontFamily="{StaticResource PhoneFontFamilyNormal}"
    FontSize="{StaticResource PhoneFontSizeNormal}"
    Foreground="{StaticResource PhoneForegroundBrush}"
    SupportedOrientations="Landscape" Orientation="Landscape"
    shell:SystemTray.IsVisible="True">

    <StackPanel x:Name="TitlePanel" Margin="0,0,0,0" Background="Black" Orientation="Horizontal" >
        <Button Name="btnHappy" Background="Green" BorderBrush="{x:Null}" Padding="0" Width="242" Tap="btnHappy_Tap">
            <StackPanel OpacityMask="Black">
                <TextBlock Text="J" FontFamily="Wingdings" FontSize="200" />
                <TextBlock Name="txtHappyCount" TextAlignment="Center" />
            </StackPanel>
        </Button>
        <Button Name="btnNeither"  Background="Orange" BorderBrush="{x:Null}" Padding="0" Width="242" Tap="btnNeither_Tap">
            <StackPanel OpacityMask="Black">
                <TextBlock Text="K" FontFamily="Wingdings" FontSize="200" />
                <TextBlock Name="txtNeitherCount" TextAlignment="Center" />
            </StackPanel>
        </Button>
        <Button Name="btnSad" Background="Red" BorderBrush="{x:Null}" Padding="0" Width="242" Tap="btnSad_Tap">
            <StackPanel OpacityMask="Black">
                <TextBlock Text="L" FontFamily="Wingdings" FontSize="200" />
                <TextBlock Name="txtSadCount" TextAlignment="Center" />
            </StackPanel>
        </Button>
    </StackPanel>
</phone:PhoneApplicationPage>

The <phone:PhoneApplicationPage> part of the xaml is standard for a page in a Windows Phone application.

Coding the functionality

During initialization, the  counters on the UI should be initialized to 0.

When you click on a button, the Tap event occurs and the method defined on each button is called. The Tap method will increment the tap counter and update the UI. The complete code looks like this:

(If you're annoyed by the fact that I've only posted a picture of the code, so you cant copy/paste it: It is intentional. I'd like to force you to do a little bit of coding yourself

Testing the finished app

Finally, press F5, press the buttons and verify that the counters works like they should.

The emulator starts with the phone in portrait mode, but you can turn it using the button on the toolbar in the top-right corner:

You might also notice the strange numbers in the top of the screen:

These numbers are performance metrics that would come in handy if you were a game developer. For now, you can just ignore them. They only show up, when the emulator is in debug mode.

That really is all there is to it!

The purpose is both to help others get started but also to show how simple it really is, to get started developing for Windows Phone 7.

Where to find everything

The best online ressource for all-thing Windows Phone 7 I have found is create.msdn.com. Here you'll find everything you need to know/download.

Install

First thing you need is to download the SDK: download here. It will install everything you need, including Visual Studio 2010 Express if necessary. NOTE: If you already have Visual Studio 2010 without Service Pack 1, prepare yourself or a looooong installation process. The Service Pack 1 installer goes on for hours with no cpu-load or activity on the harddrive. No, it isn't broken or crashed. It really does work that way! Leave it overnight and you'll be pleasently suprised the next day.

Confirm that it works

Now that you've installed the Windows Phone SDK, it is time to spin up the bad boy and see if it works.

Start Visual Studio, select new project

Select the template "Windows Phone Application".

Press F5 to start debugging and wait for the emulator to finish loading your app.

Congratulations. You have now created your first application and started it in the emulator.

You now have all the tools necessary to start coding your very own app.

Next steps

You next steps will be to learn more about application development for Windows Phone 7 and think of an actual app to develop.

A good place to start is the quickstarts part of create.msdn.com.

One very interesting ressource in my opinion is this documentation on User Experience Design Guidelines, which will help you ensure your application looks and feels wp7-like.

What are implicit styles?

A style that has a target type but no x:Key is treated as implicit and will be applied to all descendant elements in the visual tree.

Why should I use an implicit style?

I think it’s very nice to not have to set the style on each and every control in a section of your app that you want exactly the same look on. Instead just create an implicit style in one of the parent elements and let the good times roll

What does an implicit style look like in XAML?

<Grid Grid.Row="1" VerticalAlignment="Top">
    <Grid.RowDefinitions>
        <RowDefinition/>
        <RowDefinition/>
        <RowDefinition/>
    </Grid.RowDefinitions>
    <Grid.Resources>
        <Style TargetType="TextBlock"
               BasedOn="{StaticResource PhoneTextNormalStyle}">
            <Setter Property="FontSize" Value="21"/>
            <Setter Property="Foreground" Value="Pink"/>
        </Style>
    </Grid.Resources>
    <TextBlock Grid.Row="0" Text="styles"/>
    <TextBlock Grid.Row="1" Text="blend"/>
    <TextBlock Grid.Row="2" Text="wow"/>
</Grid>

the above XAML will produce:

But if we change the style to having a key:

<Style x:Key="PinkStyle" TargetType="TextBlock"
BasedOn="{StaticResource PhoneTextNormalStyle}">

we instead get:

so – it has to be an “anonymous” style.

It’s all about looks - applying the style e.v.e.r.y.w.h.e.r.e

So – what will happen if we put the style in App.xaml? You guessed it – visual tree propagation galore! All your textblocks will get the style.

<Application.Resources>
    <Style …>
        …
    </Style>
</Application.Resources>

There you go! I don’t use this all the time – but it can make the XAML nice and tidy if you are repeating many controls on a page that should share the same looks.

Happy styling!

All examples below assume that we have already instantiated CloudBlobClient cloudBlobClient. It can be done using the code.

var account = CloudStorageAccount.FromConfigurationSetting("DataConnectionString");
var cloudBlobClient = account.CreateCloudBlobClient();

Upload a Blob from a string

First example, upload a string as a text file. We, for example, use this to upload crash logs to blob storage and then mail a link to the support team.

public Uri UploadBlob(string path, string fileName, string content)
{
    var cloudBlobContainer = cloudBlobClient.GetContainerReference(path);
    cloudBlobContainer.CreateIfNotExist();

    var blob = cloudBlobContainer.GetBlobReference(fileName);
    blob.UploadText(content);

    return blob.Uri;
}

So if we would call this method using the following parameters.

var uri = UploadBlob("folder", "file.txt", "text in file");

We would get a link pointing at http://yourstorageaccount.blob.core.windows.net/folder/file.txt containing the text – “text in file”. Please note that this call is made synchronously.

Upload a Blob from a stream

You will recognize this from the previous example. The difference is that we are using a stream instead of a string and that the call is made asynchronously.

public void UploadBlob(string path, string fileName, Stream stream)
{
    var cloudBlobContainer = cloudBlobClient.GetContainerReference(path);
    cloudBlobContainer.CreateIfNotExist();

    var blob = cloudBlobContainer.GetBlobReference(fileName);
    blob.BeginUploadFromStream(stream, UploadFinished, blob.Uri);
}

private void UploadFinished(IAsyncResult asyncResult)
{
    // do something
}

List all Blobs in a container

This will give a list of links to all blobs stored in a container.

public IEnumerable<Uri> ListAllBlobs(string folder)
{
    var cloudBlobContainer = cloudBlobClient.GetContainerReference(folder);
    var listBlobItems = cloudBlobContainer.ListBlobs();

    return listBlobItems.Select(b => b.Uri);
}

Simple enough. Once you got the setup right, Azure Blob Storage is actually quite easy to use. If you would like to list blobs in subfolders as well then use the overloaded method for ListBlobs and send in BlobRequestOptions { UseFlatBlobListing = true }.

Download content from a Blob

Very similar to uploading data, it works the same way with other data types than string.

public string DownloadBlob(string folder, string fileName)
{
    var cloudBlobContainer = cloudBlobClient.GetContainerReference(folder);
    var blob = cloudBlobContainer.GetBlobReference(fileName);

    return blob.DownloadText();
}

But, before downloading a blob, you might want to see if it exists…

See if a Blob exists

The only way that I have found for doing this (and please correct me if I’m wrong here) is to do a little peek and catch the resulting exception.

private bool BlobExists(CloudBlob blob)
{
    try
    {
        blob.FetchAttributes();
        return true;
    }
    catch (StorageClientException e)
    {
        if (e.ErrorCode == StorageErrorCode.ResourceNotFound)
        {
            return false;
        }
        throw;
    }
}

Thanks to Steve Marx for the solution. FetchAttributes() is used simply because it will be a small amount of data transferred or a 404. So even if I call BlobExists() on a 4Mb block blob it won’t be any different from doing the same call on a 2Kb blob.

Some tips and tricks

Well, first of all. Azure Blob storage can be used for much more than just file storage. Scalability is built in so if you, for example, have a static html page, you can easily upload it to Azure blob storage and then link to it. It is a good way to take away load from your WebRole.

All methods that I showed you have a Begin/End method as well. So you should be able to do most of the work asynchronously, as I did when I uploaded a blob from a stream.

If an Azure Queue message risk becoming bigger than 8Kb the recommended solution is to upload the message as a blob and then store the URI as the message on the queue. You won’t get charged for the extra data traffic as long as it’s done within the same data center.

Happy blobbing.

Fix: Set the startup object on the app project’s properties page

In the .csproj file, this corresponds to the SilverlightAppEntry element:

<SilverlightAppEntry>PhotoDiary.App</SilverlightAppEntry>

I would call it a bug, that you cannot rename a project and have the SilverlightAppEntry update accordingly. But luckily, the work-around is simple.

Have a nice day!

But before I go any further I would like to thank whoever wrote the official Push Notification Sample, it helped me a lot. Also a big thanks to Nick Harris for his post dealing with push notifications and his and Darren Louie’s video from BUILD.

In order to get this to work we first need to register our application to receive push notifications. Once that is done we’ll continue with client and then server implementation. In my case I used an Azure server, but you could just as well host this anywhere else. The figure below illustrates the flow when sending a push notification. In this post I’ll show code written for the Win 8 Client and Azure Server.

Let’s get started.

Register your application to receive push notifications

The first thing that we need to do, before writing any code, is to register our application to actually be discoverable by WNS. For the moment, the address is https://manage.dev.live.com/build but I’m guessing that it will change later on.

At the site they have very clear instructions on how to proceed, but I’ll write down the steps in either case. First step is to enter your “Package display name” and “Publisher” to the website. Both can be found by opening your “Package.appxmanifest” file in your Metro client project.

And then enter those values in the form found on the website.

After pressing “I accept” you get this information.

Here you’ll copy the “Package name” and paste it into your “Package.appxmanifest” as seen below. The other two values, “Client secret” and “Package Security Identifier (SID)”, is necessary later on when our server fetches our access token from Live Services.

Notice that the “Package Family Name” at the bottom also changes. That’s it really, we can now continue with the client implementation.

Client implementation

First of all you need to open up a channel in order to receive push notifications. It can be done as in the code sample below.

PushNotificationChannel pushNotificationChannel;

void OpenChannel()
{
    var operation = PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync();
    operation.Completed = OnChannelCreationCompleted;
    operation.Start();
}

void OnChannelCreationCompleted(IAsyncOperation<PushNotificationChannel> operation)
{
    if (operation.Status == AsyncStatus.Completed)
    {
        pushNotificationChannel = operation.GetResults();

        // Send these values together with user data to your server of choice
        var notificationUri = pushNotificationChannel.Uri;
        var expirationTime = pushNotificationChannel.ExpirationTime;
    }
}

If the user accepts push notifications you would typically call OpenChannel() when the application starts. When opened it will call OnChannelCreationCompleted(…). Here you can extract two important properties of the PushNotificationChannel - Uri and ExpirationTime. Both of these should typically be posted to your server solution of choice. In our case, the Uri will be something like this (shortened).

https://db3.notify.windows.com/?token=AQQAAACL3PSmbrWaRkusVuK…

I didn’t write any code for actually sending the data to the server. I’ll leave it up to you if would like to do a simple POST, service reference or whatever. When I tried it, I just did a POST using a HttpWebRequest to a WCF Web API service that I hosted in Azure. In a normal scenario you would typically also post an user id so that you can identify which user the notification Uri belongs to.

Now, in order to actually se what was happening I needed to subscribe to PushNotificationReceived.

pushNotificationChannel.PushNotificationReceived += OnPushNotificationReceived;

OnPushNotificationReceived don’t actually do anything else than blocking the event from actually reaching the UI. When I tested it I just added a breakpoint to this method so that I could take a peak on whatever came in.

void OnPushNotificationReceived(PushNotificationChannel sender, PushNotificationReceivedEventArgs e)
{
    string notificationContent = String.Empty;
    switch (e.NotificationType)
    {
        case PushNotificationType.Badge:
            notificationContent = e.BadgeNotification.Content.GetXml();
            break;
        case PushNotificationType.Tile:
            notificationContent = e.TileNotification.Content.GetXml();
            break;
        case PushNotificationType.Toast:
            notificationContent = e.ToastNotification.Content.GetXml();
            break;
    }

    // prevent the notification from being delivered to the UI
    e.Cancel = true;
}

Note that this will only be triggered if the application is in the foreground, if it’s in the background this method will not be executed.

That’s it for the client implementation; now let’s see what we need to do on the server side.

Server implementation

I’ll keep this code raw without wrapping up the logic in any classes. The whole idea with this exercise was for me to understand what was happening and in order to do that I needed to get as close the the raw web requests as possible. I should also mention that I wrote this code on a machine running Windows 7 OS and VS2010.

Fetching an access token

First of all I needed to get a hold of my access token, we’ll need it when we push data to the client. From what I understand you should actually cache this value until it expires, but I haven’t been able to figure out where you can see the expiration date… anyway, in order to get your access token you need to do a POST.

POST https://login.live.com/accesstoken.srf HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: login.live.com
Content-Length: 212 

grant_type=client_credentials&client_id=ms-app%3a%2f%2fs-1-15-2-2540850135-1066809635-1827421751-2963426696-2171157241-2579410831-1077576199&client_secret=Si7vgThlGhKrtILSs7BWXPTdE-9yaGGI&scope=notify.windows.com

As you probably noticed, the client_id is actually a html encoded version of the “Package Security Identifier (SID)” that we retrieved when registering our application (see images above). The same goes for the client_secret that is the… well “Client secret”. So, how are we going to express all of this in code?

private string GetAccessToken()
{

    string url = "https://login.live.com/accesstoken.srf";
    var request = (HttpWebRequest)WebRequest.Create(url);
    request.Method = "POST";
    request.ContentType = "application/x-www-form-urlencoded";

    string sid = HttpUtility.UrlEncode("ms-app://s-1-15-2-2540850135-1066809635-…");
    string secret = HttpUtility.UrlEncode("Si7vgThlGhKrtILSs7BWXPTdE-9yaGGI");
    string content = "grant_type=client_credentials&client_id={0}&client_secret={1}&scope=notify.windows.com";

    string data = string.Format(content, sid, secret);

    byte[] notificationMessage = Encoding.Default.GetBytes(data);
    request.ContentLength = notificationMessage.Length;

    using (Stream requestStream = request.GetRequestStream())
    {
        requestStream.Write(notificationMessage, 0, notificationMessage.Length);
    }

    var response = (HttpWebResponse)request.GetResponse();

    string result;
    using(Stream responseStream = response.GetResponseStream())
    {
        var streamReader = new StreamReader(responseStream);
        result = streamReader.ReadToEnd();
    }

    return result;
}

Not pretty - I’m well aware of it. But you should get an idea of how the request is built up to match the POST described above. Important to note is that we need to UrlEncode both our SID and client secret. The result we receive will be.

HTTP/1.1 200 OK
Cache-Control: no-store
Content-Length: 426
Content-Type: application/json
Connection: close 

{
   “access_token”:”EgAfAQMAAAAEg…”,
   “token_type”:”bearer”
}

The access token is actually much longer, I just shortened it a bit.

Push data to the client

Now we can actually push the data to the client, in this example we’ll send a badge update. We will create a web request in a similar manner that we did when we fetched the access token. But this time we will do the following POST.

POST https://db3.notify.windows.com/?token=AQQAAACL3PSmbrWaRkusVuK…
Content-Type: text/xml
Host: db3.notify.windows.com 

X-WNS-Type: wns/badge
Authorization: Bearer EgAfAQMAAAAEg…
Content-Length: 59 

<?xml version='1.0' encoding='utf-8'?>
<badge value="2"/>

Two things worth mentioning here. First of all we POST to the pushUri received from the client. Also, the authorization contains our accessToken. Then as content we send the information used by the client to actually update its tile. The code I used to accomplish this is below.

private HttpStatusCode Push(string pushUri, string accessToken)
{
    var subscriptionUri = new Uri(pushUri);

    var request = (HttpWebRequest)WebRequest.Create(subscriptionUri);
    request.Method = "POST";
    request.ContentType = "text/xml";
    request.Headers = new WebHeaderCollection();
    request.Headers.Add("X-WNS-Type", "wns/badge");
    request.Headers.Add("Authorization","Bearer " + accessToken);

    string data = "<?xml version='1.0' encoding='utf-8'?><badge value=\"2\"/>";

    byte[] notificationMessage = Encoding.Default.GetBytes(data);
    request.ContentLength = notificationMessage.Length;

    using (Stream requestStream = request.GetRequestStream())
    {
        requestStream.Write(notificationMessage, 0, notificationMessage.Length);
    }

    var response = (HttpWebResponse)request.GetResponse();

    return response.StatusCode;
}

The response we would get from this would typically look like.

HTTP/1.1 200 OK
Content-Length: 0
X-WNS-NOTIFICATIONSTATUS: received
X-WNS-MSG-ID: 1AE359FBBE342FFA
X-WNS-DEBUG-TRACE: DB3WNS5044574

Important to note here is that a successful response only indicates that the message was sent, not that it was actually received by the client. So 200 OK only means that the request was processed by WNS. We also receive some debug information that you typically would like to log somewhere if you run into any issues and need support.

Summary

That’s it really. The push was received by the client and if I had actually implemented more support for it than a breakpoint it would work as expected. When it comes to finding documentation and online help for any issues or questions I can (while writing this) say that it’s as best sparse. Prepare for a lot of experimentation and guessing as you go along.

If you don’t want to reinvent the wheel as I did, there’s always Windows Azure Toolkit for Windows 8. It contains push notifications recipes that makes it really easy to create and send push notifications.

If you would like to learn more about developing Metro applications I recommend at visit to Øredev. It will feature a full day track covering Windows 8 development.

After a few initial days of work, I've now installed all the tools I need including but far from limited to VS2010, Resharper, SQL Server Express 2008, NUnit, Git Extensions, Tortoise, Beyond Compare and many more. The project that I will be working on is also configured with locally running IIS7 websites, SQL server databases, certificates and, again, much more.

Now is the time, I think, to do a backup/snapshot/whatever of my Windows partition, because I certainly do not want to go through the entire install/configure process again and my Windows installation is still fairly clean.

I considered using Fusions "snapshot" feature, but VMWare recommends that you don't use snapshots as a backup strategy.

My first move is to use WinClone to create a backup image of the entire boot camp partition, since Time Machine only backs up my OS X files. The otherwise incredible tool Super Duper will not do the trick here, since it only handles OS X partitions. A caveat here is that WinClone is discontinued from the originator and doesn't support Lion. However, an alternative version that does support Lion can be found here. I'm currently backing up my Boot Camp partition to a USB drive. Next step will be to test if that backup can actually be used for anything.

Extending the Picture Viewer

Described in the MSDN docs here, adding this extension to your app will put it in the list of apps available when looking at pictures.

To activate this feature, you need to add the following code to your WMAppManifest.xml, as a child of the <App> element.

<Extensions>
  <Extension
    ExtensionName="Photos_Extra_Viewer"
    ConsumerID="{5B04B775-356B-4AA0-AAF8-6491FFEA5632}"
    TaskID="_default" />
</Extensions>

You are then ready to begin receiving pictures to your app. To detect and accept the picture sent to you, you examine the “token” key of the NavigationContext, something like:

IDictionary<string, string> queryStrings =
    this.NavigationContext.QueryString;

Stream photoStream = null;
if (queryStrings.ContainsKey("token"))
{
    var library = new MediaLibrary();
    Picture picture = library.GetPictureFromToken(queryStrings["token"]);
    photoStream = picture.GetImage();
}

Gotcha 1 - Navigation & the token parameter

Invoking the app from the Picture Viewer starts your app and navigates to the main page. I think the most common scenario for handling a new picture is to do this on some other page than the main page. In my app that I’m writing (a photo diary app), I directly navigate away from the main page to the details page, thus creating a diary entry for the new picture. This is all easily done, but the quirk comes when navigating back to the main page – the “token” parameter is not cleared! So, my so simple code immediately creates yet another entry and takes me straight back to the details page.

Fix - Clear the “token” parameter after fetching the picture.

if (queryStrings.ContainsKey("token"))
{
    var library = new MediaLibrary();
    Picture picture = library.GetPictureFromToken(queryStrings["token"]);
    photoStream = picture.GetImage();
    queryString.Remove("token");
}

Gotcha 2 – You can’t debug

I really hope someone proves me wrong here. Please do

The problem:

emulator – the picture hub does not exist, neither the camera app

device – you’re now allowed to access the picture hub while connected to the computer (not even the PhotoChooserTask will launch)

So, how can we debug this? Well, I found a way, a tedious way, but still a way.

Fix 2 - Put an image in the isolated storage, then feed this image to your code on the main page.

An even more realistic test would be to put the exact same token in the queryStrings collection – but I’m not sure that the app would have privileges to read that picture from the picture hub then.

2a. Take a snapshot of the isolated storage from the emulator using ISETOOL (Isolated Storage Explorer). The app guid is the “<App ProductID=” from WMAppManifest.xml.

isetool ts xd <app-guid> .

2b. Put an image in the root (or wherever) of the isolated storage file structure

2c. Restore the snapshot to the emulator (note the folder name here, should the child folder of the folder specified in the “take snapshot command)

isetool rs xd <app-guid> IsolatedStore

2d. Fake AppConnect by reading your file

Here I read the image to a MemoryStream and hand away, to interfere with IsolatedStorage as little as possible.

The high-level code that will not change looks like:

protected override void OnNavigatedTo(NavigationEventArgs e)
{
    base.OnNavigatedTo(e);
    HandleImageFromAppConnect();
}

private void HandleImageFromAppConnect()
{
    var stream = GetPictureStream();

    if (stream != null)
    {
        ViewModel.HandleAddWithImageInvoked(stream);
        NavigateToDetails();
    }
}

And the method to get the stream:

private Stream GetPictureStream()
{
    IDictionary<string, string> queryStrings =
        this.NavigationContext.QueryString;

    Stream photoStream = null;
    if (queryStrings.ContainsKey("token"))
    {
        var library = new MediaLibrary();
        Picture picture = library.GetPictureFromToken(queryStrings["token"]);
        queryStrings.Remove("token");
        photoStream = picture.GetImage();
    }

#if DEBUG
    var isFakingImageFromAppConnect = false;
    if (isFakingImageFromAppConnect)
    {
        MemoryStream manualStream = null;
        using (var store = IsolatedStorageFile.
            GetUserStoreForApplication())
        {
            if (store.FileExists("/pic.jpg"))
            {
                using (var file = store.OpenFile("/pic.jpg", FileMode.Open))
                {
                    var bytes = new byte[file.Length];
                    file.Read(bytes, 0, bytes.Length);
                    manualStream = new MemoryStream(bytes);
                }
            }
        }

        photoStream = manualStream;
    }
#endif

That does it – we can debug-stop on the bool, set it, then let the code spin and debug away.

Finally – please – find an easier way and tell me about it

Bye for now!

double.NaN gives me update issues (ChangeConflictException) in SQL Compact, my fallback was to set the value to zero instead:

double.IsNaN(value.Altitude) ? 0 : value.Altitude

where ‘Alt’ is the property on my SQLCE entity object. Of course NaN is not the same as zero – but that does not matter to me.

Background

For a Windows Phone 7 demo app that I’m writing, I’ve been trying to store GPS locations in a SQL Compact database. The GeoCoordinate data type is not supported by SQLCE, so I just took the Latitude, Longitude and Altitude and stored those as doubles in the db. (here's a list of SQL Compact supported data types)

And, this was not my first my first version of the app (hence db), so I had to make the properties nullable – otherwise the SQLCE engine cannot add columns for them, read more about wp7 databases here. I do not think the nullable thing was a part of my problem, but you never know…

The problem

So, I happily took data from the GPS in the emulator, got double.NaN as the Altitude and saved that to the DB, all fine so far… Then when updating the database record with other values and trying to save the entry again, I kept getting the error:

ChangeConflictException {"Row not found or changed."}

Since this problem appeared when I added the Altitude to the database, it was my prime suspect and when I removed it again all was fine.

I’m not sure of the inner workings of this problem, but I suspect it having to do with the fact that when trying to compare a double with double.NaN, VS hints with:

A NaN does not compare equal with any floating point number

I can perfectly understand that NaN is a special case so I’m fine with sidestepping it like this.

The fix

Alt = double.IsNaN(value.Altitude) ? 0 : value.Altitude;

The code in the [Table] class:

private double? _alt;
[Column(CanBeNull = true)]
public double? Alt
{
    get { return _alt; }
    set
    {
        OnPropertyChanging("Alt");
        _alt = value;
        OnPropertyChanged("Alt");
    }
}

public GeoCoordinate Location
{
    get { return new GeoCoordinate(
        Lat.GetValueOrDefault(),
        Lng.GetValueOrDefault(),
        Alt.GetValueOrDefault()); }
    set
    {
        Lat = value.Latitude;
        Lng = value.Longitude;

        //just setting the double.NaN value, this gave me trouble
        //Alt = value.Altitude;

        //my fix: replacing NaN with zero
        Alt = double.IsNaN(value.Altitude) ? 0 : value.Altitude;

        _location = value;
    }            

And the code where I update the Item entity from my view model:

private void SaveEntry()
{
    var item = (from i in db.Items
                where i.Id == ViewModel.Id
                select i).First();

    db.Refresh(RefreshMode.OverwriteCurrentValues, item);

    item.PhotoUrl = ViewModel.PhotoUrl;
    item.Text = ViewModel.LongText;
    item.Title = ViewModel.Title;
    item.Location = ViewModel.Location;
    db.SubmitChanges();
}

I have of course tried the different RefreshModes, with the same result.

I hope this helped someone out there with weird SQL errors and NaN values.

Bye!

If your data is relational and fixed in the sense that there is a predefined schema, then a relational database would solve your problem just fine. However, if the problem domain is not relational in its nature, then other data structures might be better suited.

When dealing with free text qualitative data, there is really no connections that could be modeled between different sets of data. Instead a data structure of independent documents would be more suitable.

As a .NET developer the document database RavenDB is attractive since it provides us with a built-in .NET API, HTTP API and many of the features a NoSQL database can offer. In a web environment the HTTP API is useful because it could eliminate the need for a middle tier for simple scenarios where you don't need all the features the server side could offer. In RavenDB all documents are stored as JSON and its input and output is also JSON.

Since RavenDB is built in .NET, the natural way of using it is from .NET code. It is very easy to store and fetch strongly typed objects since RavenDB has APIs for doing the mapping transparently. However, you are not forced to use .NET code only. From JavaScript we can call the database directly with RavenDB's RESTful API. The mapping to a .NET class is stored as metadata with a fully qualified name. This is the only difference between a .NET mapped document and a document without any .NET type.

In RavenDB, you have to create indexes as Map/Reduce functions written as LINQ-queries. These indexes could make use of document properties, metadata or both.

The same logic is applied to collections in RavenDB; it is just some metadata specifying the Raven-Entity-Name. The major difference between this attribute and other metadata is that the Raven-Entity-Name could be used in indexes like this:

from album in docs.albums
select new {album}

Of course you can add your own metadata and use it in your own indexes.

My personal findings about RavenDB are that it is very easily deployed; you can use xcopy to a website in Internet Information Services, IIS, with all of the features it offers.
The database itself is quite straight forward but there are still things that need to be improved in the eco-system, such as management tools and more extensive documentation.

It is really nice to use Linq syntax to create indexes if you know C#, but you really have to think differently than you do when using a traditional relational database. You cannot write SQL to query RavenDB. However, in most cases it is possible to get the data you want by creating indexes.

Just remember, you store documents, not relational data.

• Håkan Reis – Version handling in TeamCity first part
• Håkan Reis – Version handling in TeamCity second part
• Fredrik Olsson – Auto incrementing Build Numbers in XCode

But the fact is, at least for Visual Studio projects, this can be done in two steps without writing any code at all. Simply put, it just got really easy. To accomplish this we’ll be using TeamCity’s Addition Build Features.

Step 1 – Set a build number format

I used the format 0.1.0.{0} (where {0} will be replaced by the build counter), but you can basically put anything you like here.

The build number format will automatically be stored in TeamCity as %build.number% which we will use in the next step.

Step 2 – Add an additional build step

When configuring your Build Steps you can also add something called Additional Build Features. One of those features is called AssemblyInfo patcher and it’s described like this.

AssemblyInfo Patcher build feature allows to set a build number to an assembly automatically, without having to patch AssemblyInfo.cs files manually. When adding this build feature you need only to specify version format. Note, that you can use TeamCity parameter references here.

So just add this feature and put your %build.number% as the assembly version format.

Done and done. For every build TeamCity will now update AssemblyInfo.cs, build your solution and then revert the changes that it made to the file. So we’ll end up with an assembly with a version number and unchanged source files.

Maintainable, clean and simple.

I am hosting my own NuGet server and I want to host my own Source and Symbol server as well. I can’t use SymbolSource.org because the code is proprietary and even though I could get a non-public account on SymbolSource.org the customer I am working with has a strict security policy of not letting the code leave the company network. So, I must host it myself, but how?

The Source Server

Setting up the source server was simple. Just create a file share, create a folder with the version number as name and put your source code there. So if I have a C# file named MySourceCode.cs in MyProject, the path to the source code will be \\myServer\MySourceShare\version1.0\MyProject\MySourceCode.cs

The Symbol Server

When you build a .Net assembly in VisualStudio you get one dll file and one pdb file. The pdb file contains debug information and references to the source code that makes up the assembly. There is only one problem with this. The references to the source files are absolute paths. If I have the source code in a file C:\Work\TheCustomer\MyProject\MySourceCode.cs, the pdb file will contain that absolute path.

Thus we must modify the pdb file to contain the path to the source server instead. This is a process call ‘Source Indexing’, and here’s an MSDN article about it, http://msdn.microsoft.com/en-us/library/ms680641(v=VS.85).aspx

The source indexing tools in ‘Debugging Tools for Windows’ is a collections of executables and perl scripts, but none of the srcipts do exactly what I want. What I want to do is replacing ‘C:\Work\TheCustomer\MyProject\MySourceCode.cs’ with ‘\\myServer\MySourceShare\version1.0\MyProject\MySourceCode.cs’. I am not proficient in Perl, so I wrote a small console program in C# that takes the replacement paths and modifies the pdb . Please see attachment.

Now we are ready to publish the pdb. Create a second file share ‘\\myServer\MySymbolShare’ and publish the modified pdb there by running symstore.exe (also from ‘Debugging Tools for Windows’).

symstore.exe add /f myProject.pdb /s \\myServer\MySymbolShare /t "MyProject" /v "1.0.0.0"

Setting Up VisualStudio

Finally we have to tell VisualStudio to search for symbols and source on our new shares.

a. In VisualStudio select "Debug->Options and Settings"

b. Select 'General' category

c. Uncheck "Enable Just My Code"

d. Check "Enable source server support"

e. Select 'Symbols' category

f. Add a new path by clicking the folder icon in upper right corner. Set name to: “\\myServer\MySourceShare”

g. Add another path. Set name to: “\\myServer\MySymbolShare”

That's it! When you debug 'MyProject', you can step in to the code and VisualStudio will automatically download the source code and display it. Sweet!

Summary

I used…

• FileAppender+MinimalLock to be able to read the log file while the system is running
• three Appenders one each for minimum LogLevel: debug, info and warning
• one logger per class – gave me a readable “tag” on each log item, but filtering problems with nhibernate
• an LoggerMatchFilter for nhibernate with AcceptOnMatch=false to reject messages

Getting started

To get any logging at all, you need to create a logger and configure it. The code for doing this and writing something to the log looks like this:

log4net.Config.XmlConfigurator.Configure();
var log = log4net.LogManager.GetLogger(this.GetType());
log.Debug(“debug message”);

(Yes, it’s not a typo – the namespace is lowercase, I know it’s hard, by try to ignore that…)

Those few lines of course require configuration, the app/web.config is a good place for that so let’s go there now. The config needs three parts; a configSections entry, a log4net appender and a log4net root directive. See for yourself:

<configuration>
  <configSections>
    <section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net"/>
  </configSections>
  <log4net>
    <appender name="RollingFileAppenderAll" type="log4net.Appender.RollingFileAppender">
      <file value="c:\logs\projectx_log_debug.txt" />
      <appendToFile value="true" />
      <rollingStyle value="Composite" />
      <datePattern value=".yyyyMMdd" />
      <maxSizeRollBackups value="10" />
      <maximumFileSize value="1MB" />
      <staticLogFileName value="true" />
      <lockingModel type="log4net.Appender.FileAppender+MinimalLock" />
      <layout type="log4net.Layout.Pattern Layout">
        <conversionPattern value="%date [%thread] %-6level %logger - %message %exception%newline" />
      </layout>
      <filter type="log4net.Filter.LoggerMatchFilter">
        <loggerToMatch value="Jayway.ProjectX" />
      </filter>
      <filter type="log4net.Filter.DenyAllFilter" />
    </appender>
    <root>
      <level value="ALL" />
      <appender-ref ref="RollingFileAppenderAll" />
    </root>
  </log4net>

Appender

The appender entry represents a consumer of the logging information. Here I use a RollingFileAppender which rotates the log file periodically, as specified by the datePattern. MaximumFileSize is also honored and breaking that limit also rolls the log file over.

The logging in my project is done from a WCF service with HTTP endpoints. I have testing endpoints (e.g. /log/debug) that just shows the latest log file – very handy. To be able to read from the log file while the service is running, the lockingModel has to be set to FileAppender+MinimalLock which tells log4net to lock the log file as little as possible, instead of all the time which is the default. This will create a performance hit for the logging, but that’s ok for my setup. Specifying a staticLogFileName causes log4net to always log to a specific file, and then rename older log files according to date etc. This allows my hand coded log reader to always know where the latest log info is.

Root

The root section is what connects a log consumer (the appender) with a log producer (the ILog in the code). The root section can be replaced by specifying a specific logger (<logger name=”myLogger”>), and that would only process log data from that specific logger. Which logger to process data from brings us to the next topic – filtering.

Filtering (and getting rid of nhibernate output)

As you probably know, logs can either say to little, just about right, or WAY too much – that’s where the power of filtering comes in. LogLevel is the most natural and direct thing to filter on. In my service, I have three different log files all set to different levels; one for everything, one for at least Info and one for at least Warning. This is done by having three different appender entries and three appender rows in the root entry. This is where I started bumping into problems, read on…

One logger per class

I followed the advice from Jim’s log4net recommended practices to create one logger per class – not to use one logger for the entire application. The theory behind this is to have a tag on each log entry allowing you to have a log that “reads like a novel”. I like the idea and it’s very nice to always know what class issued the statement. Here’s an example of log output:

10:24:57,830 [10] INFO   Jayway.ProjectX.Service - ping called
10:24:57,833 [10] WARN   Jayway.ProjectX.Proxy - ping called
10:28:03,084 [10] INFO   Jayway.ProjectX.RequestCreator - creating request
10:28:03,095 [10] INFO   Jayway.ProjectX.Proxy - sending request
10:28:03,097 [10] WARN   Jayway.ProjectX.Proxy - could not reach host
10:28:03,907 [10] INFO   Jayway.Common.Cache - getting items from cache
10:28:03,910 [10] INFO   Jayway.ProjectX.Proxy - returning cache items
10:28:28,816 [10] INFO   Jayway.ProjectX.Service - returning 100 items

I made this happen by using a logFactory that I inject into each class, instead of a log. (I’m not using an IoC container, was overkill for this project). The web service class looks like this:

private readonly ILogFactory _logFactory;
private readonly ILog _log;
public WebService()
{
   _logFactory = new LogFactoryLog4Net();
   _log = _logFactory.Create(this);
}

whilst one of the classes begins with this:

private readonly ILog _log;

public Proxy(ILogFactory logFactory)
{
    _log = logFactory.Create(this);
}

Using this technique, it would be very easy to temporarily add an appender for just a part of your system – giving you awesome control of the logging output.

nhibernate

NHibernate also uses log4net – and since I don’t have one logger but one per class, I have to use the “root” logger directive. The root logger funnel everything sent to the log4net system. This caused me to get all the nhibernate debug info in my logs. This was not what I wanted.

Inverted filtering

To get the kind of filtering output I wanted I had to use two kinds of filters; the LoggerMatchFilter and the LevelRangeFilter. Filtering in general in log4net works so that if you hit a filter that matches, it breaks the filtering chain and returns. This took me a while to figure out, I thought it just acted as a filter that could be chained, so that I could specify more and more filters to get more and more fine-grained output. But, back to the code:

<filter type="log4net.Filter.LoggerMatchFilter">
  <loggerToMatch value="NHibernate" />
  <AcceptOnMatch value="false"/>
</filter>
<filter type="log4net.Filter.LevelRangeFilter">
  <levelMin value="INFO" />
</filter>
<filter type="log4net.Filter.DenyAllFilter" />

As you can see, I use the LoggerMatchFilter inverted. So, when it hits an item that matches “NHibernate” it will immediately reject it. If it does not match, it will continue down the chain and check the level. I figured this out by reading Matthew Daugherty’s log4net tutorial, highly recommended.

Xap packaging failed. Object reference not set to an instance of an object.

Short story

A file had been removed from disk but not from the solution. Always set your sample data files to Build action: None.

Long story

The missing file

After a few rounds of clean, rebuild, machine reboot etc., I started thinking and remembered that I had replaced an image in my Expression Blend sample data and removed the old one. Looking at the solution explorer confirms this, on file missing. Excluding this file from the solution removed the problem, I can now build again. But, why would the XAP packager fail on a file only used by the sample data?

Solution explorer with a missing file

Build action

So, the XAP packaging failed due to a missing image file, something must be wrong. Normal build action for images used by the application should be either content or resource, see WindowsPhoneGeek - Working with images... for more info on this. But, an image what will only be used by Blend to show sample data should not be included in the build and therefore have build action: none. Changing my banner.png to Build action: None made the build go through. Of course the missing file should be excluded, but at least now we can build.

Original (faulty) build action for sample data file

Bye for now!

The presentation was first delivered on Techdays 2011, and we recommend you to look at that blog post first. Below, you'll find some additional links to topics covered during some of the presentation occations.

The links

ReSharper 6
Currently in "Early Access Program", with better IntelliSense and refactoring support for JavaScript and CSS in Visual Studio.

Chrome DevToolbar (presentation at Google I/O)
A lot is happening here and this tool is well worth to keep your eyes on.

JSLint
Static code analysis for JavaScript

WCF Web API
We talked a bit about some of the features of WCF Web API, a.k.a." WCF Http"

SassAndCoffee
This NuGet package makes it easier to get started with CoffeeScript and Sass in ASP.NET.

Reactive Extensions (Rx) for JavaScript
Compose asynchronous and event-based programs using observable collections and LINQ-style query operators.

Project Silk
Web Application guidance from the Patterns & Practices team at Microsoft.

HTML5 Boilerplate
Gives you a good default when building HTML5 sites/apps. Also exists as a mobile version.

Knockout
The MVVM pattern implemented in JavaScript.

ASP.NET MVC Migration Tool
Help you with the migration between different versions of ASP.NET MVC.

Localization
Localization in the browser is harder than on the server. This blog post is a nice resource on the subject.

Track site speed with Google Analytics
When the "Network tab" is not enough. Lets you track the real loading time for your users.