Posts tagged ViewModel

In all my previous MVVM in Silverlight 4 posts i was avoiding to address one painful aspect of the Silverlight: calling WCF Web Services.

And it was not without reason. Lets face it, consuming WCF Web Services from your Silverlight application can be pretty hard.

I mean hard to do it in a clean way off course.

Yes we all know how to create a Silverlight enabled WCF Web Service from Visual Studio but things become messy from that point.

First question is how to invoke methods of the web service?

Should we use Add Web Service Reference from the Visual Studio and and get the service proxy generated for us by the IDE?

If you go down that route, its easy to start and you will be invoking web service methods asynchronously in no time, but you will pay the price for that simplicity later, that is for sure.

Next problem is how to Unit Test those web service calls – its impossible to abstract the generated proxy in a clean way.

Then if you change your Web Service signature, you have to rebuild your Proxy. This can be troublesome especially if more than one person is working on the same project (can be avoided using build scripts to rebuild proxy automatically during compilation but still i don’t like that).

Also invoking web service methods asynchronously is tedious work in terms of writing the same code over and over again.

You have to subscribe to the OnCompleted event, and then invoke the actual asynchronous method, and then when your OnComplete handler is invoked, you can process the results of the web service method.

Not to mention the lifetime of the generated proxy, and handling exceptions that could be thrown in the service etc.

So as we see Visual Studio (or command line) proxy generating helps us in many ways but also brings new problems that are hard to solve.

I figured that there has to be a better way to solve this everyday problem so while working on my personal MVVM framework (yes, everyone is building one these days) i was setting these goals regarding the Web Service calls from my MVVM applications:

1. simplify as much as possible asynchronous invocation of Web Service methods (avoid writing boring boilerplate code for each call)
2. get rid of the Add Service Reference approach completely if possible
3. make the Web Services unit testable (hide them behind some interface so we can mock them in our unit tests)
4. simplify exception handling
5. fault tolerance (if web service client is faulted by exception it should be automatically recreated)

If this list of features looks interesting to you then you will soon see that all this is possible in a simple way by using ChannelFactory<T> and creating the Web Service client channel for the web service manually.

So lets start: In our example we will be using a fake WeatherForecast web service that will have just one method GetForecast and it will accept DateTime as parameter and return a simple class DailyForecast as a result that will have some fake data just to have something to work with.

First of all we need to create a service contract interface for WeatherForecastWebService and since we must allow the Silverlight client to call this web service asynchronously we will add conditional compilation code regions in the interface with additional asynchronous signatures for the GetForecast method (BeginGetForecast and EndGetForecast) like this:

namespace Abstractions
{
    [ServiceContract]
    public interface IWeatherForecastService
    {

#if SILVERLIGHT
        [OperationContract(AsyncPattern=true)]
        IAsyncResult BeginGetForecast(DateTime day, AsyncCallback callback, object state);
        DailyForecast EndGetForecast(IAsyncResult result);
#else

        [OperationContract]
        DailyForecast GetForecast(DateTime day);
#endif
    }
}

and here is the DailyForecast Data Transfer Object (DTO) class that we will receive from the web service:

namespace Abstractions
{
    [DataContract]
    public class DailyForecast
    {
        [DataMember]
        public DateTime Date { get; set; }

        [DataMember]
        public string Description { get; set; }
    }
}

Note the DataContract and DataMember attributes, they must be provided in order to receive the class on the client properly.

Since we are to consume the web service on the Silverlight client we must make available all the classes to the client side.

Here is how we are going to accomplish this: We must define service contract interface and all the classes that the service will return both on server and on the Silverlight client. We will do that by creating a Abstractions.Web class library project that will hold the service contract interface IWeatherForecastService all the needed Data Transfer Object classes (in this example its just DailyForecast class), and then we will also create Abstractions.Silverlight - Silverlight class library project where we will add the same classes (DTO’s and service contract interface) as links – by going to to right click menu on the project and choose Add -> Existing Item and add all needed files and click on Add As Link button instead of Add button.

here is how this setup looks in my Visual Studio instance: So now that we have same set of shared classes on client and on the server we can proceed with creating a web service helper class that will allow us to invoke asynchronous methods in a simple way without having to do lot of boilerplate code. As we said we want to be able to mock that helper in our Unit Tests we need to have an interface for it so lets define that first:

namespace Framework.Abstractions.Silverlight.WebServices
{
    public interface IWebServiceClientFactory<TWebService> :  IDisposable
    {
        TWebService WebServiceInstance
        {
            get;
        }

