Let’s be honest. You were probably writing all this content in an effort to look great in the eyes of search engines and so people will link to it to build your page rank. Now you have another target; to make content that people will want to share and tweet about.

The best way to share your awesome content is to make it easy for your visitors to do it for you. In my previous post, I highlighted how Facebook plugins can bring your wall to your site and how visitors can “like” from your site, letting all their friends know that they have visited your site and liked it. While you are inserting those plugins on your site, you would also want to include the Tweet button.

With this button, visitors can click on it to tweet about your content as they are on your page. The visitor will also be recommended to follow your Twitter account since they have tweeted about it.

Get your code to install the Tweet Button here.

You will have some options around the style of the button and the text in the tweet and the option to recommend a second account to the tweeter.

This is definitely another good, simple and free feature that your brand can use to spread your content around to more people. Start to help your business realise the value in social network marketing by making use of these simple features.

You can add a plugin on your website linking to your Facebook page and bringing key Facebook functions to your website. There are a range of plugins available that will display feeds from your Facebook page on your website. This is a good way to promote your site and also gain “likes” from people who would otherwise just visit your site.

Check the Facebook Developers section for the types of plugins ready for you to install.

I recommend using the Like Button on every page of your site:

This will create a story that the visitor likes the page that this is on, shared to their friends when clicked. It will also create a link on the person’s Facebook profile going to your page that was liked. The benefit from a marketing perspective is that some people in this person’s network may also be interested in your site and can reach it easily from Facebook. Think of it as the new version of “word-of-mouth”.

You can get the code to install the like button here. Adding it to the footer of your site is probably the best option so it can get onto every page.

Another plugin that I recommend is the Like Box:

This shows the most recent posts on your wall and some of the people who already like your Facebook profile. Visitors can like you on Facebook without having to visit your profile and add themselves as on of your fans directly from your site. Use this plugin if your Facebook page is actually active and if you have a decent number of likes, otherwise it would just be embarrassing.

This plugin is best installed as part of your homepage. You can get the code to install the Like Box here. You will need your profile number which is in the URL string of your Facebook profile. The width and number of pictures of connections can be adjusted within the code to fit into your page.

In most cases you will only need the iframe code.

Ensure that every visitor has the opportunity to connect with your brand. These social plugins are a must have for the connected organisation that is open to interacting with its fans.

If you are a user of foursquare then you are already using what is essentially a location-based tagging application.

Places is rolling out in the US before anywhere else so until further notice we will just have to continue typing in where we are.

Read more about it at Facebook Places.

You need to know that Google has made the move to ensure the AdWords reporting by agencies clearly breaks down the client’s spend on AdWords and therefore, your spend on the agency.

Some agencies or third-parties are known to bundle the cost of AdWords clicks and their agency service fees together. This way, there would be no way for the client to know how much their ads are actually costing them per month or per day or even per click and how much the agency is taking.

At minimum, agencies must provide a monthly summary on AdWords clicks, impressions and cost for the whole account. Even this is very top level, but it could be enough to expose the dealings of some third-parties.

If you are using the services of an agency for AdWords, your bill should break down the cost of the actual AdWords (the amount that is paid to Google) and the agency’s service fees. Check that the amount you want to spend on ads is actually going to the clicks.

This is a welcomed policy change to help ensure advertisers continue to have full transparency into what is the most accountable advertising channel available.

You can read about the changes at Google AdWords Help.

In fact, you can bind an application bar directly to the page via your View Model!

<phoneNavigation:PhoneApplicationPage
    x:Class="AlphaJax.Phone.HistoryPage"

    SupportedOrientations="Portrait"
    ApplicationBar="{Binding DefaultAppBar}"

