APPA Mundi

WPH303 Triskaidekaphobia - Session Code

Peter Foot — Tue, 31 Aug 2010 07:25:00 GMT

Attached is the code from today's session. The Windows Mobile 6 project requires Visual Studio 2008 and the Windows Mobile 6 SDK. The Windows Phone 7 project requires the Windows Phone 7 Development tools Beta. I'll blog separately about some of the individual techniques and snippets contained within this.

DataContractSerializer and Internal types

Peter Foot — Sun, 22 Aug 2010 22:21:25 GMT

Under Silverlight only public types may be serialized with the DataContractSerializer. If you want to make your data classes internal to your assembly and serialise them for use in a WCF service you will find that the service call will fail at runtime with a SecurityException inside a misleading exception about inability to communicate with the service. There is a workaround however which involves exposing your internal types to the Silverlight base class libraries with the InternalsVisibleTo attribute. Simply add the following code to your AssemblyInfo.cs file:-

 [assembly: InternalsVisibleTo("System.Runtime.Serialization, PublicKey=00240000048000009400000006020000002400005253413100040000010001008d56c76f9e8649383049f383c44be0ec204181822a6c31cf5eb7ef486944d032188ea1d3920763712ccb12d75fb77e9811149e6148e5d32fbaab37611c1878ddc19e20ef135d0cb2cff2bfec3d115810c3d9069638fe4be215dbf795861920e5ab6f7db2e2ceef136ac23d5dd2bf031700aec232f6c6b1c785b4305c123b37ab")]
 

If you use the DataContractJsonSerializer you must also add the System.Servicemodel.Web assembly (the public key is the same).

Windows Phone 7 Jump Start training Online!

Andy Wigley — Wed, 18 Aug 2010 14:44:00 GMT

Microsoft have finished processing all the video from the two days of online training that fellow MVP Rob Miles and myself delivered last month. They’ve removed the worst of the jokes and left in all the best bits, leaving 12 50 minute sessions of training on Silverlight and XNA for Windows Phone 7 to get you started with developing using the beta release of the tools.

There were 12 sessions in all:

Windows Phone 7 Jump Start (Session 1 of 12): Introduction

A quick tour of Windows Phone 7 and how you write programs for it. We take a look at the platform capabilities and the software development options. We also offer you a chance to win a prize that is almost certainly not a private jet.

Windows Phone 7 Jump Start (Session 2 of 12): Building a Silverlight Application, Part 1

Building an application from scratch. How you can take a simple idea for a program and build the user interface, followed by the program behaviors that sit behind it. We take a look at databinding on Windows Phone and how best to structure your application to make best use of it.

Windows Phone 7 Jump Start (Session 3 of 12): Building a Silverlight Application, Part 2

Making more complex applications. You also get an overview of how the built in controls work, and how to tailor the user input to match your requirements. We also take a look at page navigation within a multi-form Silverlight application on the phone and how to use the navigation inputs for best effect.

Windows Phone 7 Jump Start (Session 4 of 12): Building Games for the Windows Phone 7 Platform

Using Silverlight as a platform for game creation. We show how to get a draw/update behavior into your Silverlight games and give you a fully worked game to chew on. We also illustrate how a Silverlight game can leverage the XNA libraries to add sound effects to a game.

Windows Phone 7 Jump Start (Session 5 of 12): Building XNA Games for the Windows Phone 7 Platform, Part 1

Getting Started with XNA on Windows Phone. We talk about what makes the Windows Phone such a good platform for XNA development and how you create XNA games for it. We take a look at how games can manage the orientation of a phone and give you some tips on getting the best performance. Then we move on to take a look at the accelerometer input and how to make games that use this.

Windows Phone 7 Jump Start (Session 6 of 12): Building XNA Games for the Windows Phone 7 Platform, Part 2

Using the Windows Phone platform features in your XNA games. We continue with our look at Windows Phone features that make the platform so interesting to game developers. We cover the use of the touch screen, sound creation and finally give you some coverage of how to access the Zune media content in the device. Then we round off with a little look at how you can get text input from users by means of the Guide support in XNA.

Windows Phone 7 Jump Start (Session 7 of 12): Advanced Application Development, Part 1

Application Lifecycle. A look at the execution model on the phone, and how to create solutions that give a great user experience in the face of phone calls, termination and even total shutdown of the device itself. We show how to respond to messages to make your application give the appearance of being "always on" and the data persistence facilities that you will need to make this work.

Windows Phone 7 Jump Start (Session 8 of 12): Advanced Application Development, Part 2

Launchers and Choosers plus Using Isolated Storage. In this session we take a look at "Launchers and Choosers", how your application can use the built in phone behaviors to place calls, take pictures and select contacts, making it part of how the phone works. We also show how your application can store data in its own isolated storage on the phone device.

Windows Phone 7 Jump Start (Session 9 of 12): Advanced Application Development, Part 3

Storing Data and Using the Network. In this session we look at the connectedness of Windows Phone and how you can make this work for you. We demonstrate connected applications and how the notification service is used to allow external systems to give your application a wake-up call.

Windows Phone 7 Jump Start (Session 10 of 12): Marketing Your Windows Phone 7 Application

Using Windows Marketplace. In this session we explain how to join the Marketplace and get your applications out there. We take a look at how your solutions are packaged and deployed and how you go about registering a device for development and then using that with Visual Studio 2010 to test your applications.

Windows Phone 7 Jump Start (Session 11 of 12): Working with Media

Using XNA in 3D and with Media. In this session we take a quick look at how the Windows Phone works as an excellent platform for 3D games in XNA. We also explore how an XNA game can make use of the media stored in the phone, including photographs taken by the user and media loaded onto it from Zune.

Windows Phone 7 Jump Start (Session 12 of 12): Final Silverlight Topics and Wrap-Up

Taking Silverlight to the max. We start with a look at the Application bar, a crucial component in Windows Phone applications. We then move on to the Expression Blend tool, and how to create compelling user experiences with it. Finally we round off the session by showing how easy it is to use the map services in your phone and demonstrate some of the really cool navigation tools that are coming.

Read more on the Windows Phone 7 Team blog.

Technorati Tags: wp7dev

Windows Phone 7, VS2010 and VMWare

Pete Vickers — Sun, 15 Aug 2010 08:13:00 GMT

As anyone who has read my blog may know, I am a great fan of using Virtual Machines for development, but keeping my source code on my 'main' drive for security and backup purposes. Up until recently, I couldn't do this, as I had problems running VS2010 and the Windows Phone 7 emulator.

Yesterday, VMWare informed me that an update to VMWare Workstation was available, so I downloaded it and updated it. I updated the VMWare tools, and then fired up VS2010 and created a new Windows Phone 7 project and hit F5. Lo and behold, the emulator fired up, and my 'Hello World' project ran on the emulator.

