Llevo varios años haciendo desarrollo web. Tengo diferentes entendimientos en diferentes empresas. Recientemente trabajé en un proyecto de blog. Me di cuenta del papel de las clases de plantillas en el desarrollo web. Estoy en casa por la noche. Siempre pensé que podría crear una clase de plantilla especialmente diseñada para el desarrollo de asp.ne. Entonces escribí esta clase de plantilla.
Descargar dirección haga clic aquí
Simplemente cambie el nombre del archivo 500sea.txt descargado a Templet.rar y ábralo.
si está abierto
http://img.club.163.com/images/user/other/500sea
No aparece ningún mensaje para descargar el archivo 500sea.txt. Luego use Internet Express y otras herramientas para descargar esta dirección y cambie el archivo 500sea.txt descargado a un archivo *.rar.
A continuación se muestra un archivo de descripción dentro
//------------------------------------------------ -------------------------------------------------- --------------------------//
introducir:
Esta clase de plantilla está escrita para el desarrollo de sitios web con arquitectura de tres niveles. Componente StringTempletReplet.dll
Contiene clases de plantilla. Las clases de plantilla en el espacio de nombres StringTempletReplet se pueden usar en la capa UI o
para ser utilizado en la capa lógica.
************************************************** * ****************************
Cómo correr:
Cree un directorio virtual llamado Templet para hacer referencia a la carpeta Templet descomprimida.
Ejecute internamente RetuenString.aspx, ReturnText.aspx, WriteArticon.aspx,
Página LongLoop.aspx. Hay instrucciones correspondientes en el archivo cs correspondiente a la página.
Cuando se abre la página por primera vez, el objeto delegado y el archivo de plantilla deben guardarse en la memoria caché, por lo que la velocidad real depende de la primera página.
Una vez después.
************************************************** * ****************************
Introducción al principio:
Una plantilla para el reemplazo de etiquetas. Se utilizó aritmética de punteros en C# para encontrar la ubicación de la etiqueta.
Utilice el objeto delegado para señalar la función de análisis correspondiente a la etiqueta de imagen y utilice objetos estáticos para almacenar en caché todos los objetos delegados.
Almacene en caché todo el contenido de la plantilla sin cambiar el cuerpo de la plantilla. Las plantillas se pueden cambiar dinámicamente.
************************************************** * ****************************
Introducción de la etiqueta:
El contenido entre el par de símbolos especiales {$ y $} es una etiqueta
como
{$Nombre de etiqueta:Parámetro 1:Parámetro 2:Parámetro 3::Carácter 10$}
{$nombre de etiqueta:parámetro1:parámetro2::byte10$}
{$dt[5][nombre]$}
La etiqueta se divide en dos partes (parte de parámetro de etiqueta) y (parte de control de comando) mediante el símbolo :: dentro de la etiqueta.
{$nombre de etiqueta:parámetro1:parámetro2:parámetro3::byte10$}
(Parte de parámetro de etiqueta) :: (Parte de control de comando)
En estas dos partes, separe la parte del parámetro de etiqueta y la parte de control de comando con un signo:.
Parte del parámetro de etiqueta: el primero es el nombre de la etiqueta, que es el nombre correspondiente de la función de análisis de etiquetas, y los siguientes son los parámetros de la función.
La función de análisis de etiquetas acepta todos los tipos de parámetros como tipo de cadena y el número de parámetros es de 0 a 20.
Función, el tipo de retorno es tipo cadena. Los parámetros pueden estar codificados en la etiqueta o escritos dinámicamente.
La parte de control de comando: ahora solo hay dos caracteres de símbolo de comando y bytes, seguidos de un parámetro numérico, que indica el estándar de interceptación.
La longitud del resultado del análisis de la firma, como 10 caracteres y 10 bytes.
Ampliaré otros símbolos de mando y control en el futuro.
Para conocer la correspondencia entre etiquetas y funciones, consulte las instrucciones en el archivo Business.cs.
Para conocer las reglas de uso específicas de las etiquetas, consulte las instrucciones en template/templet/aa1.htm.
Para conocer reglas de llamada específicas, consulte las tres páginas aspx del proyecto.
WriteArticon.aspx: sistema de noticias que lee plantillas y analiza archivos escritos para generar páginas estáticas
ReturnText.aspx: lee el análisis de plantillas y las cadenas de retorno, que se utilizan para escribir páginas que a menudo necesitan cambiar su apariencia.
Página desollada. Las plantillas se pueden cambiar dinámicamente.
RetuenString.aspx: acepta cadenas de etiquetas y devuelve resultados del análisis. Comúnmente usado con ajax.
************************************************** * *******************************
Valor dinámico de la etiqueta:
La función de análisis de etiquetas puede aceptar parámetros fijos pasados en la etiqueta. Hay tres formas de aceptar parámetros dinámicos.
Después de pasar objetos Datatable y Hashtable a la clase de plantilla
(La tabla de datos se obtiene de la capa de datos, Hashtable generalmente son variables de página y otras variables)
1. dt[5][nombre] ---- significa obtener el valor en la columna de nombre de 5 filas en la tabla de datos, la primera es un número,
El segundo es el nombre de la columna.
2. dt[nombre] ---- Fuera del bucle, significa tomar el valor en la columna de nombre de la fila 0 en la tabla de datos.
Un parámetro representa el nombre de la columna.
---- En el bucle, significa tomar el valor en la columna de nombre en la tabla de datos, tomar eso
Estas líneas están determinadas por los parámetros de la etiqueta de bucle.
3. página[PageId] ----- Representa tomar el valor de la clave PageId en el objeto Hashtable y devolver el tipo de cadena
Por ejemplo, {$dos marcadores de parámetros:dt[3][palabra]:página[UserId]::carácter 10$}
{$dt[5][nombre]$} {$dt[nombre]$} {$página[ ID de página ]$}
o
{$dt[5][nombre]::Carácter 10$} {$dt[nombre]::Carácter 10$} {$página[PageId]::Carácter 10$}
Dicha etiqueta indica que el valor del objeto se muestra directamente en la página.
************************************************** * ****************************
Llame al método de clase de plantilla dentro de la página o clase:
Se puede llamar dentro de una página o clase.
Generar objetos y asociar las clases de análisis de funciones de etiquetas correspondientes.
//Aquí sólo necesitamos agregar un objeto de clase Business después de esta línea new Business()
// Al usar interfaces para implementar polimorfismo, el código parece un poco engorroso. Cuando lo use usted mismo, simplemente modifique el último "nuevo Negocio ()" a su propia clase que contiene la función de análisis de etiquetas.
ILabelAnalyStart objILabel=(ILabelAnalyStart) new TempletReplet(new Business());
//Leer el atributo de ruta de la plantilla
objILabel.ReadFilePath=this.Server.MapPath("templet/aa1.htm");
//Escribe el atributo de ruta del archivo
objILabel.WritFilePath=this.Server.MapPath("page/aa1.html");
//Obtener el objeto de la tabla de datos
objILabel.LabelDatatable=ds.Tables[0];
//Pasa las variables de esta página a la clase de plantilla usando objetos Hashtable
objILabel.LabelHashtable=ht;
Entonces se pueden lograr tres reemplazos.
//Comienza a reemplazar y escribir la plantilla
objILabel.LaberReplet();
//devuelve el resultado del análisis
cadena aa=objILabel.LaberRepletText();
// Devuelve el resultado del análisis. Esto acepta directamente la cadena de plantilla. Consulte el archivo RetuenString.cs para obtener más detalles.
string aa=objILabel.LaberRepletString();
Para obtener más información, consulte los archivos cs de estos tres archivos.
WriteArticon.aspx: sistema de noticias que lee plantillas y analiza archivos escritos para generar páginas estáticas
ReturnText.aspx: lee el análisis de la plantilla para devolver una cadena y úsala para escribir páginas que cambian su apariencia con frecuencia.
Página de cambio de piel
RetuenString.aspx: acepta cadenas de etiquetas y devuelve resultados analizados. Comúnmente utilizado con ajax
********************************************** *** *******************************
Asociación de función de etiqueta:
Consulte el archivo Business.cs para obtener más detalles.
En el constructor estático de la clase correspondiente a la capa lógica, agregue el siguiente código.
// Llame al constructor estático y coloque el delegado de la función de ejecución de etiquetas en la tabla hash estática
//Este método debe ser ejecutado
negocio estático()
{
Business _this=new Business();
parámetros
",new KeyItemDelegate(new UserDelegate.Run_0(_this.show),0));
KeyItemDelegate(new UserDelegate.Run_1(_this.tag),1));
FunctionList.objFunctionHashtable.Add("Dos marcadores de parámetros",new KeyItemDelegate(new UserDelegate.Run_2(_this.tag_two),2));
//Los marcadores están asociados con funciones de ejecución. Póngalo en el constructor estático de la clase de análisis de marcadores. Esto es para utilizar completamente los objetos en la memoria sin ejecutarlos cada vez.
// El carácter "un marcador de parámetro" corresponde a la función etiqueta de cadena pública (cadena aa). El modo correspondiente es agregar clave y valor a la tabla hash.
// ("Un marcador de parámetro",new KeyItemDelegate(new UserDelegate.Run_1(_this.tag),1));
// nombre de etiqueta |
// Utilice el delegado Run_1 para un parámetro. |
// Función de ejecución de etiqueta correspondiente |
// Para un parámetro, escribe el número uno.
// 0 o más ejemplos correspondientes arriba
}
Consulte el archivo Business.cs para obtener más detalles
******************************************* * ***********************************
Introducción al bucle dentro de etiquetas:
Se pueden implementar bucles no anidados utilizando algunos símbolos especiales dentro de la etiqueta.
//------------------------------------------------ --------------------------
{$loop(3,0,alter)$} //Muestra tres líneas, comenzando desde la línea 0. Si hay columnas alternas, ejecute las columnas alternas.
{$BlockItem$} // Línea de bucle predeterminada,
<td bgcolor="#33ccff">Título:{$dt[5][name]$}, Autor:{$Un parámetro:dt[dddf]$}</td>
{$/BloqueArtículo$}
{$BlockAlterItem$} // Filas de bucle alternativo Cuando no hay un par de etiquetas de fila predeterminado, hay un par de etiquetas de bucle alternativo. Trate el par de etiquetas alternas como el par de etiquetas de fila predeterminado
<td bgcolor="#ff6699">Título:{$dt[5][nombre]$}, autor:{$one parámetro:dt[dddf]$}</td>
{$/BlockAlterItem$}
{$BlockPatch$} // Cuando el número de filas que se repetirán es mayor que el número de filas en la tabla de datos, utilice el contenido aquí para complementar la visualización. Si no hay un par de etiquetas "suplementario". Luego, cuando el número de filas mostradas sea mayor que el número de filas en la tabla de datos, solo se mostrará el número de filas en la tabla de datos.
<td bgcolor="#33ccff">Suplemento (las etiquetas también se pueden usar en el interior)</td>
{$/BloquePatch$}
{$BlockAlterPatch$} //No hay un par de etiquetas suplementarias, pero sí pares de etiquetas suplementarias alternativas. tratar los pares de etiquetas suplementarios alternos como pares de etiquetas suplementarios
<td bgcolor="#ff6699">Suplemento alternativo (las etiquetas también se pueden usar en el interior)</td>
{$/BlockAlterPatch$}
{$/bucle$} //fin del bucle
//------------------------------------------------ ---------------
{$BlockItem$} {$/BlockItem$}: par de etiquetas de fila en bucle predeterminado
{$BlockAlterItem$} {$/BlockAlterItem$}: ciclo alternativo de pares de etiquetas de filas
{$BlockPatch$} {$/BlockPatch$}: par de etiquetas de línea suplementaria predeterminado
{$BlockAlterPatch$} {$/BlockAlterPatch$}: complementar alternativamente los pares de etiquetas de fila
//------------------------------- ------------------------
Si solo tiene la línea de bucle predeterminada, no puede agregar el par de etiquetas {$BlockItem$}.
como
{$bucle(3,0,alterar)$}
<tr><td>{$etiqueta de función$}</td></tr>
{$/bucle$}
y
{$bucle(3,0,alterar)$}
{$BlockItem$}<tr><td>{$etiqueta de función$}</td></tr>{$/BlockItem$}
{$/bucle$}
Significa el mismo efecto.
//------------------------------------------------ -------------
{$bucle(3,0,alterar)$}
{$BloquearAlterPatch$}
<tr><td>{$etiqueta de función$}</td></tr>
{$/BlockAlterPatch$}
{$/bucle$}
Si solo hay pares de etiquetas de filas de ciclos alternos y no hay un par de etiquetas de filas de ciclos predeterminado, el par de etiquetas de filas de ciclos alternos se convertirá automáticamente a
Pares de etiquetas de línea de bucle predeterminados
//------------------------------------------------ ---------------
{$bucle(3,0,alterar)$}
{$BloquearAlterPatch$}
<tr><td>{$etiqueta de función$}</td></tr>
{$/BlockAlterPatch$}
{$/bucle$}
Si solo hay pares de etiquetas de líneas suplementarias alternas y no hay un par de etiquetas de líneas suplementarias predeterminadas, los pares de etiquetas de líneas suplementarias alternas se convertirán automáticamente a
Pares de etiquetas de línea de bucle predeterminados
************************************************** * **********************
descripción del parámetro de bucle:
{$bucle(3,0,alterar)$}
Hay tres parámetros en el bucle que se pueden reducir adecuadamente.
Primer parámetro:
3: realizar un bucle 3 veces, no significa realizar un bucle todo
Segundo parámetro:
2: Empezar desde 2, no significa empezar desde 0
El tercer parámetro:
alterar: alternar
noalter: sin alternancia Si no hay indicación, el valor predeterminado es alternancia, por lo que es lo mismo si se agrega alter o no.
Si se omiten los tres parámetros, se deben conservar al menos un par de corchetes vacíos {$loop()$}.
Representa el número de filas en el bucle Datatable
A partir de la línea 0, si hay un suplemento, se mostrará el suplemento.
************************************************** * *************************
Ha habido una actualización. Principalmente bucle de optimización.
Ahora se necesitan entre 300 y 400 milisegundos para recorrer una tabla con 50.000 filas.
************************************************** * *************************
Se recomienda que la plantilla no supere los 85k y tenga cuidado de no convertirse en un objeto de gran tamaño. Se recomienda que el número de plantillas de página para objetos de segunda generación sea menor o igual a 919 y que el número de etiquetas de función correspondientes no exceda de 1597.
Es bueno ver crecer la clase de plantilla junto con mi propia comprensión.
************************************************** * ****************************