URL (Uniform Resource Locator) Rewriting

Maintain Original URL

When handling virtual URLS such as http://www. somebloghost.com/Blogs/gaidar/?Sort=Asc (that is, a virtual URL with query string parameters), it is important that you clearly distinguish parameters that were passed via a query string from parameters that were passed as virtual directories. Using the rewriting rules specified below:

<rule source="(.*)/Default.aspx" destination="Default.aspx?Folder=$1"/>,

You can use the following URL:

http://www. somebloghost.com/gaidar/?Folder=Blogs

And the result will be the same as if you used this URL:

http://www. somebloghost.com/Blogs/gaidar/

To resolve this issue, we have to create some kind of wrapper for 'virtual path parameters'. This could be a collection with a static method to access the current parameters set:

namespace UrlRewriteModule
{
    #region[Directive]
    using System;
    using System.Collections.Generic;
    using System.Collections.Specialized;
    using System.Linq;
    using System.Text;
    using System.Web;
    #endregion[Directive]
    /// <summary>
    /// This class is use to create wrapper of virtual path parameters.
    /// This is content some static methods to access current parameter set.
    /// </summary>
    public class ReWriteContext
    {
        #region[PublicField]
        /// <summary>
        /// Get the RewriteContext
        /// </summary>
        public static ReWriteContext Current
        {
            get
            {
                if (HttpContext.Current.Items.Contains("RewriteContextInfo"))
                {
                    return HttpContext.Current.Items["RewriteContextInfo"] as ReWriteContext;
                }
                else
                    return new ReWriteContext();
            }
        }

        /// <summary>
        /// Initialize object with parameterize constructor
        /// </summary>
        /// <param name="param">provide namevalueCollection</param>
        /// <param name="baseUrl">provide baseUrl</param>
        public ReWriteContext(NameValueCollection param, string baseUrl)
        {
            Params = new NameValueCollection(param);
            InitialUrl = baseUrl;
        }

        /// <summary>
        /// Initialize object with the default setting
        /// </summary>
        public ReWriteContext()
        {
            _Params = new NameValueCollection();
            _initialUrl = string.Empty;
        }

        public NameValueCollection Params
        {
            get { return _Params; }
            set { _Params = value; }
        }

        public string InitialUrl
        {
            get { return _initialUrl; }
            set { _initialUrl = value; }
        }

        #endregion[PublicField]

        #region[PrivateField]
        private NameValueCollection _Params;
        private string _initialUrl;
        #endregion[PrivateField]

    }
}

Rewriting URL

For rewriting the url we have implement the module. Which will take care of all the url rewriting technique. The code for this is provided in below.

namespace UrlRewriteModule
{
    #region[Directives]
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Text.RegularExpressions;
    using System.Web;
    using System.Configuration;
    using System.Xml;
    #endregion[Directives]

    public class ReWriteModule:IHttpModule
    {

        public void Dispose()
        {
            throw new NotImplementedException();
        }

        public void Init(HttpApplication context)
        {
            ////This event handler is execute during the BeginRequest Handler
            context.BeginRequest += new EventHandler(RewriteModule_BeginRequest);
            ////This event will execute during PreRequestHandler Execute
            context.PreRequestHandlerExecute += new EventHandler(RewriteModule_PreRequestHandlerExecute);
        }

        /// <summary>
        /// PreRequestHandler it will execute before request process to the handler
        /// </summary>
        /// <param name="sender">the object which will execute this event</param>
        /// <param name="e">Event argument that is contain all the known argument value</param>
        void RewriteModule_PreRequestHandlerExecute(object sender, EventArgs e)
        {
            HttpApplication application = (HttpApplication)sender;
            if ((application.Context.CurrentHandler is System.Web.UI.Page)
                && (application.Context.CurrentHandler != null))
            {
                System.Web.UI.Page page = application.Context.CurrentHandler as System.Web.UI.Page;
                page.PreInit += new EventHandler(page_PreInit);
            }
        }

        /// <summary>
        /// It event will execute during the pre initialization of
        /// page
        /// <remarks>
        /// This method checks if the user requested a normal ASP.NET
        /// page and adds a handler for the PreInit event of the page lifecycle.
        /// This is where RewriteContext will be populated with actual parameters and
        /// a second URL rewriting will be performed. The second rewriting is necessary to make
        /// ASP.NET believe it wants to use a virtual path in the action attribute of an HTML form.
        /// </remarks>
        /// </summary>
        /// <param name="sender">represent the page object</param>
        /// <param name="e">argument that contain </param>
        void page_PreInit(object sender, EventArgs e)
        {
            if (HttpContext.Current.Items["OriginalUrl"] != null)
            {
                string path = (string)HttpContext.Current.Items["OriginalUrl"];

                ReWriteContext reWriteContex = new ReWriteContext(HttpContext.Current.Request.QueryString, path);

                if (path.IndexOf("?") == -1)
                    path = path + "?";
                HttpContext.Current.RewritePath(path);
            }
        }

        /// <summary>
        /// It will execute BeginRequest has execute
        /// </summary>
        /// <param name="sender">Represent the object that execute the event</param>
        /// <param name="e">Provide argument that is pass as EventArg</param>
        void RewriteModule_BeginRequest(object sender, EventArgs e)
        {
            ////Read configuration section using rewriteModuleSection
            UrlRewrittingModuleHandler rewriteModuleSection = (UrlRewrittingModuleHandler)ConfigurationManager.GetSection("modulesSection/rewriteModule");

            ////check rewrite option hasbeen on or off
            if (!rewriteModuleSection.RewriteOn)
                return;

            ////Keep the current request path
            string path = HttpContext.Current.Request.Path;

            ////Check for path length
            if (path.Length == 0)
                return;

            ////Get the rule section from the xmlconfig file
            XmlNode rules = rewriteModuleSection.XmlSection;
            foreach (XmlNode node in rules.SelectNodes("rewriteRules/rule"))
            {
                try
                {
                    ////Create regural excepresion for further match
                    Regex re = new Regex(rewriteModuleSection.RewriteBase + node.Attributes["source"].InnerText, RegexOptions.IgnoreCase);
                    ////Check the match
                    Match match = re.Match(path);
                    ////match is Success or Unsuccess
                    if (match.Success)
                    {
                        ////Replace the old url with the destination one
                        path = re.Replace(path, node.Attributes["destination"].InnerText);

                        ////Check path length
                        if (path.Length != 0)
                        {
                            ////check for querystring count
                            if (HttpContext.Current.Request.QueryString.Count != 0)
                            {
                                ////check for sign
                                string sign = path.IndexOf("?") == -1 ? "?" : "&";
                                ////Reconfigure the path
                                path = path + sign + HttpContext.Current.Request.QueryString;
                            }
 
                            ////Write newly change one
                            string newUrl = rewriteModuleSection.RewriteBase + path;

                            ////Writting the OriginalUrl for future referance
                            HttpContext.Current.Items.Add("OriginalUrl", HttpContext.Current.Request.RawUrl);

                            ////Rewrite the url
                            HttpContext.Current.RewritePath(newUrl);
                        }

                        return;
                    }
                }
                catch (System.Exception ex)
                {
                    throw (new Exception("Incorrect rule.", ex));
                }
            }
            return;
        }
    }
}

Summary

In this article, we learned the URL rewriting concept in ASP.NET and how to implement it using the regular expressions.

Resources

Here are some useful related resources:

• URL Rewriting in ASP.Net
• Introduction to ASP.NET URL Rewriting with HttpHandler
• URL Rewriting in ASP.NET using C#
• Quick Steps to URL Rewriting in Asp.net 4.0