The Brain Dump

Tasks are not Threads

BenWilli — Wed, 24 Apr 2013 14:16:50 GMT

One of the common misconceptions I’ve encountered when developers first start using the Task Parallel Library is that they think Tasks are just fancy threads. This is easy to assume because in a common case, calling Task.Run(…), it actually does run the Task activity on a thread from the thread pool. But as Stephen Toub wrote

The Task-based Async Pattern (TAP) isn’t just about asynchronous operations that you initiate and then asynchronously wait for to complete. More generally, tasks can be used to represent all sorts of happenings, enabling you to await for any matter of condition to occur.

For example, let’s say I have a WPF app with two buttons, Start and End. The Start button’s event handler looks like this

        1: private async void bttnStart_Click(object sender, RoutedEventArgs e)

       2: {

       3:     MessageBox.Show("Looking for the time");

       4:     DateTime now = await GetCurrentTimeAsync();

       5:     MessageBox.Show("It is now" + now.ToString());

       6: }

which uses an async method to retrieve the current time. But we can implement GetCurrentTimeAsync() this like the following

       1: private void bttnEnd_Click(object sender, RoutedEventArgs e)

       2: {

       3:     if (_tsc != null)

       4:     {

       5:         _tsc.SetResult(DateTime.Now);

       6:     }

       7: }

       8:  

       9: TaskCompletionSource<DateTime> _tsc;

      10:  

      11: private Task<DateTime> GetCurrentTimeAsync()

      12: {

      13:     _tsc = new TaskCompletionSource<DateTime>();

      14:     return _tsc.Task;

      15: }

The Task returned from GetCurrentTimeAsync() will never complete until the user clicks the End button. In this case, the Task activity isn't code, but the act of waiting for the user to click the End button. In real code the activity could be happening on the network, the memory bus of the machine or anywhere, but it isn't necessarily on a thread.

In fact, Lucien Wischik has an excellent series on turning all sorts of things into Tasks so that they can be awaited.

Windows 8 ViewModel Property Code Snippet

BenWilli — Fri, 12 Oct 2012 20:15:00 GMT

Visual Studio provides a bunch of good code snippets for creating boilerplate code. For example if you type “prop” you get this in intellisense

You’ll see a few nice property snippets.

prop – creates a basic automatic property
propa – creates an attached property
propdp – creates a dependency property
propfull – creates a public property with a private backing field
propg – creates a basic automatic property but the set is marked private

I use these constantly but hit an issue when building my Windows 8 apps. For ViewModels in Windows 8, the default templates take advantage of a wonderful attribute CallerMemberName in the OnPropertyChanged method of the ViewModel base class. This allows you to create properties that support notifications in a very simple manner. Like this

But that pattern doesn’t have code snippet. That’s easy to fix though. I created my own snippet to generate that type of property and named it proprt.

Just create a file called proprt.snippet in the folder [USERPROFILE]\Documents\Visual Studio 2012\Code Snippets\Visual C#\My Code Snippets

It should have the following contents

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippets  xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
    <CodeSnippet Format="1.0.0">
        <Header>
            <Title>proprt</Title>
            <Shortcut>proprt</Shortcut>
            <Description>Code snippet for property and backing field with change notification in Windows Runtime view models</Description>
            <Author>Microsoft Corporation</Author>
            <SnippetTypes>
                <SnippetType>Expansion</SnippetType>
            </SnippetTypes>
        </Header>
        <Snippet>
            <Declarations>
                <Literal>
                    <ID>type</ID>
                    <ToolTip>Property type</ToolTip>
                    <Default>int</Default>
                </Literal>
                <Literal>
                    <ID>property</ID>
                    <ToolTip>Property name</ToolTip>
                    <Default>MyProperty</Default>
                </Literal>
                <Literal>
                    <ID>field</ID>
                    <ToolTip>The variable backing this property</ToolTip>
                    <Default>myVar</Default>
                </Literal>
            </Declarations>
            <Code Language="csharp">
      <![CDATA[private $type$ $field$;

    public $type$ $property$
    {
        get { return $field$;}
        set { this.SetProperty(ref this.$field$, value); }
    }
    $end$]]>
            </Code>
        </Snippet>
    </CodeSnippet>
</CodeSnippets>

