Urlriter实现URL重写

在。NET中实现URL重写有两种方法
httphandle和Urlriter
httphandle请看这里
Urlriter原文在这里
可以下载到例子的原代码
基本过程可以通过web.onfig得之
设置一个处理类
configSections>
<section name="RewriterConfig" type="URLRewriter.Config.RewriterConfigSerializerSectionHandler, URLRewriter" />
</configSections>
配制处理的URL
<ewriterConfig>
<Rules>
<!-- Rules for Blog Content Displayer -->
<RewriterRule>
<LookFor>~/abc/.aspx</LookFor>
<SendTo>~/index.aspx</SendTo>
</RewriterRule>
</Rules>
</RewriterConfig>
为 URL 重写引擎指定配置信息
<system.web>
<httpModules>
<add type="URLRewriter.ModuleRewriter, URLRewriter" name="ModuleRewriter" />
</httpModules>
</ystem.web>
思路就是这样的了，和httphandle不同，httphandle就像系统自带的，需要你去写配制文件处理，直接就可以用,并且可以在内部处理请求输出
Urlriter则需要你去写,它的好处是对于web.config中配制，你不必像httphandle一样为每一个节点去写一个类

URLRewriter.Config名称空间

RewriterConfigSerializerSectionHandler.cs

这个类返回一个反序列化 XML 文档
using System;
using System.Configuration;
using System.Xml;
using System.Xml.Serialization;
using System.Xml.XPath;

namespace URLRewriter.Config
{

public class RewriterConfigSerializerSectionHandler : IConfigurationSectionHandler
{

public object Create(object parent, object configContext, System.Xml.XmlNode section)
{
// Create an instance of XmlSerializer based on the RewriterConfiguration type...
XmlSerializer ser = new XmlSerializer(typeof(RewriterConfiguration));

// Return the Deserialized object from the Web.config XML
return ser.Deserialize(new XmlNodeReader(section));
}

}
}
RewriterConfiguration.cs

返回配制节点信息

using System;
using System.Web;
using System.Web.Caching;
using System.Configuration;
using System.Xml.Serialization;

namespace URLRewriter.Config
{

[Serializable()]
[XmlRoot("RewriterConfig")]
public class RewriterConfiguration
{
// private member variables
private RewriterRuleCollection rules; // an instance of the
public static RewriterConfiguration GetConfig()
{
if (HttpContext.Current.Cache["RewriterConfig"] == null)
HttpContext.Current.Cache.Insert("RewriterConfig", ConfigurationSettings.GetConfig("RewriterConfig"));

return (RewriterConfiguration) HttpContext.Current.Cache["RewriterConfig"];
}

#region Public Properties
/// <summary>
/// A <see cref="RewriterRuleCollection"/> instance that provides access to a set of <see cref="RewriterRule"/>s.
/// </summary>
public RewriterRuleCollection Rules
{
get
{
return rules;
}
set
{
rules = value;
}
}
#endregion
}
}

RewriterRuleCollection.cs

方法

using System;
using System.Collections;

namespace URLRewriter.Config
{

[Serializable()]
public class RewriterRuleCollection : CollectionBase
{
/// <summary>
/// Adds a new RewriterRule to the collection.
/// </summary>
/// <param name="r">A RewriterRule instance.</param>
public virtual void Add(RewriterRule r)
{
this.InnerList.Add(r);
}

/// <summary>
/// Gets or sets a RewriterRule at a specified ordinal index.
/// </summary>
public RewriterRule this[int index]
{
get
{
return (RewriterRule) this.InnerList[index];
}
set
{
this.InnerList[index] = value;
}
}
}
}

RewriterRule.cs
定义的属性

using System;

namespace URLRewriter.Config
{

public class RewriterRule
{
private string lookFor, sendTo;

public string LookFor
{
get
{
return lookFor;
}
set
{
lookFor = value;
}
}

public string SendTo
{
get
{
return sendTo;
}
set
{
sendTo = value;
}
}

}
}

URLRewriter名称空间
这个里对上面的rules进行处理

BaseModuleRewriter.cs

初始化，加载方法

using System;
using System.Web;

namespace URLRewriter
{

public abstract class BaseModuleRewriter : IHttpModule
{

public virtual void Init(HttpApplication app)
{

app.AuthorizeRequest += new EventHandler(this.BaseModuleRewriter_AuthorizeRequest);
}

public virtual void Dispose() {}

protected virtual void BaseModuleRewriter_AuthorizeRequest(object sender, EventArgs e)
{
HttpApplication app = (HttpApplication) sender;
Rewrite(app.Request.Path, app);
}

protected abstract void Rewrite(string requestedPath, HttpApplication app);
}
}

ModuleRewriter.cs

循环出每个rule执行RewriteUrl

using System;
using System.Text.RegularExpressions;
using System.Configuration;
using URLRewriter.Config;

