In ASP.NET 2.0 it is now possible to create asynchronous pages in a very simple and easy way. It gives you a whole new abstraction layer on top of the managed thread pool that let’s any webpage take advantage of multithreading. On high volume websites it means much higher performance. The single coolest thing about it is that you build the web pages as you normally would, but move some of the code into two separate methods. That means that there is no real learning curve, because of the simplicity.

The only thing needed to make is the use of classes that have asynchronous methods. It could be calling web services, doing database queries, creating a web request or many other things. In this example I’ve chosen a web request because it is the simplest to demo. The page makes an asynchronous request to a website and writes the HTTP status code to the response stream.

First of all, we have to tell the page that is has to work in asynchronous mode. We do that by adding the Async=”true” attribute to the page declaration.

<%@ Page Language="C#" Async="true" CodeFile="asyncpage.aspx.cs" Inherits="asyncpage" %>

Then we just have to add two methods and register them in the Page_Load event handler.

using System.Net;

 

protected void Page_Load(object sender, EventArgs e)

{   

  AddOnPreRenderCompleteAsync(BeginGetAsyncData, EndGetAsyncData);

}

 

private HttpWebRequest _Request = (HttpWebRequest)WebRequest.Create("http://www.google.com");

 

private IAsyncResult BeginGetAsyncData(Object src, EventArgs args, AsyncCallback cb, Object state)

{

  return _Request.BeginGetResponse(cb, state);

}

>

 

private void EndGetAsyncData(IAsyncResult ar)

{

  using (HttpWebResponse response = (HttpWebResponse)_Request.EndGetResponse(ar))

  {

    Response.Write(response.StatusCode);

  }
}

As you can see from the example, only very few extra lines of code is needed to make the page render asynchronously. Even though they are far from alike, it reminds me of the BackgroundWorker in Windows Forms.

I’ve been playing a bit with regular expressions lately and have to find some useful tasks in order to practice the skill. So, today I wanted to make a little method that strips HTML comments from an ASP.NET webpage at runtime. The practical use of the exercise is somewhat limited for most developers, but some websites have so many comments that it might just save a decent amount of bytes from the response stream.

The problem with this exercise is that a lot of JavaScript is using HTML comments to hide it’s workings from older browsers. That would mean that those script tags would be empty. That’s why I made a rule saying that every JavaScript has to implement the HTML comments correctly. Some don’t so you have to change it your self.

This is how the JavaScript is wrongly commented which also breaks my regex.

<script type="text/javascript">

<!--

  function Name()

  {  

  }

-->

</script>

The commenting should look like this which is also the right way to do it.

<script type="text/javascript">

<!--//

  function Name()

  {  

  }

//-->

</script>

The regular expression is very simple and all you need to do is to add the following method to your webpage, user control or master page.

using System.IO;

using System.Text;

using System.Text.RegularExpressions;

 

private static Regex _Regex = new Regex("((<!-- )((?!<!-- ).)*( -->))(\\r\\n)*", RegexOptions.Singleline);

 

protected override void Render(HtmlTextWriter writer)

{

  using (StringWriter sw = new StringWriter())

  {

    using (HtmlTextWriter htmlWriter = new HtmlTextWriter(sw))

    {

      base.Render(htmlWriter);

      writer.Write(_Regex.Replace(sw.ToString(), string.Empty));

    }

  }
}

Maybe not the most useful stuff I've ever written, but fine for learning. The only thing that bugs me is the JavaScript rule.

>