In our case, we have a DefaultAppBar defined as a dependency property on our ViewModelBase for binding the Application Bar to the View. We then create the Application Bar programmatically  when the View Model is constructed, see the example below:

  public ViewModelBase()
        {
            SetUpDefaultAppBar();
        }

        private void SetUpDefaultAppBar()
        {
            var appBar = new ApplicationBar();

            appBar.IsVisible = true;
            appBar.IsMenuEnabled = true;
            appBar.Opacity = 1;
            appBar.ForegroundColor = Color.FromArgb(255, 255, 255, 255);
            appBar.BackgroundColor = Color.FromArgb(255, 0, 0, 0);

            ApplicationBarIconButton turns = new ApplicationBarIconButton(new Uri("Resources/Images/AppBar/button-turns.png", UriKind.Relative))
            turns.Text = "Turns";
            turns.Click += new EventHandler(turns_Click); // handle event within view model

            ApplicationBarMenuItem accountSettings = new ApplicationBarMenuItem("account settings");
            accountSettings.Click += new EventHandler(accountSettings_Click);  // handle event within view model

            ApplicationBarMenuItem appSettings = new ApplicationBarMenuItem("app settings");
            appSettings.Click += new EventHandler(appSettings_Click);  // handle event within view model

            appBar.Buttons.Add(turns);
            appBar.Buttons.Add(create);
            appBar.Buttons.Add(history);
            appBar.MenuItems.Add(accountSettings);
            appBar.MenuItems.Add(appSettings);

            this.DefaultAppBar = appBar;
        }

        public ApplicationBar DefaultAppBar
        {
            get
            {
                return _defaultAppBar;
            }
            set
            {
                _defaultAppBar = value;
                RaisePropertyChanged(() => DefaultAppBar);
            }
        }

Disclaimer: It’s possible you may experience a bug (at least in the beta) with the rendering of the page as it redraws to include the application bar binding . This is unfortunate but can be remedied if you manually assign the Application bar in the constructor of the page’s code behind.

this.ApplicationBar = ((ViewModelBase)this.DataContext).DefaultAppBar;

If you need view model specific application bars you can simply add these to other view models, but i would imagine most applications with multiple xaml pages will benefit from the above approach which eliminates the need to copy and paste xaml and cs around your application.

This post will get you started with being able to set up navigation between pages within your Windows Phone 7 (WP7) application using the core messaging framework provided by MVVM Light.

Read our Windows Phone 7 — MVVM Light and Unit Testing Example to understand a little more about MVVM Light if you are not familiar with the framework. Also check out our Windows Phone 7 — MVVM Light Messaging and Dynamic Application Bar post for another messaging example.

System Requirements

I’ve checked every thing against the latest public beta release of the devel oper tools (as of 15/07/2010) from http://developer.windowsphone.com. Please make sure you have this installed. I’m using Visual Studio 2010, but it all should work ok with Visual Studio Express 2010 that comes with the developer tools.

Navigation as a View related concern

Within your View Model you often reach points where you want to instigate a navigation to another page within your application. A primary urge is to simply perform the navigation within the view model. However, as page navigation is a View related concern, it is better handled at that end where there is an active navigation context rather than within the View Model.

Send a message from the View Model

Put this code in your ViewModelBase class to ensure you have an easy way to send out a request for a navigation change using the MVVM Light Messaging framework.

         protected void SendNavigationRequestMessage(Uri uri)
        {
            Messenger.Default.Send<Uri>(uri, "NavigationRequest");
        }

Then in your xaml page code behind (or your own custom base PhoneApplicationPage class) you can place a single line of code to perform the navigation request

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

Conclusion

Using a messaging approach like that provided with MVVM Light helps keep your WP7 application loosely coupled. The View can remain focussed on view specific concerns and can interact with your View Model indirectly using messaging to avoid hard wiring the two together unnecessarily. For a quick and easy solution to navigation within your application, this can work well.

You can easily bind your application bar to your page via the View Model meaning that you can handle all of this login within your view Model. This post is still valid in that it demonstrates a means of using MVVM light messaging, but there is a better way now to have dynamic application bars.

Introduction

This post will get you started with being able to dynamically update the application bar within your Windows Phone 7 (WP7) application using the core messaging framework provided by MVVM Light.

Read our MVVM Light and Unit Testing Example to understand a little more about MVVM Light if you are not familiar with the framework.

System Requirements

I’ve checked every thing against the latest public beta release of the devel oper tools (as of 15/07/2010) from http://developer.windowsphone.com. Please make sure you have this installed. I’m using Visual Studio 2010, but it all should work ok with Visual Studio Express 2010 that comes with the developer tools.

Application Bar Limitations

It has to be said that the application bar in Windows Phone 7 (WP7) is a strange beast. It does not derive from Control and therefore does not support binding. Laurent Bugnion has covered these deficiencies and it essentially means we have to define an application bar within our xaml pages, and resort to hard wiring event handlers into our code behind files.

