The session is a deep dive on the new SQLite-WinRT API that we released on Codeplex last week. This new API is a thin wrapper around the native database engine, sqlite3.dll and exposes the key methods of the database engine through a modern Windows Runtime API callable from C#, Visual Basic and C++ that is all async methods and which reports unexpected results by throwing exceptions. The code is all up at http://sqlwinrt.codeplex.com. There’s no download for this project – you just download the source code, which is a complete Visual Studio 2012 solution containing projects for Windows Phone 8 and Windows 8 Store App components.

Why another database API on Windows Phone?

That’s a valid question! After all, we already have the Local Database in the Windows Phone SDK which is a LINQ to SQL API where the underlying database is SQL Server Compact Edition 3.7-ish. And we also have the SQLite-NET API for accessing SQLite which also exposes a LINQ API for working with a SQLite database. The Local Database LINQ to SQL API is not available for Windows 8 Store App development so not a great choice if you want to share code between your phone and tablet/PC apps, but SQLite-NET is available for both phone and Windows 8, as is SQLite-WinRT – so why do we need this new API?

SQLite-WinRT is for those developers who prefer to work with SQL statements rather than the object-oriented layer that LINQ gives you. It is also for those coming to Windows Phone 8 or Windows 8 from other platforms who have worked with SQLite before probably programming with C/C++ – the methods exposed by the SQLite-WinRT API are very thin wrappers around the SQLite C/C++ API. It’s all about giving choice to our developers – we have heard feedback that not all developers like to work with a local database using LINQ, so this API is for them.

To give you a comparison, this is how you might select a Customer from the Customer table using SQLite-NET:

var db = new SQLite.SQLiteAsyncConnection(App.DBPath); 
var _customer = await (from c in db.Table<Customer>() 
                        where c.Id == customerId 
                        select c).FirstOrDefaultAsync(); 
if (customer != null) 
{ 
    var Id = _customer.Id; 
    var Name = _customer.Name; 
}

And this is how you would do the same thing in SQLite-WinRT:

using (var db = new SQLiteWinRTPhone.Database(
    ApplicationData.Current.LocalFolder, "demo.db")) 
{ 
    await db.OpenAsync(); 
    using (var stmt = await db.PrepareStatementAsync(
                        "SELECT name, age FROM people")) 
    { 
        while (await stmt.StepAsync()) 
        { 
            var name = stmt.GetTextAt(0); 
            var age = stmt.GetIntAt(1); 
        } 
    } 
}

The choice is yours!

Getting Started with SQLite-WinRT

Start by installing the SQLite Extension SDK. This is the native dll, sqlite3.dll, which contains the database engine. To install this, in Visual Studio, on the Tools menu, open Extensions and Updates. In the left hand pane, select Online – Visual Studio Gallery, then enter SQLite into the search box. Select SQLite for Windows Phone and click the Download button to download and install the vsix package. (The same procedure works for the SQLite for Windows Runtime extension for Windows 8 Store Apps.)

After you’ve installed that, the native sqlite3 dlls are installed into a folder under C:\Program Files (x86)\Microsoft SDKs\Windows Phone\v8.0\ExtensionSDKs\SQLite.WP80\. That’s just for your information – you should never have to manually copy the sqlite3.dll from there in order to use the database

Warning: You will be prompted whenever an update is available for the SQLite database engine. When you install it, you will inadvertently ‘break’ SQLite-WinRT, in the sense that Visual Studio will be unable to open the project. That is because the project references the C:\Program Files (x86)\Microsoft SDKs\Windows Phone\v8.0\ExtensionSDKs\SQLite.WP80\3.7.17 path in a number of places, and when you upgrade SQLite, the version part of that path will change.
I will be adding a powershell script into the download to make it easy to update the SQLite-WinRT project file with the correct path, but if this happens to you before I do it, just edit the SQLiteWinRTPhone.vcxproj file (carefully!) to correct references to the old version and update them to pojnt at whatever new version you have installed.

Creating your Project

Create your C# or Visual Basic project as normal. Then go to http://sqlwinrt.codeplex.com and download the source code from there – remember there is no ‘official download’ for this Codeplex project.

The source code for this project is a solution containing two projects, the SQLite-WinRT component for Windows Phone, and the same thing but for Windows 8 Store Apps. Copy the Windows Phone project and use ‘Add Existing Project…’ to add it into your solution, then add a reference to the SQLite-WinRT project from your C#/VB project. That’s all you have to do!

Remember, if Visual Studio cannot load the SQLite-WinRT project, it’s probably because the SQLite extension has been updated. Read the Warning a few paragraphs before to resolve this.

Creating a database

