This one is my favorite.

Can you guess the output of this simple console application:

    class Program
    {
        static void Main()
        {
            var actions = new List();

            for (var i = 0 ; i < 10; i++)             
            {                 
                var writeToConsoleAction = new Action(() =>
                    {
                        Console.WriteLine(i);
                    });
                actions.Add(writeToConsoleAction);
            }

            foreach (var action in actions)
            {
                action();
            }

            Console.ReadLine();
        }
    }

One would expect to see numbers from 0 to 9 but here is the actual output of the app:

OK that’s strange right?

It turns out its like that by design. What you have there is a Closure over the loop variable. And closures in C# are done around variables and not around specific values of those variables – so that means that lambda expression gets to use the actual reference to the closed variable.

Let me explain in little bit more detail:

In first loop we iterate increasing the counter variable from 0 to 9 and then use it in the lambda expression. That means each lambda gets its access to the counter via closure.

So at the end of this first loop, value of the counter is 10 (its 10 because we used post-increment operator: counter++, so in last iteration of the loop we increase counter to 10 and then check if its <10 and we see its not, so we exit the loop).

Afterwards we start executing those actions we created in first loop, and they all have a Closure over this same variable counter – which has value of 10 and therefore each action prints out its current value 10 to the console.

So it works as expected, once you know what to expect.

And this is really common mistake C# developers make.

How to fix it?

Solution is very simple once you know what is going on. All we need to do is this: instead of passing the variable counter to the lambda expression, create a local copy of this variable and pass this copy to the lambda instead of passing the counter.

That way, closure will each time be done around that copy variable that has current value of counter at that moment of execution, and this local copy value stay that way and will not be changed afterwards by the loop.

Later when the actions are executed (in the second loop), each will use their own closure around copy of the counter and therefore each will have its own different, expected value.

Here is the code that works as we expect:

    class Program
    {
        static void Main()
        {
            var actions = new List();

            for (var i = 0 ; i < 10; i++)             
            {                 
                    int counterCopy = i;                 
                    var writeToConsoleAction = new Action(() =>
                    {
                        Console.WriteLine(counterCopy);
                    });
                actions.Add(writeToConsoleAction);
            }

            foreach (var action in actions)
            {
                action();
            }

            Console.ReadLine();
        }
    }

As you see we create a copy of counter called counterCopy and pass this to the lambda expression each time.

Although this seems like old news if you knew it, there are many C# developers that are not aware of this behavior (or tend to forget it from time to time) so make sure to spread the word and always remember it.

By the way, the C# team is changing this in C# version 5 to work as one would expect but until then we just need to copy those loop variables manually

Don’t Google it!

Do you know (without Googling it) what will this console application display when executed?

    class Program
    {
        static void Main(string[] args)
        {
            var originalNumbers = new List<int> { 1, 2, 3, 4, 5, 6 };

            var list = new List<int>(originalNumbers);
            var collection = new Collection<int>(originalNumbers);

            originalNumbers.RemoveAt(0);

            DisplayItems(list, "List items: ");
            DisplayItems(collection, "Collection items: ");

            Console.ReadLine();
        }

        private static void DisplayItems(IEnumerable<int> items, string title)
        {
            Console.WriteLine(title);
            foreach (var item in items)
                Console.Write(item);
            Console.WriteLine();
        }
    }

If you try to think logically, you expect that both List and Collection will contain numbers from 1 to 6 when they are displayed, right?

Wrong, otherwise this would not be a proper gotcha

Here is the actual output of the application (surprise, surprise):

Do you know why?

Answer is actually very simple. If you check the MSDN documentation for Collection constructor that accepts generic IList you will see this text:

Initializes a new instance of the Collection class as a wrapper for the specified list.

That means that this constructor creates just a wrapper around the existing IList, so adding or removing items to the original list will also affect the new Collection we just created,  because its just a wrapper and uses original List under the hood.

On the other hand List constructor that accepts IEnumerable<T> behaves properly and does what you would logically expect it to do:

Initializes a new instance of the List<T> class that contains elements copied from the specified collection and has sufficient capacity to accommodate the number of elements copied.

So when you create a new List and pass an existing List to its constructor it will create a proper new empty list, and then copy all the references from original List to the new List.

Because of that, the new List is ‘detached’ from the original and this is why it remains unchanged even if we modify the original List.

Moral of the story

This is simply how Microsoft made these two classes (i would not say its very consistent or good but who am i to judge, right?) and as long as you know it – its fine.

And if you don’t know this – it can bite you really hard.