Then you should see it show up in the Visual Studio Code Snippet Manager under My Code Snippets

Voila, start creating properties with it and build your Windows 8 Store apps even easier!

Windows Phone MessageBox implements scrolling!

BenWilli — Mon, 06 Aug 2012 20:27:17 GMT

Helpful quick and dirty debugging tip: I never noticed this before, but if you send a large amount of text to MessageBox.Show() on Windows Phone, it doesn’t just truncate it. It allows you to scroll through it all. Very cool. Very unlike the desktop message box.

I was tinkering today with the web browser control and manipulating the HTML contents via InvokeScript and needed a way to verify the changes. What I was changing was unfortunately not at the very top of the HTML, but I discovered I could easily dump the contents like this

MessageBox.Show(webBrowser1.SaveToString());

and then just scroll down to the portion I was trying to verify had changed.

Now, I’m not recommending that you dump large text to the message box for a user to scroll through – that would be poor form. But as a quick diagnostic trick it can be handy.

Managing multiple web service calls with Rx

BenWilli — Fri, 15 Jun 2012 21:33:43 GMT

Lets say I have a phone app (or any app really) that needs to make several web service calls at once. For example, imagine the user multiselects three items on a page and then taps the “add favorite” button. I then need to make three calls to the “set favorite” service. I’ll do this asynchronously so that they can all run simultaneously, but if I make three asynchronous calls to a web API that updates a local collection of resources, I want to be able to

know which ones failed, to notify the user
know which ones succeeded, to update the local data model
get a notification when all of them are complete so I can turn off the “Is Busy” indicator in the UI

Typically the first two are no problem because I could run them all through the same logic each having its own completion callback which does the right thing. The trick comes in aggregating the responses all together so that I can do #3 – turn off the progress control. Normally this would entail creating some state object and tracking how many items were started, identifying them as they finished and updating the state object all in a thread safe manner. This is also complicated by the fact that the requests may (and likely will) complete in a different order from that which I started them.

Because I like to use Rx to populate my viewmodels, my web requests are IObservables which means that I can compose them in a way to get the behavior I want without worrying about threading or state management.

Lets say I’m making a call to mark something as a favorite. The service proxy looks like this. On success, the service will echo the new value sent to it.

public IObservable<string> SetFavorite(int ID, bool isFavorite)

A single call would look something like this

private void SingleCall()
{
    FavoritesService svc = new FavoritesService();
    var svcCall = svc.SetFavorite(5, true);

    svcCall.ObserveOnDispatcher().Subscribe(
        result => Debug.WriteLine("Call succeeded = {0}", result),
        ex => Debug.WriteLine("Call failed: {0}", ex),
        () => Debug.WriteLine("Call completed")
    );
}

If I needed to favorite three items I just do it three times.

private void IndividualCalls()
{
    FavoritesService svc = new FavoritesService();

    var call1 = svc.SetFavorite(5, true);
    var call2 = svc.SetFavorite(6, true);
    var call3 = svc.SetFavorite(7, true);

    call1.ObserveOnDispatcher().Subscribe(
        result => Debug.WriteLine("Call1 succeeded = {0}", result),
        ex => Debug.WriteLine("Call1 failed: {0}", ex),
        () => Debug.WriteLine("Call1 completed")
    );

    call2.ObserveOnDispatcher().Subscribe(
        result => Debug.WriteLine("Call2 succeeded = {0}", result),
        ex => Debug.WriteLine("Call2 failed: {0}", ex),
        () => Debug.WriteLine("Call2 completed")
    );

    call3.ObserveOnDispatcher().Subscribe(
        result => Debug.WriteLine("Call3 succeeded = {0}", result),
        ex => Debug.WriteLine("Call3 failed: {0}", ex),
        () => Debug.WriteLine("Call3 completed")
    );
}

But how do I know when all three are done? My first thought was to just use Merge

private void MergedCalls()
{
    FavoritesService svc = new FavoritesService();

    var call1 = svc.SetFavorite(5, true);
    var call2 = svc.SetFavorite(6, true);
    var call3 = svc.SetFavorite(7, true);

    var allCalls = call1.Merge(call2).Merge(call3);

    allCalls.ObserveOnDispatcher().Subscribe(
        result => Debug.WriteLine("All calls succeeded = {0}",
                                    result),
        ex => Debug.WriteLine("Some calls failed: {0}", ex),
        () => Debug.WriteLine("All calls completed")
    );
}