To create a database, you can use code such as this:

    private void Application_Launching(object sender, LaunchingEventArgs e)
    {
      LoadDatabase();
    }

    private async void LoadDatabase()
    {
      // Get a reference to the SQLite database
      db = new SQLiteWinRTPhone.Database(
          ApplicationData.Current.LocalFolder, "sqlitedemo.db");

      await db.OpenAsync();

      string sql = @"CREATE TABLE IF NOT EXISTS
                    Customer (Id      INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
                                Name    VARCHAR( 140 ),
                                City    VARCHAR( 140 ),
                                Contact VARCHAR( 140 ) 
                );";
      string description = "Create Customer table";
      await ExecuteSQLStatement(db, sql, description);

      sql = @"CREATE TABLE IF NOT EXISTS
                    Project (Id          INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
                                CustomerId  INTEGER,
                                Name        VARCHAR( 140 ),
                                Description VARCHAR( 140 ),
                                DueDate     DATETIME,
                                FOREIGN KEY(CustomerId) REFERENCES Customer(Id) 
                                    ON DELETE CASCADE 
                )";
      description = "Create Project table";
      await ExecuteSQLStatement(db, sql, description);

      // Turn on Foreign Key constraints
      sql = @"PRAGMA foreign_keys = ON";
      description = "Enable foreign key constraints";
      await ExecuteSQLStatement(db, sql, description);

      DBLoaded.Set();
    }

    private static async Task ExecuteSQLStatement(
        SQLiteWinRTPhone.Database db, 
        string sql, 
        string description)
    {
      try
      {
        await db.ExecuteStatementAsync(sql);
        Debug.WriteLine(description + " executed OK");
      }
      catch (Exception ex)
      {
        var result = 
            SQLiteWinRTPhone.Database.GetSqliteErrorCode(ex.HResult);
        throw new ApplicationException(description + 
            " Failed with error " + result);
      }
    }

You can call this code from your Application_Loaded and Application_Activated event handlers. One particular thing I want to call out here: notice the last line of the LoadDatabase method:

    DBLoaded.Set();

DBLoaded is a ManualResetEvent which is used to flag when the database opening logic has completed. It is declared at the top of my App.Xaml.cs class, along with a ‘Gatekeeper’ method called GetDatabaseAsync():

    static SQLiteWinRTPhone.Database db;
    static ManualResetEvent DBLoaded = new ManualResetEvent(false);

    public static Task<SQLiteWinRTPhone.Database> GetDatabaseAsync()
    {
      return Task.Run(() =>
      {
        DBLoaded.WaitOne();
        return db;
      });
    }

The ManualResetEvent is created unset, and doesn’t get set until the last line of LoadDatabase(). All other database access code in my viewmodel classes makes a call to GetDatabaseAsync as the first thing it does. The DBLoaded.WaitOne() call in there blocks until DBLoaded is set, so this prevents any other database accessing code from executing until the LoadDatabase() method has completed.

Handling Errors

The SQLWinRT API throws exceptions when something goes wrong. Unfortunately, exceptions thrown in a WinRT component are not the most developer-friendly things ever devised. They are COMException objects, have no useful error text in them and just return to you a HResult. But you can get a meaningful error message if you call the handy GetSqliteErrorCode method which is used like this:

try
{
await db.ExecuteStatementAsync(sql);
}
catch (Exception ex)
{
var result = 
    SQLiteWinRTPhone.Database.GetSqliteErrorCode(ex.HResult);
throw new ApplicationException("Failed with error " + result);
}

GetSqliteErrorCode() returns the – yes, you guessed it – SQLite error code, which mostly are self explanatory (such as ‘SQLITE_CONSTRAINT’) are documented at http://www.sqlite.org/c3ref/c_abort.html.

CRUD operations

Create

To create records in the database, use code similar to this:

try 
{
    // Connection already opened in app.xaml.cs - get reference     SQLiteWinRT.Database db = App.db;      using (var custstmt = await db.PrepareStatementAsync(
    "INSERT INTO Customer (Name, City, Contact) VALUES (@name, @city, @contact)"
      ))
    {          // NOTE that named parameters have a leading "@",":" or "$".          custstmt.BindTextParameterWithName("@name", customer.Name);
        custstmt.BindTextParameterWithName("@city", customer.City);         custstmt.BindTextParameterWithName("@contact", customer.Contact);
        // Use StepAsync to execute a prepared statement         await custstmt.StepAsync();     } 
} 
catch (System.Runtime.InteropServices.COMException) 
{ … }

This uses a SQL statement containing named parameters (@name, @city, @contact), which you prepare using PrepareStatementAsync() and which you ‘plug in’ the values using the BindtypeParameterWithName(string parametername, type value) method. An alternative is to use anonymous parameters (shown below when describing Update).

Notice that we use the StepAsync() method to execute a row-returning SQL statement. StepAsync may seem curious, but the SQLite C/C++ API method this wraps is called Step(), so that’s the name we adopt for our WinRT method.

IMPORTANT: Remember to dispose of your Statement objects when you’re done with them – a good way of doing that is to use the C# using statement, as shown above.

Read

To read objects, use a SELECT statement:

