Faço desenvolvimento web há vários anos. Tenho entendimentos diferentes em empresas diferentes. Recentemente trabalhei em um projeto de blog. Percebi o papel das classes de modelo no desenvolvimento web. Estou em casa à noite. Sempre pensei que poderia criar uma classe de modelo especialmente projetada para desenvolvimento em asp.ne. Então eu escrevi esta classe de modelo.
Endereço para download clique aqui
Basta renomear o arquivo 500sea.txt baixado para Templet.rar e abri-lo.
se aberto
http://img.club.163.com/images/user/other/500sea
Não há solicitação para baixar o arquivo 500sea.txt. Em seguida, use o Internet Express e outras ferramentas para baixar esse endereço e alterar o arquivo 500sea.txt baixado para um arquivo *.rar.
Abaixo está um arquivo de descrição dentro
//------------------------------------------------ -------------------------------------------------- -------------------------- //
introduzir:
Esta classe de modelo foi escrita para desenvolvimento de sites com arquitetura de três camadas. Componente StringTempletReplet.dll
Contém classes de modelo. As classes de modelo no namespace StringTempletReplet podem ser usadas na camada UI ou
para ser usado na camada lógica.
************************************************** ****************************
Como correr:
Crie um diretório virtual chamado Templet para fazer referência à pasta descompactada do Templet.
Execute RetuenString.aspx interno, ReturnText.aspx, WriteArticon.aspx,
Página LongLoop.aspx. Existem instruções correspondentes no arquivo cs correspondente à página.
Quando a página é aberta pela primeira vez, o objeto delegado e o arquivo de modelo devem ser salvos no cache, portanto a velocidade real depende da primeira página.
Uma vez depois.
************************************************** ****************************
Introdução do princípio:
Um modelo para substituição de etiquetas. Aritmética de ponteiro usada em c# para encontrar a localização do rótulo.
Use o objeto delegado para apontar para a função de análise correspondente à tag de imagem e use objetos estáticos para armazenar em cache todos os objetos delegados.
Armazene em cache todo o conteúdo do modelo sem alterar o corpo do modelo. Os modelos podem ser alterados dinamicamente.
************************************************** ****************************
Introdução da etiqueta:
O conteúdo entre o par de símbolos especiais {$ e $} é um rótulo
como
{$Nome da tag:Parâmetro 1:Parâmetro 2:Parâmetro 3::Caracter 10$}
{$tagname:parâmetro1:parâmetro2::byte10$}
{$dt[5][nome]$}
O rótulo é dividido em duas partes (parte de parâmetro do rótulo) e (parte de controle de comando) através do símbolo :: dentro do rótulo.
{$tagname:parâmetro1:parâmetro2:parâmetro3::byte10$}
(Parte de parâmetro de tag) :: (Parte de controle de comando)
Nessas duas partes, separe a parte do parâmetro do rótulo e a parte do controle do comando com um sinal :.
Parte do parâmetro da tag --- o primeiro é o nome da tag, que é o nome correspondente da função de análise da tag, e os subsequentes são os parâmetros da função.
A função de análise de tag aceita todos os tipos de parâmetros como tipo string e o número de parâmetros é de 0 a 20.
Função, o tipo de retorno é do tipo string. Os parâmetros podem ser codificados na etiqueta ou gravados dinamicamente.
A parte de controle de comando --- agora existem apenas dois caracteres e bytes de símbolo de comando, seguidos por um parâmetro numérico, indicando o padrão de interceptação
O comprimento do resultado da análise de assinatura, como 10 caracteres e 10 bytes.
Expandirei outros símbolos de comando e controle no futuro.
Para a correspondência entre rótulos e funções, consulte as instruções no arquivo Business.cs.
Para regras específicas de uso de tags, consulte as instruções em template/templet/aa1.htm.
Para regras de chamada específicas, consulte as três páginas aspx do projeto.
WriteArticon.aspx – Sistema de notícias que lê templates e analisa arquivos escritos para gerar páginas estáticas
ReturnText.aspx - Leia a análise do modelo e retorne strings, usado para escrever páginas que frequentemente precisam alterar sua aparência.
Página com skin. Os modelos podem ser alterados dinamicamente.
RetuenString.aspx - aceita strings de tags e retorna resultados de análise. Comumente usado com ajax.
************************************************** *******************************
Valor dinâmico do rótulo:
A função de análise de tag pode aceitar parâmetros fixos passados na tag. Existem três maneiras de aceitar parâmetros dinâmicos
Depois de passar objetos Datatable e Hashtable para a classe de modelo
(Datatable é obtido da camada de dados, Hashtable geralmente é uma variável de página e outras variáveis)
1. dt[5][nome] ---- significa obter o valor na coluna de nome de 5 linhas na tabela de dados, o primeiro é um número,
O segundo é o nome da coluna
2. dt[nome] ---- Fora do loop, significa pegar o valor na coluna de nome da linha 0 na tabela de dados.
Um parâmetro representa o nome da coluna
---- No loop, significa pegar o valor na coluna de nome na tabela de dados, pegar isso
Essas linhas são determinadas pelos parâmetros da tag loop.
3. page[PageId] ----- Representa pegar o valor da chave PageId no objeto Hashtable e retornar o tipo de string
Por exemplo, {$dois marcadores de parâmetro:dt[3][palavra]:página[UserId]::personagem 10$}
{$dt[5][nome]$} {$dt[nome]$} {$página[ ID da página ]$}
ou
{$dt[5][nome]::Caracter 10$} {$dt[nome]::Caracter 10$} {$page[PageId]::Caracter 10$}
Essa tag indica que o valor do objeto é exibido diretamente na página.
************************************************** ****************************
Chame o método da classe template dentro da página ou classe:
Pode ser chamado dentro de uma página ou classe
Gere objetos e associe classes de análise de função de tag correspondentes
//Aqui só precisamos adicionar um objeto de classe Business após esta linha new Business()
//Usando interfaces para implementar polimorfismo, o código parece um pouco complicado. Ao usá-lo, basta modificar o último "new Business ()" para sua própria classe que contém a função de análise de tags.
ILabelAnalyStart objILabel=(ILabelAnalyStart) new TempletReplet(new Business());
//Lê o atributo do caminho do modelo
;
objILabel.ReadFilePath=this.Server.MapPath("templet/aa1.htm");
//Escrever o atributo do caminho do arquivo
objILabel.WritFilePath=this.Server.MapPath("page/aa1.html");
//Obter o objeto da tabela de dados
objILabel.LabelDatatable=ds.Tables[0];
//Passe as variáveis desta página para a classe de modelo usando objetos Hashtable
objILabel.LabelHashtable=ht;
Então três substituições podem ser alcançadas
//Começa a substituir e escrever o modelo
objILabel.LaberReplet();
//retorna o resultado da análise
string aa=objILabel.LaberRepletText();
//Retorna o resultado da análise. Isso aceita diretamente a string do modelo. Consulte o arquivo RetuenString.cs para obter detalhes.
string aa=objILabel.LaberRepletString();
Para obter detalhes, consulte os arquivos cs desses três arquivos;
WriteArticon.aspx – Sistema de notícias que lê templates e analisa arquivos escritos para gerar páginas estáticas
ReturnText.aspx - Leia a análise do modelo para retornar uma string e use-a para escrever páginas que mudam frequentemente de aparência.
Página de mudança de skin
RetuenString.aspx - aceita strings de tags e retorna resultados analisados. Comumente usado com ajax
********************************************** *** *******************************
Associação de função de rótulo:
Consulte o arquivo Business.cs para obter detalhes.
No construtor estático da classe correspondente à camada lógica, adicione o seguinte código.
//Chama o construtor estático e coloca o delegado da função de execução da tag na tabela hash estática
//Este método deve ser executado
Negócio estático()
{
Business _this=new Business();
Nenhum
marcador de parâmetro",new KeyItemDelegate(new UserDelegate.Run_0(_this.show),0));
KeyItemDelegate(new UserDelegate.Run_1(_this.tag),1));
FunctionList.objFunctionHashtable.Add("Dois marcadores de parâmetro",new KeyItemDelegate(new UserDelegate.Run_2(_this.tag_two),2));
//Os marcadores estão associados às funções de execução. Coloque-o no construtor estático da classe de análise de marcadores. Isso serve para usar totalmente os objetos na memória sem executá-los todas as vezes.
// O caractere "Um marcador de parâmetro" corresponde à função public string tag (string aa). O modo correspondente é adicionar chave e valor à tabela hash.
// ("Um marcador de parâmetro",new KeyItemDelegate(new UserDelegate.Run_1(_this.tag),1));
// nome da etiqueta |
// Use o delegado Run_1 para um parâmetro. |
// Função de execução da tag correspondente |
// Para um parâmetro, escreva o número um
// 0 ou mais exemplos correspondentes acima
}
Consulte o arquivo Business.cs para obter detalhes
***************************************** *************************************
Introdução ao loop dentro das tags:
Loops não aninhados podem ser implementados usando alguns símbolos especiais dentro da tag.
//------------------------------------------------ --------------------------
{$loop(3,0,alter)$} //Exibe três linhas, começando na linha 0. Se houver colunas alternadas, execute as colunas alternadas.
{$BlockItem$} //Linha de loop padrão,
<td bgcolor="#33ccff">Título:{$dt[5][nome]$}, Autor:{$Um parâmetro:dt[dddf]$}</td>
{$/BlockItem$}
{$BlockAlterItem$} // Loop alternado de linhas Quando não há um par de rótulos de linha padrão, há um par de rótulos de loop alternativo. Trate o par de rótulos alternados como o par de rótulos de linha padrão
<td bgcolor="#ff6699">Título:{$dt[5][nome]$}, autor:{$um parâmetro:dt[dddf]$}</td>
{$/BlockAlterItem$}
{$BlockPatch$} //Quando o número de linhas a serem repetidas for maior que o número de linhas na tabela de dados, use o conteúdo aqui para complementar a exibição. Se não houver um par de tags "suplementares". Então, quando o número de linhas exibidas for maior que o número de linhas na tabela de dados, apenas o número de linhas na tabela de dados será exibido.
<td bgcolor="#33ccff">Suplemento (tags também podem ser usadas internamente)</td>
{$/BlockPatch$}
{$BlockAlterPatch$} //Não há par de rótulos suplementares, mas existem pares de rótulos suplementares alternativos. tratar pares de tags suplementares alternados como pares de tags suplementares
<td bgcolor="#ff6699">Suplemento alternativo (tags também podem ser usadas internamente)</td>
{$/BlockAlterPatch$}
{$/loop$} //fim do loop
//------------------------------------------------ ---------------
{$BlockItem$} {$/BlockItem$}: par de rótulos de linha em loop padrão
{$BlockAlterItem$} {$/BlockAlterItem$} : alternar pares de rótulos de linha
{$BlockPatch$} {$/BlockPatch$}: par de rótulos de linha suplementar padrão
{$BlockAlterPatch$} {$/BlockAlterPatch$}: complementa alternadamente pares de rótulos de linha
//------------------------------------------ -- -----------------------
Se você tiver apenas a linha de loop padrão, não poderá adicionar o par de tags {$BlockItem$}.
como
{$loop(3,0,alter)$}
<tr><td>{$tag de função$}</td></tr>
{$/loop$}
e
{$loop(3,0,alter)$}
{$BlockItem$}<tr><td>{$rótulo de função$}</td></tr>{$/BlockItem$}
{$/loop$}
Significa o mesmo efeito
//------------------------------------------------ -------------
{$loop(3,0,alter)$}
{$BlockAlterPatch$}
<tr><td>{$tag de função$}</td></tr>
{$/BlockAlterPatch$}
{$/loop$}
Se houver apenas pares de rótulos de linhas de ciclo alternados e não houver nenhum par de rótulos de linhas de ciclo padrão, o par de rótulos de linhas de ciclo alternados será automaticamente convertido para
Pares de rótulos de linha de loop padrão
//------------------------------------------------ ---------------
{$loop(3,0,alter)$}
{$BlockAlterPatch$}
<tr><td>{$tag de função$}</td></tr>
{$/BlockAlterPatch$}
{$/loop$}
Se houver apenas pares alternados de rótulos de linha suplementares e não houver nenhum par padrão de rótulos de linha suplementares, os pares alternados de rótulos de linhas suplementares serão automaticamente convertidos para
Pares de rótulos de linha de loop padrão
************************************************** * **********************
descrição do parâmetro do loop:
{$loop(3,0,alter)$}
Existem três parâmetros no loop, que podem ser reduzidos adequadamente.
Primeiro parâmetro:
3: Faça um loop 3 vezes, não significa repetir tudo
Segundo parâmetro:
2: Começar do 2, não significa começar do 0
O terceiro parâmetro:
alterar: alternativo
noalter: sem alternância Se não houver indicação, o padrão é alternância, portanto é o mesmo se alter for adicionado ou não.
Se todos os três parâmetros forem omitidos, pelo menos um par de colchetes vazios {$loop()$} deve ser retido.
Representa o número de linhas no loop Datatable
A partir da linha 0, caso haja acréscimo, o suplemento será exibido.
************************************************** ****************************
Houve uma atualização. Principalmente loop de otimização.
Agora são necessários de 300 a 400 milissegundos para percorrer uma tabela com 50.000 linhas.
************************************************** ****************************
Recomenda-se que o modelo não seja maior que 85k e tome cuidado para não se tornar um objeto de grande porte. Recomenda-se que o número de modelos de página para objetos de segunda geração seja menor ou igual a 919 e o número de tags de função correspondentes não exceda 1.597.
É bom ver a classe de modelo crescer junto com meu próprio entendimento.
************************************************** ****************************