But there is a major issue with this. If an exception happens in an observable sequence, the sequence is over. So if any of the calls throw a fault (e.g. if there is a network error) then I wont receive any notifications for any of the calls that haven't yet completed. I tried a number of variations on this until Bart De Smet pointed out the Materialize operator to me.

Materialize “materializes the implicit notifications of an observable sequence as explicit notification values.” What this means is that if you materialize a sequence of strings you get a sequence of Notification<string>. The Notification<string> object tells you if it was a string value, exception, or completion. Therefore, you get the information but the sequence doesn’t throw errors. Instead, the error becomes a value in the sequence.

I can now materialize each of the three calls and then merge them together. If I generalize this to N calls to my SetFavorites it looks something like this

private void SetFavoritesWithMaterialize2(List<int> IDs)
{
    FavoritesService svc = new FavoritesService();
    var total = IDs.ToObservable()
                    .SelectMany(id => 
                         svc.SetFavorite(id, id % 2 == 0 ? true : false)
                            .Materialize()
                            .Select(callResult => 
                                     new { Result = callResult, ID = id })
                     );
    total.Subscribe(call =>
            {
                switch (call.Result.Kind)
                {
                    case NotificationKind.OnNext:
                        Debug.WriteLine("CLIENT {0} succeeded = {1}", 
                                           call.ID, call.Result.Value);
                        break;
                    case NotificationKind.OnError:
                        Debug.WriteLine("CLIENT {0} failed", call.ID);
                        break;
                }
            },
            ex => Debug.WriteLine("CLIENT Something failed: {0}", ex.Message),
            () => Debug.WriteLine("CLIENT All completed")
        );
}

Initially I was foreach’ing over the list of IDs, but ‘duh! it’s a sequence!’, turn it into an observable and pipe them in the SetFavorite call. Then materialized the values and inject the current ID of the call with a Select operator so that later in the Subscribe method I can determine which call is succeeding or failing. The resulting sequence is a sequence of IObservables so I used SelectMany to flatten all of them into a single sequence.

At last, I can now subscribe the the sequence which will provide me a value which has (1) the ID of the call, (2) the success/failure of the call and (3) will raise a completion event only when all of the calls are done.

Here is a sample trace of my test program. The server is hard coded to return a “400 Bad Request” on ID 7. Notice the client receives the responses out of order, handles the error condition, and notifies when everything is done.

CLIENT: PUTing http://localhost:48963/api/favorites/1/False : {"value":"False"}
CLIENT: PUTing http://localhost:48963/api/favorites/2/True : {"value":"True"}
CLIENT: PUTing http://localhost:48963/api/favorites/3/False : {"value":"False"}
CLIENT: PUTing http://localhost:48963/api/favorites/4/True : {"value":"True"}
CLIENT: PUTing http://localhost:48963/api/favorites/5/False : {"value":"False"}
CLIENT: PUTing http://localhost:48963/api/favorites/6/True : {"value":"True"}
CLIENT: PUTing http://localhost:48963/api/favorites/7/False : {"value":"False"}
SERVER: FavoritesController.Put(id:1, value:False)
SERVER: FavoritesController.Put(id:7, value:False)
CLIENT: 1 succeeded = "False"
SERVER: FavoritesController.Put(id:2, value:True)
SERVER: FavoritesController.Put(id:5, value:False)
SERVER: FavoritesController.Put(id:6, value:True)
SERVER: FavoritesController.Put(id:3, value:False)
SERVER: FavoritesController.Put(id:4, value:True)
CLIENT: 2 succeeded = "True"
CLIENT: 7 failed
CLIENT: 6 succeeded = "True"
CLIENT: 5 succeeded = "False"
CLIENT: 4 succeeded = "True"
CLIENT: 3 succeeded = "False"
CLIENT: All completed

Give formatting its own line

BenWilli — Tue, 21 Feb 2012 14:51:24 GMT

I got bitten by this not once but twice on Sunday as I hurriedly worked on a new phone app. Can you spot the difference between the the following two lines?