        void Invoke<TParam, TResult>(TParam param, object state,
                                     Func<TParam, AsyncCallback, object, IAsyncResult> beginOp,
                                     Func<IAsyncResult, TResult> endOp,
                                     Action<AsyncWebServiceCallResult<TResult>> onComplete);

    }
}

As you can see we are defining the WebServiceClientFactory of TWebService that will expose a web service client instance WebServiceInstance if we want to call it directly but more important will be the generic Invoke method for generic asynchronous calls that will allow to call any method on any web service in a simple way just by specifying the parameter, then the begin and end method we want to calla and a method that should be called with the received results when web service call is finished.

Our helper class will also implement IDisposable so we can cleanup properly.

Let us investigate the Invoke method. From its signature we see that it is a generic function and that it has two type parameters, TParam that is the type of the parameter sent to our web service when we invoke the web method, and TResult that is the type of the result we expect from the method.

Then there is a object state that we want to send to the web service method (we can pass NULL there if we don’t need it).

And then comes the fun part: Parameter beginOp is a BEGIN* method that will be invoked, and parameter endOp is the END* method that will be invoked for the web service call. In our case we will supply here BeginGetForecast and EndGetForecast methods using the WebServiceInstance property of the same factory class. But its important to note here that if our web service would have other methods that support asynchronous invoking with these BEGIN* and END* signatures, we could call them in same way, just passing another pair of Begin* and End* methods.

Last parameters is an Action> that will be called when the web method call is finished. This action will receive the instance of custom generic class AsyncWebServiceCallResult whose type parameter is the DailyForecast – result we would normally expect from the web method. So here is the definition of generic AsyncWebServiceCallResult class:

namespace Framework.Abstractions.Silverlight.WebServices
{
    public class AsyncWebServiceCallResult<TResult>
    {
        public TResult Result { get; set; }
        public bool WasSuccessfull { get; set;}
        public Exception Exception { get; set; }
    }
}

So this class is just a wrapper around the TResult we would usually receive from the web service method call and it adds just two more properties: boolean WasSuccessfull and Exception. If web method call is executed without problems WasSuccessfull is set to true and Exception is null, and on the other hand if there is some exception thrown during the invocation of the web service method call Exception will hold the Exception thrown and WasSuccessfull will be set to false.

So lets see how we would use this Web Service factory to call our WeatherForecastService:

var weatherServiceFactory = SimpleServiceLocator.Instance.Retrieve<IWebServiceClientFactory<IWeatherForecastService>>();
weatherServiceFactory.Invoke(date, null,
                                          weatherServiceFactory.WebServiceInstance.BeginGetForecast,
                                          weatherServiceFactory.WebServiceInstance.EndGetForecast,
                                          this.OnResultReceived);

And the method that will be called when results is received would look like this:

        private void OnResultReceived(AsyncWebServiceCallResult<DailyForecast> asyncResult)
        {
            if (asyncResult.WasSuccessfull)
            {
                this.StatusMessage = "New forecast received ok.";
                this.ForecastThatWasReceived = asyncResult.Result;

            }
            else
            {
                this.ForecastThatWasReceived = null;
                this.StatusMessage = "Error result received: Error description: " + asyncResult.Exception.Message;
            }
        }

And you can use this generic helper class to create wrapper around ANY web service exposed to your Silverlight application.

You just instantiate this class giving it the contract interface of the desired web service and URL of the web service.

WebServiceClientFactory will do all the plumbing for you and create ChannelFactory and web service client and expose it in WebServiceInstance property.

Then you can use Invoke method of the class to call ANY web service method with single line of code (you need on complete action to receive the result but you cannot avoid that – its asynchronous call after all).

Usable? 

So now that you have seen how we would use the interface of our web service factory, lets see how its really implemented:

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.Windows;
using Framework.Abstractions.Silverlight.WebServices;
using System.Linq.Expressions;

namespace Framework.Implementors.Silverlight.WebServices
{
    public class WebServiceClientFactory<TWebService> : IWebServiceClientFactory<TWebService> where  TWebService : class
    {
        private CustomBinding binding;
        private readonly string endpointAddress;
        private ChannelFactory<TWebService> channelFactory;

        public WebServiceClientFactory(CustomBinding binding, string endpointAddress)
        {
            this.binding = binding;
            this.endpointAddress = endpointAddress;
        }

        public WebServiceClientFactory(string endpointAddress)
        {
            this.endpointAddress = endpointAddress;
        }