public async Task<CustomerViewModel> GetCustomerAsync(int customerId)
{
    CustomerViewModel customer = null;
    using (var readstmt = await App.db.PrepareStatementAsync(
                "SELECT Id, Name, City, Contact FROM Customer WHERE Id = " 
                + customerId))
    {
        if (await readstmt.StepAsync() == true)
        {
            var customer = new CustomerViewModel()
            {
                Id = readstmt.GetIntAt(0),
                Name = readstmt.GetTextAt(1),
                City = readstmt.GetTextAt(2),
                Contact = readstmt.GetTextAt(3)
            };
        }
    }
    return customers;
}

StepAsync() returns true if there is a row to return. The example above would reasonably be expected to return just a single row, but if you get multiple rows returned from the database, then you would loop around creating your in-memory objects (your viewmodel objects) and entering them into some collection until StepAsync() returns false.

An alternative form of SELECT allows you to extract data from the rowset returned from the database by using the column name, rather than the column position as the previous code sample did. You enable this behaviour by calling the Statement.EnableColumnsProperty() method. Then the results are returned as a Dictionary<string, string> which you key into using the column name:

using (var readstmt = await App.db.PrepareStatementAsync(
    "SELECT Id, Name, City, Contact FROM Customer WHERE Id = " 
    + customerId))
{
    // Enable the columns property
    statement.EnableColumnsProperty();

    if (await readstmt.StepAsync() == true)
    {
        // it isn't super useful as all columns are returned as text and must be parsed 
        var columns = statement.Columns;
        var customer = new CustomerViewModel()
        {
            Id = int.Parse(columns["Id"]),
            Name = columns["Name"],
            City = columns["City"],
            Contact = columns["Contact"]
        };
    }
}  

This does impose a slight performance overhead, and every value returns as a string, so you have to parse the string to get the correct value type, as shown here for the Id column.

Update

Update is simple enough. This sample uses anonymous parameters in the SQL statement, rather then the named parameters we saw when discussing the Insert operation. Note that anonymous parameters are 1-based, not 0-based like just about every other collection in .NET!

// See if the customer already exists
var existingCustomer = await GetCustomerAsync(customer.Id);
if (existingCustomer != null)
{
    using (var custstmt = await App.db.PrepareStatementAsync(
        "UPDATE Customer SET Name = ?, City = ?, Contact = ? WHERE Id=?"))
    {
        // NOTE when using anonymous parameters the first has an index of 1, not 0. 
        custstmt.BindTextParameterAt(1, customer.Name);
        custstmt.BindTextParameterAt(2, customer.City);
        custstmt.BindTextParameterAt(3, customer.Contact);
        custstmt.BindIntParameterAt(4, customer.Id);

        await custstmt.StepAsync();
    }
}

Delete

Delete is simple enough:

string sql = @"DELETE FROM Customer WHERE Id={0}";
sql = string.Format(sql, customerId);

// Can use ExecuteStatementAsync to run non row returning statements
await App.db.ExecuteStatementAsync(sql);

Summary

That’s an introduction to getting started with SQLite-WinRT. In the next posts, I will talk some more about Foreign Key constraints and about working with Read-only databases.

Members of a panel selected from Microsoft, the Adobe PhoneGap team, and industry experts will choose 20 winners, based on apps that are:

• Original
• Innovative
• Easy to use
• Engaging and visually appealing to the user

The panel will pick 3 grand prize winners who each will receive a Windows Phone 8 and a Surface Pro, and 17 first prize winners who each will receive a Windows Phone 8. All winning apps will be evaluated for featured slots in the Windows Phone Store.

Full details on the Windows Phone Dev Blog here, entry page for the Windows Phone Porting Challenge competition here.

As a developer, you can update Tiles in lots of different ways:

• From the app while the user is running it
• Using Push notifications to send updates through from backend services
• Using a TileSchedule
• From a Background Agent

For most purposes, the Tile templates are plenty rich enough for the developer to be able to communicate new information to the user. For example, the Flip Tile template allows you to set all the properties shown here:

However, as you can see the areas for text are fairly limited, and sometimes the developer will want to communicate more than is possible using the available properties. The only way to do this is to create a custom image and draw the text (or additional graphics) onto the custom image, then use that to update the tile.

In Windows Phone 8, your app can also be the Lock Screen image provider. Here, all you can supply is the image, so if you wanted to communicate some up to date information, the only way you can do that is to write onto the image. But what a size of image! Plenty of room for writing additional text, icons or custom graphs for example!

Creating custom images using a User Control

The easiest way to layout a custom tile or lock screen image is to create a User Control of the required size, just as you would lay out a page. Of course, what you put onto the control is entirely up to you, but as an example, here’s the Xaml for a user control for a standard Wide Tile for the FlipTile template:

