UrlMappings en asp.net2.0 es muy fácil de usar, pero desafortunadamente no admite expresiones regulares. Sin embargo, afortunadamente, si usa IHttpModule,
no importa qué tipo de solicitud, pasará primero por IHttpModule, lo que proporciona una buena solución. oportunidad para reescribir URL:
el siguiente es un IHttpModule que escribí:
usando System;
usando System.Web
clase pública ReWriteModule:IHttpModule;
{
Módulo de reescritura público()
{
}
cadena de anulación pública ToString()
{
devolver this.GetType().ToString();
}
anular IHttpModule.Dispose()
{
}
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;
}
anular IHttpModule.Init (contexto de aplicación Http)
{
contexto.BeginRequest += delegado (remitente del objeto, EventArgs e)
{
System.Web.HttpContext cxt = contexto.Contexto;
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);
} // Se utiliza si es necesario para manejar todas las solicitudes
//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();
//}
}
};
}
}
Dado que una vez que se reescribe la URL, la Acción en el FORMATO WEB original cambiará, lo que puede causar fácilmente: el recurso solicitado no existe
¿Qué específicamente? ¡Quedará claro si le echas un vistazo con DX! ! !
Todo lo que tenemos es este ResponseFilter, que se implementa de la siguiente manera,
clase pública ResponseFilter:System.IO.Stream
{
Filtro de respuesta público (sumidero System.IO.Stream, cadena _str)
{
_fregadero = fregadero;
//
// TODO: agregue la lógica del constructor aquí
//
this.str = _str;
}
cadena privada str = "";
privado System.IO.Stream _sink;
posición larga privada;
privado System.Text.Encoding end=System.Text.Encoding.GetEncoding("GB18030");
privado System.Text.StringBuilder oOutput = nuevo System.Text.StringBuilder();
// Se deben anular los siguientes miembros de Stream.
bool de anulación pública CanRead
{
obtener {regresar verdadero}
}
anulación pública bool CanSeek
{
obtener {regresar verdadero}
}
anulación pública bool CanWrite
{
obtener {regresar verdadero}
}
anulación pública de larga duración
{
obtener {regresar 0}
}
posición larga de anulación pública
{
obtener {return_position}
establecer { _posición = valor }
}
anulación pública de búsqueda larga (desplazamiento largo, dirección System.IO.SeekOrigin)
{
return _sink.Seek(desplazamiento, dirección);
}
anulación pública void SetLength (longitud larga)
{
_sink.SetLength(longitud);
}
anulación pública nula Cerrar()
{
_sink.Close();
}
anulación pública void Flush()
{
_sink.Flush();
}
anulación pública int Read(byte[] buffer, int offset, int count)
{
return _sink.Read(búfer, desplazamiento, recuento);
}
// El método Write realmente realiza el filtrado.
anulación pública escritura vacía (búfer byte [], desplazamiento int, recuento int)
{
cadena szBuffer = System.Text.UTF8Encoding.UTF8.GetString (búfer, desplazamiento, recuento);
cadena ap="acción="";
int pos=-1;
si ((pos=szBuffer.IndexOf(ap) )!= -1)
{
int epos = szBuffer.IndexOf(""", pos + ap.Length+1);
si (epos! = -1)
{
szBuffer= szBuffer.Remove(pos + ap.Longitud, epos - pos - ap.Longitud);
}
szBuffer = szBuffer.Insert(pos + ap.Length, this.str);
byte[] datos = System.Text.UTF8Encoding.UTF8.GetBytes(szBuffer);
_sink.Write(datos, 0, datos.Longitud);
}
demás
{
oSalida.Append(szBuffer);
}
//El siguiente párrafo se puede utilizar para modificar el contenido entre <Head></head>;
//Regex oEndFile = new Regex("</head>", RegexOptions.IgnoreCase|RegexOptions.Compiled);
//si (oEndFile.IsMatch(szBuffer))
//{
// //Agregar el último buffer de datos
// //Agregar la última parte de los datos en el buffer
// oOutput.Append(szBuffer);
// //Recuperar la respuesta completa del cliente
// //Transmitir datos completos de devolución del cliente
// cadena szCompleteBuffer = oOutput.ToString().ToLower();
// int ipos = szCompleteBuffer.IndexOf("<título>");
// int epos = szCompleteBuffer.IndexOf("</title>",ipos+7);
// cadena sp = szCompleteBuffer.Substring(ipos+7, epos - ipos);
// szCompleteBuffer = szCompleteBuffer.Remove(ipos+7,sp.Length-7);
// szCompleteBuffer = szCompleteBuffer.Insert(ipos + 7, "dhz");
// // szCompleteBuffer = szCompleteBuffer.Replace(sp, "dhz");
// //No hay coincidencias, así que escribe los datos originales
// //No hay coincidencia, por lo que se escribe el código fuente
// byte[] datos = System.Text.UTF8Encoding.UTF8.GetBytes(szCompleteBuffer);
// _sink.Write(datos, 0, datos.Longitud);
//}
//demás
//{
// oOutput.Append(szBuffer);
//}
}
}
//////Las reglas de espera se configuran de la siguiente manera usando archivos xml,
por supuesto, también puede hacerlo a través de una sección de configuración personalizada en web.config
<?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>
<Buscar>~/pc</Buscar>
</Buscar>
<EnviarA>~/Test2.aspx</EnviarA>
</RewriterRule>
</Reglas>
//Esta regla no está bien escrita. Por ejemplo, la primera se puede hacer con una expresión regular. Pero no sé cómo escribirlo correctamente en este momento. Parece que necesito usar algún concepto de grupo anti-captura. ¡Estoy pensando en estas cosas! !