All that you can do is to try to remember this, and also: RTFM.

Btw, did i said that this can be an excellent job interview question?  

Until next Dot Net Gotcha, keep reading those manuals…

Correction

In my previous post on how to terminate the Windows Phone application i proposed a solution that is not really in accordance with Windows Phone Marketplace Technical Cerification Requirements (see requirement 5.1.2):

” An application that closes unexpectedly fails certification. ”

Even though I’m pretty sure that this requirement is not enforced since my apps use this approach and they were never rejected i decided to present another way.

Some good people suggested in comments of my previous post that you can terminate current application  simply by calling the XNA Game class Exit method like this:

using Microsoft.Xna.Framework;

namespace Roboblob
{
    public class AppLifetimeHelper
    {
        public void CloseApplication()
        {
            new Game().Exit();
        }
    }
}

The downside of this is that you need to add 2 XNA dll’s to your project:

1. Microsoft.Xna.Framework
2. Microsoft.Xna.Framework.Game

21/08/2012 Update: 

There is another way to close the Windows Phone application without throwing exception see more details in my next post.

We want full power!

Its known that in Windows Phone API there is no easy way to terminate the current application from your code.

I guess makers of the platform did not wanted us developers to mingle with the application lifetime too much, phone should decide when an app is not needed and terminate it.

But i just simply cannot help myself, i always like to have full control, for example in my Offline Browser application i want to end the app if user presses the hardware Back Key multiple times in short time intervals.

Because there is this annoying situation when user goes navigating between the pages in your app (main screen, then settings, then about screen,

then again main screen etc) and then when he wants to terminate it he need to click the hardware back button N number of times in order to close it.

And even in some other situations its needed to force close the app, for example if some change in application settings requires app restart etc.

Show Us The Code!

So i decided to change this and wrote this simple AppLifetimeHelper that allows you to terminate your current app without any delay.

How it works is that it uses Application.Current.RootVisual and casts it to PhoneApplicationFrame that has RemoveBackEntry method that basically simulates

the users hardware Back Key press and then in endless loop it calls this method until the navigation back stack of the app is empty.

Then all we need to do is to call the GoBack method of the PhoneApplicationFrame and it will terminate the app since there are no more entries in the app Back Stack.

Simple or what?  

So here is the code if you AppLifetimeHelper that you can freely use in your apps if you need this functionality:

using System.Linq;
using System.Windows;
using Microsoft.Phone.Controls;

namespace Roboblob
{
    public class AppLifetimeHelper
    {
        public void CloseApplication()
        {
            ClearApplicationNavigationBackStack();
            Root.GoBack();
        }

        private PhoneApplicationFrame _root;
        private PhoneApplicationFrame Root
        {
            get
            {
                if (_root == null)
                {
                    _root = Application.Current.RootVisual as PhoneApplicationFrame;
                }

                return _root;
            }
        }

        private void ClearApplicationNavigationBackStack()
        {
            if (Root == null)
            {
                return;
            }

            try
            {
                while (Root.BackStack.Any())
                {
                    Root.RemoveBackEntry();
                }
            }
            catch
            { }
        }
    }
}

And if you are really lazy today…

Here is the download link to the Visual Studio solution with Windows Phone application that uses this helper to terminate it self when a button is clicked…

Mobile is the future!

Its a known fact that mobile usage of internet is growing.

More and more people are using primarily their phones and tablets to browse the web. Yet many websites are still not optimized for small screen devices.

My application Offline Browser for Windows Phone allows you to save whole web pages for later offline reading, but what to do if the website is not optimized for mobile devices?

Mobilize it!

This is where the concept of Mobilizer Services comes in.

Offline Browser supports multiple web services that can transform given web page into simpler version, where only content and images are kept and all other ‘noise’ is removed.

Here is the list of currently supported Mobilizers:

1. Instapaper – currently the best option, creates clean output and preserves images
2. Google Mobilizer – not so nice because it pages the content
3. ReadItLater (now known as Pocket) – very nice but removes images

Each of those services are different and they give better or worse results when simplifying the webpage content – it often varies from website to website.

I prefer Instapaper since it gives cleanest output and shows images but you should try each of them to see which one is best for webpages you are opening.

Important thing to note here is that when Offline Browser uses these Mobilizer services to get the simplified content of web pages, all the images are saved to the phone and are available later when you view those pages when offline.

Another benefit of using Mobilizer service is that they reduce the bandwidth usage so if you have some tariff plan with limited number of MB this could help you keep the bandwidth usage as low as possible – not to mention that saving pages via Mobilizer is much faster!