        public TWebService WebServiceInstance
        {
            get
            {
                if (this.channelFactory == null || this.channel == null)
                {
                    this.InitializeWeatherServiceClient();
                }

                return this.channel;
            }

            private set
            {
                this.channel = value;
            }
        }
        private TWebService channel;

        private void InitializeWeatherServiceClient()
        {
            Debug.WriteLine("Initializing factory and channel in " + this.GetType().Name);
            if (this.binding == null)
            {
                var elements = new List<BindingElement>();
                elements.Add(new BinaryMessageEncodingBindingElement());
                elements.Add(new HttpTransportBindingElement());
                this.binding = new CustomBinding(elements);
            }

            channelFactory = new ChannelFactory<TWebService>(this.binding, new EndpointAddress(endpointAddress));
            channel = this.GetNewChannelFromCurrentFactory();
        }

        public void Invoke<TParam, TResult>(TParam param, object state, Func<TParam, AsyncCallback, object, IAsyncResult> beginOp, Func<IAsyncResult, TResult> endOp, Action<AsyncWebServiceCallResult<TResult>> onComplete)
        {
            beginOp(param, (ar) =>
                {
                    var asyncResult = new AsyncWebServiceCallResult<TResult>();
                    try
                    {
                        asyncResult.Result = endOp(ar);
                        asyncResult.WasSuccessfull = true;
                    }
                    catch (Exception e)
                    {
                        asyncResult.WasSuccessfull = false;
                        asyncResult.Exception = e;
                    }

                    if (Deployment.Current.Dispatcher.CheckAccess())
                    {
                        onComplete(asyncResult);
                    }
                    else
                    {
                        Deployment.Current.Dispatcher.BeginInvoke(() => onComplete(asyncResult));
                    }

                }, state );
        }

        private TWebService GetNewChannelFromCurrentFactory()
        {

            var newChannel = channelFactory.CreateChannel();

            var channelAsCommunicationObject = (newChannel as ICommunicationObject);
            if (channelAsCommunicationObject != null)
            {
                channelAsCommunicationObject.Faulted += ChannelFaulted;
            }

            return newChannel;
        }

        void ChannelFaulted(object sender, EventArgs e)
        {
            Debug.WriteLine("Service channel faulted in " + this.GetType().Name);
            var communicationObject = (this.channel as ICommunicationObject);
            if (communicationObject != null)
            {
                communicationObject.Abort();

                this.channel = this.GetNewChannelFromCurrentFactory();
            }
        }

        ~WebServiceClientFactory()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
        }

        protected void Dispose(bool disposing)
        {
            if (disposing)
            {
                // dispose managed stuff
                Debug.WriteLine("Disposing managed resources in " + this.GetType().Name);
                var communicationObject = (this.channel as ICommunicationObject);
                if (communicationObject != null)
                {
                    communicationObject.Faulted -= this.ChannelFaulted;

                    try
                    {
                        communicationObject.Close();
                    }
                    catch (Exception)
                    {
                        try
                        {
                            communicationObject.Abort();
                        }
                        catch
                        {
                        }
                    }
                }
            }

            // here we would dispose unmanaged stuff
        }

    }
}

Class has multiple constructors so you can choose how to set it up. The simplest usage is just to specify the string URL of the web service. Here is how i setup my IOC in the bootstrapper of my Silverlight application:

SimpleServiceLocator.Instance.RegisterAsSingleton<IWebServiceClientFactory<IWeatherForecastService>>
(new WebServiceClientFactory<IWeatherForecastService>("http://localhost:1000/WeatherForecastService.svc"));

When constucted like this factory class uses standard Binding that would be created for you if you would add the Web Service Reference from visual studio and it will use that Binding and that given URL as endpoint to create a generic ChannelFactory of the web service type provided in type param

<TWebService> and then it will create a communication channel to communicate with web service of given type on the given URL.

Here is the code that is doing this part:

        private void InitializeWeatherServiceClient()
        {
            Debug.WriteLine("Initializing factory and channel in " + this.GetType().Name);
            if (this.binding == null)
            {
                var elements = new List<BindingElement>();
                elements.Add(new BinaryMessageEncodingBindingElement());
                elements.Add(new HttpTransportBindingElement());
                this.binding = new CustomBinding(elements);
            }

            channelFactory = new ChannelFactory<TWebService>(this.binding, new EndpointAddress(endpointAddress));
            channel = this.GetNewChannelFromCurrentFactory();
        }

