What is “URL
rewriting”?
Most sites include variables in their URLs that tell the
site what information to be shown to the user. It is something like telling the
code to load particular details of item number 7 from a shopping site.
For example, the site may look like below:
The problem with the above URL is it cannot be remembered.
It is even difficult to read on your mobile. Even the search engines like
Google cannot get any information about the content of a page from the URL.
What if you wanted to convey that itemid = 7 means a laptop with brand as
“DELL”? This is not speaking what it
should speak.
So, what we expect from the above URL is it should be
understandable just at the first look. Will it not be good if the URL is as
below?
Now looking at the above URL you can easily tell that it is
related to laptops and the brand is DELL. So, there is a need to rewrite URL to
be somewhat meaningful and easily conveyable.
How to rewrite URL in
ASP.NET?
To rewrite URLs in ASP.NET we are going to use HTTP Modules.
HTTP Modules are called before and after the HTTP handler executes. HTTP
modules help us to intercept, participate in, or modify each individual
request. HTTP Modules implement IHttpModule interface, which is located in
System.Web namespace. Modules are the ones which handles authentication and
authorization of the ASP.NET applications. If you want to implement encryption
of URL string or any custom changes to the application, it can be done by
writing our HTTP Module.
Straight to the point, let us create a class in your app_Code
directory called “URLRewriter.cs” and add the following code:
1.
Create a web site using visual studio and name
it as “URLRewriteTestingApp” and add a class file “URLRewriter.cs”.
2.
Visual Studio will ask you that it will create a
directory called “App_Code” and place the class file in the folder. Select “OK”
to proceed.
Your solution structure should
look something like this:
3.
Now open the file “URLRewriter.cs” and add the
code for HTTP Module as below:
Basically your class must implement the
IHttpModule interface to implement its methods. You will see these 2 methods
created for you once you implement the interface.
-
Dispose
-
Init
Init method takes HttpApplication as a parameter. So, you need to create
an event handler for begin request of the HttpApplication to handle the
request.
Here
is your code for the Module:
using System;
using System.Web;
/// <summary>
/// Summary description for URLRewriter
/// </summary>
public class URLRewriter : IHttpModule
{
#region IHttpModule
Members
/// <summary>
/// Dispose
method for the class
/// If you
have any unmanaged resources to be disposed
/// free them
or release them in this method
/// </summary>
public void
Dispose()
{
//not implementing this method
//for this example
}
/// <summary>
///
Initialization of the http application instance
/// </summary>
/// <param name="context"></param>
public void
Init(HttpApplication context)
{
context.BeginRequest += new EventHandler(context_BeginRequest);
}
/// <summary>
/// Event
handler of instance begin request
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void context_BeginRequest(object sender, EventArgs
e)
{
//Create an instance of the
application that has raised the event
HttpApplication httpApplication = sender as HttpApplication;
//Safety check for the
variable httpApplication if it is not null
if
(httpApplication != null)
{
//get the request path -
request path is something you get in
//the url
string requestPath = httpApplication.Context.Request.Path;
//variable for translation path
string
translationPath = "";
//if the request path is
/urlrewritetestingapp/laptops/dell/
//it
means the site is for DLL
//else if
"/urlrewritetestingapp/laptops/hp/"
//it
means the site is for HP
//else it
is the default path
switch
(requestPath.ToLower())
{
case
"/urlrewritetestingapp/laptops/dell/":
translationPath = "/urlrewritetestingapp/showitem.aspx?itemid=7";
break;
case
"/urlrewritetestingapp/laptops/hp/":
translationPath = "/urlrewritetestingapp/showitem.aspx?itemid=8";
break;
default:
translationPath = "/urlrewritetestingapp/default.aspx";
break;
}
//use server transfer to
transfer the request to the actual translated path
httpApplication.Context.Server.Transfer(translationPath);
}
}
#endregion
}
4.
Now open your default.aspx page in the solution
and add the following html:
This code is to display two laptop brands
HP and DELL.
Note:
Since I am not deploying the application in IIS you will see the runtime
host created by Visual Studio as localhost:8648. If your application has
different port number or if you have hosted your web application in IIS, you
may have to change the values of href in the following html.
<%@ Page
Language="C#"
AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>
<!DOCTYPE html
PUBLIC "-//W3C//DTD
XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title>Laptop Brands</title>
</head>
<body>
<form
id="form1"
runat="server">
<div>
<a
href="http://localhost:8648/URLRewriteTestingApp/laptops/Dell/">Dell
</a>
<br/>
<a href="http://localhost:8648/URLRewriteTestingApp/laptops/HP/">HP</a>
</div>
</form>
</body>
</html>
5.
Since we are placing references in the html code
we do not need to do anything in the code behind file. Now add one more webform
ShowItem.aspx in the website. This page is to display the actual data that
clicking on the hyperlink in the default page should take it to. We are just
trying to make the application look simple and so we just display the name of
the laptop and a back button.
6.
HTML of the ShowItem.aspx page looks like as
below:
<%@ Page Language="C#"
AutoEventWireup="true"
CodeFile="ShowItem.aspx.cs"
Inherits="ShowItem"
%>
<!DOCTYPE html PUBLIC
"-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title>Untitled
Page</title>
</head>
<body>
<form id="form1" runat="server">
<div>
<asp:Label runat="server" ID="labelShow"></asp:Label>
<br/>
<br/>
<asp:Button runat="server" ID="back" Text="Back"/>
</div>
</form>
</body>
</html>
7.
Code behind file looks like as below:
Code behind is to display the text of the
laptop and back button event handler that takes back the user back to the
default page.
using System;
public partial class ShowItem :
System.Web.UI.Page
{
/// <summary>
/// Page load
event for the page
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void
Page_Load(object sender, EventArgs e)
{
//read the query string value of itemid that
is coming
//from default page when user clicks on the
hyperlink
string laptopName = Request.QueryString["itemid"];
//if value is "8" display the text
of the label as "HP"
//else display the label as "DELL"
labelShow.Text = laptopName == "8"
? "HP" : "DELL";
//back button event handler
back.Click += new EventHandler(back_Click);
}
/// <summary>
/// Back
button click event
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void back_Click(object
sender, EventArgs e)
{
//transfer the page back to default.aspx
Server.Transfer("../default.aspx");
}
}
8.
Now we need to configure our custom HttpModule
“URLRewriter” in the configuration file to use the module.
<system.web>
<httpModules>
<add name="URLRewriter" type="URLRewriter"/>
</httpModules>
</system.web>
Now our coding is complete and let us test our application
by pressing F5 button.
Our default.aspx page:
When I place my cursor over Dell, the URL looks like http://localhost:8648/URLRewriteTestingApp/laptops/Dell/
and similarly if you place your cursor on HP, it should look like http://localhost:8648/URLRewriteTestingApp/laptops/HP/
Put break points in your HTTP Module methods and now click
on any of the hyperlinks:
I clicked on the Dell and the value at the breakpoint now
shows the value of requestPath.
Now the requestPath variable value is
“/URLRewriteTestingApp/laptops/Dell/”.
Our rewriting code must now identify the requestPath and change the path
to the actual URL path so that correct page gets called in the IIS by the
engine. So, our translated path will be “/urlrewritetestingapp/showitem.aspx?itemdid=7”.
Now the page looks like below:
Clicking on the “Back” button will take the user to the
default page.
Hope you like this article. If you have more number of URLs
to be maintained in your application, it is better to handle the URLs by one
dedicated server that processes the requests and redirects the request to the
relevant page for processing.