<UserControl x:Class="RenderImageLibrary.WideTileControl"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    FontFamily="{StaticResource PhoneFontFamilyNormal}"
    FontSize="{StaticResource PhoneFontSizeNormal}"
    Foreground="{StaticResource PhoneForegroundBrush}"
    d:DesignHeight="336" d:DesignWidth="691">
    
    <Grid x:Name="LayoutRoot">
        <Image x:Name="BackgroundImage" Stretch="UniformToFill" />
        <Rectangle Stroke="Black">
            <Rectangle.Fill>
                <LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
                    <GradientStop Color="#99000000" Offset="0.007"/>
                    <GradientStop Color="#19000000" Offset="1"/>
                </LinearGradientBrush>
            </Rectangle.Fill>
        </Rectangle>
        <TextBlock x:Name="TextOverlayTextBox" VerticalAlignment="Center" 
                   HorizontalAlignment="Center" 
                   Text="Text" Margin="31,29,31,77" TextWrapping="Wrap"
                   Style="{StaticResource PhoneTextLargeStyle}" Foreground="White"
                   Width="629" Height="230" />
    </Grid>
</UserControl>

As you can see, this is layed out in a Grid with an Image element first, and overlaying that is a black filled Rectangle which is semi transparent and overlays the image using a gradient fill. This is there so that the text which forms the top layer – in the TextBlock – and which is drawn in white, is clearly legible, even over a light coloured background image.

In the code for this control, there is a property to set the text overlay. The background image used is included as content in this sample so is not changeable at runtime, but this could easily be changed so that any new image could be plugged into it.

using System;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.IO.IsolatedStorage;
using System.Windows.Media.Imaging;

namespace RenderImageLibrary
{
    public partial class WideTileControl : UserControl
    {
        public WideTileControl(string tileText)
        {
            InitializeComponent();

            Text = tileText;
        }

        public string Text { get; set; }

        public event EventHandler<SaveJpegCompleteEventArgs> SaveJpegComplete;

        public void BeginSaveJpeg()
        {
            // Load the background image directly - important thing is to delay 
            // rendering the image to the WriteableBitmap until the image has
            // finished loading
            BitmapImage backgroundImage = 
                new BitmapImage(new Uri("DefaultWideTile.jpg", UriKind.Relative));
            backgroundImage.CreateOptions = BitmapCreateOptions.None;

            backgroundImage.ImageOpened += (s, args) =>
                {
                    try
                    {
                        // Set the loaded image
                        BackgroundImage.Source = backgroundImage;

                        // Set the text
                        TextOverlayTextBox.Text = this.Text;

                        // Explicitly size the control - for use in a background agent
                        this.UpdateLayout();
                        this.Measure(new Size(691, 336));
                        this.UpdateLayout();
                        this.Arrange(new Rect(0, 0, 691, 336));

                        var wb = new WriteableBitmap(691, 336);
                        wb.Render(LayoutRoot, null);
                        wb.Invalidate();

                        // Create a filename for JPEG file in isolated storage
                        // Tile images *must* be in shared/shellcontent.
                        String fileName = "Tile_" + Guid.NewGuid().ToString() + ".jpg";

                        var myStore = IsolatedStorageFile.GetUserStoreForApplication();
                        if (!myStore.DirectoryExists("shared/shellcontent"))
                        {
                            myStore.CreateDirectory("shared/shellcontent");
                        }

                        using (IsolatedStorageFileStream myFileStream = 
                            myStore.CreateFile("shared/shellcontent/" + fileName))
                        {
                            // Encode WriteableBitmap object to a JPEG stream.
                            wb.SaveJpeg(myFileStream, wb.PixelWidth, wb.PixelHeight, 0, 75);
                            myFileStream.Close();
                        }

                        // Delete images from earlier execution
                        var filesTodelete = 
                             from f in myStore.GetFileNames("shared/shellcontent/Tile_*")
                                .AsQueryable()
                             where !f.EndsWith(fileName)
                             select f;
                        foreach (var file in filesTodelete)
                        {
                            myStore.DeleteFile("shared/shellcontent/" + file);
                        }

                        // Fire completion event
                        if (SaveJpegComplete != null)
                        {
                            SaveJpegComplete(this, new SaveJpegCompleteEventArgs(true, 
                                                           "shared/shellcontent/" + fileName));
                        }
                    }
                    catch (Exception ex)
                    {
                        // Log it
                        System.Diagnostics.Debug.WriteLine(
                                "Exception in SaveJpeg: " + ex.ToString());

                        if (SaveJpegComplete != null)
                        {
                            var args1 = new SaveJpegCompleteEventArgs(false, "");
                            args1.Exception = ex;
                            SaveJpegComplete(this, args1);
                        }
                    }
                };

            return;
        }
    }
}
 

The most important part of this code is the BeginSaveJpeg method which ensures the control is sized and layed out correctly, renders the control onto a WriteableBitmap which is used to write out the image to a jpg, and then fires the SaveJpegComplete event to inform callers that the work is done. Note that as this is a tile image, the method writes it to the /shared/ShellContent folder which is required for images used for tile updates.

We can now make use of this in – for example – a background agent. Here’s the code from the attached sample that creates a custom image in a background agent:

namespace BackgroundUpdate
{
    public class ScheduledAgent : ScheduledTaskAgent
    {
        ...

