The Problem Solver : VB

Workflow 4 and Visual Basic expressions

Maurice — Mon, 26 Oct 2009 15:20:46 GMT

Note: This blog post is written using the .NET framework 4.0 Beta 2

When using Windows Workflow Foundation 4 you often need to enter expression in some activity property. The new thing is these expressions are all in the Visual Basic dialect regardless of what language you project is in. So when developing a project in C# the expressions are sill in Visual Basic.

Weird right?

Well not really when you think about it!

After all power business users are expected to be able to modify workflows. And guess what their favorite tools are. That would be Microsoft Excel and Word. And what do they use to create macros? Right Visual Basic for Applications is their language of choice.

So if they use VBA letting them enter VB into expression dialogs is a far more natural fit than having them use C#.

A case for the Delay activity

So lets take a look at the delay activity. This activity takes 1 input property Duration of type Time Span. So I guess that means our VBA power users are going to have to enter something like if they want to wait 5 seconds:

Now for some reason I suspect that is not the first thing they are going to type. In fact they are more likely to time something like “0:0:05” instead. Not very VB like right?

Well it turns out workflow is smart enough to realize it can convert the string literal to a Time Span and use this. So when our power users does the following it just works

Nice, I like this!

Enjoy WF4!

www.TheProblemSolver.nl
Wiki.WindowsWorkflowFoundation.eu

Nederlandse CodeCamp 2009

Maurice — Mon, 19 Oct 2009 10:26:00 GMT

Op 21 november 2009 organiseren de SDN, Stichting dotNed en VBcentral samen het derde Nederlandse Code Camp. Dit is een dag lang met code, code sharing, freaking en gezellig samenzijn. Een evenement door ontwikkelaars, voor ontwikkelaars. De regie ligt voor een belangrijk deel bij de deelnemers! Het aantal plaatsen voor deelnemers is wel beperkt tot maximaal 150. Wacht dus niet te lang met beslissen want voor je het weet is er geen plaats meer. Vergeet bij je aanmelding niet op te geven welke onderwerpen je interesse hebben. Bovendien nodigen we iedereen graag uit om zelf een sessie in te vullen.

Op de website, www.codecamp.nl, vind je meer informatie en kan je je aanmelden.

Nationale Office Dag files

Maurice — Thu, 15 Oct 2009 20:54:43 GMT

Looking for the slides and samples from my two presentations at the Nationale Office Dag in Ede? You can download them from here.

Enjoy!

www.TheProblemSolver.nl
Wiki.WindowsWorkflowFoundation.eu

Error Logging Modules and Handlers for ASP.NET (MVC)

Maurice — Thu, 13 Aug 2009 12:40:20 GMT

I am working on a new ASP.NET MVC app and like so many other applications out there I need to log any errors should they occur. recently I heard about ELMAH Error Logging Modules and Handlers for ASP.NET through this blog post of Scott Hanselman. So as using en existing and proven solution is always better that reinventing the wheel I decided to try ELMAH and see how easy it is to get started.

Well I can only say I am positively amazed at how easy it is.

Starting from scratch it took me less that 2 hours to download and integrate it into my current ASP.NET MVC application and log all errors to SQL Server. That is including security so not everyone can check the error log.

There are lots of additional capabilities I haven’t looked at yet like setting up an RSS feed, emailing or even tweeting errors messages. But judging from the experience so far that should prove easy enough.

My only regret is that I didn’t check it out before.

Checkout the project run by Atif Aziz here.

Enjoy!

www.TheProblemSolver.nl
Wiki.WindowsWorkflowFoundation.eu

Getting started with the .NET RIA Services

Maurice — Tue, 30 Jun 2009 16:34:38 GMT

A recent article I wrote for the MSDN website just went live.

Read is here.

Passing data into a Windows Workflow Foundation 4 workflow

Maurice — Tue, 30 Jun 2009 13:51:03 GMT

Passing parameters into a workflow is similar in WF4 as it was in WF3.

In both case a Dictionary<string, object> is passed in when creating the workflow instance object. Alternatively when using the WF4 WorkflowInvoker you can pass it into the Invoke() method.

