Windows 8 Metro Runtime comes with many innovations to be used by us developers. There are quite a number of new features also regarding the Web and Http namespaces.

Imagine you were dealing with a long lasting http communication scenario. It involves an HttpRequest and a response that takes quite a while to download. In windows runtime spirit, you want to have a download progress (since this falls into the determinate progress category).

If we were not dealing with a custom HttpRequest, the perfect fit for this scenario would actually be the Background Transfer Api. However, you want to have the IAsyncOperationWithProgress using the HttpClient . (i.e. You want to have an awaitable operation that gives you progress updates and that you can easily cancel with a cancellation token.

So we start by defining our function signature:

We define it as an extension method to HttpClient. The function takes in two parameters:

• HttpRequest request               : The request that we are going to send to the server
• CancellationToken token        : The cancellation token reference that we are going to use to be able to cancel the asynchronous call.

We could have as well declared the progress callback function here as a parameter, but this is not a very common pattern.

In our quest, we will be using the AsynInfo.Run<TResult,TProgress> method to create our IAsyncOperationWithProgress. For this scenario, result type would be string (i.e. we are downloading a string) and let’s say the progress type is integer (i.e. the number of bytes downloaded already). This method has a single parameter (so-called task provider) that is the delegate to create and start the task. In our delegate method (from AsyncInfo.Run<TResult, TProgress>)

The started task is represented by the Windows Runtime asynchronous action that is returned. The function is passed a cancellation token that the task can monitor to be notified of cancellation requests, and an interface for reporting progress; you can ignore either or both of these arguments if your task does not support progress reporting or cancellation.

So if we were to create a stub, it would look something like (Task.Run part is just a place holder):

So we create the send request operation (however, not executing it), and returning our async operation with progress. Crucial point here is that the completion option for the http request is set to ResponseHeadersRead, meaning, the operation should complete as soon as the headers are received from the remote server. We want to handle the body of the response with our task provider.

Notice that if the cancellation token that comes as a parameter from our method is not an empty one, we are assigning it to the current synchronization context’s token.

Next step is to actually declare our task provider. Under normal circumstances, the task provider would simply use a cancellation token (i.e. of type CancellationToken) and the progress callback (i.e. of type IProgress<int> in our case). However, we also need the reference to the send request operation.

So we basically have to slowly execute our request (i.e. after the headers are downloaded, use a small enough buffer to go through the response stream, so we can send back progress updates), and return the result in async manner.



In (not so) short, we have a buffer of 500 bytes, and initial offset of 0. Then we

• Execute our http operation (the operation will anyways complete as soon as we receive the header response)
• Open the stream to read the body of the response.
• In each buffer read, we send a progress callback reporting the current offset.

One thing we forgot is the cancellation token. In each read sequence (i.e. in the while loop), we can actually check if there is any signal from the source about the cancellation.

This actually completes the implementation of the task provider, we can just plug it into our public function.



You can easily extend this extension class having a version that returns a Stream or IBuffer according to your needs. In this current version, you would be getting the number of bytes received as the progress information.

To use the implemented extension method we need first to implement the progress handler function (i.e. Action<int>):

IMPORTANT: Something to note here, is the fact that, if you were to update the UI with this progress value, you would need to use the Dispatcher.RunAsync function to marshal the calls back to the ui thread.




The rest of the execution is quite straightforward:



If the cancellation token is invoked either by the defined time frame or by the Cancel method, the task will throw OperationCanceledException, otherwise if there is a network problem, you can expect an HttpRequestException.


 Client Application Debug View - Operation Cancelled Exception


IMPORTANT: One more important note is about the fact that the server should be using the “chunked” transfer-encoding and no buffered transfer. By buffered transfer, I am referring to people (like myself) who will definitely open fiddler and try to see the transfer in chunks. This will be a big disappointment since Fiddler actually acts as a proxy (more as a middle man) and only after the whole response is downloaded, passes it on to the actual recipient.

Here is a test server implementation which would give you enough time to see what is going on and compare the reception of the stream:




You can download the full sample from : HttpClient Sample

Happy coding everyone...