This isn’t too bad, until we get to wanting to make things dynamic based user interaction with the page the menu is sitting on. In our example below, see the second button which has default text of ‘Pass’ and an IconUri set to the pass icon.

In our app, we want to trap user interaction such that when a particular condition occurs in the view model we want the icon to change out to say ‘Play’ and have a different icon.

    <phoneNavigation:PhoneApplicationPage.ApplicationBar>
        <shell:ApplicationBar x:Name="AppBar" IsVisible="True" IsMenuEnabled="True" Opacity="1" ForegroundColor="White" BackgroundColor="Black">
            <shell:ApplicationBar.Buttons>
                <shell:ApplicationBarIconButton x:Name="recall" Click="recall_Click" IconUri="/Resources/Images/AppBar/button-recall.png" Text="Recall">
                </shell:ApplicationBarIconButton>
                <shell:ApplicationBarIconButton x:Name="passPlay" Click="passPlay_Click" IconUri="/Resources/Images/AppBar/button-pass.png" Text="Pass">
                </shell:ApplicationBarIconButton>
                <shell:ApplicationBarIconButton x:Name="swap" IconUri="/Resources/Images/AppBar/button-swap.png" Text="Swap">
                </shell:ApplicationBarIconButton>
                <shell:ApplicationBarIconButton x:Name="chat" IconUri="/Resources/Images/AppBar/button-chat.png" Click="chat_Click" Text="Chat">
                </shell:ApplicationBarIconButton>
            </shell:ApplicationBar.Buttons>
        </shell:ApplicationBar>
    </phoneNavigation:PhoneApplicationPage.ApplicationBar>

There are a number of ways you could resolve this. You could create and hook off an event in your View Model from within your view’s code behind, or if you have an existing Dependency Property on your View Model you could hook off it’s PropertyChanged event. However, a simpler and more loosely coupled approach is to use the messaging framework within MVVM Light.

Just add this single line of code to your View Model when you want to announce something to your app. The magic string is a unique token to identify the message, and you can send anything you want. In our case we are sending a message when the hasBoardThinkingTiles property has updated within the view model.

Messenger.Default.Send<bool>(hasBoardThinkingTiles), "HasBoardThinkingTiles");

You can then register to receive this message from within the constructor of your View’s code behind with a single line of code and pass off to a method for handling. You can see here that we are dynamically setting the text and icon uri depending upon the received message from the View Model.

It’s worth nothing that you cannot appear to reference Applicaiton Bar buttons by their x:Name directly like other controls you must find the button using the ApplicationBar.Buttons[x] collection directly.

        public GamePage()
        {
            InitializeComponent();
            Messenger.Default.Register<bool>(this, "HasBoardThinkingTiles", HasBoardThinkingTilesChanged);
        }

        void HasBoardThinkingTilesChanged(bool hasBoardThinkingTiles)
        {
            var passPlay = ApplicationBar.Buttons[1] as ApplicationBarIconButton;
            if (hasBoardThinkingTiles)
            {
                passPlay.Text = "Play";
                passPlay.IconUri = new Uri("/Resources/Images/AppBar/button-play.png", UriKind.Relative);
            }
            else
            {
                passPlay.Text = "Pass";
                passPlay.IconUri = new Uri("/Resources/Images/AppBar/button-pass.png", UriKind.Relative);
            }
        }

Conclusion

Using a messaging approach like that provided with MVVM Light helps keep your WP7 application loosely coupled. The View can remain focussed on view specific concerns and can interact with your View Model indirectly using messaging to avoid hard wiring the two together unnecessarily.

I tried to hop around the talks to a variety of topics some of direct interest to my role in Marker and some quite new or challenging. First talk of the day was given by Peter McLennan. He was talking about his passion for designing and collecting Vinyl covers. This was a great way to ease myself into the day as within my comfort zone of anything designy or arty and I found the way he chose to group designs interesting some by designers, some by labels, some by genres and so on as each grouping showed ways that trends occurred and a hidden label language was created.

Next up was by the young name behind the event Ludwig Wendzich (I figured it would be plain rude not to see the founder speak atleast once). He talked about the way you can rethink the UI experience of sites for topics like magazines using the new movement recognising technology. How using this natural motion that is directly connected to what is seen on screen is more instinctual than the third party use of a keyboard or mouse driven command. I especially liked the idea of this type of technique making the web more accessible for the really young or old, eradicating the old analogy of the remote control being too fiddly/small/complicated debate.

