It’s been a while since I wrote about TFS although a post I made about it 5 years ago is still the most popular post on my blog (weird!), and I’d like to give a plug for a plug-in for TFS called Urban Turtle, that provides SCRUM tools for Agile development. 
The name seems like a play on Tortoise, which provides integration for SVN (a source-control system), and I have this vision of a turtle walking in a city with shades on and a boom-box on it’s shoulder.

The Urban Turtle website is at, and it has all the info and videos for you to get started.
Brian Harry of the TFS team has a good post about it here:

I am still exploring it, but it seems to have all the features you’d require in a SCRUM tool.

The SCRUM features are available in the Project Portal (website on SharePoint), for easy web-access to all team-members (including clients)

Creating Sprints, for example.



At work, we use TFS for source control and JIRA for SCRUM, but I don’t like the Printing possibilities of our JIRA setup, and assigning a Task to someone is not easy (because of a clunky interface with the name list).

Let’s see how things are in Urban Turtle land, and I’ll report back if I end up trying it.

We are currently developing an LOB application and one of the screens in Silverlight shows about 20,000 records. When the (Silverlight) client made the domain service call it got back no data. This was because the database calls took a long time and returned many records. This led to problems with RIA services on 2 levels viz. timeouts (the time the call takes to return) and the number of objects returned.
To resolve this, I did the following:

Setting the timeout

To work around the default timeout of 30 secs for RIA services, we need to over-ride the the timeout of the binding for the endpoint at run-time.
This is a simple concept but tricky to implement. The idea is to create a partial class that will complement the DomainContext class auto-generated for the Silverlight client.

To get a handle on this, open the auto-generated file by RIA services during compilation, named [your project].g.cs in a hidden Generate Code folder. To view this, click the Project for your Silverlight client as specified in the RIA services link.


Click on the “Show All files” button icon in VS2010 and you will see it.

This file will contain the proxy Domain Context class generated for calling your Domain Service, amongst many other namespaces and classes in that file. Ensure you have the right namespace for this class (it could be confusing) which is essentially the namespace of your Domain Service.

Create a partial class for this Context.
Make a new file and add code similar to the following to it
(replace myns and MyDomainContext with yours, and the required timeout value which I have as 5 minutes)

namespace myns
    public sealed partial class MyDomainContext
        partial void OnCreated()
            if (!DesignerProperties.IsInDesignTool)
                    .ChannelFactory.Endpoint.Binding.SendTimeout = new TimeSpan(0, 5, 0);


Add a reference to the web client of Domain Services


If the class you added does not compile, check the namespace and the Interface name (from the hidden file for that domain context constructor) and the reference.

Changing the number of objects returned

RIA Services limits the number of objects that can be returned, and this limit can be over-ridden by modifying the service behavior (not the client). This is done by modifying the web.config file to first specify a behavior node

The existence of the behavior node is specified in the services section

  <service name="myNS.myDomainService" behaviorConfiguration="myDomainService" />
The actual behavior node is specified in the behaviors node in the system.serviceModel section. Minimize the number of objects returned to suit your needs
<behavior name="myDomainService">
  <serviceMetadata httpGetEnabled="true" />
    <serviceDebug includeExceptionDetailInFaults="true" />
     <dataContractSerializer maxItemsInObjectGraph="2147483647"/>
The above changes should hopefully work for you as well.

While developing Win Phone apps, there are a few options for having a timer. Here are 2 possibilities which provide precision vs. blocking/overhead:

1. Dispatch timer
This is basically a timer that runs on the UI thread and so is precise but can block the UI for any refreshes and activity when it executes, so be careful how/when you use it.

It can be declared and created as:

System.Windows.Threading.DispatcherTimer _predictionTimer = new System.Windows.Threading.DispatcherTimer();

It is set up as: (Do this in the Page loaded event, for the Page)

_predictionTimer.Interval = new TimeSpan(0, 0, TIMER_INTERVAL_SECONDS);
_predictionTimer.Tick += new EventHandler(PredictionTimerEvent);

Note: If you type in the += after the second statement, hitting Tab twice will also generate a callback stub in code (like the one below) for you.