So how do we enable this cool feature?

We just go to the Offline Browser Settings page and switch on this feature and choose which Mobilizer service we want to use.

Here is how this screen looks on the Windows Phone:

Once we enable the Mobilizer service all the pages we save to the phone storage are retrieved via the chosen Mobilizer and when you actually read the page you will see the mobilized version instead of the full webpage.

Here is how one of the web pages looks before using mobilizer:

As you can see webpage is not optimized for mobile devices and its not easy to read on the phone.

I deliberately used desktop browser user agent in the app Settings just to prove the point.

If we now switch to using Instapaper Mobilizer in the app Settings (and we still use the same desktop browser user agent) we will get completely different content:

As you see page is much easier to read, all the images are preserved.

Yet page is saved faster and less bandwidth is wasted.

So why not always use it?

Well i do use this all the time and only when Mobilizer services fail to retrieve content of some web page, then i switch it off and load original page content.

It all depends on your usage scenario and also on your data plan limits/internet connection speed etc.

Important thing is that you do have a choice and you can setup Offline Browser to work how its most convenient for you.

If you have any feedback regarding Mobilizers feature or you know of some good Mobilizer service that i should include in the app please send me a feedback via the Offline Browser Uservoice page and i will be glad to include it!

The learning curve of a Windows Phone developer

While developing Offline Web Browser for Windows Phone i had to build a small MVVM framework in order to keep the logic out of the views.

One of the first thing i found missing was a way to force immediate propagation of text entered in TextBox control to the databound property of my ViewModel.

By default, TextBox binding is triggered only when control loses focus, and this is kind of lame.

Code reuse is not a myth!

This is really old problem. It existed in desktop Silverlight from the beginning. And it made its way to the Windows Phone platform.

Fortunately I remembered that back in the days while experimenting with Silverlight MVVM framework i already solved this problem by creating a custom silverlight TextBox control so i decided to just reuse that code and create a Behavior that will force binding update to fire on each keystroke in TextBox.

That’s the beauty of developing a Windows Phone app – you can reuse most of the Silverlight code you built over the years

But then i noticed another problem. Because now each keystroke was propagating changes to my ViewModel, if user would type fast and i do for example some web service call on each property change – then i can have too many requests to the web service (one for each keystroke) but in fact i want to do a call only when user stopped typing for a while.

Fortunately, solution is very simple – we will use Reactive Extensions (Rx) since its perfect fit and its already built-in into Windows Phone.

We just need to reference Microsoft.Phone.Reactive.dll from GAC (no additional download needed) and we are half-way there.

OK, but show us some code!

Yes lets see how the code for the ThrottledImmediateBindingBehavior looks like:

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Interactivity;
using Microsoft.Phone.Reactive;

namespace Roboblob.Mvvm.Behaviors
{
    public class ThrottledImmediateBindingBehavior : Behavior
    {
        private BindingExpression _expression;

        public bool Throttle { get; set; }

        private double _throttleDelayInSeconds = 0.5;
        private IDisposable _currentObservable;

        public double ThrottleDelayInSeconds
        {
            get { return _throttleDelayInSeconds; }
            set { _throttleDelayInSeconds = value; }
        }

        protected override void OnAttached()
        {
            base.OnAttached();

            if (Throttle)
            {
                this._expression = this.AssociatedObject.GetBindingExpression(TextBox.TextProperty);
                var keys = Observable.FromEvent(AssociatedObject, "TextChanged").Throttle(TimeSpan.FromSeconds(ThrottleDelayInSeconds));
                _currentObservable = keys.ObserveOn(Deployment.Current.Dispatcher).Subscribe(evt => OnTextChanged(evt.Sender, evt.EventArgs));
            }
            else
            {
                this._expression = this.AssociatedObject.GetBindingExpression(TextBox.TextProperty);
                this.AssociatedObject.TextChanged += this.OnTextChanged;
            }
        }

        protected override void OnDetaching()
        {
            base.OnDetaching();

            if (Throttle)
            {
                if (_currentObservable != null)
                {
                    _currentObservable.Dispose();
                    this._expression = null;
                }
            }
            else
            {
                this.AssociatedObject.TextChanged -= this.OnTextChanged;
                this._expression = null;
            }
        }

        private void OnTextChanged(object sender, EventArgs args)
        {
            if (_expression != null)
            {
                this._expression.UpdateSource();
            }
        }
    }
}

Simple Is Beautiful

