Nick's .NET Travels

Continually looking for the yellow brick road so I can catch me a wizard....

Using Uri Fragments with Windows Phone 7 instead of QueryString

There are a number of posts out there (such as this one) talking about the use of QueryString parameters as a way of passing information between pages in a Windows Phone 7 application. An alternative to this is the use of Uri Fragments.

I’ll take Rongchaua’s example as a starting point. Here you can see the code on both the source and destination pages.

// On source page
NavigationService.Navigate(new Uri("/BrowsePage.xaml?RSSSource="+strSource, UriKind.Relative));
// On destination page
private void PhoneApplicationPage_Loaded(object sender, RoutedEventArgs e)
            string strRSSSource = "";
            NavigationContext.QueryString.TryGetValue("RSSSource", out strRSSSource);
    catch (Exception ex)

Before we go on to look at using fragments instead of the query string, I’ll make one comment about this code sample. Here Rongchaua has handled the Loaded event of the page. If you want to load data you can actually override the OnNavigatedTo method which will get invoked earlier in the navigation pipeline. You do need to be careful though as the UI may not have been completely loaded at that point.

Coming back to using a uri fragment. Here is the same example, this time using a fragment instead of a QueryString.

// On source page
NavigationService.Navigate(new Uri("/BrowsePage.xaml#"+strSource, UriKind.Relative));
// On destination page
protected override void OnFragmentNavigation(System.Windows.Navigation.FragmentNavigationEventArgs e)
            string strRSSSource = e.Fragment;
    catch (Exception ex)

The OnFragmentNavigation method gets invoked after the page has been navigated to but before the loaded event is raised. It’s there so that you can process the fragment that has been sent through to your page. Of course, it’s suited to cases where you only want to pass through a single value.

Windows Phone Calculator – Design Success or Failure?

I was just trying out a couple of things on the Windows Phone emulator and came across some hidden features of the calculator application. Having started the calculator and I did a basic sum and thought, great it’s a very basic, clean looking, calculator.


Then I accidentally hit the rotate button on the emulator and wow, there’s some hidden buttons that weren’t available in portrait mode.


How on earth was the user supposed to find those buttons? I went back to portrait mode and looked for visual clues to indicate that there were some hidden buttons or that I should rotate the device. Nothing….

My question is does this constitute good Windows Phone application design? I suspect my answer is that it’s not finished and that there is some refinements still to be added. Whilst visually appealing the lack of any visual clues is a complete fail. Hopefully we’ll see this addressed before Windows Phone ships.

Don’t create Easter Eggs in your application, make sure there are some clues to allow the user to explore your application and locate all the functionality you painstakingly added to your application.

Messagebox.Show Breaks Dispatcher.BeginInvoke after DataServicesQuery on Windows Phone 7

I’m guessing this is an issue with the current CTP of the Windows Phone 7 bits, or perhaps just an emulator issue, but it appears that if you call MessageBox.Show it throws a spanner in the works when you try to do a UI update from a background thread.

Take for example if you were to follow Alex’s post on Accessing WCF Services then you would be calling BeginExecute on a DataServiceQuery. As you would imagine this goes off and does an asynchronous call. When the call is complete the callback method (in our case an anonymous method) is invoked. In the following sample code all the call back does is to call Dispatcher.BeginInvoke to execute a method that will refresh the UI.