Adbreak here, I have to say the food alone is reason to come as we had everything from healthy fruit to scones with cream and jam, carrot cake, M&Ms and brownies to lasagna and salad. I have to say the best spread at a conference I have ever eaten — beats the bain-marie slop often had at the hotel based ones. The t-shirts were also a great design and very wearable once you upped your size x 2 as the fit was extremely small for the ladies.

Then I enjoyed some healthy debate about the future of Digital TV in NZ with Steven Ellis at the helm.

Usability was next on the cards from a one month kiwi Haunani Pao (A new inductee from San Fran) whose breakdown on what and why we have this thing called usability provided me with lots of great ways to help sell the benefits to clients. Particularly liked her picture representation of why with the beautiful red jug that although on the surface looked great due to the spout and handle being on the same side was rendered useless.

Then hands down my favourite discussion of the day from Mike Dickison who presented from his academic point of view what the roadblocks to getting Wikipedia into mainstream use in Universities were and his ideas on ways to rid them. I loved his suggestion of replacing or supplementing the essay form of testing to making the students actually publish their research as a wiki page and leave it open for public debate as opposed to the one person critique of the lecturer. I also appreciated his emphasizing the need for a mind-shift from research only to more focus on critique of the said research sources.

Then we landed in the world of Science Fiction for an analysis of leadership in today’s working environments. Corporate being similar to Star Trek, Independent to Doctor Who and Start-up to Firefly. It was a fabulous way to make concepts which are sometimes quite abstract really tangible. Can’t wait to read the book once its out.

My last talk for the day was by my colleague Darren Wood who I love to hear speak as his passion for his craft is always so evident in his presentations and the reduction of code and new way of adopting the flexibility of new working styles in HTML5 was really interesting I appreciated the fact that even at code level they had recognised the need for people to show their individual flair. He was partnered by Matthew Buchanan who I am also a bit of a fan of via his blog as he has a knack for hunting out great design on the web. His brief demo on the possibilities for rendering what was once image based only solutions now being done with CSS was simultaneously exciting and scary as can see the ever faster shift to the blurring of art and science and wonder when the science will become too hard for the artist to use and as such render them handicapped and the world of the web into many an un-designy hand. I am a fan of the pretty picture after all.

Overall I was really impressed by the entire day and will be back if I can secure a spot next year.

This post assumes you are doing or have done some Windows Presentation Foundation (WPF), Silverlight (SL) or Windows Phone 7 (WP7) development in the past and are eager to get some unit testing going in your WP7 applications.

It should get you started with setting up a solution structure which supports WP7 unit testing and full source code (including all referenced 3rd party libraries) is supplied at the end of the article. The core purpose is to demonstrate core testability via separation of the view model from the view.

System Requirements

I’ve checked everything against the latest public beta release of the developer tools (as of 15/07/2010) from http://developer.windowsphone.com. Please make sure you have this installed. I’m using Visual Studio 2010, but it all should work ok with Visual Studio Express 2010 that comes with the developer tools installation.

Choosing an MVVM Framework

MVVM (Model-View-ViewModel) is an architectural pattern well described by Josh Smith in his MVVM MSDN Article. When you use MVVM in your WP7 application, it becomes more suited to automated unit testing. Testability of WP7 applications relies on a clean separation between the various layers of our WP7 application, particularly between the View (the .xaml UI construct) and the ViewModel (the .cs class that is usually set as the DataContext of the View).

There are some great MVVM frameworks out there for Silverlight including Prism combined with the Managed Extensibility Framework (now part of .net 4 and Silverlight 4). However, WP7 is relatively new and these more ‘full on’ practices and frameworks are not yet usable within WP7 which is largely based on SL3 (with a bit of SL4 sprinkled in).

For WP7 I’ve opted for MVVM light as it appears to me to deliver the best ‘bang for buck’. It’s easy to set up and gives you the core separation of concerns between view and model in a nice simple way. It provides…

• A base class for your View Model classes called ‘ViewModelBase’
• A commanding framework to bind UI events to the ViewModel directly in xaml (no code behind event handlers)
• A messaging framework to decouple View Models
• Various snippets, project and item templates for Visual Studio

This post makes use of the ViewModelBase class and the commanding framework to abstract out event handling. There is a commanding framework in SL4, but this is not available within WP7 (being based largely on SL3). MVVM Light therefore comes in particularly handy here.