There is a another constructor that accepts Binding if you want to provide your own.
Next interesting part of the class is the Invoke method:

        public void Invoke<TParam, TResult>(TParam param, object state, Func<TParam, AsyncCallback, object, IAsyncResult> beginOp, Func<IAsyncResult, TResult> endOp, Action<AsyncWebServiceCallResult<TResult>> onComplete)
        {
            beginOp(param, (ar) =>
                {
                    var asyncResult = new AsyncWebServiceCallResult<TResult>();
                    try
                    {
                        asyncResult.Result = endOp(ar);
                        asyncResult.WasSuccessfull = true;
                    }
                    catch (Exception e)
                    {
                        asyncResult.WasSuccessfull = false;
                        asyncResult.Exception = e;
                    }

                    if (Deployment.Current.Dispatcher.CheckAccess())
                    {
                        onComplete(asyncResult);
                    }
                    else
                    {
                        Deployment.Current.Dispatcher.BeginInvoke(() => onComplete(asyncResult));
                    }

                }, state );
        }

As you can see no big deal there, we just invoke the BEGIN* operation with lambda method as complete handler where we wrap the call to END* operation in Try..Catch so we can recover from any exception.
If there was an exception we set WasSuccessfull to false and Exception property.
If all went ok we populate the Result property with the result of the web method call and then we invoke the onComplete action that was supplied by the user of the class.
But we make sure that we invoke it on the UI thread just as a convenience for the user so he does not need to do it by himself.

One more important thing is that if our web service channel gets faulted by some communication error we will catch that event and recreate the channel:

        void ChannelFaulted(object sender, EventArgs e)
        {
            Debug.WriteLine("Service channel faulted in " + this.GetType().Name);
            var communicationObject = (this.channel as ICommunicationObject);
            if (communicationObject != null)
            {
                communicationObject.Abort();

                this.channel = this.GetNewChannelFromCurrentFactory();
            }
        }

Previously, we subscribed that method to the OnFaulted event on the channel.

Other parts of the class are not too much interesting so you can dig yourself if you want.

So lets see how we would use the class in our view model.
Here is the listing of the ForecastViewModel that will allow us to invoke the WeatherForecast web service:

using System;
using Abstractions;
using Framework.Abstractions.Silverlight.Intefaces;
using Framework.Abstractions.Silverlight.WebServices;
using Framework.Implementors.Silverlight.Comanding;
using Framework.Implementors.Silverlight.MVVM;

namespace ViewModels
{
    public class ForecastViewModel : ViewModel
    {
        private readonly IWebServiceClientFactory<IWeatherForecastService> weatherServiceFactory;

        public ForecastViewModel(IWebServiceClientFactory<IWeatherForecastService> weatherServiceFactory)
        {
            this.weatherServiceFactory = weatherServiceFactory;

            this.GetForecastCommand =
                new DelegateCommand<DateTime>(
                    date =>
                    {
                        this.StatusMessage = string.Format("Invoking web service with parameter {0}", date.ToString());
                        this.weatherServiceFactory.Invoke(
date,
null,
this.weatherServiceFactory.WebServiceInstance.BeginGetForecast,

this.weatherServiceFactory.WebServiceInstance.EndGetForecast,

this.OnResultReceived);

                    });

        }

        private void OnResultReceived(AsyncWebServiceCallResult<DailyForecast> asyncResult)
        {
            if (asyncResult.WasSuccessfull)
            {
                this.StatusMessage = "New forecast received ok.";
                this.ForecastThatWasReceived = asyncResult.Result;

            }
            else
            {
                this.ForecastThatWasReceived = null;
                this.StatusMessage = "Error result received: Error description: " + asyncResult.Exception.Message;
            }
        }

        private IDelegateCommand getForecastCommand;

        public IDelegateCommand GetForecastCommand
        {
            get { return getForecastCommand; }
            set { getForecastCommand = value;
                this.OnPropertyChanged("GetForecastCommand");
            }
        }

        private DailyForecast forecastThatWasReceived;

        public DailyForecast ForecastThatWasReceived
        {
            get { return forecastThatWasReceived; }
            set { forecastThatWasReceived = value;
            this.OnPropertyChanged("ForecastThatWasReceived");
            }
        }

        public DateTime ValidForecastDate
        {
            get
            {
                return DateTime.Now;
            }
        }

        public DateTime BadForecastDate
        {
            get
            {
                return DateTime.MinValue;
            }
        }