In the following code, SimpleUpdate is never executed.

        ServiceEntities context;

        void SimpleUpdate()
            this.button.Content = "Updated Text";

        private void button_Click(object sender, RoutedEventArgs e)
            MessageBox.Show("Hi Everyone!");

            context = new ServiceEntities(new Uri(http://myserver/Services/myservice.svc/));

            var query = context.Customers;
                       (asyncResult)=> {

                                                 },  query);


If we remove the MessageBox.Show line, the code executes without an issue and SimpleUpdate is called and the button text is updated.

In my case I came across this because I was using the MessageBox for debugging. In a real world Windows Phone application you really need to reconsider the use of MessageBox at all – it’s generally a symptom that something hasn’t been designed well or that something has gone wrong (eg exception thrown).

Windows Phone 7: Add Reference for Syndication

In my previous post, Building an RSS Reader for Windows Phone 7, you may have wondered how I was able to reference SyndicationFeed as this class is in the System.ServiceModel.Syndication namespace which isn’t available in the default list of references for a new Windows Phone 7 project, nor is this assembly in the list of .NET assemblies when you do Add Reference.

The secret is that you need to add a reference to the desktop Silverlight v3 assembly, C:\Program Files\Microsoft SDKs\Silverlight\v3.0\Libraries\Client\System.ServiceModel.Syndication.dll. This will get deployed along with your application, giving you access to the Syndication namespace.

Happy RSS Reading!

Building an RSS Reader for Windows Phone 7

I noticed that Sam over on the Silverlight Show posted about a Windows Phone 7 Series RSS Reader which uses the WebBrowser control to render the content. I figured that whilst that was a neat approach to displaying content an alternative would be to parse the feed, extract the content and display using a combination of TextBlock, Run and LineBreak elements. The following screenshot shows my blog being viewed using such an approach.

Here’s the core code that makes this all happen. It uses the SyndicationFeed class to extract the posts – in my case I’ve just embedded the feed source as a text resource file (hence var rss = RssResources.BlogPosts, where RssResources is a reference to the designer generated wrapper). I then loop through looking for html tags, specifically end of paragraphs and images. I’m sure there’s a more elegant way of doing this but for demo purposes this did the trick.

        private void Page_Loaded(object sender, RoutedEventArgs e)
            // Load RSS into a feed
            var rss = RssResources.BlogPosts;
            using(var strm = new System.IO.StringReader(rss))
            using(var reader = System.Xml.XmlReader.Create(strm))
                var feed = System.ServiceModel.Syndication.SyndicationFeed.Load(reader);
                // Regular expression to look for html tags
                var tagFinder = new System.Text.RegularExpressions.Regex("<(.|\n)+?>", System.Text.RegularExpressions.RegexOptions.IgnoreCase);

                // Create the initial textblock
                var txt = new TextBlock() { TextWrapping = TextWrapping.Wrap };
                foreach (var item in feed.Items)
                    // Add a title
                    txt.Inlines.Add(new Run() { FontWeight = FontWeights.Bold, Text = item.Title.Text });
                    txt.Inlines.Add(new LineBreak());
                    var itemText = item.Summary.Text;
                    var match = tagFinder.Match(itemText);
                    var startidx = 0;
                    while (match.Index >= 0 && match.Length > 0)
                        if (match.Value == "</p>" || match.Value == "<p />" || match.Value == "<br />")
                            // Found the end of a paragraph, so append this text to the textblock
                            var text = itemText.Substring(startidx, match.Index - startidx);
                            text = tagFinder.Replace(text, "");
                        else if (match.Value.Contains("<img"))
                            // Add the text up to the image tag
                            var text = itemText.Substring(startidx, match.Index - startidx);
                            text = tagFinder.Replace(text, "");

                            // Locate the url of the image
                            var idx = match.Value.IndexOf("src");
                            var url = match.Value.Substring(idx + 5, match.Value.IndexOf("\"", idx + 6) - (idx + 5));

                            // Create an image and add to stackpanel
                            var img = new Image() { Source = new BitmapImage(new Uri(url)) };
                            img.Width = this.scrollViewer1.ActualWidth / 2;
                            img.Stretch = Stretch.UniformToFill;

                            // Create a new textblock and add to stackpanel
                            txt = new TextBlock() { TextWrapping = TextWrapping.Wrap };

                        // Look for the next tag
                        startidx = match.Index + match.Length;
                        match = tagFinder.Match(itemText, match.Index + 1);

                    // Add the remaining text

                    // Add some space before the next post
                    txt.Inlines.Add(new LineBreak());
                    txt.Inlines.Add(new LineBreak());

Zune Software 4.2 in Windows Update for Windows Phone

I somehow only just realised that Windows Update was blinking at me indicating there were updates available. I’m usually pretty good about installing all the important ones but this time I noticed there was an optional component titled Zune Software 4.2. I had to ask…”why am I getting an update for Zune software when I’ve never installed the Zune software”. Not thinking much about it I proceeded with the download and subsequent install.


Now it occurred to me that I’d heard that the Zune software is going to be used by Windows Phone 7 to sync media, which seems logical since all Windows Phone 7 series devices are a Zune device. Having downloaded the developer tools (see if you want them) I figured that it this update must have to do with some component that was part of those tools. Spinning up a couple of my VMs I tested this out – sure enough on the VM that had the dev tools installed, there was the update but on the other VM, without the dev tools, the update was missing.

Unfortunately just because there appears to be a relationship there, doesn’t mean that you can start syncing with the Windows Phone 7 emulator. I tried both with the emulator that ships with the dev tools and the hacked emulator image that’s floating around. I’m sure there’s probably a magic unlock code/flag that you can set to enable syncing but at this stage I’m just waiting for the next official drop from Microsoft where we’ll hopefully see more of what’s going to be available in the platform as part of the emulator.

Detecting Orientation with Windows Phone 7

With the preview developer bits for building Windows Phone 7 applications now publically available I was experimenting with a few things and one of the first things I went looking for is support for handling device orientation. More specifically the event where the orientation of the device changes. Now you can actually do this two ways: you can either attach to the OrientationChanged event on the PhoneApplicationPage, or since your page inherits from this class you can override the OrientationChanged method. Note there is also an OrientationChanging event/method pair that you can also use.

        private void PhoneApplicationPage_OrientationChanged(object sender, OrientationChangedEventArgs e)
        { … }


       protected override void OnOrientationChanged(OrientationChangedEventArgs e)

One of the interesting things to note is that if you are actually interested in whether the device is now in portrait or landscape you have to be careful how you test the new orientation. For example the following condition will probably never be true:

if (e.Orientation == PageOrientation.Portrait)

If you take a look at the PageOrientation enumeration you will see that it actually defines values for each orientation:

public enum PageOrientation
        None = 0,
        Portrait = 1,
        Landscape = 2,
        PortraitUp = 5,
        PortraitDown = 9,
        LandscapeLeft = 24,
        LandscapeRight = 52,

So the only way the previous condition would hold true is if the system decided to return an Orientation set to the more general Portrait, rather than the specifics of PortraitUp and PortraitDown.

Fine you say, it must be a flag in which case you have to “AND” it to work out whether it’s in Portrait or Landscape. Well yes, but you need to make sure that you only do that with the Portrait value. You will notice that the values associated with these values are not your typical flag values of 1, 2, 4, 8 etc. This means that when you AND say the Landscape value of 2 (binary 00010) with LandscapeLeft (binary 11000) you will get 0, when you were expecting to get a value of 2. Luckily when you are testing against Portrait you will notice that both PortraitUp (binary 00101) and PortraitDown (binary 01001) you will get the value 1, which is what you’d expect. So the code for doing different actions based on just the Portrait/Landscape orientation would look something like:

private void PhoneApplicationPage_OrientationChanged(object sender, OrientationChangedEventArgs e)
           if ((e.Orientation & PageOrientation.Portrait)>0)

Perhaps someone out there can let me know why the enumeration has the values it does? Clearly I’m missing the obvious here, or perhaps this is a feature of the current preview bits.

Enabling Windows Phone 7 Themes in Emulator Applications

I just noticed that Peter has put up a post on how to make a Windows Phone 7 application theme aware. I couldn’t help but recall one of the more obscure side comments in one of the MIX sessions where the presenter commented out a bunch of code in the App.xaml file in order to get theming to work correctly.  Anyhow, if you’re interested the section of xaml to comment out is the following:

        <!-- Brush Resources -->
        <!--<SolidColorBrush x:Key="PhoneAccentBrush" Color="{StaticResource PhoneAccentColor}"/>
        <SolidColorBrush x:Key="PhoneBackgroundBrush" Color="{StaticResource PhoneBackgroundColor}"/>
        <SolidColorBrush x:Key="PhoneContrastForegroundBrush" Color="{StaticResource PhoneContrastForegroundColor}"/>
        <SolidColorBrush x:Key="PhoneForegroundBrush" Color="{StaticResource PhoneForegroundColor}"/>
        <SolidColorBrush x:Key="PhoneInactiveBrush" Color="{StaticResource PhoneInactiveColor}"/>
        <SolidColorBrush x:Key="PhoneDisabledBrush" Color="{StaticResource PhoneDisabledColor}"/>
        <SolidColorBrush x:Key="PhoneSubtleBrush" Color="{StaticResource PhoneSubtleColor}"/>
        <SolidColorBrush x:Key="PhoneContrastBackgroundBrush" Color="{StaticResource PhoneContrastBackgroundColor}"/>
        <SolidColorBrush x:Key="PhoneTextBoxBrush" Color="{StaticResource PhoneTextBoxColor}"/>
        <SolidColorBrush x:Key="PhoneBorderBrush" Color="{StaticResource PhoneBorderColor}"/>
        <SolidColorBrush x:Key="PhoneTextSelectionBrush" Color="{StaticResource PhoneTextSelectionColor}"/>
        <SolidColorBrush x:Key="TransparentBrush" Color="Transparent"/>—>

You should be aware that this effectively breaks the current design experience within Visual Studio and can even cause the IDE to crash.  I actually closed all my open documents before making this change and then un-commented the xaml once I was done testing the theme support.

Anyhow, here’s a (poorly designer) test application that shows the Light theme option:


Windows Phone 7 series, Silverlight, XNA, Compact Framework, Background Processing and… Symbian S60

So here are a few things I found interesting from the first day of MIX:

- Windows Phone 7 series…. duh, well yes that one was obvious. It seems that nearly everyone is talking about it. In case you’ve been living in a hole somewhere you’ll have noticed that the development story is Silverlight and XNA for this platform

- Compact Framework v3.7. If you inspect System.Environment.OSVersion in the emulator you’ll see that it reports version Microsoft Windows CE 7.0.6077. This is confirmed by this post that talks about the WP7 Programming Model.

- Background Processing – That’s right, if you’re application is a good phone citizen (as defined by Microsoft of course) and you don’t consume too many resources your application will continue to operate in the background. This is demonstrable in the emulator if you create a background thread that increments a counter or prints a debug statement – when your application looses focus it will continue to increment/print.

- Symbian S60 support for Silverlight (in-browser model). The Silverlight model for WP7 is entirely out of browser. In fact your Silverlight application will be deployed via Marketplace and will not have any contact as such with the browser. S60 support, as discussed in the post Silverlight on Nokia S60 platform, is in-browser and is only a very limited subset of Silverlight 2. The obvious questions here are whether WP7 will get SL in-browser support (they’ve already been talking about Flash inclusion but why not SL) and which other platforms will be next to get in-browser support.

I’m sure there will be plenty more bits emerging from MIX over the coming days.

Windows Phone 7 series Developer Preview…. Virtual Machine Fail

Having sat through the MIX keynote I was excited to see the announcement of the Windows Phone 7 series development tools.  These can all be downloaded from  The downloads are only compatible with VS2010 RC and so installing these on my main machine (which I haven’t had a chance to upgrade from the beta) is going to be a major effort.  I thought I’d go an install them on one of my many virtual machines I have running on my Hyper-V server – FAIL… According to the release notes this is not a supported option. I also noticed that round-tripping between VS and Blend is not supported – doesn’t that defeat the whole purpose?

Scenarios Not Supported

  • Opening Windows Phone projects in Expression Blend® is not supported, except for Expression Blend 4 Beta with “MICROSOFT EXPRESSION BLEND ADD-IN PREVIEW FOR WINDOWS PHONE.”
  • Round-trip editing of the Windows Phone projects between Expression Blend and Visual Studio is not supported.
  • Windows XP and Windows Server® are not supported.
  • Virtual PC and Hyper-V™ are not supported.

I’m actually guessing the issue with Virtual PC/Hyper-V is to do with the emulator, rather than the actual developer experience. This is something that we saw with very old versions of the Windows Mobile emulator where they couldn’t be run in a virtual machine – this was fixed when the emulator was moved to true ARM emulation.

Update: I’ve just finished installing the tools on a VM and the emulator, whilst slow to load the first time did in fact load and run my hello world application. Big kudos to Microsoft – the tooling looks great so far.

Also, don’t forget to check out the following discussion documents on the platform and designing for Windows Phone 7 series.

Windows Phone 7 – Will it be everything Microsoft wants it to be?

Charlie Kindel’s posted about some internal planning that the team did as part of building Windows Phone 7 series. I’m assuming that this isn’t an ordered list but I’m also guessing that this was the order the points were on some list somewhere (perhaps as they were written on a whiteboard during a brainstorming session). If this is the case, it’s concerning that “It’s easy to build beautiful applications users just love" falls at the bottom of the list.

For those that are familiar with Windows Mobile development you’ll have gone through the list and gone yep, yep, yep to most of the points. Most of these points we could achieve on the current Windows Mobile platform (perhaps with the exception of protecting the developers IP and until recently a single marketplace). Where Windows Mobile sucks is the ability to generate awesome applications that users really want to use – it’s not impossible by the way, just hard to do. Actually, it’s hard to do this full stop. I’d almost stake my life on it that despite Microsoft’s attempt at making it easy to build “beautiful” applications, beauty is definitely in the eye of the beholder and we are going to get some hideous creations appearing on the marketplace.

I’m looking forward to MIX next week when we’ll hear just how great we can my Windows Phone 7 series applications.

Breaking Changes: Windows Phone 7 series Development Story

Well the cat’s out of the bag… actually no all that’s happened is that Microsoft has confirmed that one of the cats that was in the bag is now dead: The rumour that legacy applications will run on Windows Phone 7 series is officially dead with Charlie Kindel confirming the lack of backwards compatibility in a post entitled Different Means Better with the new Windows Phone Developer Experience.

What’s interesting is just how well the whole Windows Phone 7 series announcements have been. If you look at other blogs from Microsoft, they all have similar posts talking about the decisions that were made in order to give developers an awesome platform to start building applications on. For example the following blogs all have posts coinciding with Charlie’s post:

Andre Vrignaud:

Break with the Past, Bright New Future: Windows Phone Application Development Platform built on XNA and Silverlight

Christian Schormann:

Windows Phone 7 Series for Designers and Developers

Shawn Hargreaves:

Backward compatibility

Anand Iyer:

Windows Phone 7 Series – Developers, Developers, Developers

Michael Klucher:

Gaming Development for the Go!

Also confirmed in a twitter Q&A at @WP7dev was support for both Silverlight and XNA development for Windows Phone 7 series. Hopefully this will provide a much more consistent rapid development environment for building phone applications whilst still making them perform.

Currently on Windows Mobile we have a number of technologies to choose from, none of which provide a great experience to both developer and consumer without a lot of cycles invested in making your application look good. The worst part about this is not the cycles spent working out what the application should look like (eg working with a designer to make it look awesome), it’s the wasted cycles having to code it from the ground up each time.

Native C++: Sure you can do nearly anything you want but you take a major productivity hit. Not to mention building a team of top notch c++ developers is becoming very difficult.

WinForms: This just sux for anything other than a mundane LOB application. Sure you can use some of the transparency tools out there to get stylish buttons, or override OnPaint to DIY it to make it look reasonable but you aren’t really going to be doing much in the way of animations, rotating elements etc.

Direct3D: Well this is a technology flop in so far as there is little hardware rendering support out there on a lot of devices. Best to ignore this one….

OpenGL: This is an interesting beast. You can write all your code in C#, yet you have the power of doing nearly any sort of animation, rotation, translation, in fact there is a lot you can do with vectors, triangles and quads. Documentation on getting started and troubleshooting is a little light on but once you get things up and running the results are quite good. You do of course have to think in matrices, projections etc which for those not familiar with these constructs can pose a bit of a learning barrier.

So, if you were going to build a mobile application today, what would you do….. Well contrary to Charlie’s post in which he suggests that developers will continue to build for Windows Mobile, I suspect the reality is that nearly every mobile developer out there will start building Windows Phone 7 series applications as soon as the tooling arrives.

Windows Phone 7 Series Development – What Do You Want?

Since it’s announcement over a week ago the question on all our lips is “what’s the development story going to be?” Whilst there has been countless rumours regarding support for Silverlight (perhaps third time’s like for this can of worms….) and XNA it won’t be until MIX that we’re going get a good look at what Microsoft has in store for us mobile developers going forward.

In the meantime, I took a little bit of time out to think about the current generation of development tools. Now, I’m going to overlook the obvious failing around stylish controls for building Windows Mobile applications (which in my opinion is one of the fundamental reasons the iPhone is trumping Windows Mobile applications at the moment, after all it sure as hell isn’t the development language!). What I’m interested in is the development/debugging/testing/deployment story, so here’s a list of the tools/frameworks etc that we have at the moment. I’ll start this list but I suspect it may have to be continued as I remember things that I’ve omitted.


IDE - Visual Studio

- Support for Native, C# and VB.NET development
- Visual Designer for Forms and Controls, including designer skin
- Intellisense, Code completion
- Debuggin support
>> Breakpoints
>> Watches and variable inspection
>> Datatips
>> Step through/over

Managed Frameworks

- .NET Compact Framework
- Windows Mobile managed libraries
>> POOM (contacts, calendar, email, tasks)
>> Camera
>> Contact picker
>> State and Notification Broker
[missing APIs could be p/invoked to native APIs]
- Rich networking stack (sockets & httprequest)

Data Story

- SQL Server Compact
- Multiple Synchronization Frameworks (RDA, Merge Replication, Sync Services)
- Designer support for connecting to web services

Support Tools

- Device Emulator
>> Able to change configuration
>> Able to adjust system state
>> Able to connect to ActiveSync/WMDC to simulate docking real device
- Cellular Emulator
- Hopper 

3rd Party

- Smart Devices Framework (OpenNETCF)

- Mobile In The Hand

- Mobile Client Software Factory

- Orientation Aware Control

- NLog


With this list in mind, what do you feel is missing? If your answer is nothing, then think harder – after all there must be a reason why Windows Mobile 6.x was failing to attract users and developers alike.

Is Windows Phone 7 series going to be great for developers?

As you’ve no doubt seen Microsoft announced Windows Phone 7 series last week at Mobile World Congress in Barcelona. I guess I’ll start off with the mandatory “here’s what it looks like” piece: Here’s a couple of screenshots for you to go “oh-ah” over – if you want more you can head over to Rob’s blog where he’s got some more images, as well as the official Windows Phone 7 Series website.

startscreen web 158x300 Windows Phone 7 Series debuts at Barcelona!officescreen web 300x181 Windows Phone 7 Series debuts at Barcelona!

Now the reason for this post is a way of providing commentary following the Focus, Focus, Focus post by Charlie Kindel. Firstly, I want to say that I love the fact that there appears to be such a high level of “focus” from the Windows Phone team. It would appear that despite severely dropping the ball with Windows Mobile 6.x I think the departure from this platform to Windows Phone 7 series will definitely be a positive move and will position Microsoft in a strong position in the mobile market.

Yes, I know everyone’s (well at least a large proportion of the techie crowd) going on about Android this and Android that but they’re seeing the same issues Microsoft saw 5 years ago with market fragmentation and a UI that is already very dated. Unless Google does something remarkable prior to Windows Phone 7 hitting the stores I suspect we’ll see an un-remarkable end to Android phones being the alternative to buying an iPhone.

Coming back to Charlie’s post – What I found particularly interesting is the priority list regarding the developer audience, which essentially puts us enterprise developers close to the bottom of the heap. Initially you might look at that and say “but enterprise has been Microsoft’s staple when it comes to WM” but you have to remember this is NOT Windows Mobile, it’s Windows Phone 7, it’s a new era of devices and with that comes all the issues you’d expect to see with a v1 product.  Actually as an aside I’m surprised they went with 7 – this is so radically different they could have just gone with Windows Phone and be done with it. Alternatively they could have just picked a single manufacturer and released the Microsoft Phone but that’s a completely different topic altogether.

So, where does that leave us enterprise developers? Well the first thing you should do is realise that Charlie’s list is only a priority list, it doesn’t imply that you can’t do enterprise development. In fact, I’m guessing that in order to support the Pro and non-Pro developer audience in their ability to create awesome applications for consumers, a large proportion of the enterprise capabilities will be there.

So what may be missing for enterprise developers? If you consider enterprise as including line of business applications such as stock management, then it is highly likely that when Windows Phone 7 ships there won’t be hardware out there to support barcode scanning etc. This isn’t actually a new problem as hardware manufacturers for LOB devices typically take 6-12 months (or more in some cases) to update their devices with new operating system versions.

Microsoft also hasn’t talked about what the deployment story will be for applications and the extent of the programming apis that will be available for application developers to interact not only with other services on the device (eg camera or the phone), storage, other applications, PIM data (eg contacts, calendar) and whether there will be developer libraries for connecting to Windows Azure, Live Id and other hosted services. My guess is that like previous versions of Windows Mobile there will be apis for accessing some of these – how this affects enterprise development is really dependent on what apis are there and which are missing. For anyone interested in this story, you should be heading to MIX where they’ll be disclosing the developer story.

Your Phone, My Phone, they’re all Windows Phones….

Well that should be the Microsoft chant with the simultaneous release of Windows Mobile 6.5, Marketplace and a host of complementary applications such as an updated MyPhone that’s available for download via Marketplace. If you’re like me, one of the cool new “premium” features of MyPhone is the ability find your lost phone.  Here I’m showing the “known location” feature but you can get MyPhone to ring your phone, even if it’s on vibrate.  I so want that feature for when I lose my phone (no pun intended….)