Flushed with success, I opened one of my projects from a mapped drive, located on my 'host' machine. I hit F5 to run the project, and got an error message:-

Error 1 Could not load the assembly file:///Y:\Users\Pete Vickers\Documents\Visual Studio 2010\Projects\APPATest\APPATest\obj\Debug\APPATest.dll. This assembly may have been downloaded from the Web. If an assembly has been downloaded from the Web, it is flagged by Windows as being a Web file, even if it resides on the local computer. This may prevent it from being used in your project. You can change this designation by changing the file properties. Only unblock assemblies that you trust. See http://go.microsoft.com/fwlink/?LinkId=179545 for more information. APPATest

After searching this, saw a few people with the same problem, and several suggestions, including hosting the project on my local system. I didn't want to do this, as it would interfere with my backup strategy, and keeping all my source code on a 'host' drive. Then I read a couple of suggestions to add an entry to 'devenc.exe.config'...

"Open devenv.exe.config (in C:\Program Files\Microsoft Visual Studio 10.0\Common7\IDE on my machine), and add this

<runtime>
  <loadFromRemoteSources enabled="true" />
  ....
</runtime>

Restart Visual Studio and it should work."

I made the change, restarted VS2010, and everything worked as it should. So now I can have the best of all worlds. I can do my Windows Phone 7 development in a VM, I can keep my source files on my host system, and I can use TFS in VS2010.

So, for anyone who has tried Windows Phone 7 development in VMWare Workstation in the past, without success, try updating to version 7.1.1 and see if it helps.

Data connection when travelling

Pete Vickers — Sat, 07 Aug 2010 08:28:00 GMT

I do a reasonable amount of travelling, and spend quite a bit of time in Menorca. I have a Vodafone ES dongle for this, which gives me unlimited 3G access for €20 for 7 days, and have been using this for over a year without a problem. Last week, I plugged in the dongle, and the modem couldn't be recognised, even though 3 weeks earlier, there wasn't a problem using it! The obvious solution is to search the internet for the solution, but with no connection, how to do it.

In this case, I removed the sim card from the dongle, put it in my Windows Mobile phone, made a connection and used 'Internet Sharing' so I could use the phone as a modem. There is an excellent guide here on how to setup internet sharing. I was fortunate that my phone was unlocked and would allow use of my Spanish Sim, and that I could find the APN settings to connect. I was also fortunate enough (and sad enough) to have a 'spare' Windows Mobile phone with me.

So this all worked great. But to further complicate matters, I was doing some work with a device that is debugged over wirless, but appears to consider an ad-hoc wireless network the work of the devil, and refused to associate with my ad-hoc network regardless of what I do.

I was pointed at a Zoom 3G Wireless-N Desktop Router by a friend who was using this set-up. So I ordered one from Amazon and it was waiting for me when I got home. Unwrapped it, configured it through a brilliantly simple web-interface, plugged in a T-Mobile dongle, and it just connected to the Internet - that was it. No fuss, no messing, just a connection. The wireless network was immediately visible (supports WEP/WPA/WPA2) and I connected to it as a router from several devices just to test it out. It is a fully fledged router supporting DHCP, has a Lan and a Wan port, so in theory, you could use the Lan cable in a Hotel, and then set up your own Wireless network using the Zoom.

It is early days, but this is an amazing piece of kit, and for the price, amazing value. At a stroke, it solved all the problems I was facing connecting. It is small (12cm*13cm*3cm), lightweight and doesn't have a brick for a power supply. I have nothing but praise for this and it will certainly become part of my travelling kit from now on.

Windows Phone 7 UI Guide and Design Templates

Pete Vickers — Thu, 29 Jul 2010 06:06:00 GMT

Microsoft has update the UI Design and Interaction Guide for Windows Phone 7 for the newly release beta. At the same time, also available are Design Templates for Windows Phone 7

These are a collection of 28 layered Photoshop template files and the Segoe WP font family that can be used to create pixel-perfect application layouts, to help guide UI development, or to pitch an idea. These design templates showcase many controls that are a part of the Windows Phone Developer Tools Beta. They also include examples of controls that are a part of Windows Phone, but are not available as a part of the Windows Phone Developer Tools.

Windows Phone 7 Jumpstart Training - Recordings available

Pete Vickers — Sat, 24 Jul 2010 17:05:00 GMT

If you didn't get to see the excellent Jumpstart Training sessions last week, the recordings are now available here.

For anyone who didn't get to attend this event 'live', and wants to know more about writing apps for Windows Phone 7, these recordings are a must. Andy Wigley and Rob Miles did an excellent (and entertaining) job of the training, and there was a lot of new information following the release of the beta.

I recommend these recordings if you have any interest at all in Windows Phone 7 development. If nothing else, watch session 3 for a great explanation of 'tombstoning' and 'reactivation'

Uninstalling the Windows Phone 7 CTP

Pete Vickers — Tue, 13 Jul 2010 13:54:00 GMT

If you are having problems uninstalling the Windows Phone 7 CTP, take a look at the excellent link from Nick Beradi

Updated Windows Phone 7 Training

Pete Vickers — Tue, 13 Jul 2010 08:32:00 GMT

Microsoft have updated their Windows Phone 7 Training kit for Developers - get it here

Windows Phone 7 Jump Start

Pete Vickers — Tue, 13 Jul 2010 07:05:00 GMT

Our esteemed colleague Andy Wigley, along with Rob Miles will be doing FREE on-line training for Windows Phone 7 next week. You can register for the event here - it is sure to be popular, so book early!

Get Trained – Windows Phone 7 Jump Start

Andy Wigley — Mon, 12 Jul 2010 19:48:00 GMT

Windows Phone 7 JumpStart is a FREE virtual live class for developers interested in developing applications and games for Windows Phone 7. The Microsoft Phone 7 team are providing this in partnership with the MS Learning team. The course is organized into four virtual instructor-led sessions that are of 3-hour duration.

This training will be presented by me, Andy Wigley and fellow MVP and MS Press author Rob Miles. It will provide developers a jump start for developing Windows Phone 7 applications. The Labs will be completed offline with office hours access to the instructors.

The dates for these course sessions are:

July 20 – 8am: Session One: Getting Started with Microsoft Windows Phone and Silverlight
July 20 – 1pm: Session Two: Programming Game Applications with XNA
July 22 – 8am: Session Three: Programming Applications with Silverlight
July 22 – 1pm: Session Four: Review and Wrap Up

Go register for the course now!

Migrating WP7 April CTP projects to WP7 Beta

Andy Wigley — Mon, 12 Jul 2010 19:36:56 GMT

The Beta of the Windows Phone 7 developer tools has been released today! Get them from http://developer.windowsphone.com.

