The devil is in the detail as they say. As Silverlight is essentially a client-based runtime, a large amount of resource will be invested in downloading data, posting data and generally interacting with resources external to the client. This means frequent use of the WebClient or the associated WebRequest classes.
All of Silverlight’s APIs for interacting with resources on the web are async by nature. This means that it looks by the design of the API that we can easily do all our interaction on a separate thread and let the UI thread do it’s important rendering work. However, as is always with Silverlight, all is not as it seems. This is because even though Silverlight lets you do all the interaction on a thread other than the UI thread, the networking is ALWAYS marshalled back to the UI thread at some point in the networking stack.
What does this mean for me as a developer?
It means, that even though you have invested time and effort to keep the UI thread as empty as possible, the Silverlight runtime will execute networking operations back onto the thread that is in most applications, starved of resources.
Can we prove this?
Definitely. Below I’ve included a solution to download which proves the point. It allows the user to schedule (using Rx of course 🙂 ), every second, a web request to a local long running http handler. The picture below shows this:
Clicking either the webclient or webrequest buttons will in an infinite loop, on the thread pool, download the result from a local HttpHandler. Clicking the 3rd button will simply do a Thread.Sleep() on the UI thread. If you hook up Fiddler, as required by the solution, you will notice that the web requests stop, and wait until the UI thread is released. Once the UI thread has been released, all the queued web requests will all start executing and catch up.
What does this mean for me?
This should, in my opinion, be considered a bug in the runtime. In my current role, we stream pricing data very quickly to our controls with the data being incredibly time sensitive. Our UI is also very busy rendering some quite complex controls, animations and UI interactions. If our UI is busy rendering frames, it means it cannot process network calls. If it is busy processing network calls, it cannot process rendering requests. For busy, complex LOB Silverlight application this poses a very large problem for the developer. How can we justify networking shuddering to a halt, because a large control is being rendered? The answer is that unfortunately, there is no answer. We either have to slow down our networking calls, potentially caching if possible, or render less to the UI.
This bug exists in both Silverlight 3.0 and 4.0, and I definitely think the runtime requires a fix. Is this a problem where the browser is imposing this restriction? Is it a simple restriction that the runtime places on us as developers for some esoteric reason?
Thanks must go to the guys in the office, who came up with this simple test to prove the UI interaction in the networking stack.
Source code download