This is quite simple but I have never been a fan of the very loose coupling here. basically on the outside you have to create a dictionary with as key something inside of the workflow. No compile time checking. No improvement where, unless you consider the somewhat easier unit testing with the WorkflowInvoker.

The actual behavior between WF3 and WF4 is quite different however.

In Wf3 if you pass in a key that doesn’t match up you get a System.Reflection.TargetInvocationException with a System.InvalidOperationException inner exception with the text: “This operation can not be performed at runtime.”. Great help in debugging

In WF4 on the other hand you get no error at all. The value is just ignored so it is even harder to detect typos. Well I guess not every change can be an improvement. And just in case you where thinking “But a unit test will take care of that right?” keep in mind that workflows tend to be complex and long running things not very well suited to unit testing.

Starting a workflow with a parameter:

Shared Sub Main()

    Dim inArgs As New Dictionary(Of String, Object)

    inArgs("Name") = "Maurice"

    Dim myInstance As WorkflowInstance = New WorkflowInstance(New Sequence1(), inArgs)

    myInstance.OnCompleted = AddressOf OnWorkflowCompleted

    myInstance.OnAborted = AddressOf OnWorkflowAborted

    myInstance.OnUnhandledException = AddressOf OnWorkflowUnhandledException

    myInstance.Run()

    syncEvent.WaitOne()

End Sub

So where is this Name value actually stored?

Well in WF3 that would have been stored in a property, possibly a dependency property, or a field. The types must match, exactly.

In WF4 the notion of properties and fields is gone. No more dependency properties to tie everything together. So instead we have Variables and Arguments. Basically a variable is just like a variable in a function, only here it holds some value for an activity. Big difference is that a Variable is in scope, i.e. visible, to all nested activities as well. So basically it is a way of sharing state between different activities.

To allows us to pass data into a workflow, or get something out, we need to use an Argument.

In this case I have defined two arguments, the Name to pass into the workflow and the Greeting that will be the result of the workflow.

Getting the result out is done in the OnCompleted delegate. This delegate is passed a WorkflowCompletedEventArgs which in turn contains another dictionary with all out argument.

Shared Sub OnWorkflowCompleted(ByVal e As WorkflowCompletedEventArgs)

    Dim greeting As String = e.Outputs("Greeting")

    Console.WriteLine(greeting)

    syncEvent.Set()

End Sub

Again not very different from WF3 where we used the WorkflowCompleted event and the OutputParameters dictionary from the WorkflowRuntime.

Conclusion

While there are quite a few differences in the details the basic approach remains the same. And as the old approach with dictionaries was rather error prone I consider this a missed chance

Enjoy!

www.TheProblemSolver.nl
Wiki.WindowsWorkflowFoundation.eu

Paging with the Silverlight RIA services DomainDataSource

Maurice — Mon, 27 Apr 2009 08:57:46 GMT

Using the declarative DomainDataSource that is part of the upcoming Silverlight 3 RIA services makes it quite easy to work with data. All you need to do is add a DomainDataSource control to the the XAML, point it to the generated DomainContext class (in this case NorthwindContext) and tell it which method to use to load the data from the web service(in this case LoadCustomers). Next add a DataGrid to display the data and you are good to go.

     <UserControl xmlns:dataControls="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data.DataForm"  x:Class="LOBUsingRIAServices.CustomerListPage"

                 xmlns:data="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data"  

                 xmlns:riaControls="clr-namespace:System.Windows.Controls;assembly=System.Windows.Ria.Controls"

                 xmlns:web="clr-namespace:LOBUsingRIAServices.Web"

                 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 

                 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

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

            <riaControls:DomainDataSource x:Name="CustomerDataSource"

                                          LoadMethodName="LoadCustomers">

                <riaControls:DomainDataSource.DomainContext>

                    <web:NorthwindContext />

                </riaControls:DomainDataSource.DomainContext>

            </riaControls:DomainDataSource>

            <data:DataGrid ItemsSource="{Binding Data, ElementName=CustomerDataSource}" />

        </Grid>

    </UserControl>

Pretty simple and that is the way I like it

Adding paging.