If you have been building projects using the April CTP of the Windows Phone 7 developer tools, you’ll find a number of changes needed to get them to compile with the Beta version which was released on July 12th.

You should also read this posting from Jaime Rodriguez. In it he gives much more detail about the changes – read that for the complete story on the beta changes.

Namespace Declarations in XAML

In the CTP, there were multiple small dlls containing the various phone classes: Microsoft.Phone.dll, Microsoft.Phone.Controls.dll, Microsoft.Phone.Controls.Navigation.dll, Microsoft.Phone.Shell.dll. In the beta, these have all been combined into one: Microsoft.Phone.dll.

The main impact of this is in the namespace declarations at the head of each xaml file. In the project item templates for the CTP, when you added a xaml page each had a namespace declaration mcp pointing at the Microsoft.Phone.Controls namespace – delete this. You will also find a phoneNavigation namespace declaration pointing at the Microsoft.Phone.Controls namespace, but in Microsoft.Phone.Controls.Navigation.dll.Change this to Microsoft.Phone.dll. I like to change the declared prefix from phoneNavigation to just ‘phone’ but that’s a personal preference:

Change

    xmlns:mpc="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone.Controls"
    xmlns:phoneNavigation="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone.Controls.Navigation"

    xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"

If you change the prefix, you’ll need to change uses of the old prefix as well, of course. For example, in each page:

<phone:PhoneApplicationPage 
    x:Class="MyPhoneSample.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:shell="clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone.Shell"
    xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone">

…

</phone:PhoneApplicationPage>

Removal of declaration of Phone Styles from App.Xaml

You should always use the built-in style names when styling controls, such as PhoneTextNormalStyle. These styles ensure the output of a control is presented appropriately for Windows Phone and respects the users Theme selection.

In the CTP, these styles were defined in each application in App.Xaml. In the Beta, you should remove these style declarations from App.Xaml as the definition of these styles is ‘baked into’ the runtime and you should only include style definitions in your xaml files for any custom styles you create that differ from the built-in ones.

Delete everything from the <!--************ THEME RESOURCES ************—> comment to the end of the resources section:

    <!-- Resources for following the Windows Phone design guidelines -->
    <Application.Resources>

            <!--************ THEME RESOURCES ************—>   !DELETE FROM HERE DOWN
        <!-- Color Resources –>
       …

    </Application.Resources>

So now that these styles are no longer helpfully listed in your App.xaml, how do you look up the styles available? Well, read the documentation is one solution, or you can go to the <installDrive>:\\Program Files\Microsoft SDKs\Windows Phone\v7.0\Design folder and open up one of the theme files, for example DarkBlue.xaml – these contain the design time definitions of the phone styles. Open up System.Windows.xaml from the same folder and you can see the design time values of the styles for each of the standard controls.

Since control styles are now implicit, you should remove Style property settings on your input controls from your xaml (unless you’ve created a custom style of course!). For example:

          <TextBox Text="{Binding FirstName, Mode=TwoWay}" VerticalAlignment="Center"
            x:Name="tbFirstName" Style="{StaticResource PhoneTextBoxStyle}" Grid.Column="1"
            Margin="23,0,8,0"/>

Title Blocks

These have changed a bit in the beta. The style names have changed, and you also need to define a margin on your title block to ensure it sits nicely under the phone status bar and indented from the left side of the screen:

Change

        <!--TitleGrid is the name of the application and page title-->
        <Grid x:Name="TitleGrid" Grid.Row="0">
            <TextBlock Text="MY APPLICATION" x:Name="textBlockPageTitle" Style="{StaticResource PhoneTextPageTitle1Style}"/>
            <TextBlock Text="list" x:Name="textBlockListTitle" Style="{StaticResource PhoneTextPageTitle2Style}"/>
        </Grid>

        <!--TitleGrid is the name of the application and page title-->
        <Grid x:Name="TitleGrid" Grid.Row="0" Margin="24,24,0,12">
            <TextBlock Text="MY APPLICATION" x:Name="textBlockPageTitle" Style="{StaticResource PhoneTextNormalStyle}"/>
            <TextBlock Text="list" x:Name="textBlockListTitle" Style="{StaticResource PhoneTextTitle1Style}"/>
        </Grid>

List Items

In the CTP, there was a ListViewItem control that was a container for each item defined in a ListBox. Typically, the xaml looked like this:

            <ListBox x:Name="ListBoxOne" ItemsSource="{Binding Items}" MouseLeftButtonUp="ListBoxOne_MouseLeftButtonUp" 
                     Style="{StaticResource PhoneListBox}">
                <ListBox.ItemTemplate>
                    <DataTemplate>
                        <StackPanel x:Name="DataTemplateStackPanel" Orientation="Horizontal">
                            <Border x:Name="DataTemplateBorder" Height="44" Width="44" BorderBrush="White" … >
                                <Path x:Name="DataTemplatePath" Height="16" Width="11" Fill="White" Stretch="Fill" … />
                            </Border>
                            <mpc:ListViewItem Layout="TextAndDetailsWithIcon" Text="{Binding LineOne}" 
                                         Details="{Binding LineTwo}" Style="{StaticResource PhoneListBoxItemLayout}"/>
                        </StackPanel>
                    </DataTemplate>
                </ListBox.ItemTemplate>
            </ListBox>

As you can see, the <mpc:ListViewItem… line defines the content of each list item (the Text and Details properties are databound to the LineOne and LineTwo fields of the data source respectively), the Style property is set to ="{StaticResource PhoneListBoxItemLayout}" which is a style that you just deleted when we removed all those style definitions from App.Xaml and the Layout property is set to the name of one of the layout options built into the ListViewItem control.

Well, the predefined ListViewItem templates are no more, so instead we define the layout of our list item directly in the DataTemplate, as follows:

            <ListBox x:Name="MainListBox" ItemsSource="{Binding Items}" SelectionChanged="MainListBox_SelectionChanged">
                <ListBox.ItemTemplate>
                    <DataTemplate>
                        <StackPanel x:Name="DataTemplateStackPanel" Orientation="Horizontal">
                            <Image x:Name="ItemImage" Source="/WindowsPhoneListApplication1;component/Images/ArrowImg.png" Height="43" Width="43" VerticalAlignment="Top" Margin="10,0,20,0"/>
                            <StackPanel>
                                <TextBlock x:Name="ItemText" Text="{Binding LineOne}" Margin="-2,-13,0,0" Style="{StaticResource PhoneTextExtraLargeStyle}"/>
                                <TextBlock x:Name="DetailsText" Text="{Binding LineTwo}" Margin="0,-6,0,3" Style="{StaticResource PhoneTextSubtleStyle}"/>
                            </StackPanel>
                        </StackPanel>
                    </DataTemplate>
                </ListBox.ItemTemplate>
            </ListBox>