Our Binding class has bool property Throttle where we can enable/disable throttling and also a ThrottleDelayInSeconds where we specify after how many seconds later after user stops typing our property is updated.

In the OnAttached – we just hook to the TextChanged and each time user types something we update the binding source.

But if Throttle is set to true, we hook to the TextChanged event over Reactive Extensions and we setup throttling so that binding do not trigger if changes are too fast.

In this only after changes stop firing for the time defined in ThrottleDelayInSeconds, only then binding update is triggered.

Off course we do a little cleanup in the OnDetaching as all good coders

What about the Xaml???

Yes in Xaml we can use it like this:

            <TextBox Text="{Binding SearchCriteriaText, Mode=TwoWay}">
                <i:Interaction.Behaviors>
                    <RoboblobBehaviors:ThrottledImmediateBindingBehavior Throttle="True" ThrottleDelayInSeconds="1" />
                </i:Interaction.Behaviors>
            </TextBox>

For those who are lazy to type I’m attaching a zipped source code of simple Windows Phone Mango project that is demonstrating the usage of the behavior.

Btw does somebody even remember how it was to type source code from printed computer magazines int your 8bit computer?

Probably not

Well at least I hope that someone will find this useful.

Until next time, happy coding!

Lets set some expectations here. We wont be adding new items to Instapaper.com reading list or removing items or anything similar.

We can use our desktop PC for that.

Here we will just explain how to use Offline Browser for Windows Phone to get all those links from Instapaper.com reading list via RSS feed and download them to the phone so we can read them whenever we want – even when we are offline.

So first we need to add the Instapaper unread items Rss feed into Offline Browser as a Links Feed.

Here is how you can do that:

1. Open the Offline Browser for Windows Phone and on the Browser page go to Instapaper.com and login to your account.

Once you are logged in, you will be redirected to this url: http://www.instapaper.com/u which is your unread items list.

2. Now we should find the RSS feed of your unread Instapaper items and use it as links source (Link Feed) of the Offline Browser app.

The RSS feed icon and link are at the bottom right corner of the http://Instapaper.com/u web page, take a look at the screenshot below:

3. Now long tap that link ‘This folder’s RSS’ and context menu of Offline Browser will appear:

4. Click on the “Add Link as Links Feed” item and RSS feed of your unread instapaper items will be added as Links Feed for the Offline Browser.

5. Now lets enable Links Feed synchronization in settings:

There we see the RSS feed from instapaper added to the app as Link Feed and we see that background downloading of the URLs from the feeds is enabled and done every 2 hours.

So even if our application is not running, a background task will retrieve the RSS feed and if there are new links they will all be added to the download queue.

When this happens you will get a toast notification and live tile of the Offline Browser will show number of new links retrieved from all feeds.

Here is how this looks on the Windows Phone start screen:

6. When we click on the Offline Browser icon and there are new items to download we are immediately taken to the download queue screen.

There you can simply click on the Sync button and all new links from download queue will be downloaded.

(app will also check if there are some newer items in the feed and retrieve them together with the items that are already in the download queue).

Once pages are downloaded we can go to the saved pages screen and open them in the browser screen:

Its important to say that once you go through this process and your instapaper RSS feed is added to the app, it becomes automatic and phone will download any links you add to your instapaper reading list.

So now that you know how you can use Offline Browser as your Instapaper client – go ahead, download it from marketplace and give it a try!

Here is some good news:

finally my Windows Phone application Offline Browser is available for download in the Windows Phone Marketplace!

Offline Web Browser? But who needs that?

Well actually i do. To be honest app was created (as many other apps) in order ‘to scratch an itch‘.

I’m an old information junkie and while traveling to work i like reading books and surfing the web, but often i don’t have internet connection or its very slow (for example when I’m in the subway).

Although there are many excellent E-Book readers for Windows Phone (one of the best is for sure Freda) i could not find a single offline internet web browser that would allow me to save full content of web pages to my phone and read them later when I’m offline.

This is how idea for Offline Browser for Windows Phone was born.

Here are some of Offline Browser current features:

• save to your phone full content of web pages (HTML content with all images, CSS Style Sheets, JScript etc)
• later view all saved pages even when you are offline
• all links between saved pages work even when you are offline
• save all the links that are on current page with one click (useful for online news/magazines that have many links to related content)
• long tap gesture on link/image shows context menu with additional options for that link/image
• automatic retrieval of links for download queue by adding RSS or Atom feeds as source (add your Instapaper or Delicious or any other feed)
• download all queued links by Sync option
• change Browser User Agent (mobile or desktop Internet Explorer, IPhone or any other custom string)
• save pages via Mobilizer service (Instapaper, ReadItLater, Google Mobilizer etc)
• page scroll position is preserved so when you later open saved page its scrolled down exactly where you were last time
• its simple to use and can completely replace built in Internet Explorer browser since its uses same page rendering engine but adds more features

