O urlMappings no asp.net2.0 é muito fácil de usar, mas infelizmente não suporta expressões regulares. No entanto, felizmente, se você usar o IHttpModule,
não importa o tipo de solicitação, ele passará primeiro pelo IHttpModule, o que fornece um bom resultado. oportunidade para reescrever URL:
A seguir está um IHttpModule que escrevi:
using System;
usando System.Web;
classe pública ReWriteModule:IHttpModule
{
módulo ReWrite público()
{
}
string de substituição pública ToString()
{
retornar this.GetType().ToString();
}
void IHttpModule.Dispose()
{
}
private static System.Xml.XmlDocument regraDoc = null;
System.Xml.XmlDocument GetRuleConfig estático privado (aplicativo System.Web.HttpContext)
{
if (ruleDoc == nulo)
{
regraDoc = novo System.Xml.XmlDocument();
regraDoc.Load(app.Server.MapPath("~/rule.xml"));
}
retornar regraDoc;
}
string estática pública GetUrl (System.Web.HttpContext cxt, caminho da string)
{
System.Xml.XmlDocument doc = GetRuleConfig(cxt);
System.Xml.XmlNodeList lst= doc.GetElementsByTagName("RewriterRule");
string pat="";
foreach (System.Xml.XmlNode nd em lst)
{
System.Xml.XmlNodeList sub = nd.ChildNodes[0].ChildNodes;
foreach (System.Xml.XmlNode verifica no sub)
{
pat = "^" + chk.InnerText+"$";
System.Text.RegularExpressions.Regex reg = new System.Text.RegularExpressions.Regex(pat, System.Text.RegularExpressions.RegexOptions.Compiled | System.Text.RegularExpressions.RegexOptions.IgnoreCase);
if(reg.IsMatch(caminho))
{
retornar reg.Replace(caminho, nd.ChildNodes[1].InnerText);
}
}
}
retornar nulo
;
void IHttpModule.Init (contexto HttpApplication)
{
context.BeginRequest += delegado (remetente do objeto, EventArgs e)
{
System.Web.HttpContext cxt = context.Context;
if (cxt.Request.ContentType! = "imagem/pjpeg")
{
tipo de string = cxt.Request.ContentType.ToLower();
string caminho = cxt.Request.Path;
string apppath = cxt.Request.ApplicationPath;
caminho = caminho.Remove(0, apppath.Length);
caminho = "~" + caminho;
string newUrl = GetUrl(cxt, path.TrimEnd().TrimStart());
if (newUrl! = nulo)
{
cxt.Response.Filter = novo ResponseFilter(cxt.Response.Filter,cxt.Request.Path);
cxt.Response.Write("Caminho solicitado:" + caminho);
cxt.Response.Write("<BR>");
cxt.Response.Write("URL de destino redirecionado: " + newUrl);
cxt.Response.Write("<BR>");
cxt.RewritePath(newUrl);
} // Usado se necessário para lidar com todas as solicitações
//outro
//{
//cxt.Response.Write(cxt.Request.Path + "<BR>");
// cxt.Response.Write("O recurso que você solicitou não existe ou você não tem permissão para acessá-lo!");
//cxt.Response.Flush();
//cxt.Response.End();
//}
}
};
}
}
Uma vez que a URL é reescrita, a Ação no WEBFORM original mudará, o que pode facilmente causar: o recurso solicitado não existe
O que especificamente? Ficará claro se você DX der uma olhada! ! !
Tudo o que temos é este ResponseFilter, que é implementado da seguinte forma,
classe pública ResponseFilter:System.IO.Stream
{
ResponseFilter público (coletor System.IO.Stream, string _str)
{
_sink = pia;
//
// TODO: adicione a lógica do construtor aqui
//
isto.str = _str;
}
string privada str = "";
privado System.IO.Stream _sink;
posição comprada privada;
private System.Text.Encoding end=System.Text.Encoding.GetEncoding("GB18030");
private System.Text.StringBuilder oOutput = new System.Text.StringBuilder();
// Os seguintes membros do Stream devem ser substituídos.
substituição pública bool CanRead
{
obter {retornar verdadeiro};
}
substituição pública bool CanSeek
{
obter {retornar verdadeiro};
}
substituição pública bool CanWrite
{
obter {retornar verdadeiro};
}
substituição pública de comprimento longo
{
obter {retorno 0;
}
substituição pública posição longa
{
obter {retornar _posição};
definir {_posição = valor};
}
substituição pública Long Seek (deslocamento longo, direção System.IO.SeekOrigin)
{
return _sink.Seek(deslocamento, direção);
}
substituição pública void SetLength (comprimento longo)
{
_sink.SetLength(comprimento);
}
substituição pública void Close()
{
_sink.Fechar();
}
substituição pública void Flush()
{
_sink.Flush();
}
substituição pública int Read(byte[] buffer, int offset, int count)
{
retornar _sink.Read(buffer, deslocamento, contagem);
}
// O método Write realmente faz a filtragem.
substituição pública void Write (byte [] buffer, deslocamento interno, contagem interna)
{
string szBuffer = System.Text.UTF8Encoding.UTF8.GetString(buffer, deslocamento, contagem);
string ap="ação="";
intpos=-1;
se ((pos=szBuffer.IndexOf(ap) )!= -1)
{
int epos = szBuffer.IndexOf(""", pos + ap.Length+1);
se (epos! = -1)
{
szBuffer= szBuffer.Remove(pos + ap.Comprimento, epos - pos - ap.Comprimento);
}
szBuffer = szBuffer.Insert(pos + ap.Length, this.str
byte[] dados = System.Text.UTF8Encoding.UTF8.GetBytes(szBuffer);
_sink.Write(dados, 0, dados.Comprimento);
}
outro
{
oOutput.Append(szBuffer);
}
//O parágrafo a seguir pode ser usado para modificar o conteúdo entre <Head></head>;
//Regex oEndFile = new Regex("</head>", RegexOptions.IgnoreCase|RegexOptions.Compiled);
//se (oEndFile.IsMatch(szBuffer))
//{
// //Acrescenta o último buffer de dados
// //Acrescenta a última parte dos dados no buffer
// oOutput.Append(szBuffer);
// //Retorna a resposta completa do cliente
// //Transmite dados completos de retorno do cliente
// string szCompleteBuffer = oOutput.ToString().ToLower();
// int ipos = szCompleteBuffer.IndexOf("<title>");
// int epos = szCompleteBuffer.IndexOf("</title>",ipos+7);
// string 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");
// //Não há correspondência, então escreva os dados originais
// //Não há correspondência, então o código-fonte foi escrito
// byte[] dados = System.Text.UTF8Encoding.UTF8.GetBytes(szCompleteBuffer);
// _sink.Write(dados, 0, dados.Length);
//}
//outro
//{
// oOutput.Append(szBuffer);
//}
}
}
//////As regras de espera são configuradas da seguinte forma usando arquivos xml,
é claro, você também pode fazer isso através de uma seção de configuração personalizada em web.config
<?xml version="1.0" encoding="utf-8" ?
<Regras>
<ReescritorRegra>
<Procurar>
<LookFor>~/(d{4})/(d{2}).html</LookFor>
<LookFor>~/(d{4})/(d{2})/</LookFor>
<LookFor>~/(d{4})/(d{2})</LookFor>
<LookFor>~/(d{4})/(d{2})/index.html</LookFor>
</LookFors>
<SendTo>~/Pro.aspx?year=$1&month=$2</SendTo>
</RewriterRule>
<ReescritorRegra>
<Procurar>
<LookFor>~/pc</LookFor>
</LookFors>
<SendTo>~/Test2.aspx</SendTo>
</RewriterRule>
</Regras>
//Esta regra não está bem escrita. Por exemplo, a primeira pode ser feita com uma expressão regular. Mas não sei como escrever direito no momento. Parece que preciso usar algum conceito de grupo anti-captura, estou pensando nessas coisas! !