This is easier to edit the layout on an app by app basis.

Note the best way of getting this right is simply to create a new Windows Phone List project using the beta tools and copy the markup from there.

Application Bar Buttons

Application Bar Buttons must have a Text property defined, which defines a small string that shows underneath the button when the App Bar has focus.

    <phone:PhoneApplicationPage.ApplicationBar>
        <shell:ApplicationBar IsVisible="True" IsMenuEnabled="True">
            <shell:ApplicationBarIconButton x:Name="appbar_button1" IconUri="/Images/appbar_button1.png" Text="Button 1"></shell:ApplicationBarIconButton>
            <shell:ApplicationBarIconButton x:Name="appbar_button2" IconUri="/Images/appbar_button2.png" Text="Button 2"></shell:ApplicationBarIconButton>
            <shell:ApplicationBar.MenuItems>
                <shell:ApplicationBarMenuItem x:Name="menuItem1" Text="MenuItem 1"></shell:ApplicationBarMenuItem>
                <shell:ApplicationBarMenuItem x:Name="menuItem2" Text="MenuItem 2"></shell:ApplicationBarMenuItem>
            </shell:ApplicationBar.MenuItems>
        </shell:ApplicationBar>
    </phone:PhoneApplicationPage.ApplicationBar>

Summary

So that’s a quick run through the major changes. Of course there are a number of other changes, but these are the ones that most people will encounter when updating CTP projects to the Beta. Enjoy!

Technorati Tags: wp7dev

Review: .NET Compact Framework 3.5 Data Driven Applications

Peter Foot — Mon, 05 Jul 2010 06:01:12 GMT

Like Peter Nowak I was asked to review this recent release. Unfortunately due to other commitments it has taken the best part of a month to finish it. To avoid repeating the same points I recommend you read Peter’s review. While the current focus at Microsoft is on the upcoming Windows Phone 7 platform, we should not forget that there is still a demand for line of business applications for custom Windows CE platforms and Windows Mobile (and its Windows Embedded Handheld offspring) for enterprise devices.

I think the format of following a real-world application through the book provides a nice thread to tie together the various concepts described but often with this kind of approach you find features are shoe-horned in to show off a particular technology – a good example in this case is the IrDA/Bluetooth transfer of accounts between agents in a Sales application. Peter noted that the book does not describe the current situation with Visual Studio 2010 and why 2008 is needed for .NETCF 3.5 development but I think this is excusable based on the timescales involved in writing a book and how clearly this message was communicated by Microsoft.

The application design focuses exclusively on Windows Mobile and doesn’t cover issues when targeting other Windows CE platforms (such as Windows Mobiles enforced single-instance versus Windows CE default support for multiple instances of an application or just difference between the shells and screen layout). It also doesn’t cover form rotation and design for different DPI screens or implemented a locked-down kiosk mode. A personal gripe is the use of a SerialPort to do a Bluetooth transfer which is not the nicest solution, but then I suppose I’m biased.

Ultimately there is some good content in the book but it is unfortunately let down by being late to the party and the application scenarios try too hard to be all things to all people and ultimately not always 100% believable. It provides a starting point to work from and introduces a lot of functional areas from data synchronisation through to automatic update.

VS2008 - An operation was attempted on something that is not a socket.

Pete Vickers — Wed, 30 Jun 2010 21:12:00 GMT

We have recently been doing a .Net CF project, where the device doesn't connect to the development PC using Activesync, but is connected via WiFi or even Infra Red.

Peter had a problem trying to deploy the project, and kept getting the message 'An operation was attempted on something that is not a socket.' This was despite the fact that nothing in the infrastructure had changed.

We briefly chatted about it, and decided to come back to it. I made some mods to the code, attempted to deploy, and lo-and-behold I got the message 'An operation was attempted on something that is not a socket.'. I did the usual things:-

Reboot PC
Reboot Device
Connect to device
FTP To device

Connecting to the device succeeded, as did FTP, but as soon as I tried to deploy, I got the error message. At that point I could no longer connect to the device. After some diligent 'Googling', and starting to look at the 101000 results, I came across a several people with the same problem, several suggestions, but no real answers. One solution was to re-install the OS, and Visual Studio - a bit drastic considering our deadlines.

Then I hit pay dirt - try deleting the target folder on the device, and then deploy. Bingo - it worked. I emailed this suggestion to Peter, and it solved the problem. Hope this helps someone else in the future - and is easier to find.

Microsoft Surface Bluetooth Connect Code Sample

Peter Foot — Mon, 21 Jun 2010 23:45:24 GMT

APPA Mundi recently worked with the Microsoft Surface team to put together a code sample showing the exchange of information from a Surface to a nearby Bluetooth enabled phone using standard protocols. This means that any phone which supports standard Object Exchange (OBEX) protocols can receive items from the Surface without installing any client software.

The sample code is available in the MSDN Code Gallery:-

http://code.msdn.microsoft.com/surfacebluetooth

This code sample is designed for use with the Microsoft Surface 1.0 SP1 SDK and makes use of the .NET Bluetooth library binary file available from http://32feet.codeplex.com. The sample code is provided "as-is" and is not supported. Alongside the standard functionality in 32feet.NET the sample illustrates using the notifications supported in the desktop Windows API and shows how to consume these from within a WPF application (the API uses native Windows messages).

New Book on .NETCF 3.5 Development

Peter Foot — Thu, 17 Jun 2010 05:07:41 GMT

Despite Windows Phone 7 Development being all-the-rage at the moment I was recently informed of a new book on .NET Compact Framework development. I’ll be reviewing it shortly, in the mean time you can check out the details (including a free chapter download):-

.NET Compact Framework Data Driven Applications

DDD-Day Sydney 17th July

Peter Foot — Wed, 16 Jun 2010 05:00:30 GMT

Following the format of the excellent Developer-Developer-Developer-Day events in the UK, Lewis Benge is organising an event on 17th July in Sydney. If you are in the Sydney area then I urge you to check out the website and register for this free event:-

http://www.dddsydney.com

As well as a range of .NET topics there will be a Windows Phone 7 session and labs.

Programming Silverlight for Windows Embedded from .NET – Part 2

Andy Wigley — Tue, 15 Jun 2010 17:28:47 GMT

In this series of posts, I explain how you can use a Silverlight for Windows Embedded (SWE) UI but write all your application logic using C# or Visual Basic. In the first post, you can find the example code and links to the slides and video recording of the session I delivered at Tech Ed North America 2010, In this post, I will walk through using the Windows Embedded Silverlight Tools to create a native executable, then in the next posts I will convert the native exe to a dll, export some functions from it and then control the UI from managed code.

Using the Windows Embedded Silverlight Tools (WEST)