So now that we have an overview of what the app does, lets see how it looks and works:

The main browser page

First and main application screen is the Browser page and this is where most of the magic happens:

As you can see UI is minimal.

I wanted to be able to focus on the page I’m currently viewing and not on the UI elements of the app.

Its very similar to the stock phone browser and icons do not cover too much of the screen space.

The main feature of the app is the Save button at the bottom of the page (annotated in the screenshot with the red arrow).

By pressing this button the whole page is downloaded to the phone with all the content including images etc.

Sliding Menu on the bottom of Browser page:

When we click on the three dots in the lower right corner the sliding menu appears at the bottom with links to the other pages in the app and additional options available for this web page.

Browser Context Menu

When we do a long tap on any link or image on the web page a context menu appears with additional options available for link/image.

We can save all the links pointing to the same domain and share the link URL over phone email or social networks accounts.

Images can be saved to the phone Media Library.

Also you can add link as your link feed URL. So you can just long tap on some RSS/Atom feed URL and add it as a source for new links for your download queue. More on this feature later in this post.

Similar context menu appears when you long tap (hold) somewhere on a page – but with slightly different options that are available for current page.

Same menu can be invoked also from the bottom sliding menu when clicked on three dots icon.

Saved Web Pages screen:

All saved pages are displayed and managed on this screen. You can see a list of your downloaded web pages sorted by date in descending order.

Filter box on top can be used to narrow down a list to some specific pages if you have a lot of them.

On this screen you can long tap on a page in the list to get context menu with options for that specific page like Delete, Delete All and View.

By just clicking on a page you are taken to the browser screen and full content of this page is loaded from the phone storage without the need of internet connection.

Neat right?

So how do we automate this thing?

Yes i know, I’m also lazy. I don’t like having to go into the mobile app, browsing websites on the phone and saving pages for later viewing or typing long URLs.

So i came up with this solution:

When I’m at my desktop computer and i see a web page I want to read later on my phone i add it to my Instapaper.com reading list or i bookmark it under special tag in my Delicious.com account.

Then i copy URL of these RSS feeds from Instapaper account or Delicious.com to Offline Browser application settings page as Link Feeds and these feeds will be used as source for new links that i will later download to my phone.

Here is how it looks in the application settings page for the Link Feeds:

 You can switch on/off background retrieval of the links from the feeds and you can set how often synchronization is performed.

 Below you can manually add more Link Feeds by typing their URL or pasting it into the text box.

 Its important to note here that if you switch on this option then feeds are synced in the background tasks even when your app is not running.

 Due to limitations in Windows Phone Background Tasks application does not sync full content of the pages from those URLs but only fetches their URLs and adds them to the download queue.

You can then see those links in the Download Queue page and download them all just by clicking on the Sync button.

 Application tile counter

When you are using background syncing of Link Feeds, application fetches new URLs in the background and notifies you via Toast notification and via Application Tile counter like this:

Here application has downloaded new links from all the Link Feeds and its showing us that there are 5 new web pages to be downloaded.

Download Queue

When we have some pages in the download queue then on application start we are immediately taken to the Download Queue page:

This can be configured in the settings so that you are not redirected here when there are links in the queue so you can choose whats more logical for you.

Once we click the sync button on the top of the page, application starts downloading all the web pages from the download queue and saves them to phone.

Once they are downloaded you can access them from the Saved Pages screen.

Browser User Agent settings

Another feature of the app is that you can choose in Settings the Browser User Agent String to be used when browsing and downloading web pages:

You can pick one of the existing browser User Agent Strings like Mobile or Desktop Internet Explorer or IPhone or simply choose Custom and enter or copy/paste your own User Agent of choice.

Before going to sleep

So this was just a short introduction on what this handy application is and and what it can do.

If you want to test it go to the marketplace and download a trial version of Offline Browser (its fully functional trial with ads) and give it a try.

If you really find it useful well you might as well buy it, right? 

In my upcoming blog posts i will explain some of the less visible features like how saving of page scroll position works etc.

Also expect some Windows Phone programming posts since i have a lot of tips and tricks to share so stay tuned and happy offline browsing!

Windows Phone? How did that happen?