Sometimes the lost of data to load can get somewhat large and you might not want to load all data. In that case all you need to do is add a PageSize and the DomainDataSource will only load enough data to display on a single page. You can do this by just setting the PageSize on the DomainDataSource but as we also need a control to allow the user to page trough the data it is easier to also add the DataPager control. Now you have the option of setting the PageSize on the DomainDataSource or the DataPager. I found that setting it on either would work just was well except for the initial load where the DataPager shows page 0 when the PageSize is set on the DomainDataSource while it is set to 1, the correct value, when set on the DataPager. I assume this is just a small bug in the current preview.

Another thing you can specify is the LoadSize. This determines how many rows are loaded with each request and if not set equals the PageSize. Setting this to double the PageSize will improve the responsiveness of the the client application so might be a good idea if the data isn’t too large.

    <UserControl xmlns:dataControls="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data.DataForm"  x:Class="LOBUsingRIAServices.CustomerListPage"

                 xmlns:data="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data"  

                 xmlns:riaControls="clr-namespace:System.Windows.Controls;assembly=System.Windows.Ria.Controls"

                 xmlns:web="clr-namespace:LOBUsingRIAServices.Web"

                 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 

                 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

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

            <riaControls:DomainDataSource x:Name="CustomerDataSource"

                                          LoadMethodName="LoadCustomers"

                                          LoadSize="40">

                <riaControls:DomainDataSource.DomainContext>

                    <web:NorthwindContext />

                </riaControls:DomainDataSource.DomainContext>

            </riaControls:DomainDataSource>

            <data:DataGrid ItemsSource="{Binding Data, ElementName=CustomerDataSource}" />

            <dataControls:DataPager Source="{Binding Data, ElementName=CustomerDataSource}" 

                                    PageSize="20" />

        </Grid>

    </UserControl>

The DataPager control is quite easy to use as well. Just drop it below the DataGrid and point it to the DomainDataSource to use and it just works. One problem I ran into was adding the DataPager above the DataGrid though. When I did that the DataPager didn’t show up on the UI so the user could not page through the data even though it still limited the data to the first page.

Using progressive loading

Another nice option is delayed loading. When using progressive loading all you need to do is specify the LoadSize on the DomainDataSource. The DomainDataSource will now load the specified number of rows, wait a bit and load the next set of rows. It will keep on doing this until all data is loaded. The nice thing here is that all the data is loaded but the UI still stays responsive for the user. De the default interval between load requests is 0.75 seconds but this can be fine tuned using the LoadDelay time span on the DomainDataSource.

    <UserControl xmlns:dataControls="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data.DataForm"  x:Class="LOBUsingRIAServices.CustomerListPage"

                 xmlns:data="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data"  

                 xmlns:riaControls="clr-namespace:System.Windows.Controls;assembly=System.Windows.Ria.Controls"

                 xmlns:web="clr-namespace:LOBUsingRIAServices.Web"

                 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 

                 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

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

            <riaControls:DomainDataSource x:Name="CustomerDataSource"

                                          LoadMethodName="LoadCustomers"

                                          LoadSize="10"

                                          LoadDelay="0:0:0.25">

                <riaControls:DomainDataSource.DomainContext>

                    <web:NorthwindContext />

                </riaControls:DomainDataSource.DomainContext>

            </riaControls:DomainDataSource>

            <data:DataGrid ItemsSource="{Binding Data, ElementName=CustomerDataSource}" />

        </Grid>

    </UserControl>

And all of this was done without writing any code add everything was completely declarative. Of course it is just a matter of setting properties so doing so from code is easy enough.

Enjoy!

Adding a custom machineKey section to the web.config

Maurice — Wed, 08 Apr 2009 12:41:00 GMT

