Andy Wigley

Windows Phone 7 Series Announced

2010-02-16T09:27:00Z

Yesterday, at Mobile World Congress in Barcelona, Microsoft announced their new mobile phone strategy and platform.

As Peter Foot has already reported in his blog (http://mobileworld.appamundi.com/blogs/peterfoot/archive/2010/02/15/developing-for-windows-phone-7.aspx), the dev story will not be revealed until MIX 2010, which is next month: http://windowsteamblog.com/blogs/wmdev/archive/2010/02/15/windows-phone-7-series-going-big-for-developers-at-mix10.aspx .

What we can see from the news conference and other postings on the web such as http://www.microsoft.com/presspass/presskits/windowsphone/videoGallery.aspx is that Microsoft has really made a clean break from the earlier generations of Windows Mobile phones. The OS is called 'Windows Phone OS 7' but no details have been released yet on how closely it resembles its predecessors and what it will be like as a platform for app development.

How all this will affect developers is yet to be explained, but clearly life is going to be exciting for those of us working in this space!

Windows Mobile 6.5 Developer Toolkit now available!

2009-06-04T11:49:00Z

The Windows Mobile 6.5 Developer Toolkit is now available!

http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=20686a1d-97a8-4f80-bc6a-ae010e085a6e

There are downloads for WM6.5 Professional and Standard - the Professional version includes the new Gesture APIs and samples!

See also, Jorge Peraza's recent blog post: Getting started with widgets on Windows Mobile 6.5

TechEd Online: Can Windows Mobile UIs Look as Good as the iPhone?

2009-05-22T11:39:00Z

Love it or loathe it, nobody can deny that the Apple iPhone set a new bar for what constitutes a good mobile UI. In the Windows Mobile development community, many of us have been exploring ways of enhancing the UI of the apps we build to give a rich, compelling experience and there is plenty of good guidance and samples available at sites like the new Windows Mobile developer site: http://developer.windowsmobile.com and at established collaboration sites such as http://www.codeproject.com. There are also good controls available from companies such as Resco (www.resco.com) .

Andrej and I enjoyed a 15 minute chat about these topics to camera at Tech Ed in Los Angeles. Watch the video here at Tech·Ed Online: Can Windows Mobile UIs Look as Good as the iPhone? Yes, They Can!.

TechEd Online: Extend Dynamics AX and NAV to Devices with Microsoft Dynamics Mobile

2009-05-22T11:35:00Z

If you are a Microsoft Partner selling Dynamics AX and NAV solutions, you should know about Microsoft Dynamics Mobile. This allows you to extend the system to incorporate mobile devices.

One of Appamundi's specialities is in delivering training and development, design and consultancy services to other Microsoft Partners for Microsoft Dynamics Mobile. At Tech Ed Los Angeles, Andrej Radinger and I chatted for 15 minutes or so about this. You can watch the video at Tech·Ed Online: Extend Dynamics AX and NAV to Devices with Microsoft Dynamics Mobile.

TechEd Online: patterns & practices Mobile Application Blocks v.Next

2009-05-22T11:01:00Z

Anyone remember the Mobile Client Software factory?

If you have read our Microsoft Press book, Mobile Development Handbook, you will know that quite a few of the security and web service samples use application blocks from the MCSF. Unfortunately, it's kinda hard to use the MCSF with Visual Studio 2008, because the installer for the MCSF requires pre-reqs of some Visual Studio add-ins that were only available for Visual Studio 2005 and are hard to find now.

Thankfully, Microsoft patterns & practices group are doing a refresh! All the best bits from MCSF v1 are being upgraded and updated to Visual Studio 2008, and there are some interesting new additions, especially the ContainerModel block which is a fast, lightweight Inversion of Control container. I'll be blogging a lot more on these topics over the next few months. You can download the latest drop of these bits at http://mobile.codeplex.com and there are also a lot of additions done mainly by myself and fellow MVP Nick Randolph which you can find at http://mobilecontrib.codeplex.com .

At Tech Ed last week, I spent 20 minutes talking to camera about this new effort and why I am so excited about it. Andrej Radinger asked the questions. See this video at Tech·Ed Online: patterns & practices Mobile Application Blocks v.Next.

TechEd Online: Windows Mobile Application Development

2009-05-22T10:53:00Z

Last week in Los Angeles, Andrej Radinger and myself took part in a panel discussion with fellow MVPs Ginny Caughey and Alex Feinman, along with Microsoft's Loke Uei Tan, John Bruno, Jorge Peraza and Steve Bell. Constanze Roman of Microsoft led the discussion.

Topics included Windows Mobile 6.5, SkyMarket, cool UI and other Windows Mobile-related matters.

Loke made things interesting by asking the community for questions during the talk using Twitter, so we got live questions thrown at us - interesting!

Watch the video at Tech·Ed Online: Windows Mobile Application Development.

Sync Services: Implementing Batching to Reduce Data Transfer Volumes

2009-04-27T10:59:00Z

Synchronization Services supports a limited batching capability which performs multiple transfers of the changed data in smaller batches from server to client, rather than all the changed rows in one go. In order to understand how batching works, you need to understand how SQL Server 2008 change tracking tracks changes, and how Synchronization Services uses that information.

How Synchronization Services Uses Change Tracking Version Numbers

When you enable change tracking on a database server, SQL Server 2008 starts to maintain a change version number which increments from zero. Also it maintains a special internal ‘changetable’ for each table for which you have enabled change tracking. Whenever a row in the table is updated, a record is written to the internal changetable containing the primary key of the changed record and the associated change version number.

When a client synchronizes, the server returns to the client the current value of its server-wide change version number, which is available by calling the SQL Server 2008 CHANGE_TRACKING_CURRENT_VERSION function. You define the T-SQL command to use in your application code by setting the SelectNewAnchorCommand property of a key object in the server side code of your sync solution, a Microsoft.Synchronization.Data.Server.DbServerSyncProvider instance. The standard way of defining this, and similar to the code generated by the OCS Designer, is to write code in the DbServerSyncProvider class initialization logic as follows:

// selectNewAnchorCmd command.
SqlCommand selectNewAnchorCommand = new SqlCommand();
selectNewAnchorCommand = new System.Data.SqlClient.SqlCommand();
selectNewAnchorCommand.CommandText =
"Select @sync_new_received_anchor = CHANGE_TRACKING_CURRENT_VERSION()";
selectNewAnchorCommand.CommandType = System.Data.CommandType.Text;
System.Data.SqlClient.SqlParameter selectnewanchorParameter =
    new System.Data.SqlClient.SqlParameter(
          "@sync_new_received_anchor",
          System.Data.SqlDbType.BigInt);

selectnewanchorParameter.Direction =
    System.Data.ParameterDirection.Output;
selectNewAnchorCommand.Parameters.Add(selectnewanchorParameter);

// Set to the DbServerSyncProvider
this.SelectNewAnchorCommand = selectNewAnchorCommand;

The client also sends to the server the change tracking version it received from the server the previous time it synchronized (or 0 if this is the first synchronization), so now all the server side code has to do is select all changed rows with a change version greater than the change tracking version the client received at the previous synchronization, and less than or equal to the databases current change version number. This actual logic required is more complex than this, as I have not described how the logic to track inserts, updates and deletions separately is implemented, nor how the ID of the client that made the last update is tracked, but I have simplified this so that it is easier to understand the general process. Refer to SQL Server 2008 documentation for full details.

How to Implement Batching In Synchronization Services

The batch mechanism in Synchronization Services allows you to limit the range of change versions to be sent to the client in each response to a client synchronization request. For example, if the client previously synchronized to version 50, the servers’ change tracking version is currently 120, and you define a batch size of 30, then the changed rows will be sent in three separate batches: 51-80 in the first transfer, 81-110 in the second and 111-120 in the third.

One way of enabling this behavior is to define a stored procedure such as the following. This procedure takes five parameters which are required by Synchronization Services:

· @sync_last_received_anchor which is the change version associated with the clients’ previous synchronization

· @sync_batch_size which is the requested range of change version numbers requested for each batch

· @sync_max_received_anchor which is an ‘out’ parameter which returns the current change version on the server

· @sync_new_received_anchor which returns the actual maximum change version number of the set of records selected for the current batch

· @sync_batch_count which returns the number of batches that are required to complete the synchronization

The logic of the stored procedure is described in the comments included in the following script:

USE [Northwind]
GO

/**** Object: StoredProcedure [dbo].[usp_GetNewBatchAnchor] ****/
CREATE PROCEDURE [dbo].[usp_GetNewBatchAnchor] (
      @sync_last_received_anchor bigint,
      @sync_batch_size int,
      @sync_max_received_anchor bigint out,
      @sync_new_received_anchor bigint out,
      @sync_batch_count int output)
AS
       -- Set a default batch size if a valid one is not passed in.
       IF @sync_batch_size IS NULL OR @sync_batch_size <= 0
           SET @sync_batch_size = 1000

         -- Before selecting the first batch of changes,
         -- set the maximum anchor value for this synchronization
         -- session. After the first time that this procedure is
         -- called, Synchronization Services passes a value for
         -- @sync_max_received_anchor to the procedure. Batches of
       -- changes are synchronized until this value is reached.
       IF @sync_max_received_anchor IS NULL
         SELECT @sync_max_received_anchor =
                    change_tracking_current_version()

       -- If this is the first synchronization session for a database,
       -- get the lowest change version value from the tables. By
       -- default, Synchronization Services uses a value of 0 for
       -- sync_last_received_anchor on the first synchronization. If
       -- you do not set @sync_last_received_anchor,
       -- this can cause empty batches to be downloaded until the
       -- lowest change version value is reached.
       IF @sync_last_received_anchor IS NULL OR
              @sync_last_received_anchor = 0
       BEGIN
            SELECT @sync_last_received_anchor = 0

        -- Changes are only retained in the change table for a limited
        -- period of time set by the CHANGE_RETENTION parameter
        -- (on ALTER DATABASE).
        -- Check that we haven't had changes cleaned up on this table
        -- (i.e. CHANGE_TRACKING_MIN_VALID_VERSION returns > 0)
            IF CHANGE_TRACKING_MIN_VALID_VERSION(
               object_id(N'dbo.Customers')) >
                   @sync_last_received_anchor
            RAISERROR (N'SQL Server Change Tracking has cleaned up
tracking information for table ''%s''. To recover from this error, the
client must reinitialize its local database and try
again',16,3,N'dbo.Customers')

            SET @sync_new_received_anchor =
                @sync_last_received_anchor + @sync_batch_size

            -- Determine how many batches are required during the
            -- initial synchronization.
            IF @sync_batch_count <= 0
            SET @sync_batch_count = (
                 (@sync_max_received_anchor / @sync_batch_size) -
                 (@sync_last_received_anchor / @sync_batch_size)
              )
       END
     ELSE
       BEGIN
        SET @sync_new_received_anchor =
           @sync_last_received_anchor + @sync_batch_size

        -- Determine how many batches are required during subsequent
         -- synchronizations.
            IF @sync_batch_count <= 0
              SET @sync_batch_count = (
                 (@sync_max_received_anchor / @sync_batch_size) -
                 (@sync_new_received_anchor / @sync_batch_size)) + 1

      END

     -- Check whether this is the last batch.
     IF @sync_new_received_anchor >= @sync_max_received_anchor
     BEGIN
       SET @sync_new_received_anchor = @sync_max_received_anchor
       IF @sync_batch_count <= 0
         SET @sync_batch_count = 1
     END

In order to activate batch support, create the stored procedure in the database, and then modify the SelectNewAnchorCommand property of the Microsoft.Synchronization.Data.Server.DbServerSyncProvider instance to call it, specifying the requested batch size:

       SqlCommand selectNewAnchorCommand = new SqlCommand();
    selectNewAnchorCommand.CommandText = "usp_GetNewBatchAnchor";
    selectNewAnchorCommand.CommandType = CommandType.StoredProcedure;
    selectNewAnchorCommand.Parameters.Add("@" +
      SyncSession.SyncLastReceivedAnchor, SqlDbType.BigInt, 8);
    selectNewAnchorCommand.Parameters.Add("@" +
      SyncSession.SyncMaxReceivedAnchor, SqlDbType.BigInt, 8);
    selectNewAnchorCommand.Parameters.Add("@" +
      SyncSession.SyncNewReceivedAnchor, SqlDbType.BigInt, 8);
    selectNewAnchorCommand.Parameters.Add("@" +
      SyncSession.SyncBatchSize, SqlDbType.Int, 4);
    selectNewAnchorCommand.Parameters.Add("@" +
      SyncSession.SyncBatchCount, SqlDbType.Int, 4);
    selectNewAnchorCommand.Parameters["@" +
      SyncSession.SyncMaxReceivedAnchor].Direction =
        ParameterDirection.Output;
    selectNewAnchorCommand.Parameters["@" +
      SyncSession.SyncNewReceivedAnchor].Direction =
        ParameterDirection.Output;
    selectNewAnchorCommand.Parameters["@" +
      SyncSession.SyncBatchCount].Direction =
        ParameterDirection.InputOutput;

    // Set to the DbServerSyncProvider
    this.SelectNewAnchorCommand = selectNewAnchorCommand;
    // Set the requested batch size
    this.BatchSize = 10;

Batching for Client Incremental Changes

There is no support in Synchronization Services for sending changes from a client up to the server in smaller batches. You should ensure that your client code synchronizes with the server sufficiently often that the volume of changes cached on the client does not grow to a large number. Large numbers of changes cached on the client could lead to out of memory exceptions when attempting to serialize the DataSet to be sent to the server, and to difficulties in transmitting large amounts of data over slow connections such as cell data networks.

Why Batching May Not Work After Enabling SQL Server 2008 Change Tracking on Populated Tables

There is one particular problem that may occur with batching. If you enable change tracking on a database table before any data is inserted in that table, then as each row is added to the source table, the change will be recorded in the internal changetable and will be assigned a new, unique change version number. In this case, batching will be able to limit the number of rows that are sent to the client on each communication.

However, if you enable change tracking on a table that already has many rows of data, then the initial state of the table is recorded by adding records to the changetable for all rows with the same initial change version number. As a result, even with batching implemented, when a client synchronizes for the first time, the Synchronization Services server-side code will attempt to return all the rows in the requested table.

In this circumstance, you must initialize the client in a different way, perhaps by creating a desktop app to perform the initial sync and then deploy the resulting database to the device.

Tech Ed North America, May 11-15, Los Angeles

2009-04-21T08:16:00Z

Andrej Radinger and myself are part of the Windows Mobile team at Tech Ed North America. We will be available to answer questions and talk mobility throughout the conference and much of the time we will be found in the Ask The Experts area on the main exhibit floor.

We are also delivering a Technical Learning Center session: Windows Mobile 6 SDK Tools during which we will show how to use the many tools found in the SDK. That session is on Wednesday 13th at 10:15am, so please add that to your schedule if you are attending the conference.

To find out more, or if you still want to register, go to www.msteched.com

MSDN Webcast: Hiding the Key: Practical Security for Windows Mobile Applications

2009-04-20T08:59:00Z

I am delivering a webcast on 27 April 2009 at 18:00(British Summer Time)/19:00 (Central Europe)/10:00am Pacific Time (US and Canada)/22:30(New Delhi).

During this webcast I will show some simple demos of how to use synchronbous encryption to encrypt data on a device and explain the importance of securing the encryption key. I will show an example of how to derive an encryption key from a user-entered password as one solution.

Finally I will show how to use the Password Authentication Block from the Microsoft patterns and practices Mobile App Blocks V2 (the successor to 2005's Mobile Client Software Factory). The Password Authentication Block provides a great easy to use method of encrypting data such as configuration files and providing a method for distributing encrypted data to hundreds or thousands of clients, and still allow each user to have a unique username and password as the key to decrypting the data. These blocks are currently under development and I am working with the team as a mobile developer community expert advisor; you can find out more and download the blocks at http://mobile.codeplex.com.

Please register for this webcast, or download the recording after the event, at:

Attendee Registration URL:

http://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032409117&Culture=en-US

UPDATE: You can download the demo code from this webcast through the Atachments link at the bottom of this posting.

Building a Sync Services for ADO.NET Solution for Mobile Devices

2008-12-08T16:30:00Z

*Update* :This is the first in a series of posts on Sync Services.
You can read the second post on batching here: Sync Services: Implementing batching to reduce data transfer volumes.

In my recent webcast '24 Hours of Mobile Development: Networking', I showed a sample that used Microsoft Synchronization Services for ADO.NET to synchronize a local cache database on a Windows Mobile device with backend SQL Server via a WCF service. I didn't really go into detail on how to build it, and I've had a few enquiries since, so this is how you do it (This is also what I showed at one of my sessions at Tech Ed EMEA in Barcelona in November):

Setup your environment

First you need to get the right bits for this to work. You need:

SQL Server 2008/2005 or SQL Server Express 2008/2005
Visual Studio 2008 SP1
Microsoft Synchronization Services 1.0 SP1 (Devices)
Microsoft SQL Server Compact 3.5 Service Pack 1 for Windows Mobile

Note that Visual Studio 2008 already includes Sync Services and SQL Server 3.5 SP1 - but only for desktop clients, so you have to install these bits for devices separately.

Install the Database

Download the sample code for this article (link at the bottom of the page), and use the instnwnd.sql script that is included to create a Northwind database in your database server. Easiest way to do this is to open SQL Server Management Studio, connect to your database server, then use Windows Explorer to navigate to where instnwnd.sql is and double-click it. The script will open in SQL Server Management Studio, then you just have to click the Execute icon in the toolbar and the database will get created. If you are using SQL Server Express, I recommend you first download SQL Server Express Management Studio from MSDN and install it, then use the same technique to execute the database creation script.

Create the Solution

The key thing here is to create a solution containing two projects - one which is a devices project to contain the client code, and one which is a WCF Service Library or an ASP.NET Web Service which contains the server-side code. In this example, I'll walk you through creating a solution which uses a WCF Service on the server side.

Start Visual Studio 2008 (use 'Run as Administrator' if you're developing on Vista).
Create a Smart Device project, call it 'SmartDeviceSyncClient' or something else suitable. You can use any Windows Mobile 5 or Windows Mobile 6 target platform and .NET Compact Framework 3.5. Make it a 'Device Application' though so it is a Windows Forms application.
Now add a second project to the same solution. Make this a WCF Service Library project with the name 'MiddleTierServiceLibrary' - or your own name.
When the WCF Service Library has been added, delete IService1.cs and Service1.cs - we are going to use the Sync Services wizards to generate the WCF Service interface and implementation.

Run the Sync Designer

This is the bit that confuses most people. Normally, you start the Sync Services Designer by adding a new project item of type Local Database Cache to the client-side project, but this template is not available in device projects. The way you do this is actually to add it to the server-side project, which seems a bit illigical, but works just fine:

In Solution Explorer, right-click the MiddleTierServiceLibrary project, then click Add - New Item. Select Local Database Cache and give it a suitable name, such as NorthwindCache.sync.
In the Configure Data Synchronization wizard, the first thing you must do is use the Server connection dropdown to select an existing database connection to the backend database server where the Northwind database is, or click New to create a new connection. The wizard will automatically generate the client connection for you.
Next click the Add button underneath the Cached Tables pane. Here is where you select which tables to copy to the client database cache. For this example, just select the Customers table. In the Data to download dropdown, select the default, which is New and incremental changes after first synchronization. This means that Sync Services will only transfer changes between the client and server when synchronizing - the alternative is to transfer the entire table every time.
After you click OK, you return to the main Sync Designer wizard screen. Here you must click the Advanced button to reveal additional configuration options. Make sure you select the MiddleTier ServiceLibrary for the Server Project location, and the device project, SmartDeviceSyncClient, as the Client project location.
Now click OK, and the wizard will generate the code for synchronization between the SQL Server Compact 3.5 SP1 database on the client side, and the SQL Server database on the server side. It also does an initial sync and adds a SQOL Server Compact 3.5 SP1 database to your client-side project which already has the Customer table data copied across.
Next, it displays the Data Source Configuration Wizard. This is prompting you to setup a typed DataSet in your client-side project, because it thinks you'll need to have something in that project to use in order towork with the data in the client-side database. You can cancel that if you have your own ideas on what you're going to do with the data once it gets to your client-side application, but for this demo a typed DataSet is fine, so click the Tables checkbox to select all tables (there's only one of course, the Customers table) and accept the default name of NorthwindDataSet, and then click Finish.

Setup the WCF Service

Think that's all there is to it? No, not at all! The Sync Designer does a lot of the setup work for you, but you have to do quite a lot more work to get this working.

Open up NorthwindCache.SyncContrct.cs - you'll find it in the server-side project.
Scroll down to the bottom, and add the XmlSerializerFormat attribute to the INorthwindCacheSyncContract interface definition. This is necessary because the .NET Compact Framework does not support the WCF DataContractSerializer which is the default used by WCF when serializing data for transfer over the network, so adding this attribute ensures that the XmlSerializer is used, which is supported by .NET Compact Framework 3.5.

    [ServiceContractAttribute()]
    [XmlSerializerFormat()]
    public interface INorthwindCacheSyncContract {

        [OperationContract()]
        SyncContext ApplyChanges(SyncGroupMetadata groupMetadata, DataSet dataSet, SyncSession syncSession);

        [OperationContract()]
        SyncContext GetChanges(SyncGroupMetadata groupMetadata, SyncSession syncSession);

        [OperationContract()]
        SyncSchema GetSchema(Collection<string> tableNames, SyncSession syncSession);

        [OperationContract()]
        SyncServerInfo GetServerInfo(SyncSession syncSession);
    }
Now scroll up to the top of this file. You will see a large comment block which tells you how to setup the configuration file for the WCF service.
First, copy the <service>..</service> definition from the comment block, and paste it into the app.config file, replacing the existing <service>..</service> configuration. You need to remove the c# comment characters of course, but there are two other changes that are important:
- First, change the binding="wsHttpBinding" to binding="basicHttpBinding" - .NET Compact Framework doesn't support wsHttpBinding.
- Second, change the localhost:8080 in the baseAddress configuration to the proper host name and port where the service will be running, for example 'myPC:8088', or you can use the raw IP address, for example '192.168.1.8:8080' - the important thing here is to use an address that the device will be able to use to connect to your server; 'localhost' is no good because the device will interpret 'localhost' as being itself, where of course the WCF service is not running.
Now go back to the code file and copy the <behavior>..</behavior> configuration. Paste this into App.Config replacing the existing definition. No changes are required, other then to uncomment it of course.
The app.config should now look something like this:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  ...
<system.serviceModel>
    <services>
      <service name="MiddleTierServiceLibrary.NorthwindCacheSyncService" behaviorConfiguration="MiddleTierServiceLibrary.NorthwindCacheSyncServiceBehavior">
        <host>
          <baseAddresses>
            <add baseAddress ="http://192.168.1.104:8088/NorthwindCacheSyncService/"/>
          </baseAddresses>
        </host>
        <endpoint address ="" binding="basicHttpBinding" contract="MiddleTierServiceLibrary.INorthwindCacheSyncContract"/>
        <endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange" />
      </service>
    </services>
    <behaviors>
      <serviceBehaviors>
        <behavior name="MiddleTierServiceLibrary.NorthwindCacheSyncServiceBehavior">
          <serviceMetadata httpGetEnabled="True" />
          <serviceDebug includeExceptionDetailInFaults="False" />
        </behavior>
      </serviceBehaviors>
    </behaviors>
</system.serviceModel>
</configuration>

Adding the Service Reference

The server-side code is good to go now, so we need to add a service reference to the client-side project.

There is a trick to doing this successfully with a devices project. If this was a desktop client, we could just right-click on the project and click 'Add Service Reference', but that option is not offered for devices projects. We can use the netcfsvcutil tool that's in the Power Toys to generate a client-side proxy, but there's actually an easier way. Since the WCF basicHttpBinding is actually the same thing as an 'old-fashioned' Web Service, we can just Add Web Reference to generate ourselves a client-side proxy for this service. This isn't quite as easy as it sounds, because first we must get the service running so that the Add Web Reference tool can query it to interrogate the WSDL and generate the proxy.

To get the service running, right-click on the WCF Service Library project and then click Set as Startup Project. Now click the Debug menu, option Start without Debugging (or CTRL-F5 if you're using C# developer keymappings in Visual Studio). The solution will build, and then it will put up the Deploy SmartDeviceSyncClient window. Click Cancel here, because we don't want to deploy the client-side project yet. You'll then see the There were deployment errors. Continue? pop-up, but here click Yes because we want to continue to run the WCF Service.
If all is well, you'll then see the WCF Test Client window displaying - the red exclamation marks against the methods simply indicate that the datatypes they expose are too complex to allow you to use the WCF Test Client to exercise them.
Leaving the WCF Test Client running, now go to Solution Explorer, right-click the devices project and then click Add Web Reference. In the Add Web Reference wizard, enter the URL where the WCF Service is running - be careful to append a trailing '/' !! If you leave that off, it won't find it!
Change the Web Reference name to something meaningful such as NorthwindProxy, then click Add Reference.
This should generate you the proxy class for the service, and if you compile it, no compile errors will be reported. However, there is still a problem with the proxy that has been generated, and if you try to run this solution (later on when we've added a bit more code to the client), then you'll get runtime errors as you'll find that certain classes used for Sync Services are multiply defined. That's because the methods exposed by the WCF Service use a number of classes defined in the Sync Services namespaces, so the Add Web Reference wizard has looked at the WSDL for the service and generated versions of those classes in the proxy - but those classes are also defined in the Sync Services assemblies that are already referenced by the client project.
To fix this, simply edit the proxy code. To find the code, click the Show All Fles icon at the top of Solution Explorer, and expand the Web References node in the client project, and drill down until you see the Reference.cs/.vb file. Open this up in the editor, and delete every class apart from the first, NorthwindCacheSyncService. Finally add using Microsoft.Synchronization.Data; (Imports... of course, for VB) to the top to fix up the now-missing class definitions and we're good to go. Remember though that if you ever refresh the Web Reference, you'll have to come in and make this edit again.

Coding the client

All that remains is to create a UI, add some code to sync the data and then run it.

To create the UI, first build the solution. Then, show Form1 in the Designer. Double-click the Form background to create the Form1_Load event handler. Inside this, just add a call to a new method called Sync():

        private void Form1_Load(object sender, EventArgs e)
        {
            Sync();
        }

        private void Sync()
        {

        }
Next on the Data menu, click Show Data Sources and drag the Customers table onto the Form (Design view), which will create a DataGrid for you. Set the Dock property to Fill to cover the entire form.
Now let's complete the Sync method, where we need to write the code to synchronize the local cache database with the backend database.
The Sync Designer helps here: open the designer again by double-clicking on NorthwindCache.sync in the WCF project, and click the Show Code Example link shown bottom right just above the OK-Cancel buttons. It now displays you the code you need on the client side, and also allows you to copy the code to the clipboard. Do this, and paste the code into the Sync method:

        private void Sync()
        {
            // Call SyncAgent.Synchronize() to initiate the synchronization process.
            // Synchronization only updates the local database, not your project's data source.
            NorthwindCacheSyncAgent syncAgent = new NorthwindCacheSyncAgent();
            Microsoft.Synchronization.Data.SyncStatistics syncStats = syncAgent.Synchronize();

            // TODO: Reload your project data source from the local database (for example, call the TableAdapter.Fill method).

        }
Now this code is fine for a two-tier solution, but for a 3-tier solution where synchronization takes place via a WCF or Web Service, some additional code is required. First you need to create an instance of your service proxy, then create an instance of Microsoft.Synchronization.Data.ServerSyncProviderProxy, the constructor of which requires the service proxy object, and then you set the RemoteProvider property of the SyncAgent object to that ServerSyncProviderProxy instance before calling Synchronize.
If we add some code to refresh the DataSet object with the data from the database after it has been synchronized, and a MessageBox just to report what has happened during sync, the end result looks like this:

        private void Sync()
        {
            Cursor.Current = Cursors.WaitCursor;
            NorthwindProxy.NorthwindCacheSyncService svcProxy = new NorthwindProxy.NorthwindCacheSyncService();
            Microsoft.Synchronization.Data.ServerSyncProviderProxy syncProxy =
                new Microsoft.Synchronization.Data.ServerSyncProviderProxy(svcProxy);

            // Call SyncAgent.Synchronize() to initiate the synchronization process.
            // Synchronization only updates the local database, not your project's data source.
            NorthwindCacheSyncAgent syncAgent = new NorthwindCacheSyncAgent();
            syncAgent.RemoteProvider = syncProxy;
            Microsoft.Synchronization.Data.SyncStatistics syncStats = syncAgent.Synchronize();

            // TODO: Reload your project data source from the local database (for example, call the TableAdapter.Fill method).
            customersTableAdapter.Fill(northwindDataSet.Customers);

            // Show synchronization statistics
            MessageBox.Show("Changes downloaded: " + syncStats.TotalChangesDownloaded.ToString()
                + "\r\nChanges Uploaded: " + syncStats.TotalChangesUploaded.ToString());

            Cursor.Current = Cursors.Default;
        }
To finish up, click the SmartTag top right of the DataGrid in Design View, then click Generate Data Forms which will generate some UI to allow you to edit records on the client-side.
Make the following code addition to the customersDataGrid_Click method to ensure that changes you make during editing are written back to the underlying database:

        private void customersDataGrid_Click(object sender, EventArgs e)
        {
            SmartDeviceSyncClient.CustomersSummaryViewDialog customersSummaryViewDialog = SmartDeviceSyncClient.CustomersSummaryViewDialog.Instance(this.customersBindingSource);
            customersSummaryViewDialog.ShowDialog();
            // Update the database with changes made to the dataset
            customersTableAdapter.Update(northwindDataSet.Customers);
        }
Now create a menu item on the right menu key of Form1 with the text Sync, and in the click event handler just call the Sync() method we created earlier.
Finally, we have to set the sync up for bidirectional synchronization, as it is configured for download only by default. You program this change in the client project.
In Solution Explorer, find NorthwindCache.Client.sync, right click it and click View Code. Add the following line to the OnInitialized method:

        partial void OnInitialized(){
            Customers.SyncDirection = Microsoft.Synchronization.Data.SyncDirection.Bidirectional;
        }
That's it! Make sure you set the client project as the Startup project, then debug this on a device that is cradled, or connected by WiFi to the network where your server is located and it will first sync when the Form loads. It will report no changes uploaded or downloaded first time, because the project was setup with a pre-synchronized database. But if you now click on a row in the datagrid, and change the contents of one of the fields in the Edit form, then click the Sync menu, you'll see that the changes are synced back to the server. Change some data on the server side (an easy way of doing this is to click on the Customers table in Server Explorer in Visual Studio, then click Show Table Data to open up a Grid view of the data on the server side), then sync the client again, and the changes get sent up to the device.

Connect to devices over USB in Virtual PC using 'USB Over Network'

2008-11-28T14:39:00Z

I recently moved all my development work into Virtual PCs - I got fed up with trying to keep my main PC up to date with the latest tools, and more and more I run projects that require different versions of the tools. So now, my main PC just has Office and Virtual PC on it, and not a lot else.

But it does have 4GB of RAM, which allows me to run two Virtual PCs at the same time which gives me the flexibility I need. Now doing mobile development in Visual Studio running in a virtual PC is fine, as long as you only want to develop using emulators. But sometimes, you really need to work with a real device, and here Microsoft Virtual PC gives us a problem because it does not support connections to USB ports on the host PC. One solution is to use VMWare which does include USB support, but if you want to use Microsoft Virtual PC then an alternative solution is to use a neat product called USB Over Network from FabulaTech which allows you to share access to USB devices over the LAN or even over the Internet. Read about it here: http://www.fabulatech.com/usb-over-network.html

It's really simple to use. Just install the USB over Network Server on your host PC then connect up your device. After your device has connected, open up Network Over USB Server, find the Microsoft Windows Mobile Remote Adapter in the list of USB devices, then click the Share icon on the toolbar.

When you share your device, USB Over Network takes over the USB connection to your device, so it is logically no longer connected to your PC.

Next, go to your Virtual PC and install USB Over Network Client on it. Start it up and enter the name or IP address of the server, after which it displays the shared devices on that server. Select the shared device and then click the 'Connect USB Device' toolbar button and that's it - your mobile device is connected to the virtual PC just as if you had it plugged in directly.

The price for this solution goes up the more USB devices you want to share concurrently, and at $149 for one device, some may find the price a bit steep purely to get around the lack of USB connectivity in Virtual PC. However, the convenience this gives to device developers who want to develop using Virtual PC is probably worth that investment.

Accessing RESTful 'Astoria' Data Services in .NET Compact Framework

2008-11-24T17:17:00Z

In my recent presentation at Microsoft Tech Ed EMEA 2008 in Barcelona (session MBL304), I talked about how to access RESTful web services from the .NET Compact Framework. I promised that I would post the sample code on my blog, so this post is to fulfil that promise, and also to explain how to do this for those who weren't in Barcelona. I also used this sample as an example of how to use HttpWebRequest in my recent webcast on Networking, so this post is also relevant to that webcast.

What is a RESTful Data Service?

REST stands for 'REpresentational State Transfer' and is a technique for exposing data over the web in a lightweight manner that is suitable for accessing programmatically using simple HTTP GET, PUT, POST and DELETE verbs. The actual resource that you wish to get/delete/update/create is identified by the uri of the request. For example, if you have a data service that exposes the data of the Northwind database, to get a list of the top-level collections in the data service (maps to the tables or views in the Northwind database), you might issue an HTTP GET to http://myserver/myNorthwindDataService/Northwind.svc and you'll get back a bunch of XML. To get a list of all the Customers in Northwind, you issue a GET to http://myserver/myNorthwindDataService/Northwind.svc/Customers and if you want a specific customer record, you can put the primary key in the URI like this: http://myserver/myNorthwindDataService/Northwind.svc/Customers('ALFKI') which returns all the data for that customer record as XML:

Creating an ADO.NET Data Services website

To create a site that exposes the Northwind database in this way, you need Visual Studio 2008 SP1 and the Northwind database installed in SQL Server 2005/2008 - I've included a script to create the Northwind database in the download accompanying this post. Follow these steps:

Create a new ASP.NET Website project called DataServicesWebsite - this should be hosted in IIS not the file System to allow devices to access it.
Delete Default.aspx as we'll be generating our own service
In Solution Explorer, right-click on the website root and then click Add New Item
In the Templates window, select ADO.NET Entity Data Model, and in the Name field, enter NorthwindModel.edmx. Click Add. Click Yes to the 'You are attempting to add a special file type...' pop-up.
In the Entity Data Model window, select Generate from database and click Next.
Click New Connection to make a connection to the SQL Server where you have Northwind installed, and when you have that setup click Next.
In the Choose Your Database Objects window, click the checkbox to select all the Tables, then click Finish.
You should now see the entity data model diagram - this model will provide the source for our data services website.
Right-click on the website root in Solution Explorer and then click Add New Item. Select ADO.NET Data Service on the Templates window, and then click Add.
You will now see a code editor window with the source of a class called WebDataService, which has a couple of TODOs in it. First you'll see that WebDataService inherits from a generic class: DataService< /* TODO: put your data source class name here */> - replace that TODO with the name of the data source class, which is NorthwindModel.NorthwindEntities. Then inside the InitializeService method, you need to set some access rules, which you can do easily by uncommenting the suggested lines and replacing the first parameter of each with a wildcard character. After this, the class should look like this:

public class WebDataService : DataService< NorthwindModel.NorthwindEntities >
{
    // This method is called only once to initialize service-wide policies.
    public static void InitializeService(IDataServiceConfiguration config)
    {
        config.SetEntitySetAccessRule("*", EntitySetRights.AllRead);
        config.SetServiceOperationAccessRule("*", ServiceOperationRights.All);
    }
}
That's it! Now just right-click on WebDataService.svc in Solution Explorer, and click Set as Start Page. Now you can hit CTRL-F5 to run the site to check it works - you'll be able to fetch data from the database just by using a browser window. Try adding '/Customers' or '/Products' to the starting address in the browser window to see how it works.

Creating a .NET Compact Framework Client

If you are lucky enough to be a desktop or Silverlight developer, then the ADO.NET Data Services team have created a client-side library for you to use called System.Data.Services.Client, but for some unfathomable reason, they didn't create this library for .NETCF. That library gives you what is sometimes known as 'LINQ to URI', as it translates LINQ queries into the required HTTP calls to fetch the data. So if you want to know how to use that library from a desktop or Silverlight client, you can look at this blog from Guy Burstein.

However, we mobile devs must do it the hard way - which actually is not so hard if we use some simple calls using HttpWebRequest and HttpWebResponse to fetch the XML, and a little bit of LINQ to XML to extract the data we want from the response.

First, we need to get the XML from the service. We can use a couple of utility methods to do this. Here's the entire class containing both methods:

using System;
using System.Text;
using System.Net;
using System.IO;

namespace RESTLibrary
{
     public enum HttpMethods {
      GET = 0,
      PUT,
      POST,
      DELETE,
      HEAD,
      OPTIONS,
      LIST,
      UNKNOWN }

    public class REST
    {
        public static HttpWebRequest CreateRequest(string uri, HttpMethods method, string data, string contentType, string userName, string password)
        {
          WebRequest request = HttpWebRequest.Create(uri);
          request.Method = Enum.ToObject(typeof(HttpMethods), method).ToString();
          request.Credentials =
            new NetworkCredential(userName, password);
          request.ContentType = contentType;
          ((HttpWebRequest)request).Accept = contentType;

          if (method != HttpMethods.GET && method != HttpMethods.DELETE)
          {
              Encoding encoding = Encoding.UTF8;
              request.ContentLength = encoding.GetByteCount(data);
              request.ContentType = contentType;
              request.GetRequestStream().Write(
                encoding.GetBytes(data), 0, (int)request.ContentLength);
              request.GetRequestStream().Close();
          }
          else
          {
              // If we're doing a GET or DELETE don't bother with this
              request.ContentLength = 0;
          }

          // Finally, return the newly created request to the caller.
          return request as HttpWebRequest;
        }

        public static string ReadResponse(HttpWebResponse response)
        {
            // Read the contents to a string
            // and return that to the caller.
            string responseBody = String.Empty;
            using (Stream stm = response.GetResponseStream())
            {
                using (StreamReader reader = new StreamReader(stm))
                {
                    // Simply read in the entire response to our string.
                    responseBody = reader.ReadToEnd();
                    reader.Close();
                }
            }

            return responseBody;
        }
    }
}

The first of these methods, CreateRequest, creates an HttpWebRequest instance properly configured to make the call to fetch the data. The second utility method, ReadResponse, reads the string that is sent back from the web data service and returns it to the caller. The client code to use these looks like this:

            // Create the request object using the utility method
            // This code accesses host ppp_peer so the device must be connected to the server by ActiveSync.
            HttpWebRequest request = REST.CreateRequest(@"http://ppp_peer/DataServicesWebsite/NorthwindService.svc/Customers",
              HttpMethods.GET, String.Empty, @"application/atom+xml", "", "");

            // Now, attempt to read in the data.
            using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
            {
                string responseXml = REST.ReadResponse(response);

                // Do something with the response XML
                ...
            }

All that remains is to extract the data we want from the XML. If you haven't used LINQ to XML much, here is the important stuff you need to know.

Let's say we want to extract the CustomerID, CompanyName and City of every customer in the Customers collection. If you use a browser to look at the XML returned for the Customers collection, you'll see that the elements we want are all children of the properties tag:

<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
- <feed xml:base="http://localhost/DataServicesWebsite/NorthwindService.svc/" xmlns:d="http://schemas.microsoft.com/ado/2007/08/dataservices" xmlns:m="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata" xmlns="http://www.w3.org/2005/Atom">
<title type="text">Customers</title>
<id>http://localhost/DataServicesWebsite/NorthwindService.svc/Customers</id>
  ...
- <content type="application/xml">
- <m:properties>
    <d:CustomerID>ALFKI</d:CustomerID>
    <d:CompanyName>Alfreds Futterkiste</d:CompanyName>
    <d:ContactName>Maria Anders</d:ContactName>
    <d:ContactTitle>Sales Representative</d:ContactTitle>
    <d:Address>Obere Str. 57</d:Address>
    <d:City>Berlin</d:City>
    <d:Region m:null="true" />
    ...
</m:properties>

The m: prefix to the properties tag, and the d: prefix to the individual fields tags are important - they indicate that the tag belongs in a particular XML namespace. The 'd' and 'm' are both symbols for namespaces, which are defined at the top of the XML in the <feed> element:

- <feed xml:base="http://localhost/DataServicesWebsite/NorthwindService.svc/" xmlns:d="http://schemas.microsoft.com/ado/2007/08/dataservices" xmlns:m="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata" xmlns="http://www.w3.org/2005/Atom">

Tags that do not have a prefix are in the default namespace, which is the one specified in the <feed> element that does not have prefix, which is the last one listed, xmlns=http://www.w3.org/2005/Atom.

Once you understand the definition of the namespaces, the LINQ to XML query to select the required customer properties from every record in the Customers collection becomes the following. This example not only selects the target fields, but uses the values to initialise a new instance of a CustLite object, which is a custom class defined for this example that just has three public properties, CustomerID, CompanyName and City. As a result, the type of the customerIdList, defined as var in the code, is actually a List<CustLite>:

// After reading in the response parse the response into a XDocument.
XDocument customerDoc = XDocument.Parse(responseXml);

XNamespace ads = @"http://schemas.microsoft.com/ado/2007/08/dataservices";
XNamespace m = @"http://schemas.microsoft.com/ado/2007/08/dataservices/metadata";

                var customerIdList =
                  from c in customerDoc.Descendants(m + "properties")
                  select
                    new CustLite()
                    {
                        CustomerID = c.Element(ads + "CustomerID").Value,
                        CompanyName = c.Element(ads + "CompanyName").Value,
                        City = c.Element(ads + "City").Value,
                    };

Once we have our List<CustLite> we can use it in our app, for example to display it in a DataGrid:

You can download the code for the sample from the link below. Note that this example shows how to get data formatted using the ATOM MPP XML format, but ADO.NET Data Services also returns data in JSON if you ask it right - that's the subject for another post...

MSDN Webcast: 24 Hours of Windows Mobile Application Development: Windows Mobile Networking (Level 300)

2008-11-17T10:08:00Z

I am giving a webcast for MSDN on Wednesday November 19, 2008 at 10:00am Pacific Time/3:00pm EST/6:00pm UK/19:00 Western Europe.

From the event overview:
"In this webcast, you learn how to create a network connection in code and how to discover if you have network connectivity. We look at the design of applications that need to be network aware and strategies for creating applications that can operate when disconnected from the network and then sync up data when network connectivity is restored. We also compare the options for transferring data over a network connection, which include ActiveSync, Microsoft SQL Server merge replication, remote data access (RDA), SQLClient, Microsoft Synchronization Services for ADO.NET, Windows Communication Foundation (WCF), SOAP-based Web services, RESTful data services, and Microsoft Message Queuing (MSMQ). We explain the benefits and shortcomings of each sync technology and demonstrate many of them so you can select the right solution for your data synchronization needs.In this webcast, you learn how to create a network connection in code and how to discover if you have network connectivity. We look at the design of applications that need to be network aware and strategies for creating applications that can operate when disconnected from the network and then sync up data when network connectivity is restored. We also compare the options for transferring data over a network connection, which include ActiveSync, Microsoft SQL Server merge replication, remote data access (RDA), SQLClient, Microsoft Synchronization Services for ADO.NET, Windows Communication Foundation (WCF), SOAP-based Web services, RESTful data services, and Microsoft Message Queuing (MSMQ). We explain the benefits and shortcomings of each sync technology and demonstrate many of them so you can select the right solution for your data synchronization needs."

Please go to the MSDN Webcasts event page to register, or if you missed it, to download the recording.

Hope you can watch and ask some questions!

Sample code for WM6 SDK Tools session

2008-11-11T10:08:00Z

Here is the sample code for the session Andrej and I just gave on the Windows Mobile 6 SDK Tools here at Barcelona.

The sample illustrates SMS interception, Pockket Outlook Object Model programming, WCF programming, camera capture and State and Notification Broker.

Tech Ed EMEA 2008

2008-11-11T09:54:00Z

I am in sunny Barcelona, giving five sessions this year.

MBL01-IS Windows Mobile 6 SDK Tools
November 11 09:00 - 10:15 Room 134
Visual Studio 2008 brings lot of improvements for mobile developers, and Windows Mobile 6 SDKs tools that allow developers easier and faster solution development. This interactive session will show you what is new in .NET Compact Framework 3.5, as well as WM 6 SDK Tools. Learn how to emulate GPS, how to configure and use emulators, and how to simulate input stress using Hopper. You will also see how to use Cellular Emulator to emulate presence of mobile operator network to make and receive calls, and transfer data and learn about FakeServer. Session will be packed with live demos and you will have the opportunity to ask what you always wanted to ask and discuss your experiences or problems.

MBL304 Accessing RESTful Web Data Services in the Microsoft .NET Compact Framework: The Lightweight Alternative to SOAP
November 12 10:45 - 12:00 Room 125
Most Microsoft developers are used to working with SOAP-based Web services and these RPC-like services have been used successfully in many mobile applications that need to access services hosted on remote servers. However, now there's a new kid on the block for remote data access that - its proponents claim - is lightweight, flexible, and works in the way the architects of the Web intended, using many of the built-in features of HTTP. REST stands for Representational State Transfer and is gathering supporters throughout the Web for its flexibility and the ease with which you can perform CRUD (Create, Read, Update, Delete) operations on remote data. Indeed, REST is used for exposing data in new Microsoft products such as ADO.NET Data Services and SQL Server Data Services. In this session, we compare the strengths and weaknesses of REST and SOAP, take a look at how to serialize data using JSON, and work through some demos to show how to program .NET Compact Framework applications that use REST to access services built with ADO.NET Data Services and those exposed by Web 2.0 APIs such as Facebook.

MBL402 Building Data Sync Solutions with Microsoft Synchronization Services for ADO.NET
November 13 17:30 - 18:45 Room 115
In this session we will take a detailed look at Microsoft Synchronization Services for ADO.NET to explain solutions for the things that make data synchronization solutions tough, such as how to batch updates so that you can successfully sync large volumes of updates over low bandwidth connections, and how to build a custom server sync provider for when your backend database isn't SQL Server. There will be plenty of demos, as we walk through practical examples of synchronizing data items between a backend Server and 'Edge of the Network' computers such as laptops and mobile devices.

MBL05-IS Sync This Way: Comparing the Sync Solutions
November 14 09:00 - 10:15 Room 132
Are you confused by all the data sync options for Windows Mobile applications? Are you having trouble working out which is the best solution for you? In this Interactive Session, we will look at each of the current choices for synchronising data between your device and back-end servers. Come along with your questions about ActiveSync, SQL Server merge replication, RDA (remote data access), SQLClient, Microsoft Synchronization Services for ADO.NET, WCF, SOAP-based Web services, RESTful data services and MSMQ. There will be lots of demos of these technologies so you can see what it takes to configure and program each one. You'll go away with a good understanding of the benefits and shortcomings of each sync technology, so you'll be able to select the right solution for your data synchronization needs.

MBL01-PAN Ask the Windows Mobile Panel
November 14 15:15 - 16:30 Room 119 (DEV)
In this panel session, you will have an opportunity to ask the team of Microsoft and community experts any burning questions related to Windows Mobile! Share industry experience, express your opinions and make your wishes known to Microsoft about what you want the future of Windows Mobile to look like. This is a great opportunity to drive dialogue among your peers, Microsoft and our community leads, to clarify technical understanding, provide ideas for moving ahead and just have fun networking with our Windows Mobile gurus.

I am here with Appamundi colleague, Andrej Radinger. If you are in Barcelona, come to our sessions, and come and talk to us!