The method to call for the timer event is written as:

void PredictionTimerEvent(object sender, EventArgs e)
   …do something…}

2. IDisposible timer

This timer is not very precise, but runs on its own thread and not the UI thread  and so does not block the UI. It does need to switch contexts to do anything with the UI/display. So, you need to get a handle to the UI thread to do anything with the display. I use the MVVM Light Messenger and subscribe to a message that I then send in the timer so I don’t need to do any switching myself.

It is declared as:

        IDisposable _timer;

It is created as: (Do this in the Page loaded event)

if (_timer== null)


        IScheduler scheduler = Scheduler.Dispatcher;

    _timer = scheduler.Schedule

                              (new Action<Action<TimeSpan>>TimerInterrupt), 


The timer event handler is written as:

        void TimerInterrupt(Action<TimeSpan> action)         {             …do something…             action(TimeSpan.FromSeconds(TIMER_INTERVAL_SECONDS));         }

To kill the timer (while navigating away, for e.g.)

_timer.Dispose();  //kill timer

Both of the above essentially do the same thing, but there are different reasons to use either.
Hope that helps.

It is a common scenario to navigate to another URI on a button click. If you have MVVM fully wired up, this command in your View will likely connect to a method in your ViewModel. But the View is the one that can navigate via the NavigationService.

So, this means the ViewModel will need to tell the View to do so. One way to do this is by using the Messaging framework in MVVM Light toolkit.

For e.g. Let’s say your About button needs to go to to the About Uri. The following are the various steps involved.

1. View – Register the Message (to receive) in the source View.
Let’s say we want to look for a Uri and a token of “Navigate”. When it is received, we want to invoke the Navigation. This can be elegantly done with a delegate as follows

Messenger.Default.Register<Uri>(this, "Navigate", 
        (uri) => NavigationService.Navigate(uri));

2. ViewModel – Send this Message from a ViewModel, and MVVM Light will deliver it to the View

private void About(object param)
    Uri uri = new Uri("/View/About.xaml", UriKind.Relative);
    Messenger.Default.Send<Uri>(uri, "Navigate"); 

This ensures there is no tight coupling between the ViewModel and the View, as the pattern requires.

You can use this pattern even between 2 Views if you need.

Here is a presentation about MVVM and implementing the design pattern with MVVM Light toolkit, that I made to the San Francisco Silverlight User group.

Feel free to use this as you may please.

As part of developing for WP7, I came across a few issues that I’d like to share with you, and maybe help you avoid some pitfalls I faced…

1. WebClient requests are cached by emulator
If you use the WebClient class to download information from the web, be aware that the web requests are cached by the emulator (and the actual phone?) and this can be quite confusing, especially for real-time data from the web. There is no straight-forward workaround, and the only way for me to get this working was to tag on a GUID in my query string. Something like:

downloadUrl = url + “&guid=” + Guid.NewGuid()

This, of course is a hack which might work with most websites because they only pick out params they care about and ignore the rest. Watch out for some strict sites that check for a fixed number of params and I have nothing around that at the moment.

2. Fiddler with WP7

As part of troubleshooting my first problem, I tried to use Fiddler which will not track WP7 web requests out of the box, but can be made to do so with the following steps:

  1. Start Fiddler (ensure you have the latest version).
  2. Click Tools > Fiddler Options.
  3. Open the Connections tab and tick the Allow remote computers to connect box. Click OK.
  4. In the QuickExec box (shown in red) under the session list, type prefs set [HostName] where HostName is the name of your desktop computer.


   5. Close and restart Fiddler and the Windows Phone 7 Emulator.

Now you should  be able to track requests from the Emulator in Fiddler.

I referred to Eric’s blog post and the Phone 7 blog for this issue.

3. Application Icon and Splash Screen don’t show up in app
I replaced my ApplicationIcon.png and SplashScreenImage.jpg but was scratching my head when they did not show up at run-time. A little looking into showed that when I replaced the original files, I lost their Properties and these files need to marked as Content Resources, like this:


4. WP7 toolkit installation problems