Normal 0 21 false false false MicrosoftInternetExplorer4  /* Style Definitions */ table.MsoNormalTable {mso-style-name:"Table Normal"; mso-tstyle-rowband-size:0; mso-tstyle-colband-size:0; mso-style-noshow:yes; mso-style-parent:""; mso-padding-alt:0cm 5.4pt 0cm 5.4pt; mso-para-margin:0cm; mso-para-margin-bottom:.0001pt; mso-pagination:widow-orphan; font-size:10.0pt; font-family:"Times New Roman"; mso-ansi-language:#0400; mso-fareast-language:#0400; mso-bidi-language:#0400;}

Normally you should never have to set the <machineKey> in the in the web.config. This is only needed when am ASP.NET site runs on a web farm and in that case the machines in question should be configured using the machineKey instead of individual web applications. However we have run into the following exception a few times: “System.Web.UI.ViewStateException: Invalid viewstate” after leaving the browser idle for some time.

Turns out that the <machineKey> that where supposed to be on the web farm where missing. Now this is a shared hoster so not much we can do about the machine configuration but adding this key to the web.config before deploying is simple enough.

And generating the values to add is simple using this nifty, not my words, little generator.

www.TheProblemSolver.nl
Wiki.WindowsWorkflowFoundation.eu

.NET RIA Services and data communication

Maurice — Mon, 06 Apr 2009 13:55:02 GMT

I was working on an article about the .NET RIA Services and decided to fire up Fiddler to take a close look at the data actually passed around. I was sort of expecting to see a WCF REST based approach with XML messages. Turns out I was wrong, though I expect this option will be added in the future.

It turns out the .NET RIA Services use JSON as their serialization format. This is actually kind of nice as the DataContractJsonSerializer is part of the System.ServiceModel.Web assembly and therefore usable by all .NET clients.

The good part is that a .NET RIA Service is also usable from a JavaScript browser based client. So the same .NET RIA Services library gives us lots of client options. Now this was always the plan but it is nice to see that the default already enable it.

And the best thing?

Well that is that I was already using the .NET RIA Services and never even needed to know how the messages where actually send across the wire, something I shouldn't have to worry about when developing a RIA style application. Which is exactly the goal of the .NET RIA Services.

Cool stuff and highly recommended if you want to create browser based LOB apps

www.TheProblemSolver.nl
Wiki.WindowsWorkflowFoundation.eu

And now on Twitter at http://twitter.com/mauricedb.

Want to download all MIX sessions?

Maurice — Tue, 31 Mar 2009 06:52:40 GMT

Then you should check Mike Swanson’s blog post here. He has two batch files, the first downloads all MIX session recordings with in the format you like, the second renames them so it is easier to make sense of all the media file names.

If you just want a list of all sessions with download links this page might be the thing for you.

So much better than downloading them by hand. Not as good as going to the MIX itself but if you, like me, couldn’t go it is still a nice way to see all the content.

Enjoy!

Visual Basic QuickStarts and How-to Topics for the Composite Application Guidance for WPF and Silverlight

Maurice — Wed, 25 Mar 2009 08:12:57 GMT

The P&P team have just release a VB version of the Prism quick starts.

You can download the goods here.

Enjoy!

Software Development Event march 30th

Maurice — Mon, 23 Mar 2009 15:40:29 GMT

Just one week to go to the next Software Development Event. The schedule with all the sessions is looking good. But this time there is even more!

We will have a Microsoft Surface machine somewhere in the common area for people to try our. And if you have never played, oops tested, with a Surface machine before this is a truly exiting machine!

Just goes to show, the SDN will go to extraordinary efforts to please all attendees

You can see the full schedule here. And don’t forget, we are not in Ede this time but in a great new location in Driebergen.

Hope to see everyone there next week Monday.

www.TheProblemSolver.nl
Wiki.WindowsWorkflowFoundation.eu

And now on Twitter at http://twitter.com/mauricedb.

Samples and PowerPoint from my WCF talk

Maurice — Wed, 11 Mar 2009 04:25:00 GMT

Attached is are the samples and slides I used for my intro into WCF talk yesterday at the VB Central meeting in the Netherlands.

Download samples

Enjoy!

www.TheProblemSolver.nl
Wiki.WindowsWorkflowFoundation.eu

Now also on twitter at http://twitter.com/mauricedb

Using a TransactionScopeActivity with a WCF ReceiveActivity revisited

Maurice — Tue, 10 Mar 2009 12:42:15 GMT

Last year Marcel and I worked on a problem using a TransactionScopeActivity inside a WCF ReceiveActivity. I blogged a number of time about our finding, for example here.

Last week I heard from Marcel that a hotfix was finally available that solves this problem. He blogged about it here. Great work to see there is a fix for this serious problem.

Enjoy!

www.TheProblemSolver.nl
Wiki.WindowsWorkflowFoundation.eu

And now on Twitter at http://twitter.com/mauricedb.

Looking back at the MVP Summit

Maurice — Sat, 07 Mar 2009 11:08:09 GMT

Last week lots of MVP, myself included, where in Redmond visiting Microsoft on our yearly MVP pilgrimage. The MVP Summit is always a great event. Not only do we get to talk to the MS team members who actually design and build all the software we love and use but we also get to meet each other. And with MVP’s being located around the world that is kind of rare as well.

Despite this being a great event I still have very mixed feelings about this last MVP summit. The problem isn’t the events itself or the people I met, that was al great . No the problem was in some of the technological decisions made in product groups. Unfortunately I can’t divulge details yet because I have signed an NDA but as soon .NET 4.0 as beta 1 is made public I will be able to blog about some of these decisions. And rest assured I will!

The reason we really need to is the way these important changes are communicated. Or should I say not communicated. Some very important changes where not communicated at all and could only be derived by bullet points missing from PowerPoint slides. Only when directly asked about the missing bullet point would someone say “Yes that is right, we decided to …. NDA … because … NDA …”. Sorry about the NDA part .

I can only say that these decisions are a big problem and I know several MVP’s who decided to skip other sessions on the same product as a result. I didn’t, as far as I am concerned ignoring a problem is not going to make it go away, but I really think this product team needs to reevaluate this decision and the general future trend.

Despite this hiccup I am very exited about lots of the things I got to see and am really looking forward to .NET 4 and Visual Studio 2010. Now if we only could have a beta today . When we will have a first beta is still a big question though. If a date was announced I missed it, the best I heard was a quarter and is quite a time span.

Enjoy.

www.TheProblemSolver.nl
Wiki.WindowsWorkflowFoundation.eu

Presenting at VB Central

Maurice — Tue, 03 Mar 2009 13:46:17 GMT

Next week, on march 10th, I will be doing a presentation on getting started with WCF at the VB Central user group in the Netherlands. Its a free event so if you are in the neighborhood feel free to drop by. They do ask you register beforehand. Besides my session on WCF there will also be a session on using WPF and data binding.

Mode details and the registration page can be found here.

Hope to see you there.

www.TheProblemSolver.nl
Wiki.WindowsWorkflowFoundation.eu

SilverUnit - Unit testing framework for Silverlight

Maurice — Wed, 25 Feb 2009 08:11:13 GMT

Roy Osherove has just released SilverUnit, a unit testing framework for Silverlight code. I haven't tried this yet but it certainly looks really interesting as you can start running your Silverlight unit tests inside of MS Test or NUnit.

And kind cool to hear this is written in VB

You can find more information and download SilverUnit from CodePlex here.

Enjoy!

www.TheProblemSolver.nl
Wiki.WindowsWorkflowFoundation.eu

WrapPanel in ListBox revisited

Maurice — Mon, 08 Dec 2008 18:11:42 GMT

Last week logged about using a WrapPanel in a listBox and demonstrated how to get the content to wrap around, read about it here.

Turns out the XAML can be even easier. In the previous post I used a ControlTemplate with a Grid to stop the WrapPanel from just expanding horizontally. Turns out there us an even easier way to do so by disabling the horizontal scrollbar using the ListBox ScrollViewer. The following XAML will do the trick just fine:

<UserControl xmlns:controls="clr-namespace:Microsoft.Windows.Controls;assembly=Microsoft.Windows.Controls"  
             x:Class="SilverlightApplication4.Page"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
             Width="400" Height="300">
    <Grid x:Name="LayoutRoot" Background="White">
        <ListBox x:Name="DemoList" 
                 ScrollViewer.HorizontalScrollBarVisibility="Disabled">
            <ListBox.ItemsPanel>
                <ItemsPanelTemplate>
                    <controls:WrapPanel />
                </ItemsPanelTemplate>
            </ListBox.ItemsPanel>
            <ListBox.ItemTemplate>
                <DataTemplate>
                    <TextBlock Text="{Binding}" 
                   TextAlignment="Right" 
                   Width="25" />
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>
    </Grid>
</UserControl>

Used in combination with the following code:

using System.Linq;
using System.Windows;
using System.Windows.Controls;

namespace SilverlightApplication4
{
    public partial class Page : UserControl
    {
        public Page()
        {
            InitializeComponent();
            Loaded += new RoutedEventHandler(Page_Loaded);
        }

        void Page_Loaded(object sender, RoutedEventArgs e)
        {
            DemoList.ItemsSource = Enumerable.Range(1, 250);
        }
    }
}

it produces this Silverlight page:

We even get some keyboard support with the new XAML although I am not quite sure if I am happy about that or not. Selecting an element and pressing the down arrow key makes the selection move to the right. Makes sense in that it is the next item in the ItemsSource bit not quite what I was hoping for.

Just for a quick comparison I copied the XAML and code to a WPF application to see what would happen there. Fortunately the only change I hard to make to the ListBox was removing the controls namespace. Great

When I ran the same in WPF I do see the keyboard behavior I would like. Pressing the down arrow selects the next item below the current, the same with up and the other arrow keys and even the page up/down scroll a page but move in the same column. Now this is much better behavior!

Enjoy!

www.TheProblemSolver.nl
Wiki.WindowsWorkflowFoundation.eu

Unit testing in Silverlight part 2

Maurice — Sun, 07 Dec 2008 21:11:23 GMT

Part 1
Part 2
Part 3
Part 4

In my previous post I described the basic setup of unit testing in Silverlight, you can read all about it here.

The basics where very nice but lots of code we write in Silverlight has to do with networking and in Silverlight that means asynchronous code, something that is always hard to test!

Because, just I like using Flickr, lets download some pictures and see what it takes to make that testable. Below is the very simple application we need to unit test, basically a list of pictures from my Flickr photo stream.

Nothing fancy, just a ListBox with pictures

The code in the page is no big deal either and looks like this:

public partial class Page : UserControl
{
    public Page()
    {
        InitializeComponent();
        Loaded += new RoutedEventHandler(Page_Loaded);
    }

    void Page_Loaded(object sender, RoutedEventArgs e)
    {
        PhotoCollection photoCollection = 
            (PhotoCollection)Resources["PhotoCollectionDS"];
        FlickrRequest request = new FlickrRequest();

        request.PhotoSearchByUser("97044050@N00", 
            (photo) => photoCollection.Add(photo));
    }
}

Basically it just retrieves the PhotoCollection, creates a FlickrRequest object and tells it to search for a users photos and add each photo found to the collection. The PhotoCollection is no big deal either and is just a ObservableCollection<Photo>.

The interesting stuff is in the FlickrRequest class. This is the one that needs to be unit tested and looks like this:

public class FlickrRequest
{
    private const string _flickrUrl = "http://api.flickr.com/services/rest";

    public void PhotoSearchByUser(string userId, Action<Photo> action)
    {
        string url = string.Format(
            @"{0}/?method={1}&api_key={2}&user_id={3}&extras=original_format",
            _flickrUrl, "flickr.photos.search", App.FlickrApiKey, userId);

        WebClient client = new WebClient();
        client.OpenReadCompleted += (sender, e) =>
        {
            if (e.Error == null)
            {
                FlickrResponse response = DeserializeResult(e.Result);
                if (response.Status == "ok")
                {
                    foreach (var photo in response.Photos.Photos)
                        action(photo);

                    if (response.Photos.Page < response.Photos.PageCount)
                    {
                        string nextUrl = string.Format("{0}&page={1}", 
                            url, response.Photos.Page + 1);
                        client.OpenReadAsync(new Uri(nextUrl));
                    }
                }
            }
        };

        client.OpenReadAsync(new Uri(url));
    }

    public static FlickrResponse DeserializeResult(Stream stream)
    {
        FlickrResponse response = null;
        try
        {
            XmlSerializer ser = new XmlSerializer(typeof(FlickrResponse));
            response = (FlickrResponse)ser.Deserialize(stream);
        }
        catch (InvalidOperationException)
        {
            response = new FlickrResponse();
        }

        if (response.Photos == null)
            response.Photos = new ResponsePhotoCollection();
        if (response.Photos.Photos == null)
            response.Photos.Photos = new Photo[] { };

        return response;
    }
}

The PhotoSearchByUser function here is the interesting one as it uses the WebClient class and the Flickr REST API to download the photo information. This code also has the complexity that not all the data is returned from the first call but we need to do multiple calls to get all the photo information. Creating a unit test should be straightforward expect for the fact that we do not want to depend on Flickr and fake out the networking parts. After all if we didn’t it would be a integration test instead of a unit test. So we need to somehow fake the networking behavior.

With regular .NET code I use TypeMock to help out with unit testing and I am sure that would make live easy here but unfortunately there is no Silverlight version of TypeMock yet. In fact, as far as I am aware, there is not a single mock framework for use with Silverlight. So we need to do this some other way.

First we need to get rid of the WebClient class because non of its methods are virtual and we cannot substitute another type. So the first thing I did was create a TestableWebClient, which looks just like the original WebClient only it allows me to change the behavior for testing purposes. The TestableWeblient looks like this:

public class TestableWebClient
{
    public event EventHandler<TestableOpenReadCompletedEventArgs> OpenReadCompleted;

    public virtual void OpenReadAsync(Uri address)
    {
        WebClient client = new WebClient();
        client.OpenReadCompleted += (s, e) =>
            {
                OnOpenReadCompleted(e);
            };
        client.OpenReadAsync(address);
    }

    protected void OnOpenReadCompleted(OpenReadCompletedEventArgs e)
    {
        TestableOpenReadCompletedEventArgs args = 
            new TestableOpenReadCompletedEventArgs(e);
        OnOpenReadCompleted(args);
    }

    protected void OnOpenReadCompleted(TestableOpenReadCompletedEventArgs e)
    {
        if (OpenReadCompleted != null)
        {
            OpenReadCompleted(this, e);
        }
    }
}

Unfortunately the OpenReadCompletedEventArgs type doesn’t have a public constructor so I cannot create one myself so I have to use a TestableOpenReadCompletedEventArgs instead. This class looks like this:

public class TestableOpenReadCompletedEventArgs : AsyncCompletedEventArgs
{
    public TestableOpenReadCompletedEventArgs(
        Stream result, Exception error, bool cancelled, object userState)
        : base(error, cancelled, userState)
    {
        Result = result;
    }

    public TestableOpenReadCompletedEventArgs(
        OpenReadCompletedEventArgs args)
        : base(args.Error, args.Cancelled, args.UserState)
    {
        Result = args.Result;
    }

    public Stream Result { get; private set; }
}

So with these new classes I can change the PhotoSearchByUser function to use the new class and it now looks like this:

public void PhotoSearchByUser(string userId, Action<Photo> action)
{
    string url = string.Format(
        @"{0}/?method={1}&api_key={2}&user_id={3}&extras=original_format",
        _flickrUrl, "flickr.photos.search", App.FlickrApiKey, userId);

    TestableWebClient client = new TestableWebClient();
    client.OpenReadCompleted += (sender, e) =>
    {
        if (e.Error == null)
        {
            FlickrResponse response = DeserializeResult(e.Result);
            if (response.Status == "ok")
            {
                foreach (var photo in response.Photos.Photos)
                    action(photo);

                if (response.Photos.Page < response.Photos.PageCount)
                {
                    string nextUrl = string.Format("{0}&page={1}", 
                        url, response.Photos.Page + 1);
                    client.OpenReadAsync(new Uri(nextUrl));
                }
            }
        }
    };

    client.OpenReadAsync(new Uri(url));
}

Not much changes, in fact only a single line changed but we are not quite there yet. We still need a way to get our unit tests to use a different TestableWebClient implementation. Do do so I will pass in the type of TestableWebClient to use with the FlickrRequest constructor. Check the new code:

public class FlickrRequest
{
    private string _flickrUrl = "http://api.flickr.com/services/rest";
    private Type _webClientType = typeof(TestableWebClient);

    public FlickrRequest()
    {
    }

    public FlickrRequest(Type webClientType)
    {
        _webClientType = webClientType;
    }

    public void PhotoSearchByUser(string userId, Action<Photo> action)
    {
        string url = string.Format(
            @"{0}/?method={1}&api_key={2}&user_id={3}&extras=original_format",
            _flickrUrl, "flickr.photos.search", App.FlickrApiKey, userId);

        TestableWebClient client = (TestableWebClient)
            Activator.CreateInstance(_webClientType);
        
        // Rest of the code left out.
    }
}

Now we can start testing this code

I created two unit tests for this code as an example, they look like this:

[TestClass]
public class FlickrDownloadTest : SilverlightTest
{
    [TestMethod]
    [Asynchronous]
    public void Test1()
    {
        FlickrRequest request = new FlickrRequest(typeof(MockTestableWebClient));

        request.PhotoSearchByUser("97044050@N00", (photo) => EnqueueTestComplete());
    }
    
    [TestMethod]
    [Asynchronous]
    public void Test2()
    {
        int pageCount = 0;
        FlickrRequest request = new FlickrRequest(typeof(MockTestableWebClient));

        request.PhotoSearchByUser("97044050@N00", (photo) => pageCount++);
        EnqueueConditional(() =>
            {
                return pageCount == 5;
            });
        EnqueueTestComplete();
    }
}

The fake, or mock, WebClient looks like this:

public class MockTestableWebClient : TestableWebClient
{
    private int _page = 0;

    public override void OpenReadAsync(Uri address)
    {
        _page++;

        FlickrResponse response = new FlickrResponse();
        response.Status = "ok";
        response.Photos = new ResponsePhotoCollection();
        response.Photos.Page = _page;
        response.Photos.PageCount = 5;
        response.Photos.Photos = new Photo[] { new Photo() };
        Stream stream = SerializeResult(response);
        stream.Position = 0;
        TestableOpenReadCompletedEventArgs args = 
            new TestableOpenReadCompletedEventArgs(stream, null, false, null);
        OnOpenReadCompleted(args);
    }


    public static Stream SerializeResult(FlickrResponse response)
    {
        MemoryStream stream = new MemoryStream();
        XmlSerializer ser = new XmlSerializer(typeof(FlickrResponse));
        ser.Serialize(stream, response);

        return stream;
    }
}

Basically I just return a response stating that there are 5 pages and each contains a single blank photo.

Running these tests produces the following output showing both tests passed

Am I happy with the changes I had to make to the Silverlight app to make it unit testable? Well yes and no. I didn’t like having to create a wrapper class for the WebClient and the OpenReadCompletedEventArgs. Bit now that I have done so creating using other test for code using the WebClient is a lot easier. In this case I only added the OpenReadAsync() function but doing the same with the other functions is a breeze. And the end result is I could unit test the code in PhotoSearchByUser() pretty much the way I wrote it without having to change the code a lot just to make it unit testable and that is good! So overall I am reasonably happy with the result

I pretty much skipped all details of the actual unit testing code itself. Now there is some new stuff so in a future blog post I am going to explain what I did in the unit tests themselves.

And thanks to Jeff Wilcox for providing some useful feedback.

Enjoy!

Update: Part 1, Part 2, Part 3.

www.TheProblemSolver.nl
Wiki.WindowsWorkflowFoundation.eu

Unit testing and Windows Workflow Foundation

Maurice — Wed, 03 Dec 2008 12:17:30 GMT

A while a go I wrote some posts about unit testing Windows Workflow foundation Activities, you can find the posts here and here. Fortunately I am not the only one who thinks unit testing is important as you can find various other blog posts about it like this one from Ron Jacobs.

But Cliff Simpkins has taken this one step further and just blogged about a new MSDN virtual lab "Using Test-First Development with WF"! Excellent work and I recommend doing the lab, I know I did! And while you are at it, there are a number of other interesting labs you can do.

Read more about Cliffs announcement here or go straight to the lab here.

Enjoy!