namespace URLRewriter
{
/// <summary>
/// Provides a rewriting HttpModule.
/// </summary>
public class ModuleRewriter : BaseModuleRewriter
{
/// <summary>
/// This method is called during the module's BeginRequest event.
/// </summary>
/// <param name="requestedRawUrl">The RawUrl being requested (includes path and querystring).</param>
/// <param name="app">The HttpApplication instance.</param>
protected override void Rewrite(string requestedPath, System.Web.HttpApplication app)
{
// log information to the Trace object.
//app.Context.Trace.Write("ModuleRewriter", "Entering ModuleRewriter");

// get the configuration rules
RewriterRuleCollection rules = RewriterConfiguration.GetConfig().Rules;

// iterate through each rule...
for(int i = 0; i < rules.Count; i++)
{
// get the pattern to look for, and Resolve the Url (convert ~ into the appropriate directory)
string lookFor = "^" + RewriterUtils.ResolveUrl(app.Context.Request.ApplicationPath, rules[i].LookFor) + "$";

// Create a regex (note that IgnoreCase is set...)
Regex re = new Regex(lookFor, RegexOptions.IgnoreCase);

// See if a match is found
if (re.IsMatch(requestedPath))
{
// match found - do any replacement needed
string sendToUrl = RewriterUtils.ResolveUrl(app.Context.Request.ApplicationPath, re.Replace(requestedPath, rules[i].SendTo));

// log rewriting information to the Trace object
app.Context.Trace.Write("ModuleRewriter", "Rewriting URL to " + sendToUrl);

// Rewrite the URL
RewriterUtils.RewriteUrl(app.Context, sendToUrl);
break; // exit the for loop
}
}

// Log information to the Trace object
app.Context.Trace.Write("ModuleRewriter", "Exiting ModuleRewriter");
}
}
}

RewriterUtils.cs

根据设定的路径转换URL并进行RewritePath
可以看到最后，只是执行了context.RewritePath(path)方法,在httphandle中，用的是context.Server.Transfer(url)

using System;
using System.Web;

namespace URLRewriter
{
/// <summary>
/// Provides utility helper methods for the rewriting HttpModule and HttpHandler.
/// </summary>
/// <remarks>This class is marked as internal, meaning only classes in the same assembly will be
/// able to access its methods.</remarks>
internal class RewriterUtils
{
#region RewriteUrl
/// <summary>
/// Rewrite's a URL using <b>HttpContext.RewriteUrl()</b>.
/// </summary>
/// <param name="context">The HttpContext object to rewrite the URL to.</param>
/// <param name="sendToUrl">The URL to rewrite to.</param>
internal static void RewriteUrl(HttpContext context, string sendToUrl)
{
string x, y;
RewriteUrl(context, sendToUrl, out x, out y);
}

/// <summary>
/// Rewrite's a URL using <b>HttpContext.RewriteUrl()</b>.
/// </summary>
/// <param name="context">The HttpContext object to rewrite the URL to.</param>
/// <param name="sendToUrl">The URL to rewrite to.</param>
/// <param name="sendToUrlLessQString">Returns the value of sendToUrl stripped of the querystring.</param>
/// <param name="filePath">Returns the physical file path to the requested page.</param>
internal static void RewriteUrl(HttpContext context, string sendToUrl, out string sendToUrlLessQString, out string filePath)
{
// see if we need to add any extra querystring information
if (context.Request.QueryString.Count > 0)
{
if (sendToUrl.IndexOf('?') != -1)
sendToUrl += "&" + context.Request.QueryString.ToString();
else
sendToUrl += "?" + context.Request.QueryString.ToString();
}

// first strip the querystring, if any
string queryString = String.Empty;
sendToUrlLessQString = sendToUrl;
if (sendToUrl.IndexOf('?') > 0)
{
sendToUrlLessQString = sendToUrl.Substring(0, sendToUrl.IndexOf('?'));
queryString = sendToUrl.Substring(sendToUrl.IndexOf('?') + 1);
}

// grab the file's physical path
filePath = string.Empty;
filePath = context.Server.MapPath(sendToUrlLessQString);

// rewrite the path...
context.RewritePath(sendToUrlLessQString, String.Empty, queryString);

// NOTE! The above RewritePath() overload is only supported in the .NET Framework 1.1
// If you are using .NET Framework 1.0, use the below form instead:
// context.RewritePath(sendToUrl);
}
#endregion

/// <summary>
/// Converts a URL into one that is usable on the requesting client.
/// </summary>
/// <remarks>Converts ~ to the requesting application path. Mimics the behavior of the
/// <b>Control.ResolveUrl()</b> method, which is often used by control developers.</remarks>
/// <param name="appPath">The application path.</param>
/// <param name="url">The URL, which might contain ~.</param>
/// <returns>A resolved URL. If the input parameter <b>url</b> contains ~, it is replaced with the
/// value of the <b>appPath</b> parameter.</returns>
internal static string ResolveUrl(string appPath, string url)
{
if (url.Length == 0 || url[0] != '~')
return url; // there is no ~ in the first character position, just return the url
else
{
if (url.Length == 1)
return appPath; // there is just the ~ in the URL, return the appPath
if (url[1] == '/' || url[1] == '//')
{
// url looks like ~/ or ~/
if (appPath.Length > 1)
return appPath + "/" + url.Substring(2);
else
return "/" + url.Substring(2);
}
else
{
// url looks like ~something
if (appPath.Length > 1)
return appPath + "/" + url.Substring(1);
else
return appPath + url.Substring(1);
}
}
}
}
}

以上仅个人愚见，难免有错误