Well over the last couple of months i was experimenting with mobile devices a lot because i was kind of tired of the Desktop and the whole HTML5 madness (yes i don’t like Java Script that much and i certainly don’t think its the-way-of-the-future, but that’s subject for another post).

Out of desperation at first i tried Android and got me a LG Optimus One phone. And I must admit that i liked it very much.

Yes, battery lifetime was problem at start, but installing CyanogenMod custom ROM completely solved that. I even spent some time programming an Android game but that failed miserably because my productivity was close to zero considering all the new things i needed to learn (Java, Open GL).

And all that time one good friend was constantly telling me how great his Windows Phone was. I was very skeptical about that since I previously owned Windows Mobile 6.5 phone  and it was complete failure. I even recall at some time in the past promising to my self that i will never buy Windows powered phone again!

But after hearing all the good things about new Microsoft phone OS I eventually decided to give it a try and got me a Samsung Focus with Windows Phone Mango installed.

Boy was i pleasantly surprised.

And lets be honest here: its not that i did not like Android.  Its good and mature mobile OS.
Its (kind of) Open Source and its has significant market share – not without good reason.

But using Windows Phone after Android was a really pleasent and refreshing experience. And there is no way I’m going back.

Disclaimer: before I continue i want to make few things clear: i don’t work for Microsoft, and i never did and probably never will. Everything i say on this blog is my personal opinion and not of my neighbors or my dog.

So now let me try to summarize the things i

personally love about my new Windows Phone:

• Superb UI - The whole phone User Interface is absolutely AMAZING!  Its very simple and intuitive.
  Yet at the same time it manages to stay slick and beautiful with subtle animations and transitions that do not annoy user but enhance the overall UI experience and make it fun and pleasant.
  UI team did a great job – without any compromises. This is huge win for the platform.

• Live Tiles – When we speak of the User Experience I must mention the excellent Live Tiles concept.
  Live Tiles are actually just animated squares on your home screen  that represent applications or shortcuts for documents, contacts, URLs or any other static/dynamic piece of information that you can pin and arrange on your mobile ‘desktop’.
  They are called Live for a good reason – they often change their content to show additional information – like number of emails in inbox for email application Live Tile, current temperature for weather app Live Tile etc.
  I like this because it works great for the limited screen space of the phone – each of the tiles can show more info by flipping to display live content as it becomes available/relevant.

• The phone Just Works – From the practical everyday usage perspective the OS feels very natural and in 99% of cases works exactly as you think it will.
  I have to admit that i never expected this from Microsoft but the whole Windows Phone is so well planed and designed that its never in the way when you are using it. One good example is how built-in music player works with non-standard headphones.
  I tried plugging in the headphones from my old Android phone (it’s a different manufacturer) and I was able to control music playback by pressing the hardware button on the headphones, one press for play/pause, double press to skip current track. Yes I know this is minor and expected thing, but  remember i found this out just by trying and expecting that it should work, and it ‘just worked’  even with non-supported headphones.
  And when you use the phone you often catch yourself thinking ‘Wow this works just as I expected it to work’. After few moments like that and I was already bought.

• General Email experience is great! In my opinion its superior when compared to the built in email clients on IPhone or  Android. And I don’t mean just MS Exchange email.
  I’m a long time Google Mail user and i don’t use Exchange Server at all. So i was little worried how this will work with MS phone – but without any reason.Gmail works flawlessly out of the box without ANY additional  apps or customizations. I  just added my Google account and it worked. Even the push notifications worked without a single glitch. It also synced my Google Email Contacts and Google Calendar  in expected way, no fuss.

• Built in keyboard is great! Unlike Android you cannot replace keyboard with 3rd party replacement, but there is really no reason for you to do so any way.
  Default keyboard flawlessly supports multiple languages – I’m using English and Czech settings and i can enter all the Czech special characters very easily (they appear by long pressing the keys – as expected).
  Actually I’m deliberately writing this post on the phone using that same keyboard just to prove the point (therefore don’t mind my spelling, please).
  Copy and paste works very nice and another thing i like is the caret repositioning – just by long pressing the screen and then moving the caret around – i would love to see this working so nice on Android.

• Multitasking experience is very nice at least in the Mango Windows Phone version that i have.
  Actually there is no real multitasking (if you exclude the occasional background data sync) because only one app is active at the moment. Others are ‘tombstoned‘ until you activate them.
  But there is very nice illusion of multitasking that does the job pretty well.
  By long pressing the Back hardware button you get on the screen very cool visual ‘Task Manager’ where you can see list of your app screens which you can scroll through and choose which app you want to activate now.
  Simply brilliant.
  On the other hand Android has true multitasking but list of running apps is hidden in phone settings and not so slick at all.