        /// <summary>
        /// Agent that runs a scheduled task
        /// </summary>
        /// <param name="task">
        /// The invoked task
        /// </param>
        /// <remarks>
        /// This method is called when a periodic or resource intensive task is invoked
        /// </remarks>
        protected override void OnInvoke(ScheduledTask task)
        {
            // Render a new image for the lock screen
            System.Threading.ManualResetEvent mre = new System.Threading.ManualResetEvent(false);

            Deployment.Current.Dispatcher.BeginInvoke(() =>
            {
                if (LockScreenManager.IsProvidedByCurrentApplication)
                {
                    LockScreenImageControl cont = new LockScreenImageControl();
                    cont.SaveJpegComplete += (s, args) =>
                        {
                            if (args.Success)
                            {
                                // Set the lock screen image URI - App URI syntax is required!  
                                Uri lockScreenImageUri = new Uri("ms-appdata:///Local/" 
                                                        + args.ImageFileName, UriKind.Absolute);
                                Debug.WriteLine(lockScreenImageUri.ToString());

                                LockScreen.SetImageUri(lockScreenImageUri);
                            }
                            mre.Set(); 
                        };
                    cont.BeginSaveJpeg();
                }
            });

            // Wait for Lock Screen image to complete
            mre.WaitOne();
            // Then reset for the Tile Image operation
            mre.Reset();

            Deployment.Current.Dispatcher.BeginInvoke(() =>
            {
                // Render the new tile image
                RenderImageLibrary.WideTileControl wtc = new RenderImageLibrary.WideTileControl(
                    "This text is written onto the image - allows you to specify more text than " 
      + "you can fit onto a standard tile using the available properties in the tile templates");

                wtc.SaveJpegComplete += async (s, args) =>
                {
                    try
                    {
                        if (args.Success)
                        {
                            // Set the tile image URI - "isostore:/" is important! 
                            // Note that the control already
                            // puts the image into /Shared/ShellContent which is where tile 
                            // images in the local folder must be
                            Uri tileImageUri = new Uri("isostore:/" 
                                              + args.ImageFileName, UriKind.RelativeOrAbsolute);
                            Debug.WriteLine(tileImageUri.ToString());
                            


                            // Set the tile image
                            FlipTileData ftd = new FlipTileData();
                            ftd.WideBackgroundImage = tileImageUri;
                            ftd.Title = "Set by BG agent";

                            ShellTile.ActiveTiles.First().Update(ftd);
                        }
                        else
                        {
                            Debug.WriteLine(args.Exception.ToString());
                        }
                    }
                    catch (Exception ex)
                    {
                        Debug.WriteLine(ex.ToString());
                    }
                    finally
                    {
                        mre.Set();
                    }
                };

                wtc.BeginSaveJpeg();
            }
    );
            // Wait for tile operation to complete
            mre.WaitOne();

            NotifyComplete();

        }
    }
}

The result is a pretty custom tile image which you can see after you tap and hold on the sample app where it is listed in the Programs list, and then tap ‘Pin to Start’:

The sample code gives examples for both a custom tile and a custom Lock Screen Image. If you study the code, you can see that the Windows Phone APIs show a shocking disregard (!) for consistency over how the URI of the image must be supplied. For the LockScreen API, the image can be anywhere in local storage, but you must use an ‘Application URI’ format, for example:

Uri lockScreenImageUri = new Uri(“ms-appdata:///Local/myNewLockScreenImage.jpg” UriKind.Absolute);
LockScreen.SetImageUri(lockScreenImageUri);

The ShellTile API is different. Its images must be in /Shared/ShellContent or a subfolder of it, and the URI must be specified as an absolute URI, using the isostore: protocol:

Uri tileImageUri = new Uri(“isostore:/Shared/ShellContent/myNewTileImage.jpg” , UriKind.RelativeOrAbsolute);                            
// Set the tile image
FlipTileData ftd = new FlipTileData();
ftd.WideBackgroundImage = tileImageUri;
ShellTile.ActiveTiles.First().Update(ftd);

That minor grumble apart, the results are great!

Portable HttpClient for .NET Framework and Windows Phone

As they describe on their blog post here, the .NET Framework team have released a Beta release of the portable version of HttpClient, the modern networking API. The HttpClient library is a set of APIs for .NET which provide a flexible and extensible way to access all things exposed through HTTP. HttpClient exposes the new Task based asynchronous methods, which makes writing responsive and performant UI applications across all platforms a lot simpler.

This is particularly significant for anyone developing apps for both Windows Phone and Windows 8 as it allows you to standardise your networking code around HttpClient.  In addition it also enables other portable library developers who require networking support to use HttpClient while targeting all or a subset of the supported platforms.

To use it, first make sure you have got NuGet v2.1 or later installed (Go to Tools – Extensions and Updates). Then to use the HttpClient package, right click on your solution, go to the Manage Nuget Packages dialog, search for Id Microsoft.Net.Http, and make sure “Include Prerelease” is turned on.

Now you can go ahead and program against the HttpClient API. For example, here’s the code to access the OData feed for the Northwind sample feed at Odata.org:

HttpClient httpClient = new HttpClient();    
httpClient.DefaultRequestHeaders.Add("Accept", "application/json;odata=verbose");
HttpResponseMessage response = null;
try
{            
    response = await httpClient.GetAsync(
        "http://services.odata.org/Northwind/Northwind.svc/Suppliers");

    response.EnsureSuccessStatusCode(); // Throws exception if bad HTTP status code
    Debug.WriteLine(response.StatusCode + " " + response.ReasonPhrase);

    string responseBodyAsText = await response.Content.ReadAsStringAsync();
    var feed = Newtonsoft.Json.JsonConvert.DeserializeObject<SupplierODataFeed>(responseBodyAsText);

    MessageBox.Show("Received payload of " + responseBodyAsText.Length + " characters");

    SuppliersList.ItemsSource = feed.d.results;
}
catch (HttpRequestException hre)
{
    MessageBox.Show("RespCallback Exception raised! Message:{0}" + hre.Message);
}

Using Compression with the Portable HttpClient

Anyone who knows me or has seen the Networking JumpStart video, will know that I am running a bit of  a crusade against the non-application of compression. Too many devs forget the simple fact that mobile apps on cellular networks (that’s not just Phone people – same for Windows 8 machines that have integrated cellular networking!) often find themselves trying to communicate over poor quality networks. Stack the cards in your favour, increase the chance of success and USE COMPRESSION!

Fortunately, many other people share my views on this. The excellent people at AdvancedREI have created the HttpClient.Compression NuGet package, based on original work by the super-excellent Morten Nielsen.

This is also a pre-release NuGet package. After you install that package, all you do is new up an instance of the CompressedHttpClientHandler and pass that into the constructor of HttpClient:

// Requires HttpClient.Compression NuGet package
var handler = new AdvancedREI.Net.Http.Compression.CompressedHttpClientHandler(); 

HttpClient httpClient = new HttpClient(handler); 

As long as your server is configured to serve up compressed content, you will receive data compressed over the wire and the handler will take care of decompression on receipt.

Get recognised and rewarded for building your original apps. Further, get bonus rewards for migrating your Windows Phone app to Windows Store and vice versa or incorporating one or more Windows Azure Services.

Follow these 4 Simple Steps to Start Earning Points for your Awesome Apps:

1. Register yourself on the UK App Builder Reward Programme website.

2. Build & publish your original & unique app.

3. Claim points by telling us about the app you’ve published and we’ll award points to you accordingly.

4. Redeem your points for a range of fantastic prizes and gadgets.

Introducing Our First Ever One Day Special

On Tuesday 19 March 2013, we will be announcing a special one day deal for the Rewards Programme. To make sure you can take advantage of this special one day deal, publish your apps and ensure you claim your points before Thursday 14 March 2013 (less than 2 weeks away) so you will have your all of your eligible points in your account to use. You do not want to miss this one day special! Look out for the announcement for the One Day Special on Tuesday 19 March.

Don’t forget about our Bonus Rewards

The bonus rewards are limited deals where you must fulfil the stated criteria. Once you have fulfilled the criteria, you will be notified by our team and delivery of your bonus reward will be arranged. The bonus reward is exactly that and it will not affect the balance of your points therefore, you will still be able to use your points to claim for your reward(s) of your choice. Nokia have generously sponsored the first set of bonus rewards. You have to be quick to take advantage of this special bonus reward.

Bonus Reward 1: Receive a Nokia Lumia 620 Windows Phone 8 Handset if you are one of the first 20 App Builders who accumulate 100 points from Windows Phone Apps published.

Bonus Reward 2: Receive a Nokia Lumia 920 Windows Phone 8 Developer Handset if you are one of the first 10 App Builders who accumulate 200 points for publishing Windows Phone apps.

Show us that you’re a game changer and collect points every step of the way of your app building journey to redeem rewards like a brand new Lenovo Tablet 2. Create the next app phenomenon by building your original and unique Windows Store and/or Windows Phone app – and get recognised and rewarded for your hard work. Further, get bonus rewards for migrating your Windows Phone app to Windows Store and vice versa or incorporating one or more Windows Azure Services.

4 Simple Steps to Start Earning Points for your Awesome Apps

1. Register yourself on the UK App Builder Reward Programme website.

2. Build & publish your original & unique app.

3. Claim points by telling us about the app you’ve published and we’ll award points to you accordingly.

4. Redeem your points for a range of fantastic prizes and gadgets.

Build & publish an app between Monday 4^th Feb 2013 and Tuesday 30^th Apr 2013 to be eligible for points you can redeem for rewards. Here are the different ways you can earn points:

Points for Apps
Publish a New Windows Store App	50 Points
Publish a New Windows Phone App	25 Points

Bonus Points
Your Windows Store or Phone App incorporates one or more Windows Azure Services	+ 25 Points
Your app Windows Store app is migrated from Windows Phone or Windows Phone app is migrated from Windows Store	+25 Points

Example

For example, if you have built and publish a Windows Store app which was ported from an existing Windows Phone app and is hosted on Windows Azure, you will be eligible for up to 100 points for that app. Windows Store App = 50 Points + Hosted on Windows Azure = 25 Bonus Points + Ported from Windows Phone = 25 Bonus Points Total = 100 Points

To recognise your hard work, the more apps you publish, the more points you receive. The more points you get, the more exciting rewards you can claim. Here’s a brief selection:

Publish 1 Windows Phone App	Publish 1 Windows Store App	Publish 5 Windows Store apps + Windows Azure Services + Migrated from WP	Publish 10 Windows Store apps + Windows Azure Services + Migrated from WP
Get a XBOX360 Wireless Headset	Get a XBOX360 12 Months Gold Subscription	Get a Lenovo Tablet 2	Get a Two Night Deluxe Paris Cuisine Break for 2

In addition to the fantastic selection of rewards and experiences you can redeem using your points, we’re also offering some bonus rewards to give your journey to publishing great apps that extra boost.

For Windows Store Apps Builders	For Windows Phone Apps Builders
Receive one of the latest XBOX360 titles if you are one of the first 50 app builders who accumulate 150 points from publishing Windows Store Apps.	Receive a Nokia Lumia 620 Windows Phone 8 Handset if you are one of the first 20 App Builders who accumulate 100 points from Windows Phone Apps published (~windows phone apps)
Receive a copy Visual Studio 2012 Professional (with MSDN Subscription) if you are one of the first 5 app builders who accumulate 400 points from publishing Windows Store Apps.	Receive a Nokia Lumia 920 Windows Phone 8 Developer Handset if you are one of the first 10 App Builders who accumulate 200 points for publishing Windows Phone apps (~8 Windows Phone apps)

The UK App Builder Rewards Programme finishes on the 30^th April so get your thinking caps on and we look forward to rewarding your awesome apps very soon.

UK App Builder Rewards Programme www.appbuilder-rewards.co.uk

Unfortunately, the networking APIs in Windows Phone 8 have not been upgraded to support async and await. On Windows 8 Store Apps by contrast, HTTP networking APIs have been completely re-implemented to offer only async and await methods: the WebClient API has been removed and replaced with a more performant API, HttpClient, and HttpWebRequest has been revamped and now only offers Async methods. However, by use of some extension methods, we can enjoy the goodness of async and await with the WebClient and HttpWebRequest APIs on Windows Phone 8. It will work with Windows Phone 7.5/7.8 projects as well, as long as you add a reference to the NuGet Microsoft.bcl.Async package which adds in async and Task support for Windows Phone OS 7.1.

First, let’s look at HttpWebRequest. The GetResponseAsync extension method for this allow you to write code that is exactly the same as for Windows 8 – great if you are porting code between the two. Kudos to Mathias Shapiro, colleague at Microsoft, who developed this!

using System.Net;
using System.Threading.Tasks;

namespace WinPhoneExtensions
{
    public static class HttpExtensions
    {
        public static Task<HttpWebResponse> GetResponseAsync(this HttpWebRequest request)
        {
            var taskComplete = new TaskCompletionSource<HttpWebResponse>();
            request.BeginGetResponse(asyncResponse =>
            {
                try
                {
                    HttpWebRequest responseRequest = (HttpWebRequest)asyncResponse.AsyncState;
                    HttpWebResponse someResponse = (HttpWebResponse)responseRequest.EndGetResponse(asyncResponse);
                    taskComplete.TrySetResult(someResponse);
                }
                catch (WebException webExc)
                {
                    HttpWebResponse failedResponse = (HttpWebResponse)webExc.Response;
                    taskComplete.TrySetResult(failedResponse);
                }
            }, request);
            return taskComplete.Task;
        }
    }

    public static class HttpMethod
    {
        public static string Head { get { return "HEAD"; } }
        public static string Post { get { return "POST"; } }
        public static string Put { get { return "PUT"; } }
        public static string Get { get { return "GET"; } }
        public static string Delete { get { return "DELETE"; } }
        public static string Trace { get { return "TRACE"; } }
        public static string Options { get { return "OPTIONS"; } }
        public static string Connect { get { return "CONNECT"; } }
        public static string Patch { get { return "PATCH"; } }
    }
}

Using this, your HttpWebRequest calls now look something like this (don’t forget to add a using WinPhoneExtensions; import to the top of your class!):

        private async System.Threading.Tasks.Task GetSuppliers()
        {
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create("http://services.odata.org/Northwind/Northwind.svc/Suppliers");
            request.Method = HttpMethod.Get;
            request.Accept = "application/json;odata=verbose";

            try
            {
                HttpWebResponse response = (HttpWebResponse)await request.GetResponseAsync();

                Debug.WriteLine(response.ContentType);
                // Read the response into a Stream object.
                System.IO.Stream responseStream = response.GetResponseStream();
                string data;
                using (var reader = new System.IO.StreamReader(responseStream))
                {
                    data = reader.ReadToEnd();
                }
                responseStream.Close();

                var feed = Newtonsoft.Json.JsonConvert.DeserializeObject<SupplierODataFeed>(data);
                SuppliersList.ItemsSource = feed.d.results;
            }
            catch (Exception ex)
            {
                var we = ex.InnerException as WebException;
                if (we != null)
                {
                    var resp = we.Response as HttpWebResponse;
                    var code = resp.StatusCode;
                    MessageBox.Show("RespCallback Exception raised! Message:{0}" + we.Message);
                    Debug.WriteLine("Status:{0}", we.Status);
                }
                else
                    throw;
            }
        }

…which is exactly the same as you would use in a Windows 8 store app.

We can do a similar thing for WebClient, though here the benefits are simply that the code you end up writing becomes so much cleaner. You don’t get the benefit of compatibility with Windows 8 since WebClient is not available on that platform.

I won’t list the code of the extension methods here, as it’s a bit lengthier than for HttpWebClient. Please download the samples attached to this post to get the extension methods code. When using the extension methods, you end up with lovely clean code like this:

string url = "https://api.twitter.com/1/statuses/user_timeline.xml?include_entities=true&include_rts=true&screen_name="
    + nameTextBox.Text + "&count=10";

var client = new WebClient();
string response = await client.DownloadStringTaskAsync(new Uri(url));

If you would like to watch me explaining this (and much, much more!) on video, check out the Networking video in the JumpStart series at http://aka.ms/i5qr0z.

Download the accompanying samples for the code!

Microsoft has launched a new contest with a very special top prize – featured placement of the winner’s app in a Windows Phone Primetime TV ad which will be broadcast in the U.S. There are many other prizes such as Nokia Lumia 920 phones and Dev Center subscriptions.

Participation is easy and the contest is open to developers worldwide. Just visit the Windows Phone Dev Centre to opt-in to the contest and then publish a new app by March 5th. All apps submitted will then be judged based on an equal rating of user ratings and app quality, including the implementation of new Windows Phone 8 features, such as the new Tile templates.

This judging will narrow the field to 64 finalists and these will participate in a head-to-head competition, in which public voting will narrow the field to 32, then 16, 8, 4, 2 and finally the Grand Prize Winner. The 64 finalists will win prizes such as Nokia Lumia 920 phones and Dev Center subscriptions.

The last app standing will be announced the ‘Windows Phone Next App Star’ and will be featured in the Primetime TV ad!

So what are you waiting for? Visit the Windows Phone Dev Center now and opt-in to the contest, then get your app published by March 5th to submit your entry. Good Luck!

For more details, read the original announcement on the Windows Phone Developer Blog.

Nokia and Windows Phone Geek have teamed up to offer the LUMIA GEEK 8-WEEK CHALLENGE. There’s only ….ahem… less than one week left. But if you have submitted a new or significantly updated app to the Windows Phone Store between 13^th November 2012 and 8^th January 2013, then you can enter this great competition.

There are three awesome prize categories all with amazing prizes to be won. They are looking for the best Windows Phone developers to make amazing apps for the new WP8 Nokia Lumia devices. The Top prize wins you goodies such as:

• Trip for 2 to MWC in Barcelona. Includes: Airfare, Hotel Accommodations, & Event Passes
• App Demo @ WIPJam @ MWC
• Customized Nokia Lumia Device & Nokia Gear
• $300 ad credit on Nokia’s Ad Exchange (NAX)
• 1 Year Free Subscription to Nokia’s Premium Developer Program (NPDP)

Head over to http://windowsphonegeek.com/lumia-geek-8-week-challenge for full details.

We start 2013 with a Windows Phone competition that is being run by Core77, Inc. and Microsoft.

Now You Can Change the Future
Challenge ends February 3, 2013

Design an app for Windows Phone that showcases how to create, connect or impress the pants off your future self. Apps are a way to take control of your day-to-day life. Today they help you wake up, dress, commute, stay on top of news and reach the important people in your life throughout the day, and at their best they help you do things the way YOU want to do them. But what more could your apps do for you tomorrow?

Why wait to find out? REGISTER NOW to design your own App to the Future! Full details: http://apptothefuture.core77.com/

5 WINNERS WILL RECEIVE:

A Microsoft Surface Tableta Windows Phone 8 device   and a one year subscription to the Windows Phone DEV CENTER.

App to the Future is an app design competition open to the international design community, challenging entrants to design and mockup conceptual apps for the Windows Phone platform to help with their day-to-day challenges, better connect with their family or friends, or showcase an innovative, new app idea. The goals of Core77 and Microsoft are to showcase and triumph innovative designs through the Core77 Design Network of websites and the Microsoft Windows Phone Store and related websites such as Channel 9. Top winning entrants will be further encouraged to develop and sell their app in the Windows Phone Store utilizing prizes, resources and assistance provided by Core77 and Microsoft.