I’m not using the messaging framework in this example or delving into other related topics like service location/dependency injection of view models to keep things simple. You can naturally extend things to support these features once you have got the core separation in place.

Choosing a Unit Testing Framework

A quick search brought me to Jeff Wilcox’s blog on this and his out of band release of the Silverlight Unit Testing Framework for Windows Phone 7 (WP7) which can be found here http://www.jeff.wilcox.name/2010/05/sl3-utf-bits/. I believe this is your only option at this stage, and I would imagine this will be formalised in some way as the official WP7 unit testing framework in due course.

Solution Structure

Windows Phone 7 Testing — Solution Structure

We have 2 projects in our WP7UnitTestSample solution, Sample.Phone and Sample.Phone.Tests. The Sample.Phone is the main WP7 application that you would be deploying to end users. The WP7.Phone.Tests is another WP7 application which you will run simply to test out your application.

The WP7 Core Application Project

This project is pretty simple, we have a MainPage.xaml which shows a text box, a button and text block to display results of clicking that button and submitting the text. The core xaml of the page is shown below.

 <Grid x:Name="LayoutRoot">
        <StackPanel Orientation="Vertical" HorizontalAlignment="Left" VerticalAlignment="Top" >
            <TextBlock Text="Test Text (6-15 chars valid)" />
            <TextBox Width="300" MaxLength="20" x:Name="TestText" Height="49" Text="{Binding TestText, Mode=TwoWay}" FontSize="12" />
            <Button x:Name="TestTextSubmit" Content="Send Test Text" Width="300">
                <i:Interaction.Triggers>
                    <i:EventTrigger EventName="Click">
                        <cmd:EventToCommand Command="{Binding TestTextButtonClick}"/>
                    </i:EventTrigger>
                </i:Interaction.Triggers>
            </Button>
            <!-- result here-->
            <TextBlock x:Name="Result" Text="{Binding StatusCode, Mode=TwoWay}" Height="80" Width="300" />
        </StackPanel>
    </Grid>

The View Model is defined as an application resource within App.Xaml, and referenced as a StaticResource in the MainPage.xaml as the DataContext of MainPage.xaml. (You can use the ViewModelLocator approach within the MVVM Light framework to avoid hard wiring, but not really necessary for apps where you don’t need this flexibility).

DataContext="{StaticResource MainPageViewModel}"

And here’s how you add a View Model as an application resource:

<Application.Resources>
<viewModels:MainPageViewModel x:Key="MainPageViewModel" />
</Application.Resources>

Note that there is nothing added to the code behind MainPage.xaml.cs. Having empty code behinds isn’t really a goal in itself (although it can be a rather satisfying pursuit if you’re so inclined), however you should ensure that any non View specific code is placed away from your View’s code behind as much as possible so it can be easily tested.

In this example we have two way data binding from the text box which contains the text to be submitted and also the text block  which will show the results of the submission. So far so normal. The MVVM Light framework (specifically EventToCommand) is then used to link the button click to the ViewModel by way of a bound command rather than a strongly coupled link to an event handler within the code behind of the MainPage.xaml.

Let’s take a look at the MainPageViewModel.cs class which can be found in the ViewModels folder of the core Sample.Phone project.

    public class MainPageViewModel : ViewModelBase
    {
        private string _statusCode = String.Empty;
        private string _testText = String.Empty;

        public MainPageViewModel()
        { }

        public string StatusCode
        {
            get
            {
                return _statusCode;
            }
            set
            {
                _statusCode = value;
                RaisePropertyChanged("StatusCode");
            }
        }

        public string TestText
        {
            get
            {
                return _testText;
            }
            set
            {
                _testText = value;
                RaisePropertyChanged("TestText");
            }
        }

        public ICommand TestTextButtonClick
        {
            get
            {
                return new RelayCommand(() => ProcessTestText(), () => ProcessTestText_CanExecute());
            }
        }

        public void ProcessTestText()
        {
            this.StatusCode = "SUCCESS";
        }

        public bool ProcessTestText_CanExecute()
        {
            if (String.IsNullOrEmpty(this.TestText) || this.TestText.Length < 6 || this.TestText.Length > 15)
            {
                this.StatusCode = "FAILURE - Invalid test text!";
                return false;
            }
            return true;
        }

    }