The Windows Embedded Compact 7 CTP includes tools that integrate into Visual Studio 2008 which read the XAML files in a Expression Blend 3 project and generate a functional native exe which contains placeholder event handler code for any events declared in the XAML – all you have to do is edit the template code to complete your application functionality.

In this sample, I’ve built a simple UI using Expression Blend that incorporates key elements that we would like to be able to program from managed code:

Some buttons – we want to write event handler code in C# or VB
A TextBox – from managed code, we want to be able to set and get the Text in the control
An animation – we would like to be able to start an animation storyboard from managed code

The XAML for this looks like this:

So, nothing too complex, but it’s good for the purposes of this exercise which is to run a XAML UI, to handle click and other events and to set and get properties of controls, all from managed code.

Running the WEST tools

It turns out that the easiest way to build a managed SWE app is to first build a native app and then convert that to something we can call from managed.

To generate a SWE native app using the tools:

Save your files in Expression Blend
Open Visual Studio 2008 and create a new project. Select Visual C++ – Smart Device Application and then select the Silverlight for Windows Embedded Application project type. Give it a suitable name: I called mine SWENative.
In the Silverlight for Windows Embedded Application Wizard, it
- First asks you which SDK to target. Select an SDK (if you’re new to Platform Builder this will confuse you; In Platform Builder, you build the Windows Embedded Compact 7 OS for your target hardware and you can optionally generate an SDK for your OS design that contains all the header files and libraries for the OS components you have selected for your OS – read the MSDN documentation for more info on this).
- Then it asks you the path to your Expression Blend project
- It parses the XAML files in that project and checks the validity
- Then it generates the C++ project code for you

The code it has generated is a functioning application, only the event handlers are empty. It’s really worth examining the code it has generated, as these are effectively the keys to our kingdom, albeit for this very simple example.

The application entry point and control logic is in Winmain.cpp:

#include "stdafx.h"
#include "App.h"

// ============================================================================
//  WinMain
//
//  Description: Set the window creation parameters for this application.
//
//  Parameters:  hInstance - Handle to the current instance of the application.
//               hInstPrev - This parameter is always NULL.
//               lpCmdLine - Command line for the application, excluding the program name.
//               nCmdShow - Specifies how the window is to be shown.
// ============================================================================
INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE /*hInstPrev*/, LPWSTR /*lpCmdLine*/, int /*nShowCmd*/)
{
    App AppInstance;

    HRESULT hr = AppInstance.Initialize(hInstance);
    if(SUCCEEDED(hr))
    {
        hr = AppInstance.Run();
    }

    return AppInstance.GetWinMainResultCode();
}

That’s it! You can see that it declares an instance of the App class, calls the Initialize method of that class, then calls the App::Run method. Run doesn’t return until the UI message pump exits – in other words not until your user clicks a Close button on your UI, assuming you’ve added one and written logic in the event handler to shut down the XAML UI). Those two methods, App::Initialize and App::Run contain all the logic we need to get our XAML UI running and in the next post I’ll show you how to convert this WinMain function into a function you can call from a managed app.

If you dig a little deeper, you’ll find that the tools have generated a C++ class for each of the XAML files in your Expression Blend project. In this sample, there is only one XAML file, MainPage.xaml, so the tools have generated MainPage.cpp and MainPage.h. If you take a look inside it, you’ll see that in MainPage.h, the tools have generated a field member for each named control in the XAML:

#pragma region GeneratedCode
    // ============================================================================
    //  WARNING: DO NOT EDIT THIS ALWAYS-GENERATED CODE
    // ============================================================================
    HRESULT OnLoaded(__in IXRDependencyObject* pRoot);
    HRESULT InitializeComponent();

    IXRGridPtr                 m_pLayoutRoot;                 // <Grid x:Name="LayoutRoot">
    IXRButtonPtr               m_pMyButton;                   // <Button x:Name="MyButton">
    IXRButtonPtr               m_pBtnStart;                   // <Button x:Name="BtnStart">
    IXRTextBoxPtr              m_pMyTextBox;                  // <TextBox x:Name="MyTextBox">
    // ============================================================================
    //  WARNING: DO NOT EDIT THIS ALWAYS-GENERATED CODE
    // ============================================================================
#pragma endregion GeneratedCode

And inside MainPage.cpp, you can find a method called InitializeComponent which locates the objects in the XAML object tree simply by calling the FindName method which searches for a control of the right type with the correct name. There are also the placeholder event handlers for the Click events on the buttons.Here’s the complete code for MainPage.cpp in my sample:

#include "stdafx.h"
#include "SWENativeGenerated.h"
#include "MainPage.h"
#include "App.h"
#include "resource.h"

// ============================================================================
//  OnLoaded
//
//  Description: Calls InitializeComponent to bind member variables to named
//               elements, and attach event handlers specified in XAML
//
//  Parameters:  pRoot - The root dependency object.
// ============================================================================
HRESULT MainPage::OnLoaded(__in IXRDependencyObject* pRoot)
{
    UNREFERENCED_PARAMETER(pRoot);

    HRESULT hr = InitializeComponent();

    // Add calls to FindName or Add___EventHandler() methods after this comment.
    if (m_pMyButton)
    {
        m_pMyButton->AddClickEventHandler(CreateDelegate(this, &MainPage::OnButtonClick));
    }

    if (m_pBtnStart)
    {
        m_pBtnStart->AddClickEventHandler(CreateDelegate(this, &MainPage::BtnStart_Click));
    }


    return hr;
} // OnLoaded

// ============================================================================
//  OnButtonClick
// 
//  Description: Event handler implementation
//
//  Parameters:  pSender - The dependency object that raised the click event.
//               pArgs - Event specific arguments.
// ============================================================================
HRESULT MainPage::OnButtonClick (IXRDependencyObject* pSender, XRMouseButtonEventArgs* pArgs)
{
    HRESULT hr = E_NOTIMPL;

    if ((NULL == pSender) || (NULL == pArgs))
    {
        hr = E_INVALIDARG;
    }

    if (App::ClickCallback != NULL)
    {
        BSTR controlName;
        pSender->GetName(&controlName);
        App::ClickCallback((LPWSTR)controlName);
        hr = S_OK;
    }
    return hr;
}

// ============================================================================
//  BtnStart_Click
// 
//  Description: Event handler implementation
//
//  Parameters:  pSender - The dependency object that raised the click event.
//               pArgs - Event specific arguments.
// ============================================================================
HRESULT MainPage::BtnStart_Click (IXRDependencyObject* pSender, XRMouseButtonEventArgs* pArgs)
{
    HRESULT hr = E_NOTIMPL;

    if ((NULL == pSender) || (NULL == pArgs))
    {
        hr = E_INVALIDARG;
    }

    if (App::ClickCallback != NULL)
    {
        BSTR controlName;
        pSender->GetName(&controlName);
        App::ClickCallback((LPWSTR)controlName);
        hr = S_OK;
    }
    return hr;
}