• Phone and SMS functionality – Simple, quick and feature rich yet not in your way when you want to do quick call or SMS somebody. And I could hardly say that for Android or IPhone. Very impressive.

• TextToSpeech and SpeechToText – Windows Phone has pretty decent voice recognition and when you use wireless or wired headsets you can set it up so that it reads you your SMS messages and you can reply to them over voice command and then dictate your answer. Have a look at this Windows Phone voice commanding demo if you want to know more. Yes i know its not Siri and it can be much better but even as it is now is quite usable if you are native English speaker.

• Marketplace – Even though there are less apps then for other platforms, there are enough of them and number is growing so time will fix that. But generally speaking Marketplace is already mature and useful.

• Social Networks integration is flawless. Again without any third party tools.
  Facebook, Twitter, LinkedIn you name it. Its all integrated into People hub on the phone, so you can merge Facebook account with your SIM card phone contact to use it as his/hers account picture etc.

• do i need to mention that phone integrates nicely with desktop MS Office? OneNote, Word, Excel it works as good as it can get on a mobile device. I don’t use it too much except for OneNote but i think its huge win for corporate users.

• Built in Music Player and Radio app are great and i enjoy using them for they simplicity and stability. Not a single crash. Try that on android device and good luck trying!

• One big advantage of Windows Phone for .NET software developers especially for Silverlight folks is that programming Windows Phone is very familiar experience.  Visual Studio has very good support for phone development and Emulator for Windows Phone is in my personal opinion much better and faster then Android one. (Off course one could say I am biased since I’m .NET developer but speed is something that is easily measurable).
  If you have .NET background you can start app development or XNA game development in no time.
  And the Marketplace is not overcrowded. Anyone mentioned word Opportunity?

• Another small thing that can be a lifesaver is the phone boot time.
  My Samsung Focus boots in 20 seconds and its immediately ready to make phone calls or to write SMS.
  My Android device was not even close to that and even when it was booted it remained to be slow for some time, probably until Micro SD card is initialized and until all the services are up and running.
  Sometimes when you need to make an urgent call this can be really important feature.

• Every Windows Phone has built in Find My Phone feature that allows you (if you enable it) to see on the map where is your phone and to start the Ringing on the phone, Lock it or Erase it (off course it needs to be connected on the network for this to work).
  This is useful if you lose your phone, or if it gets stolen. I’m not sure about IPhone but I know that on Android you need to install third party apps for this so this is another nice benefit of this platform.

• Battery Saver – if enabled phone automatically switches to power saving mode when battery is low (stops background sync for example)  and your phone calls and SMS functionality continues to work until there is juice in the battery. I really like this because after all this is a phone device so my calls are more important then my Facebook updates

• Lock Screen on Windows Phone is beautiful. It is following the general minimalistic approach but still manages to show all the relevant information – calendar items, missed calls, messages, emails etc. If you are playing some music there are small controls there.
  All in all very nice without unnecessary bells and whistles.

I could continue like this for some times because there are many other nice things that deserve mention.

But at the same time this is young phone platform so there are also some problems to be addressed.

The biggest issue I currently see for Windows Phone is that its not open enough for developers. Many OS features are exclusively used only by OS apps and by Vendors apps and everyday developers don’t have APIs to access them. Much has been written on the subject so I wont repeat it here, so read the post 10 ways to improve Windows Phone 7 if you are interested or WP7 Extensibility Rant from same author.

Typical example is that in 3rd party apps you cannot subscribe to some user invoked actions, for example there is no way for user to send url to non system application.

I dont see anyone benefiting from this kinds of limitations.

I really hope that Windows Phone team will address these problems and give developers more power.

There is WPDev User Voice Feedback site where all the requests from the developer community are listed – so there is hope this will change soon.

Another thing I don’t like is that for some settings there is no quick way of access.
For example WiFi or Flight Mode. In order to manipulate them you need to go to System Settings and choose menu item  and then switch them on or off. Instead of this hassle I would like to have quick toggle button somewhere on the phone desktop.

Again this is something that would be solved if developers could have access to those settings to programmatically manipulate them.

I guess Microsoft do not want to open the Pandora’s Box by giving  too much power to 3rd party apps, but I think they over did it in this case.

Right balance between opennes and system security on Windows Phone needs yet to be determined.