I had a few headaches getting the toolkit to install, and it kept failing for some reason and I think they were related to not having VS Express (or whatever the free version is).
I don’t remember what I did exactly, but there are people who have workarounds and a few retries worked for me, for installing the XMA framework for example.

If you’re having an installation problem, look for the toolkit iso and shut down and even reboot and try again. If not, ask in the WP7 forum at and hopefully you will get some help.

5. Consider the LongListSelector control for nested lists

I had a situation whereby I had a kind-of master-detail view shown together where the master items are shown with their details items next to them, for eg.

Master 1
      detail 1.1
      detail 1.2

Master 2
     detail 2.1

Master 3
    detail 3.1
    detail 3.2
    detail 3.3
    detail 3.4

I started with nested Listboxes but then realized that the ItemsControl is also a possibility since I did not need Listbox behavior like selection of items, etc.
Think of ItemsControl as the insides of a ListBox.

But then scrolling became an issue because I wanted all items to be visible at once and not need to scroll the detail list for item 3 for example.

Fyi, you can make the ItemsControl scrollable by adding a View Template, like so:

<ItemsControl x:Name="myItems">
  <ControlTemplate TargetType="ItemsControl">
      <ScrollViewer VerticalScrollBarVisibility="Auto" Margin="0,0,0,0">
	<ItemsPresenter />
There are many nice posts about ItemsControl which you can look at to tweak and use them well.
Unfortunately, they couldn’t work easily for me, since I needed to autosize the nested details so that either 1 or 4 items could be shown without scrolling.
I say easily because I am sure sure some WPF gurus can do almost anything with ListBoxes, but not me.
I am now working to adapt the LongListSelector control from the toolkit. It was mainly made for virtualizing the View and the data to give you a fast scrolling and grouped list.
The Contacts list on the phone is a good example of it.
So, if you want to use nested lists and want the children to autosize, etc., look at the LongListSelector sample in the toolkit.
This mini-series by WindowsPhoneGeek helped me understand it better.

6. Re-entrancy problems are possible with MVVM Light
I am using the MVVM Light framework which is quite handy for locating ViewModels, but you also need to be careful about manipulating collections while in a loop.
This is more an issue of bad implementation than the framework itself, but iterating over static ViewModel is enticing and a common mistake and should be done with caution.
If you change any item in the List will throw an Exception. I forget now exactly, but I think I was getting a NullReferenceException.
So, my advice while manipulating a ViewModel List, is to create a new List and iterate over the static ViewModel List and copy it’s contents and then set the ViewModel list to your new local List.
Hope these points saved some of your time…

Since everyone (including me) and their mother is now dabbling in WP7 development, I thought I’d write about some of it and share my experiences with the community.

Before getting into dev details, let’s start with the setup and getting off the ground.

The page to access the wormhole is at:
It has a link to download the (free) tools you’ll need.


Please go ahead and install the various components required; I’ll wait.
The pieces include the VS extensions which installs the various phone app templates, the WP7 emulator that lets you run and test apps without a real phone in hand, etc.

We are now ready to write our first app.
Note that we are going to explore Silverlight apps and not XNA apps. These run on a managed Silverlight layer on the phone, as opposed to an XNA platform that conceptually treats the device like a console where you can manipulate each pixel.

Open VS and select New Project –> Silverlight for Windows Phone – Windows Phone Application (the first item), as shown below.


Give it a name and location and you will be faced with the Mainpage.xaml


If you just want to run the project and hit F5, you will get a compile error stating that “Zune software is not installed. Install the latest version of Zune software.”


This happens because the output is set to a device, and you can change it to go to the Emulator by changing the dropdown selection next to the Play button to Windows Phone Emulator.


Hitting F5 now, loads the Emulator and shows the app in it.

To end debugging, the instinctual way is to close the Emulator. But I like to keep the Emulator running in order to save time in further debugging sessions.
Hit the Back <- button at the bottom of the Emulator or go to VS and hit Stop to exit from Play mode.

So, now you have a very basic Phone app running in Visual Studio. That’s all for now. More to come in future posts…


Get every new post delivered to your Inbox.