        private string statusMessage;
        public string StatusMessage
        {
            get { return statusMessage; }
            set { statusMessage = value;
            this.OnPropertyChanged("StatusMessage");
            }
        }
    }
}

As you can see from the ForecastViewModel we have a command that’s invoking the web service called GetForecastCommand and we have a action method OnResultReceived that receives the result.

If the web service call fails we set the ForecastThatWasReceived to null and we set the StatusMessage to the Message of the Exception we received from server.

So here is our simple ForecastView:

<UserControl x:Class="Views.ForecastView"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    d:DesignHeight="300" d:DesignWidth="400" MinHeight="400" MinWidth="400">

    <Grid x:Name="LayoutRoot" Background="Red">

        <Grid.RowDefinitions>
            <RowDefinition></RowDefinition>
            <RowDefinition></RowDefinition>
            <RowDefinition></RowDefinition>
        </Grid.RowDefinitions>
        <StackPanel Orientation="Vertical" Grid.Row="0">
            <Button Content="Invoke valid web service call" Command="{Binding GetForecastCommand}" CommandParameter="{Binding ValidForecastDate}" HorizontalAlignment="Center" VerticalAlignment="Center" Margin="10" />

            <Button Content="Invoke web service call that throws exception on server" Command="{Binding GetForecastCommand}" CommandParameter="{Binding BadForecastDate}" HorizontalAlignment="Center" VerticalAlignment="Center" Margin="10" />

        </StackPanel>

        <Grid Grid.Row="1">
            <StackPanel Orientation="Vertical">
                <TextBlock Text="{Binding ForecastThatWasReceived.Date, StringFormat='Date: {0}', FallbackValue=' ?'}" />
                <TextBlock Text="{Binding ForecastThatWasReceived.Description, StringFormat='Description: {0}', FallbackValue=' ?'}" />

            </StackPanel>
        </Grid>

        <Grid Grid.Row="2">
            <TextBlock Text="{Binding StatusMessage}" TextWrapping="Wrap" />

        </Grid>

    </Grid>
</UserControl>

As you can see we have two buttons, each wired up to the same GetForecastCommand but with different parameters.
One is sending the current date to the server and other is using the BadForecastDate databound from ViewModel which is set to DateTime.Min. When web service receives any other date then DateTime.Min it returns valid instance of DailyForecast class and if it receives DateTime.Min it throws some bogus exception.
This is how we will test our WebServiceFactory class to see if it can handle the exceptions thrown on server side or not.

you can test the live sample application here.

So here is screenshot of the app (in case you dont have the Silverlight 4 runtime installed) when we invoke the web service with current date:

As you can see when we click on first button we receive the valid forecast and when we click the second one, we will receive the error but it will be catched and wrapped in our AsyncWebServiceCallResult class and our UI won’t hang and we will be able to recover from that error and immediately invoke the web service call again with different parameters.

Here is the same app when we invoke the web service method with invalid (min) date so it throws exception:

So this should help us handle the web service with greater ease right ?

But wait! We are not finished yet! Those of you that were paying attention noticed i promised a unit testable web services.

So lets do that also.

We will add another SIlverlight application to our sample code and set it up with Silverlight Unit Testing Framework.

Also we will reference all the needed projects – ViewModels, Abstractions.Silverlight, Framework.Abstractions and Framework.Implementors.

Also we need to make a fake WebServiceClientFactory and IWeatherService implementations so we can use them in our tests instead of the real implementations.

So lets do that first. here is the FakeWebServiceClientFactory:

using System;
using Abstractions;
using Framework.Abstractions.Silverlight.WebServices;

namespace Silverlight.Tests
{
    public class FakeWebServiceClientFactory : IWebServiceClientFactory<IWeatherForecastService>
    {
        public FakeWebServiceClientFactory()
        {
            this.WebServiceInstance = new FakeWeatherService();
        }

        public void Dispose()
        {
            throw new NotImplementedException();
        }

        public IWeatherForecastService WebServiceInstance { get; private set; }

        public object LastParameterSentToInvoke;

        public object NextResultToReturn;

        public void Invoke<TParam, TResult>(TParam param, object state, Func<TParam, AsyncCallback, object, IAsyncResult> beginOp, Func<IAsyncResult, TResult> endOp, Action<AsyncWebServiceCallResult<TResult>> onComplete)
        {
            this.LastParameterSentToInvoke = param;

            var nextResult = NextResultToReturn as AsyncWebServiceCallResult<TResult>;

            if (nextResult != null)
            {
                onComplete(nextResult);
            }
            else
            {
                onComplete(new AsyncWebServiceCallResult<TResult>
                               {Exception = new Exception("Some exception"), WasSuccessfull = false});
            }
        }
    }
}