I would also love to see support for more languages for Text To Speech and Voice Recognition. Im not sure abut Microsoft plans but this would be a killer feature since i think voice is the way to go when it comes to the future of mobile platforms.

Wow this was longer post that I originally intended it to be!

I hope I was able to explain why I personally choose Windows Phone over other modern phone platforms.

Then again, this is all my personal experience and your mileage may vary.

It all depends on what you expect from your phone:

• If you want to pay for Brand, then simply buy IPhone.
• If you want phone that does everything you want and that is completely customizable yes often fails because its complex and bloated with unstable apps – get Android.
• if you just wont cool phone that dont stand in your way but does all things you really could need from mobile device – i recommend Windows Phone

I don’t really expect my phone to be Swiss army knife capable of EVERYTHING but failing to do anything efficiently.

I like minimalistic approach and simplicity so probably this is why I like Windows Phone so much.

But the war of the platforms is still on so don’t be surprised if tomorrow I choose another

Those were my 2 cents on the subject, let me know what’s your experience and what is your best mobile OS out there, and most importantly: WHY?

Unit Testing in Silverlight? But you need Web Browser to do that!

No you do not! Ok maybe you do. But not in a direct way. I will clarify that later. Lets first go back in time to the root of the story:

Since the initial release of Silverlight i was really annoyed by the fact that Unit Testing had very slim support.

Even later when Silverlight Unit Testing Framework was introduced by Microsoft things became little better but still it was far from good.

You could create Unit Tests, but you had to start your Visual Studio in order to run them – eventually looking at the results of tests in your favorite Web Browser.

That ruled out one of the most important facets of Test Driven Development – running your Unit Test on Continuous Integration server, so that you can easily see when any of your Unit Tests are broken – in other words treating your Unit Tests equally as all your code, like you should.

Not to mention that there was no way to run Unit Tests from Reshaper! (oh boy don’t even let me get started on that one).

Can feeling of anger be a motivation for good deeds?

Very likely. I started by investigating what open source projects were available to fill these Silverlight TDD gaps.

And i did found few of them. But they were either too complex or simply did not work properly and failed to run tests from one reason or the other.

This is how i decided to create project Lighthouse – probably in same way how many other open source projects are born: to scratch an itch of single developer, for the benefit of the community

What is it for? What’s the Roadmap?

Lighthouse is envisioned as project that will host multiple tools that will allow Silverlight developers to do Test Driven Development much easier then before.
First tool in this project Silverlight Command Line Unit Test Runner has just been released on Codeplex website.

Lighthouse Command Line Unit Test Runner is console application that runs given Silverlight Unit Testing Framework Unit Tests and collects their results and saves them in known NUnit XML Unit Tests results file format on your hard-drive.

What can i expect?

The rule of the thumb goes like this:

YOUR SILVERLIGHT UNIT TESTS SHOULD BEHAVE EXACTLY THE SAME WHEN YOU RUN THEM WITH LIGHTHOUSE AS IF YOU ARE RUNNING THEM FROM VISUAL STUDIO OR WEB BROWSER.

In other words: If they failed in browser, they will fail when you run them via Lighthouse in completely same way (same timing, same exception etc) – and vice versa.

You can use Lighthouse to run tests in XAP packaged application or you can use it to run tests directly specifying your Silverlight DLL’s – it is very flexible.

Currently Lighthouse saves results in NUnit XML Unit Tests results file format so that means you can use it to run your Unit Tests in ANY Continuous Integration server that supports this format – CCNet, Team City you name it.

In future we will maybe add more output XML formats, but for start this should suffice.

Lighthouse Silverlight Command Line Unit Tests runner supports variety of command line switches so you can tweak it to work how you need it.

You can specify Tag Filter to run only certain test cases.

You can specify timeouts, output log file, output directory etc.

Make sure you visit the Lighthouse Command Line Test Runner Documentation page to get familiar with all the options.

In the future we are planning to develop Resharper plugin to run Silverlight Unit Tests, but you will here more on that when its ready.

And how does all this work?

Its much simpler to explain then it was to make it work:

In its essence, Lighthouse analyzes your XAP/Assemblies and modifies them in a way so that it can control the Unit Test execution. It then fires up a web browser instance in the background and start this modified Silverlight application and collects the results of all Unit Tests. Results are saved in XML file and everyone go home and live happily ever after.

What now?

Until future releases I’m asking all interested Silverlight developers to use Lighthouse and send us feedback or even join the Lighthouse team to make it better.

For the end check out this short video where Lighthouse Command Line Runner executes Silverlight Unit Tests from Sterling project:

Stay tuned…