Uri uri = new Uri(string.Format("/View/DataView.xaml?collection={0}&id={1}", collection, currentItem.getID(), UriKind.Relative));

Uri uri = new Uri(string.Format("/View/DataView.xaml?collection={0}&id={1}", collection, currentItem.getID()), UriKind.Relative);

Typically I like to put any String.Format() call on its own line because they tend to be long and sometimes complicated. This is an example of why. Notice the placement of the parenthesis? The first line compiles just fine, but it includes the UriKind as a parameter to String.Format and not to Uri(). Then at runtime the formatting just ignores it as “unused 3rd parameter” but when I try to navigate to this Uri in my phone app, the navigation service chokes because it requires a relative Uri. The error then says something like “can’t find view /View/DataView.xaml”. You look in that folder –yep the XAML is there. You look at the code – yep it seems to check out ok. This can turn into a real head scratcher.

So anytime you call an API that has variable number of parameters like String.Format() its not a bad idea to do it on its own line like this

string tmp = string.Format("/View/DataView.xaml?collection={0}&id={1}", collection, currentItem.getID());

Uri uri = new Uri(tmp);

Using Rx? Subscribe to exceptions!

BenWilli — Thu, 12 Jan 2012 22:05:02 GMT

I have an app in the Windows Phone Marketplace which suddenly saw a spike in Little Watson email reports back to me last weekend. Each one looked like the last so I responded back to each user (always keep the user’s happy!) and went to investigate.

The service it was talking to suddenly changed its behavior unexpectedly. This caused a ripple effect in that my WebClient code calls started to fail and one backwater section of my app did not have good error handling. So a service error (not my fault) caused the app to crash (my fault big time!). I had dealt with it nearly everywhere but missed it in one place in which it had never happened before.

Using the Rx pattern discussed before my code looked something like this

1 var outstandingRequest = svc.GetDataFromWeb(id)
2     .SubscribeOnDispatcher()
3     .Subscribe( data => DoSomething(data));

Notice something? I’m not using the overload of Subscribe() which provides the exception handling. If you are subscribing, its a good idea to grab the errors that come out of the observable. Don’t do it and the phone app crashes.

A small but important change handles the exception and solved the problem. (In reality I added a little more complex logic than shown here so that it would retry the request to the service). Next step was to quickly get it into the marketplace.

1 var outstandingRequest = svc.GetDataFromWeb(id)
2     .SubscribeOnDispatcher()
3     .Subscribe( 
4         data => DoSomething(data),
5         ex => { App.LogError("Error loading data {0}: {1}", id, ex),
6         () => 
7     );

Unfortunately the marketplace crash data isn't real time so I didn’t have this graph available until yesterday. That hockey stick shape is not something you want to see on your dashboard!

Hopefully the users weren't scared away from the app by the experience. Its easier to get them to come in the first place than it is to get them to come back after a bad experience.

Rx ensures Unsubscribe

BenWilli — Tue, 08 Nov 2011 17:00:00 GMT

I recently had an ObservableCollection which did not currently contain the item I was interested in, but it would sometime in the near future. The questions is how best to get notified that the item is available so I could access its full property set? I only had the item’s ID and the collection’s CollectionChanged event to work with.

My first instinct was to just go with simple lambda expression subscribed to the CollectionChanged event in order to filter for the item’s appearance in the collection

public void WaitForMovie_UsingLambda(int ID, ObservableCollection<MovieData> collection)
{
collection.CollectionChanged += new NotifyCollectionChangedEventHandler(
(sender, e) =>
{
if (e.Action == NotifyCollectionChangedAction.Add)
{
var movie = ((MovieData)e.NewItems[0]);
if (movie.ID == movieSearchID)
{
DoSomething(movie);
}
}
});
}

The problem with this pattern is that you can’t unsubscribe from the event notification. Every time something is added (even after we have found our item) this logic will execute wasting CPU processing power. In addition, this also has the potential to create memory issues/leaks because objects may remain alive longer since the subscription will exist as long as the collection does. If the subscription has side effects (there are none in this simple case) then they are essentially permanent.

We can go with a basic delegate structure which allows us to unsubscribe but the logic gets a little more complicated and we have to spread it out into multiple sections.

private int movieSearchID;
private ObservableCollection<MovieData> movieSearchCollection;
public void WaitForMovie_UsingDelegate(int ID, ObservableCollection<MovieData> collection)
{
movieSearchID = ID;
collection.CollectionChanged += new NotifyCollectionChangedEventHandler(moveCollectionChanged);
}
void moveCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
if (e.Action == NotifyCollectionChangedAction.Add)
{
var movie = ((MovieData)e.NewItems[0]);
if (movie.ID == movieSearchID)
{
DoSomething(movie);
movieSearchCollection.CollectionChanged -= new NotifyCollectionChangedEventHandler(moveCollectionChanged);
}
}
}