As you can see it does not do much, its just a manually written mock class we can use in our test instead of the real web service client factory.
It allows us to check what was sent to the Invoke method as parameter and it allows us to set what will be sent to the OnComplete handler when client code invokes some web service call.

Also we need a stub for the IWeatherForecastService so here it is:

using System;
using Abstractions;

namespace Silverlight.Tests
{
    public class FakeWeatherService : IWeatherForecastService
    {
        public IAsyncResult BeginGetForecast(DateTime day, AsyncCallback callback, object state)
        {
            throw new NotImplementedException();
        }

        public DailyForecast EndGetForecast(IAsyncResult result)
        {
            throw new NotImplementedException();
        }
    }
}

Again its very simple its just a Stub class that allows us to instantiate and use it without really calling it.
So now we can write few tests for our ForecastViewModel:

using System;
using Abstractions;
using Framework.Abstractions.Silverlight.WebServices;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using ViewModels;

namespace Silverlight.Tests
{
    [TestClass]
    public class ForecastViewModelTests
    {
        [TestMethod]
        public void GetForecastCommand_WhenExecutedWithParam_InvokesCallOnWebServiceClientFactoryInstance()
        {
            var fakeFactory = new FakeWebServiceClientFactory();
            var viewModel = new ForecastViewModel(fakeFactory);

            var date = DateTime.Now;

            viewModel.GetForecastCommand.Execute(date);

            Assert.AreEqual(date, fakeFactory.LastParameterSentToInvoke);
        }

        [TestMethod]
        public void GetForecastCommand_WhenExecutedWithMinDateANdWebserviceReturnsUnsuccessfullResult_SetsTheForecastThatWasReceivedToNull()
        {
            var fakeFactory = new FakeWebServiceClientFactory();
            var viewModel = new ForecastViewModel(fakeFactory);
            viewModel.ForecastThatWasReceived = new DailyForecast() {Description = "just dummy so we can test if it was set to null."};

            fakeFactory.NextResultToReturn = new AsyncWebServiceCallResult<DailyForecast>() {WasSuccessfull = false, Exception = new Exception("Bad error.")};
            viewModel.GetForecastCommand.Execute(DateTime.MinValue);

            Assert.IsNull(viewModel.ForecastThatWasReceived);
        }

        [TestMethod]
        public void GetForecastCommand_WhenExecutedWithMinDateANdWebserviceReturnsUnsuccessfullResult_SetsTheStatusMessageToErrorFromReturnedException()
        {
            var fakeFactory = new FakeWebServiceClientFactory();
            var viewModel = new ForecastViewModel(fakeFactory);
            viewModel.ForecastThatWasReceived = new DailyForecast() { Description = "just dummy so we can test if it was set to null." };

            fakeFactory.NextResultToReturn = new AsyncWebServiceCallResult<DailyForecast>() { WasSuccessfull = false, Exception = new Exception("Bad error.") };
            viewModel.GetForecastCommand.Execute(DateTime.MinValue);

            Assert.IsTrue(viewModel.StatusMessage.Contains("Bad error."));
        }

        [TestMethod]
        public void GetForecastCommand_WhenExecutedWithOkDateANdWebserviceReturnsSuccessfullResult_SetsTheStatusMessageToOkMessage()
        {
            var fakeFactory = new FakeWebServiceClientFactory();
            var viewModel = new ForecastViewModel(fakeFactory);
            viewModel.ForecastThatWasReceived = null;

            fakeFactory.NextResultToReturn = new AsyncWebServiceCallResult<DailyForecast>() { WasSuccessfull = true};
            viewModel.GetForecastCommand.Execute(DateTime.Now);

            Assert.IsTrue(viewModel.StatusMessage.Contains("New forecast received ok."));
        }

    }
}

And when we run them, as you can see from the screenshot below, they are all GREEN!

So there you go, we have completed in this lengthy posts most of the tasks we set in the beginning. Off course there are many places for improvement but the basis of a simple way to invoke WCF web services from Silverlight and MVVM and Unit Testability are there.

If you have some comments and improvements to the solutions presented here i would be happy to hear them out.

You can download Visual Studio 2010 Solution with the code from this post if you want to run it locally.

Until then, happy testing!