#pragma region GeneratedCode
// ============================================================================
//  WARNING: DO NOT EDIT THIS ALWAYS-GENERATED CODE
// ============================================================================
HRESULT MainPage::InitializeComponent()
{
    HRESULT hr = E_FAIL;

    FindName(L"LayoutRoot", &m_pLayoutRoot);
    FindName(L"MyButton", &m_pMyButton);
    FindName(L"BtnStart", &m_pBtnStart);
    FindName(L"MyTextBox", &m_pMyTextBox);

    if (m_pLayoutRoot &&
        m_pMyButton &&
        m_pBtnStart &&
        m_pMyTextBox
       )
    {
        hr = S_OK;
    }

    return hr;
}
// ============================================================================
//  WARNING: DO NOT EDIT THIS ALWAYS-GENERATED CODE
// ============================================================================
#pragma endregion GeneratedCode

This simple technique of using FindName is how you find controls so you can get or set their properties or call methods on them, and this will come in useful in the next post when we write some logic to allow a managed app to call exported functions in a native dll to interact with controls in the XAML visual tree. Also in the next post, I will add code into the event handlers to call back to event handler logic inside a C# application.

Programming Silverlight for Windows Embedded from .NET

Andy Wigley — Thu, 10 Jun 2010 21:04:00 GMT

Today at Tech Ed in New Orleans, I gave a presentation on how to use a Silverlight for Windows Embedded (SWE) UI from a .NET Compact Framework app. SWE is available for Windows CE 6.0 R3 and Windows Embedded Compact 7, but in both cases it ships with only a native API. In this presentation, I demonstrated how you can use some relatively simple p/invoke techniques to allow you to write all your application logic using C# but control and interact with a native dll that drives a SWE UI.

You can download the app I built from the 'Attachment' link shown at the bottom of this post. For now, I present this without further explanation so that those people who came to the talk can get the code. I will update this post sometime soon with an explanation of the techniques and instructions on how to get the sample running (hint: you have to download the Windows Embedded Compact 7 CTP, install onto a system with Visual Studio 2008 SP1, use Platform Builder to cook a CE7 OS and build an SDK and boot the new OS into a virtual machine!).

Thank you to all those people who attended the talk!

*UPDATE* You can now view the video recording of this session at http://www.msteched.com/2010/NorthAmerica/WEM309, and download the slides or the WMV or MP4 recording.

Perst - a database for Windows Phone 7 Silverlight - Part 2

Andy Wigley — Tue, 08 Jun 2010 16:05:00 GMT

In this post, I explain some of the key logic in the Perst sample showing how to create a database and create, delete, read and search records. You'll need to look at the full sample code that you can download from the previous post on this topic: Perst - a database for Windows Phone 7 Silverlight

Creating a Perst Database

