1: ¡El problema de la eliminación durante la reescritura en asp.net1.1! ! !
Como la siguiente expresión regular:
<Reglas>
<Regla de reescritura>
<Buscar>
<LookFor>~/(d{4})/(d{2}).html</LookFor>---------<1>
<Buscar>~/(d{4})/(d{2})/</Buscar>--------------<2>
<Buscar>~/(d{4})/(d{2})</Buscar>-----------<3>
<LookFor>~/(d{4})/(d{2})/index.html</LookFor>----<4>
</Buscar>
<SendTo>~/Pro.aspx?year=$1&mes=$2</SendTo>
</RewriterRule>
</Rules>
Entre ellos, 1 y 4 se pueden asignar normalmente a la página correspondiente
, ¡pero 2 y 3 provocarán un error http404! ! !
La razón radica en el flujo de procesamiento del propio IIS. ¡La solución es reescribir el procesamiento del error 404 en el propio sitio web! ! !
1: Personalice la URL para manejar errores 404 (configurado en IIS, la configuración en web.config es inútil para reescribir)
2: Agregue la siguiente sección a la sección System.Web:
<httpHandlers>
<añadir verb="*" ruta="404.aspx" type="lt.Http404,lt"></add>
</httpHandlers>
<httpMódulos>
<añadir tipo="lt.ReWriteModule,lt" nombre="ModuleRewriter" />
</httpModules>
El código fuente es el siguiente:
clase pública Http404:System.Web.IHttpHandler
{
público Http404()
{
//
// TODO: agregue la lógica del constructor aquí
//
}
#región IHttpHandler miembro
público void ProcessRequest (contexto System.Web.HttpContext)
{
// TODO: Agregar implementación Http404.ProcessRequest
cadena errorPath=context.Request.RawUrl.Split(new char[]{';'})[1];
cadena appPath=context.Request.ApplicationPath;
int ipos=errorPath.IndexOf(appPath
cadena url=errorPath.Substring(ipos+appPath.Length);
// si(!url.EndsWith("/"))
// {
// URL+="/";
// }
// url+="index.html";
// contexto.Respuesta.Write(url);
// contexto.RewritePath(url);
//context.Response.Write(url);
url="~"+url;
cadena nuevaUrl =lt.ReWriteModule.GetUrl(contexto,url);
//context.Response.Write(nuevaUrl);
si (nueva URL! = nulo)
{
//cxt.Response.Filter = nuevo ResponseFilter(cxt.Response.Filter,cxt.Request.Path);
context.Response.Write("Ruta solicitada:" + url);
contexto.Response.Write("<BR>");
context.Response.Write("URL de destino redirigida: " + nuevaUrl);
contexto.Response.Write("<BR>");
contexto.RewritePath(nuevaUrl);
}
demás
{
context.Response.Write("¡¡El recurso que solicitó no existe!!");
contexto.Respuesta.End ();
}
}
bool público EsReutilizable
{
conseguir
{
// TODO: Agregar implementación del getter Http404.IsReusable
devolver falso;
}
}
/////////////////El httpModule en el procesamiento de la sección de configuración es el siguiente:
clase pública ReWriteModule:System.Web.IHttpModule
{
Módulo de reescritura público()
{
//
// TODO: agregue la lógica del constructor aquí
//
}
#región IHttpModule miembro
público void Init (contexto System.Web.HttpApplication)
{
// TODO: Agregar implementación ReWriteModule.Init
contexto.BeginRequest+=new EventHandler(this.ReWrite);
}
system.xml.xmlDocument estático privado ruleDoc = nulo;
Estático privado System.Xml.XmlDocument GetRuleConfig (aplicación System.Web.HttpContext)
{
si (reglaDoc == nulo)
{
reglaDoc = nuevo System.Xml.XmlDocument();
ruleDoc.Load(app.Server.MapPath("~/rule.xml"));
}
devolver reglaDoc;
}
cadena estática pública GetUrl (System.Web.HttpContext cxt, ruta de cadena)
{
System.Xml.XmlDocument doc = GetRuleConfig(cxt);
System.Xml.XmlNodeList lst= doc.GetElementsByTagName("RewriterRule");
cadena pat="";
foreach (System.Xml.XmlNode y en lst)
{
System.Xml.XmlNodeList sub = nd.ChildNodes[0].ChildNodes;
foreach(System.Xml.XmlNode chk en sub)
{
palmadita = "^" + chk.InnerText+"$";
System.Text.RegularExpressions.Regex reg = nuevo System.Text.RegularExpressions.Regex(pat, System.Text.RegularExpressions.RegexOptions.Compiled | System.Text.RegularExpressions.RegexOptions.IgnoreCase);
si (reg.IsMatch (ruta))
{
return reg.Replace(ruta, nd.ChildNodes[1].InnerText);
}
}
}
devolver nulo;
}
ReWrite vacío privado (remitente del objeto, EventArgs e)
{
System.Web.HttpContext cxt =(remitente como System.Web.HttpApplication).Context;
si (cxt.Request.ContentType! = "imagen/pjpeg")
{
tipo de cadena = cxt.Request.ContentType.ToLower();
ruta de cadena = cxt.Request.Path;
cadena apppath = cxt.Request.ApplicationPath;
ruta = ruta.Remove(0, apppath.Length);
ruta = "~" + ruta;
cadena nuevaUrl = GetUrl(cxt, ruta.TrimEnd().TrimStart());
si (nueva URL! = nulo)
{
//cxt.Response.Filter = nuevo ResponseFilter(cxt.Response.Filter,cxt.Request.Path);
cxt.Response.Write("Ruta solicitada:" + ruta);
cxt.Response.Write("<BR>");
cxt.Response.Write("URL de destino redirigida: " + nuevaUrl);
cxt.Response.Write("<BR>");
cxt.RewritePath(nuevaUrl);
}
//demás
//{
// cxt.Response.Write(cxt.Request.Path + "<BR>");
// cxt.Response.Write("¡El recurso que solicitaste no existe o no tienes permiso para acceder!");
// cxt.Response.Flush();
// cxt.Response.End();
//}
}
}
eliminación pública vacía ()
{
// TODO: Agregar implementación ReWriteModule.Dispose
}
#endregion
}
---------rule.xml está configurado de la siguiente manera:
<?xml version="1.0" encoding="utf-8" ?>
<Reglas>
<Regla de reescritura>
<Buscar>
<Buscar>~/(d{4})/(d{2}).html</Buscar>
<Buscar>~/(d{4})/(d{2})/</Buscar>
<Buscar>~/(d{4})/(d{2})</Buscar>
<LookFor>~/(d{4})/(d{2})/index.html</LookFor>
</Buscar>
<SendTo>~/Pro.aspx?year=$1&mes=$2</SendTo>
</RewriterRule>
<Regla de reescritura>
<Buscar>
<LookFor>~/Pro.aspx?year=(d{4})&mes=(d{2})</LookFor>
</Buscar>
<EnviarA>~/(d{4})/(d{2}).html</EnviarA>
</RewriterRule>
<Regla de reescritura>
<Buscar>
<Buscar>~/pc</Buscar>
</Buscar>
<EnviarA>~/Test2.aspx</EnviarA>
</RewriterRule>
<Regla de reescritura>
<Buscar>
<LookFor>~/index.html</LookFor>
<LookFor>~/default.html</LookFor>
</Buscar>
<EnviarA>~/default.aspx</EnviarA>
</RewriterRule>
</Rules>
///////// Para cambios de acción causados por la reescritura, consulte el problema de urlMappings en asp.net2.0 escrito por mí. ! ! ! !