But now we’ve lost the encapsulation the lambda provided us so its harder to read. We also have to be careful because the code isn’t reentrant due to the state variables.

Now lets look at the Reactive Extensions solution

public void WaitForMovie_UsingRx(int ID, ObservableCollection<MovieData> collection)
{
var changes = Observable.FromEventPattern<NotifyCollectionChangedEventArgs>(collection, "CollectionChanged");
var itemWeWant = from change in changes
where change.EventArgs.Action == NotifyCollectionChangedAction.Add
let movie = ((MovieData)change.EventArgs.NewItems[0])
where movie.ID == ID
select movie;
itemWeWant.Take(1).Subscribe( movie => DoSomething(movie));
}

The Take(1) ensures we only have a single result. This causes the observable to complete after that one result. When observables complete, the subscription to the event is unsubscribed. Plus we don’t have any state to manage ourselves and the code is short and concise. It is readable and directly expresses our intended purpose to the reader.

This is an excellent pattern for any type of .NET event where you expect to receive a specific number of notifications instead of a permanent stream of notifications and you don’t want to worry about managing state or cleaning up your delegates.

Implementation detail notes

In this case I know that only one item is being added to the collection at a time. This allows me to just look at NewItems[0] instead of the whole NewItems collection. If that wasn’t the case we could add logic to filter the entire NewItems collection as well, but it wouldn’t change the overall point.
If you have read some of my other blog posts on Rx you might notice that sometimes I use FromEventPattern and sometimes I use FromEvent. They are essentially the same. The reason it varies depends on what type of project I am working on. FromEvent is used in the phone’s Rx library while the desktop Rx library has evolved since the phone was released and has changed the name of the method to FromEventPattern.

Windows Phone travel tip – pin your map locations

BenWilli — Mon, 07 Nov 2011 19:02:25 GMT

Whenever I’m travelling I always have two freshly pinned tiles at the bottom of my start screen. Before I leave, I use my phone to look up the hotel I’m staying at and the location I’m visiting (like a customer’s address) and pin them both to the start screen. That way while I’m in an unfamiliar city I can easily find my way back to either of the two major way points during my trip without needing to dig through old emails to find the addresses. Just click the hotel tile, then click directions and I instantly know how to find my way back to a comfortable bed.

Bonus points if you also add an additional tile for the local weather!

(posted from 35,000 feet with my phone already ready to guide me through the city when I land)

Populating Windows Phone view models with Rx

BenWilli — Tue, 01 Nov 2011 23:13:00 GMT

I’ve gotten rather fond of using the Reactive Extensions for populating my data from the web in my Windows Phone applications. They provide a lot of flexibility and the code stays in a readable form.

To demonstrate in a traditional MVVM model, let’s drop some movie information from Netflix onto our Windows Phone screen. First we need a structure to hold that movie data.

public struct MovieData
{
public string Name { get; set; }
public string Description { get; set; }
}

We also need a view model for the view to bind to. The view model will expose two interesting properties for the the UI use. The NetworkBusy property can be bound to a progress bar to automatically show/hide the bar while the underlying network service is busy. The Movies property can be bound to a listbox so that the user can scroll through the list.

public ObservableCollection<MovieData> Movies { get; set; }
private bool _networkBusy = false;
public bool NetworkBusy {
get { return _networkBusy; }
set {
if (_networkBusy != value)
{
_networkBusy = value;
RaisePropertyChangedNotification("NetworkBusy");
}
}
}

