Most browsers (if not all of them) have only one thread, which means that while a script is loading in a form or one of it's frames, the others simply wait and not respond to user actions. For loading of contents to an HtmlBox that takes a considerable amount of time, this makes your application non-responsive until the load compleates.

This article presents a best-practice, of using an asynchronous pattern for loading the HtmlBox's contents via BeginInvoke initiated delegate with an asynchronous callback and then a Timer to make sure your UI gets updated.

What exactly goes on behind the scenes threadwise, can be read in the referenced articles in the References section. What this does to, or more precisely for, your application is clearly demonstrated by the attached demo application. The application loads a "long running" contents into two HtmlBoxes. The contents will delay the load for 5 seconds before returning. One of the buttons will load the contents into each HtmlBox one after the other, with a total loading time of 10 seconds, and while waiting, the application does not respond to UI requests like mouse clicks. The other button uses the BeginInvoke method which will load the contents in parallel, both at the same time, and the total loading time will be 5 seconds with the application fully responding to UI requests while loading.

The downside of using this method is that the asynchronous callback will reach your server-side code, and as with other updates coming in from a different thread than the UI thread, the server can not initiate the update of the browser UI. That update must be initiated from the browser. You can choose to just leave it that way, and your UI will be updated as a part of the next request your browser sends to the server, or you can do as we chose to do in this demo application, to add a Timer to your form which will make sure those requests will be made on a regular basis.

Demo application loading contents to two HtmlBox controls

Although this asynchronous approach does keep your application fully responsive while the long-running loads are taking place, you need to be aware of that the processing power required is of course consumed by the target of your request. If the target of the request is a gateway within your application, this may be a concern, depending on the resource intensivity of the request.

Using this BeginInvoke approach will post your long-running request, and then your request is set on IO-wait-hold, until the long-running request has been handled, then a new thread is created to perform the callback to your callback procedure. This new thread is allocated from an IIS thread pool which is a different threadpool than your worker threads are allocated from, but still it is a limited resource as any other resource. In extream cases this might become a problem, and in the Other references section you will find articles on how you can have these threads allocated from a custom threadpool.

• HTML holds web page

• Build Asynchronous Handlers in Your Server-Side Web Code
  
• Asynchronous Delegated Programming Sample

• Use Asynchronous Execution Pattern in ASP.NET
  
• Best Practices for Implementing the Event-based Asynchronous Pattern
  
• Asynchronous pages in ASP.NET 2.0
  
• Processing Long Running Tasks With Asynchronous Handlers and XMLHTTP
  
• Run a .BAT file from ASP.NET
  
• Run a Command Shell Executable from ASP.NET
  
• WebRequest class
  
• Using WebRequest and WebResponse classes
  
• Retrieving HTTP content in .NET