When the app starts up, the ApplicationStartup event handler gets a reference to the IsolatedStorage for the application and looks to see if the database container file exists (the name of the container file is defined in the StorageName property of the DataGenerator class as "PerstDemoDB.dbs". If the file already exists, then the app has been run before so we just call the InitializePerstStorage method to setup the objects to access the existing database. If the file does not exist, then this is the first running of the app so no further logic executes during startup - the user has to open the menu on the main screen and tap the generate data menu item to create the database.

private void ApplicationStartup(object sender, StartupEventArgs e)
{
    using (var stor = IsolatedStorageFile.GetUserStoreForApplication())
    {
        if (stor.FileExists(DataGenerator.StorageName))
        {
            InitializePerstStorage();
        }
    }
}

The InitializePerstStorage method calls the CreateStorage method of the StorageFactory singleton to create the perst persistant storage. Then it sets a couple of properties that set the initial size of the container file (on first opening) and the amount it will be auto-extended by each time it needs to grow to accomodate more objects, after which it calls the Open method to create the Perst storage container. Finally it creates a Database object that wraps the Perst storage and allows you to program it in much the same way as you would a relational database, working with tables and rows. The Database wrapper is optional, but if you program Perst using its 'vanilla' object database API, the code you write to interact with it is different from that used in this sample. If you are interested in using Perst as an object database, then read the documentation here: Tutorial and Getting Started for .NET.

internal void InitializePerstStorage()
{
    var storage = StorageFactory.Instance.CreateStorage(); // Creating Instance of Perst Storage
    storage.SetProperty("perst.file.extension.quantum", 512 * 1024); // Initial Size set 512KB
    storage.SetProperty("perst.extension.quantum", 256 * 1024); // Step of storage extension 256KB
    storage.Open(DataGenerator.StorageName, 0); // Open Storage
    //Create Database wrapper over Perst Storage
    Database = new Database(storage, false, true, new FullTextSearchHelper(storage));
    Database.EnableAutoIndices = false; //Turn off auto-index creation (defined manually)
}

Creating Tables

All the code that creates the database and the records of sample data inside it are in the DataGenerator class. When using the Perst database wrapper, you don't have to explicitly create tables - you can just create an instance of a 'persistence-enabled' class and store it in the database; the table that contains it is created implicitly.

How do you create a 'persistence-enabled' class? One simple way is to have your viewmodel class inherit from the Perst.Persistent class which is what is done here. If you look at the Contact class in the ViewModels folder, you'll see that it inherits from a class called Base, which itself inherits from Persistent. You'll also notice that certain fields are marked with the [FullTextIndexable] attribute which causes them to be included in the full text search index that perst maintains. Notice that the fields have to be public which is regrettable, but you'll get runtime errors if you make them private as the Perst Database wrapper uses reflection to get at field values of data records which falls down if you make them private.

public class Contact : Base, INotifyPropertyChanged
{
    // Fields must be public because Perst database class uses reflection to get field values
    [FullTextIndexable]
    public string address;
    [FullTextIndexable]
    public string company;
    public string email;
    [FullTextIndexable]
    public string firstName;
    [FullTextIndexable]
    public string lastName;

    public string Address
    {
        get { return address; }
        set {
            address = value;
            InvokePropertyChanged(new PropertyChangedEventArgs("Address"));
        }
    }

    // Lots more not shown...

    private void InvokePropertyChanged(PropertyChangedEventArgs e)
    {
        var handler = PropertyChanged;
        if (handler != null) handler(this, e);
    }
}

Saving Records in Tables

To save a record, you call the Store method of the Persistent base class. In this sample, the Base class that Contact (and the other data classes in this sample) inherit from has a method called Save that not only stores the object in the database but also updates the Full Text Search index as follows:

public void Save()
{
    Store();
    // Manually updating index for all fields marked with [FullTextIndexable] attribute
    Database.UpdateFullTextIndex(this);
}

Deleting Records from a table

To delete a record, you call the Database.DeleteRecord method. This is found in the Deallocate method of the Base class:

public override void Deallocate()
{
Database.DeleteRecord(this);
}

Getting Records from a Table

If you look at the constructor of the ContactsViewModel class, you can see two examples of how to fetch all the Contacts records from the database. The uncommented version shows how you can use the Database.Select<T> method to use T-SQL - like syntax to fetch a subset - or in this case ordered - collection of records:

public ContactsViewModel()
{
    Contacts = new ObservableCollection<Contact>();
    // Get all contacts from database
    if (Database != null)
    {
        //Contacts = Database.GetRecords<Contact>().ToObservableCollection(); // Load all contacts
        Contacts = Database.Select<Contact>("order by LastName").ToObservableCollection();
        // Load them but sorted
    }
}

The commented out line is valid too, just not used here. It shows how to retrieve all the records of a certain type from the database using the Database.GetRecords<T> method.

Using Full Text Search

One really interesting feature of this sample is the Full Text Index search. As you can see in the code samples earlier in this post, certain fields in the Contact record are marked with the [FullTextIndexable] attribute, and when a record is stored in the database, the Database.UpdateFullTextIndex(object) record is called to keep the index up to date (you should also call this method after updating a data object).

When the user taps the Search icon on the AppBar (and yes, I know: the search should be enabled by the physical search button on the phone, but in this version of the tools there is no event fired by the phone search button), the Search box shows on the screen. The control shown there is a custom control of type AutosuggestTextBox which is a specialisation of the AutoCompleteBox control from the Silverlight Toolkit. This sample app uses the Full Text Search in two interesting ways: firstly, as the user enters characters into the search box, the code in the AutosuggestTextBox.OnPopulating method returns a list of words from the Full Text Search index that contain the characters entered. This list is then set to be the ItemsSource of the AutosuggestTextBox which determines the list of words that display in the dropdown list component of the control. The user can select a word in the list to save them typing in the full word.

Here's the code from AutosuggestTextBox.cs that fetches the matching words from the index. The try catch is just a workaround for a bug in the WP7 tools CTP that was throwing an InvalidCastException at design time only which was stopping the designer working in Visual Studio:

protected override void OnPopulating(PopulatingEventArgs e)
{
    try
    {
        if (((App)Application.Current).Database == null) return;

        var kwrds = new List<string>();
        foreach (Keyword keyword in ((App)Application.Current).Database.GetKeywords(Text))
            kwrds.Add(keyword.NormalForm);
        ItemsSource = kwrds;
    }
    catch (InvalidCastException)
    {
        // workaround for CTP bug
    }
}

In addition to that logic, the XAML for the AutosuggestTextBox control in MainPage.xaml hooks the TextChanged event with event handler tbSearch_SearchStringChanged which is in the codebehind in MainPage.xaml.cs. That method calls the Search method of MainPage which contais the logic to select records based on a search string. In there, it first calls the Database.SearchPrefix method which locates all objects in the database that contain words that start with the specified search string and returns a FullTextSearchResult object. It creates a new List<FullTextSearchHit> object and calls its AddRange method to 'apply' the FullTextSearchResult and the output of that is a filtered list of any documents (i.e. database objects) that contain an indexed field that starts with the search string.

The database contains Contacts, Leads and Activity records, so the final part of the Search method determines whether the matched record is indeed a Contact, and if it is adds it to the ObservableCollection<Contact> collection which we then set to be the ItemsSource of the ContactsList. The result of all this is the user sees only those Contacts that match the search string. Cool functionality for a phone app which effectively limits the typing the user has to do!

private void tbSearch_SearchStringChanged(object sender, EventArgs e)
{
    if (!tbSearch.IsEmpty)
        Search();
    else
        RefreshContacts();
}

private void Search()
{
    if (Database == null) return;

    // Make full-text search in DB limited to 1000 items and 4 seconds without results sorting
    var prefixes = Database.SearchPrefix(tbSearch.Text.ToLower(), 1000, 4000, false);
    var contacts = new ObservableCollection<Contact>();
    var arrayRes = new List<FullTextSearchHit>();
    if (prefixes != null) arrayRes.AddRange(prefixes.Hits);
    foreach (var hit in arrayRes)
    {
        if (hit.Document is Contact)
        {
            if (!contacts.Contains((Contact)hit.Document))
                contacts.Add((Contact)hit.Document);
        }
    }

    this.ContactsListBox.ItemsSource = contacts;
}

Perst - a database for Windows Phone 7 Silverlight

Andy Wigley — Mon, 07 Jun 2010 10:10:00 GMT

Download Source Code **UPDATED for Beta libraries 21st July 2010**

There has been some comment about the lack of a client side database for Windows Phone 7 Silverlight. Windows Phone 7 does have SQL Server Compact Edition installed in the OS image, but in the initial release, it is there to support the built-in apps only and has no public API to allow Silverlight developers to use it for data persistence.

However, there is a database available that WP7 Silverlight developers can use: it's called Perst .NET which is developed by McObject and the source code is pure C# and freely downloadable. As distributed, it works fine with the full .NET Framework, with the .NET Compact Framework and with desktop Silverlight, and they have a demo app of a CRM that runs in the desktop browser in Silverlight (read about it here). Using Perst for .NET, developers using Silverlight can now include true database management system features in their Silverlight applications, including adding persistence to this data by storing it in a container file in isolated storage.

I thought it would be fun to see if I could port the database and implement the CRM app on Windows Phone 7 and it wasn't too hard!

Here you can see the contacts list, and the details view when you select a contact from the list.

You can download the full source code from the link at the top of this post (developed with the Windows Phone 7 April Devtools refresh that you can download here) . Inside it you will find three projects:

PerstWP7 - this is a Windows Phone 7 port of the database code. It doesn't have the replication code in it that the full .NET framework version supports, and it doesn't have a few methods in the database wrapper that require IQueryable, which is not supported on WP7.
PerstDemo - This is the source code for the CRM app. This is a work in progress! At present, the app allows you to generate test data to fill the database, allows you to list, add, edit, delete and search Contacts. At present there is no UI to allow you to work with Leads and Activities, as the full Silverlight CRM demo app does, but I plan to add this over the coming months, perhaps using a panoramic view which would be nice!
SilverlightToolkit.Controls.Input - Although according to blog posts such as this you are supposed to be able to use the Silverlight Toolkit libraries directly - at least for some of the controls in there - I couldn't get it to work with the current drop of the WP7 dev tools. I wanted an AutoSuggestTextbox to use in the search function, so I extracted the source for the toolkit version of this control and compiled it into this WP7 class library.

Using the App

When you start the app, you'll just see an empty heading of Contacts. Click the ellipses on the menu bar to reveal the menu for generating test data. Use the slider to select the total number of Contact, Lead and Activity objects to generate: for example, 5000 will give you a long list of a few hundred contacts.

As you play with the app, you'll see that you can view and edit details of Contacts in the list, you can delete contacts and you can add new contacts by tapping the '+' icon at the foot of the main screen.

Full Text Search

'Well, is this really a database?' you might be asking. Well - how about this: it's got a Full Text Search facility! If you tap on the Search icon on the menu bar, you get a Search box appear, which is the AutoSuggestTextBox. As you enter characters into the search box, it displays a list of contacts that match as you type in a drop down list. You can select a contact from the dropdown, or just display a subset of contacts that include the search string in any of the Full Text Search index fields, which are LastName, FirstName and CompanyName.

Using Perst for Commercial Use.

One point to make about this: Perst is free to use for non-commercial use and is released under the GPL license. Perst is cross-platform as there is a Java version as well as the .NET one, and Perst is already used in J2ME and on Android. If you want to use it in a commercial app, then a license fee applies which should only amount to a few pennies per copy. If you are in the UK, you can talk to MPC Data who distribute Perst to that market. I don't know about other markets so I suggest you contact McObject.

Next Steps

Over the next few days I will follow up with a few posts showing how you write code to work with a Perst database. In the meantime, please download the sample code and take a look at how it works.

In this sample, we are using Perst's database wrapper which gives relational database-like behaviour so you create tables and keys and store and retrieve objects from tables in a manner that will be familiar to anyone who has worked with relational databases before. However, Perst is actually an object database, and if you don't use the database wrapper, you simply work with .NET classes in exactly the same way an any other .NET object, but it just so happens that these objects have the ability to be persisted. That's really interesting to me as I hate writing all that unnecessary object relational mapping (ORM) code to convert objects to and from their database format. However, that's a topic for another day.

Over time, I plan on extending this sample to add the UI for working on Leads and Activities as well - it's a learning exercise for me to really learn WP7 development in depth, and hopefully will be of interest to you too!

Perst - a database for Windows Phone 7 Silverlight - Part 2

Tech Ed North America

Andy Wigley — Tue, 01 Jun 2010 13:01:00 GMT

I will be in New Orleans next week for Tech Ed North America (7th through 10th June).

I am speaking on Thursday morning at 9:45am in Room 283. The presentation is called WEM309 - Programming Microsoft Silverlight for Windows Embedded Using Microsoft .NET and explains how .NET Compact Framework developers can build managed apps that use a Silverlight UI.

Big deal, you might think? However, Silverlight for Windows Embedded is the wierd, unruly child of the family because it only has a C++ API - no built in support for programming from C# or VB. In this session, I show how you can use the Windows Embedded Silverlight Tools that are a part of the Windows Embedded Compact 7 product set to generate a working Silverlight application from XAML files that you create using Expression Blend 3. Then we modify the Silverlight app project and instead of an exe, create a dll and define a few exported functions to allow a client to start up the Silverlight UI and to do things like set/get control properties and start or stop animation storyboards. In C#, we can then use p/invoke to drive the UI from the managed app. The other key ingredient is the use of reverse p/invoke which we use to allow a click (or other event) handler on the native side to callback to the managed application.

I have some pretty cool demos to show what is possible - I think it should be pretty entertaining!

If you are in New Orleans, please come to my session and/or find me at the Technical Learning Center (At the Windows Embedded or Windows Phone stands) to talk about all things mobile: .NET Compact Framework on Windows Embedded Compact, on Windows Mobile and Silverlight on Windows Phone 7.

070-580: Windows Mobile 6.5 Application Development

Peter Foot — Mon, 24 May 2010 05:05:44 GMT

This may be a little late to the party but I thought I would share some information on this exam. Because you sign an NDA when you take the exam I cannot comment on specifics of the exam content, however I can offer some guidance on the study guide:-

http://www.microsoft.com/learning/en/us/exam.aspx?ID=70-580

This exam replaced the previous 070-540 exam which covered application development using Windows Mobile 5.0, .NET Compact Framework 2.0 and Visual Studio 2005. Therefore a large percentage of the material is the same between the two. The new topics come in the form of Widgets, LINQ, ADO.NET Sync Services and Windows Mobile Tools such as FakeGPS. The full list of skills measured can be read on the exam link above. There are a couple of oddities:–

The material is updated for .NETCF 3.5 by including LINQ but WCF is not listed.
ADO.NET Sync Services has never really been a core part of the development tools.
Finally one of the skills measured is creating a desktop installer for your application. There is not standard way of doing this but the guidance does exist (see list below) to put together a dll which acts as a custom install action within your desktop installer.

So once you’ve familiarised yourself with all the skills measured you’ll skip to the next tab on Preparation Materials and find there is nothing at all listed. Here is a list I think will help with your preparation:-

Microsoft Mobile Development Handbook – Microsoft Press. While the main book covers .NETCF 2.0 and Visual Studio 2005, the last chapter gives a run down on new features in Visual Studio 2008 and .NETCF 3.5 including LINQ. It ticks almost all of the Skills measured, there are a few articles which cover the new topics:-

Developing Widgets for Windows Mobile 6.5 – MSDN. The Windows Mobile 6.5.3 SDK added some support for Widget development to Visual Studio 2008 but I find it just hangs Visual Studio. This article shows the “old” approach from creating the HTML, JavaScript and building the ZIP file and renaming.

Programming Microsoft Synchronization Services for ADO.NET (Devices) – MSDN. Andy’s article describes Synchronization services from setting up and running synchronization through to optimisations for mobile use.

Using the FakeGPS Utility – MSDN.

The 70-580 exam is quite new and it is quite clear that if and when there is an exam created for Windows Phone 7 development it will by necessity be completely different. However for now 70-580 is the most up-to-date Microsoft exam for Mobility and is one of the requirements for the Mobility competency within the Microsoft Partner Program. Currently it doesn’t appear that there are any exams at all for Silverlight, but there are some coming in the next few months for .NET 4.0 and WPF.

Resco announces support for Windows Phone 7

Pete Vickers — Wed, 19 May 2010 05:35:00 GMT

I am a big fan of Resco tools for developers, and have blogged about them in the past. Resco have become the first of the Windows Mobile tools developers to announce they will be releasing their tools for Windows Phone 7. Read more about it here.

This is great news for developers of new Windows Phone 7 applications.

Microsoft English 1.0

Peter Foot — Fri, 14 May 2010 06:06:04 GMT

More proof (if really needed) that Microsoft is abandoning English and making up its own language:-

"We have noted your concern and we have given your feedback to our upstream."

From Microsoft Subscriptions Support (TechNet/MSDN)