If our service class provides the view model with an IObservable<MovieData> when we ask for all the movies, we can just subscribe to the stream of MovieData objects it provides and add them to our Movies collection. Furthermore, since an Observable sequence provides error and completion notifications, we will know exactly when to disable the progress bar the UI uses by setting NetworkBusy to false. We can also take action on errors as needed. So we’d like it to be as simple as this.

public void LoadData()
{
NetworkBusy = true;
Movies.Clear();
var svc = new MovieService();
var results = svc.GetMovies();
results.ObserveOnDispatcher().Subscribe(
item => Movies.Add(item),
ex => { LogException(ex); NetworkBusy = false; },
() => NetworkBusy = false
);
}

Also, note that the only thing we need to do to avoid accessing the UI on the wrong thread is to add ObserveOnDispatcher() to the mix.

Next we need to build the method on the MovieService class that will generate the Observable stream of MovieData objects for the view model. In this case we will return all the films that have a rating greater than 4. Here is the code for the method. I’ll break it down after the snippet.

public IObservable<MovieData> GetData()
{
// create the observable for the download event
WebClient wc = new WebClient();
var o = Observable.FromEvent<DownloadStringCompletedEventArgs>(wc, "DownloadStringCompleted");
// initiate the transfer
wc.DownloadStringAsync(new Uri("http://odata.netflix.com/Catalog/Titles?$filter=AverageRating gt 4"));
// convert string to data we are interested in
var results = o.Take(1).SelectMany(item =>
{
// use LINQ to XML to project the XML nodes
// to a collection of MovieData objects
var doc = XDocument.Parse(item.EventArgs.Result);
var movies = from movie in doc.Descendants(XName.Get("entry","http://www.w3.org/2005/Atom"))
select new MovieData
{
Name = movie.Element(XName.Get("title", "http://www.w3.org/2005/Atom")).Value,
Description = movie.Element(XName.Get("summary", "http://www.w3.org/2005/Atom")).Value
};
return movies;
});
return results;

Lines 4-5: create the WebClient and subscribe to the event in a manner that provides us an Observable. Because this wraps the even, ‘o’ is of type IObservable<DownloadStringCompletedEventArgs>

Once the download is initiated we provide some filtering and projection to the current sequence to transform it to an IObservable<MovieData> and return that to the user. The consumer doesn’t want to deal with EventArgs, he wants MovieData!

Line 11: Take(1) - Normally observables wrapped around events never complete. Adding Take(1) provides us the completion event because we know the event will only be raised once. 1 web request = 1 web response.

Line 11: SelectMany(…) – The single response of the web request is a string that contains multiple movies. If we just did Select() and returned a collection of MovieData objects, the consumer would have to loop over collection. If we use SelectMany(), the collection gets flattened out and we will return just the MovieData objects in the sequence.

Lines 15-21: take the resulting downloaded string and transform it with LINQ to XML into a collection of MovieData objects

Additional Fun: This on its face is a nice enough pattern, but there are a couple of others patterns which can emerge nicely on top of this one.

If you create multiple requests at the same time you can easily compose an observable from all of them in order to determine when all of them are complete.
With a single stream, you can create multiple sub streams to populate things like “first 10 items” on your front page or create filtered lists for pivots very easily.
If you leave out the Take(1) you leave open the possibility to reuse the WebClient again and continue to push additional pages of data back into the view model without the view model needing to be aware of the paging going on – its just waiting for a stream of MovieData’s

Type, don’t look!

BenWilli — Thu, 18 Aug 2011 19:00:05 GMT

Just a quick tip for Windows Phone users regarding the onscreen keyboard. Most people I’ve talked to who complain about using an onscreen keyboard have a common issue. They are looking at what they type. This is their biggest mistake. When I first started using my Samsung Focus device I was getting a little frustrated with the results of my typing as well. I’d hit a wrong key then back up and fix it then hit another wrong key and back up and fix it too. Then I discovered the secret. Don’t look at what you are typing until you are done. This provided me two benefits: (1) I can look at the keyboard instead which helps while you are getting used to the size of a different keyboard and (2) I started to let the phone’s amazing keyboard do its thing.

Stop fighting it. Its really very smart.

Don’t try to out smart it. Blaze away at the keys as best as you can and then look up only when your sentence is finished. I think you’ll be pleasantly surprised at how few corrections you have to make at this point… and you just might start to impress people with your newly found speed texting skills.