Rewriting URLs in ASP.NET without using ISAPI.

I've been following the new ASP.NET MVC framework fairly closely over the last few weeks.

Phil Haacked recently posted on the ability to use REST style URL's with ASP.NET MVC.

So what's IMHO the main aspect of the MVC framework? It uses a REST-like approach to ASP.NET Web development. It implements each request to the Web server as an HTTP call to something that can be logically described as a "remote service endpoint". The target URL contains all that is needed to identify the controller that will process the request up to generating the response--whatever response format you need

The ASP.NET MVC framework is still months away from release, so I have been writing CodeBlog (Yeah, thats the temporary name of my little blog engine) using standard 3-tiered design with WebForms for the presentation layer.

However, I still wanted to take advantage of REST style url's, even if I was largely faking it.

This means that I want:

http://yourdomain.com/ViewSinglePost.aspx?PostId=1241414

To become:

http://yourdomain.com/Posts/ThisIsAExamplePost/

To do URL Rewriting on ASP.NET usually requires the installation of a ISAPI module, requiring Admin access to IIS. I want to run CodeBlog on a shared server. This forces me to implement URL Rewriting entirely in my code.

I solved this problem by creating a HTTPModule that contains a Application_BeginRequest event handler. This is called for each request to the ASP.NET service.

A crucial flaw of this design became obvious when I tested the HTTPModule under IIS 5.1 (Yeah, I'm still running XP here. I really need to upgrade.)

IIS automatically serves the default 404 error without invoking ASP.NET, so the Application_BeginRequest event is never fired. This can be fixed by assigning a ASPX page to IIS's 404 Error mapping.



Or, in the case of a shared server, just setting the default 404 Error page to point to an ASPX file. This can usually be done within the hosts control panel.

Creating a 404.aspx file allows you to generate a nice clean custom error if you really do need to serve a 404 error, so I recommend doing this even if you do not use URL Rewriting.

With that problem solved, the HTTPModule was intercepting and transferring URL's without a hitch. The full code of the HTTPModule is below:

    1 using System;

    2 using System.Web;

    3 using System.Collections;

    4 using CodeBlog.BOL;

    5 

    6 namespace CodeBlog.HttpModules

    7 {

    8     public class UrlRewrite : IHttpModule

    9     {

   10 

   11         public void Init(HttpApplication application)

   12         {

   13             application.BeginRequest += (new EventHandler(this.Application_BeginRequest));  

   14 

   15         }

   16 

   17         private void Application_BeginRequest(Object source, EventArgs e)

   18         {

   19             // The RawUrl will look like:

   20             // http://domain.com/404.aspx;http://domain.com/Posts/SomePost/

   21 

   22             if (HttpContext.Current.Request.RawUrl.Contains(";")

   23                     && HttpContext.Current.Request.RawUrl.Contains("404.aspx"))

   24             {

   25                 // This places the originally entered URL into url[1]

   26                 string[] url = HttpContext.Current.Request.RawUrl.ToString().Split(';');

   27 

   28                 // Element 0-2 of this string array are the domain.

   29                 string[] urlInfo = url[1].Split('/');

   30                 if (urlInfo.Length > 2)

   31                 {

   32                     // Element 3 defines the action

   33                     string action = urlInfo[3];

   34 

   35                     // In this case, we only care about one action: POSTS

   36 

   37                     if (action.ToUpper() == "POSTS" && urlInfo.Length > 4)

   38                     {

   39                         // The key value is passed after posts...IE : Posts/SomePost/

   40                         string key = urlInfo[4];

   41 

   42                         // This code verifies that there is a matching Post in the database

   43                         // by calling our handy static Business Object PostService.

   44                         int postId = PostService.GetPostIdFromUrlKey(key);

   45 

   46                         if (postId != int.MinValue)

   47                         {

   48                             // Using Server.Transfer changes the response to

   49                             // the new page without letting the client know, so the fake URL remains.

   50                             Server.Transfer("/ViewSinglePost.aspx?PostId=" + postId.ToString());

   51                         }

   52                         else

   53                         {

   54                             // No Matching Post was found.

   55                             HttpContext.Current.Response.Redirect("/NoPostFound.aspx");

   56                         }

   57                     }

   58                 }

   59             }

   60 

   61             // If we get here, then the actual contents of 404.aspx will get loaded.

   62         }

   63 

   64         public void Dispose()

   65         {

   66             // Needed for implementing the interface IHttpModule.

   67         }

   68     }

   69 }

This module is compiled into its own class project and included as a reference in my main CodeBlog project. In the case of doing real URL Rewriting, you can define rewrite rules in that Application_BeginRequest method, instead of just faking REST with a quick post lookup.

To use a HTTPModule, you just need to add a few lines to your web.config:

    1 <httpModules>

    2   <add name="UrlRewrite" type="CodeBlog.HttpModules.UrlRewrite" />

    3 </httpModules>

Hopefully this helps a few people out who are trying to implement Url Rewriting on shared hosts, or on older versions of IIS.