Firstly, notice how we have the 2 dependency properties TestText and StatusCode to support the databinding to the xaml UI elements. Secondly we have an ICommand bound to the TestTextButtonClick EventToCommand which returns a RelayCommand.

This is an interesting one because when this is fired, it will do 2 things. It will first of all call ProcessTestText_CanExecute() which is essentially how you validate whether or not the event can proceed. Notice how we abstract out the business logic of validating the UI here away from the View. We’re just setting the StatusCode text so that the failure of the user to enter a valid TestText value is then reflected back to the user.

Assuming this method returns true then ProcessTestText() is called which allows to process the data submitted by the user. In this case we just write out a success value which will then be reflected back in the view to let the user know everything is ok.

The idea here is that your ViewModel could be going to a web service, database etc. and your View wouldn’t care. We have completely separated the ViewModel from the View and only have a single line of code linking the two (the initial setting of the DataContext).

All well and good. Now, onto our view model tests.

The WP7 Test Application Project

Open up the Sample.Phone.Tests project and upon opening MainPage.xaml.cs you will see the following code in the constructor. This is all it takes to set up the WP7 app to run the tests found within the project.

            // set up unit testing
            Content = UnitTestSystem.CreateTestPage();
            IMobileTestPage imtp = Content as IMobileTestPage;

            if (imtp != null)
            {
                BackKeyPress += (x, xe) => xe.Cancel = imtp.NavigateBack();
            }

We have a single test class in the ViewModels folder which is MainPageViewModelTests.cs. If you take a look at this you will see that there are various test methods testing one of our View Model classes within the main Sample.Phone application.

  [TestMethod]
        public void Constructor_InstantiatesSuccessfully()
        {
            var sut = new MainPageViewModel();
            Assert.IsNotNull(sut);
        }

        [TestMethod]
        public void TestTextButtonClick_CanExecute_ShortTestText_Failure()
        {
            var sut = new MainPageViewModel();
            sut.TestText = "short";
            Assert.IsFalse(sut.TestTextButtonClick.CanExecute(null));
        }

        [TestMethod]
        public void TestTextButtonClick_CanExecute_LongTestText_Failure()
        {
            var sut = new MainPageViewModel();
            sut.TestText = "farfarfarfartoolong";
            Assert.IsFalse(sut.TestTextButtonClick.CanExecute(null));
        }

        [TestMethod]
        public void TestTextButtonClick_CanExecute_Success()
        {
            var sut = new MainPageViewModel();
            sut.TestText = "just right";
            Assert.IsTrue(sut.TestTextButtonClick.CanExecute(null));
        }

        [TestMethod]
        [Asynchronous]
        public void TestTextButtonClick_TestText_PropertyChange_Success()
        {
            bool success = false;
            var sut = new MainPageViewModel();
            sut.PropertyChanged += (sender, e) =>
                {
                    if (e.PropertyName == "TestText")
                    {
                        success = sut.TestText == "changing";
                    }
                };

            sut.TestText = "changing";
            Assert.IsTrue(success);
           EnqueueTestComplete();
        }

The Silverlight Unit Testing Framework is based on the standard Visual Studio Unit Testing so if you have used this you will be familiar with the annotations. As you can see we are able to test instantiation of the MainPageViewModel along with various failure and success paths.

One thing I really want to highlight is the availability of the [Asynchronous] attribute which is important because a lot of the time your ViewModel may be calling out (either directly or via some other layer) to a web service and all service calls must be asynchronous in WP7 (being based mostly as it is on SL3).

In this example we are keeping things simple and testing that the TestText property has changed correctly by hooking off the PropertyChanged event of that Dependency Property. Notice that you call EnqueueTestComplete() when your happy for the test to end.

To run the tests, ensure that Sample.Phone.Tests is set as the startup project in Visual Studio and hit CTRL+F5. You should then see that all tests are passing with the following screen:

Windows Phone 7 All Tests Passing

Conclusion

With a little bit of effort you can ensure that you have basic clean separation between your View and View Model layers in WP7. From this, you can easily test your View Model operations from a test project that will give you more complete confidence in the correct behaviour of your application.

More Reading

I highly recommend getting Josh Smith’s book on MVVM.

Shawn Wildermuth’s article on MVVM on MSDN is also worth a read

Download

Windows Phone 7 — MVVM Light and Unit Testing Sample