Miembro registrado, cree su base de datos de desarrollo web, prefacio
ASP.NET no es una actualización simple de ASP, sino una parte importante del plan de Microsoft .NET. A la programación de ventanas de Windows, proporciona una buena interfaz de programación para el desarrollo de grandes funciones de aplicación de red, y puede mejorar en gran medida la eficiencia laboral de los desarrolladores.
Sin embargo, el proceso "Conversión de un tiempo, dos compilaciones" hace que el archivo ASPX parezca ligeramente inadecuado cuando la primera ejecución (o la primera operación después de la actualización), especialmente en el entorno de aplicación de una gran cantidad de archivos de código ASPX y CodeHind, compil La compilación de archivos ASPX se publica después de DLL (en el .NET, conocido como el conjunto de aplicaciones), eliminando el tiempo de "una conversión, una compilación" y la tasa de uso de la CPU, que mejorará en gran medida el rendimiento general de los servicios web. Por supuesto, después de ser compilado en DLL, la confidencialidad del código fuente también ha mejorado en cierta medida.
Este artículo presenta el proceso de procesamiento básico de ASP.NET y un análisis de un descubrimiento secreto. "" Trap ", compila los archivos ASPX disponibles con el archivo ASPX de CodeBehind en el proceso DLL. Al final del artículo, también se introducen consejos para el proceso de operación real.
Dado que este artículo involucra los conceptos tales como aplicaciones ASP.NET, compilación de línea de comandos, archivos de configuración web.config, etc., para permitir a los lectores comprender mejor el contenido de este artículo, y hacer que este artículo ya no se acumule, En primer lugar, los sistemas correspondientes a este artículo, este artículo corresponde al sistema correspondiente de este artículo.
Entorno del sistema:
Win2000 (SP3) + IIS5 + .NET Framework 1.0 (versión china).
Nombre del servidor:
Dado que los ejemplos de este artículo se prueban en esta máquina, el nombre del servidor es localhost.
Configuración de IIS:
Establezca un directorio virtual dlltest (la ruta real es w:/wwwroot/dlltest), y establecerlo como una aplicación para crear un directorio bin en dlltest. Todos los archivos de origen se colocarán en el directorio DllTest, y todos los archivos DLL se colocarán en el directorio DllTest/bin.
Archivo de configuración de la aplicación ASP.NET --web.config
Cree un archivo web.config en el directorio dlltest.
<? Versión XML = 1.0?>
<Configuración>
<System.web />
</figuration>
Ventana de comando (ventana DOS)
Abra la ventana de comando y use el comando CD para hacer el directorio actual como w:/wwwroot/dlltest.
1. Establezca un mapeo de ASPX a DLL
En primer lugar, veamos cómo el archivo ASPX es procesado por ASP.NET:
Cuando se envía una solicitud http (como "http: //webserver/webapp/webpage.aspx") desde el cliente al servidor IIS, IIS captura y analiza la solicitud, y cuando analiza esta solicitud como una página ASPX, inmediatamente Use la página ASPX para usar inmediatamente la página ASPX. Existe WebApp/Webpaage.aspx ". Si no existe, regrese al cliente y vuelva a HTTP 404 (archivo no encontrado) Error, de lo contrario, encuentre el archivo DLL correspondiente en el directorio temporal de ASP.NET, si no existe existe O el DLL es "antiguo" que el archivo fuente ASPX, llame al compilador CSC (si el script de servicio ASPX del script del lado del servicio del ASPX, el idioma es VB o JScript, luego llama al compilador VBC correspondiente, compilador JSC) para compilar) para compilar El archivo ASPX en DLL, y luego ASP.NET llama a la DLL para manejar solicitudes específicas de los clientes y volver a la respuesta del servidor.
Se puede ver en este proceso de procesamiento. Entonces, ¿hay alguna otra forma de forzar el procesamiento de "ruta" a un archivo ASPX a una DLL compilada? El método es agregar ASPX a los elementos de mapeo DLL en la sección Httphandlers de la sección System.Web de la sección System.Web en la aplicación ASP.NET.
<dd verb =* path = ASPX Nombre de archivo Tipo = nombre de clase, archivo dll/>
Archivo ASPX: se requiere el nombre virtual del "enrutamiento", y la extensión debe ser ASPX, de lo contrario, IIS procesará el archivo primero en el entorno ASP.NET en ejecución.
Archivo DLL: nombre DLL (conjunto de aplicaciones), no es necesario ingresar ".dll". ASP.NET primero busca en la DLL de ensamblaje en la aplicación de la aplicación para la aplicación de la aplicación, y luego busca en la DLL de ensamblaje en la memoria caché de conjunto de configuración del sistema.
Nombre de la clase: dado que una DLL puede tener múltiples nombres o múltiples clases, qué clase debe cargarse automáticamente cuando DLL llama.
Por ejemplo, el archivo web.config de una determinada aplicación ASP.NET es el siguiente:
<? Versión XML = 1.0?>
<Configuración>
<System.web>
<httphandler>
<dd verb =* rath = index.aspx type = bbs.indexpage, bbs />
</httphandler>
</ssystem.web>
</figuration>
El archivo de configuración le dice a ASP.NET que cuando el cliente solicita el archivo index.aspx de esta aplicación, llama directamente al bbs.dll en el directorio bin de la aplicación y carga automáticamente la clase BBS.Dindepage.
2. El desarrollo puede manejar la DLL de la página HTML
Cabe señalar que no todas las aplicaciones DLL pueden implementar el modo de solicitud/respuesta HTTP. Echemos un vistazo a la descripción del "programa de procesamiento HTTP y fábrica" en el tutorial de entrada rápida de Microsoft ASP.NET (http://chs.gotdotnet.com/quickstart/aspplus/)::
ASP.NET proporciona API de solicitud/respuesta de bajo nivel, lo que permite a los desarrolladores usar la clase .NET Framework para proporcionar servicios para las solicitudes HTTP que se introdujeron. Con este fin, los desarrolladores deben crear una clase que admita la interfaz System.Web.ihttphandler e implementar el método ProcessRequest (). Al procesar la solicitud HTTP no requiere el servicio proporcionado por el marco de página de alto nivel, el programa de procesamiento suele ser útil. Los usos comunes de los programas de procesamiento incluyen pantallas y aplicaciones similares a CGI, especialmente aquellas aplicaciones que devuelven datos binarios.
Cada solicitud de la solicitud HTTP recibida por ASP.NET finalmente es manejada por una instancia específica de la clase que implementa ihttphandler. IhttphandlerFactory proporciona una estructura que procesa el análisis real de la solicitud de URL de instancia de Ihttphandler. Además de la clase IhttPhandlerFactory predeterminada proporcionada por ASP.NET, los desarrolladores también pueden optar por crear y registrar fábricas para admitir una gran cantidad de soluciones de análisis y activación de solicitudes.
Se puede ver en este texto que cuando la página ASPX no involucra la tecnología de interfaz avanzada proporcionada por el marco .NET (como caché de datos, mantenimiento de estado, referencia de control de ventanas web, etc.), especialmente al devolver datos binarios (como Como imágenes, sonidos, etc.) al cliente, puede usar un archivo de aplicación .cs (usando el idioma C#aquí, si usa VB o JScript, ...), y la aplicación del programa debe tener una clase para implementar System.web.ihttphandler interfaz e implementa el método ProcessRequest (). Un ejemplo simple es el siguiente:
/* Archivo de origen: EX1.CS inicia*/
usando System.web;
espacio de nombres dlltenst
{{
/*
La clase debe implementar la interfaz ihttphandler. Si el programa accederá al estado de la sesión, se debe implementar la interfaz IREQuiressessionState (la interfaz de marcador que no incluye ningún método).
*/
Clase pública EX1PAGE: IHTTPHANDLER
{{
/*
El atributo ISREUSable le dice al marco .NET que este programa puede ser utilizado por varios hilos al mismo tiempo.
Verdadero corresponde;
*/
Público bool isreusable
{{
Get {return true;}
}
/*
Implemente el método ProcessRequest y devuelva los datos de respuesta al cliente.
En este ejemplo, devuelva una página HTML simple al cliente
*/
Public void ProcessRequest (contexto httpContext)
{{
httpresponse res = context.Response;
res.write (<html> <body>);
res.write (<h1> dlltest -ex1 (ejemplo 1) </h1> <hr>);
Res.write (esta página se maneja directamente por DLL);
res.write (</html> </body>);
}
}
}
/* Archivo de origen: EX1.CS End*/
En el estado de la línea de comando, los siguientes comandos de compilación compilan ex1.cs en ex1.dll y guárdelo en el directorio bin.
CSC /T: biblioteca /xin/ex1.dll ex1.cs
Agregar aspx-> dll asignación al archivo de configuración web.config.
<? Versión XML = 1.0?>
<Configuración>
<System.web>
<httphandler>
<Ded verb =* ruta = dllTest1.aspx type = dlltest.ex1page, ex1 />
</httphandler>
</ssystem.web>
</figuration>
Ahora, cuando el navegador visita http: //localhost/dlltest/dlltest1.aspx, es en realidad el método ProcessressQuest de dlltest.ex1page clase en ex1.dll.
Tercero, compile un solo archivo ASPX en DLL
A juzgar por el "significado fuera de Microsoft" descrito públicamente en la sección anterior, Microsoft no admite a los desarrolladores a compilar archivos ASPX directamente en DLL. Sin embargo, la tecnología de interfaz avanzada ASP.NET (control HTML del servidor, control web, etc.) debe mostrarse a través del archivo ASPX. . de.
Ahora cálmate para analizar:
El compilador CSC es solo un compilador de lenguaje C#. archivo de origen.
Por lo tanto, para compilar el archivo ASPX en un archivo DLL, el archivo ASPX debe convertirse en un archivo fuente CS que pueda ser reconocido por el compilador CSC. Entonces, ¿qué herramientas se utilizan para convertir? Aunque creo que esta herramienta debe estar oculta.
Oh, no hay forma del mundo, y una oportunidad accidental todavía me hace descubrir este secreto.
Eche un vistazo al archivo fuente ex2.aspx:
/* Archivo de origen: EX2.aspx Start*/
< %@ page idioma = c# %>
<script runat = servidor>
/*
Lo lees bien, la siguiente línea es "Abcdefg".
En el texto, llamo a esta línea "trampa de código"
*/
abcdefg // trampa de código
void page_load (objeto src, eventArgs args)
{{
if (! ispostback) nolabel.text = Por favor ingrese su nombre:;
}
nulo onnamesubmit (objeto src, eventargs args)
{{
name de cadena = f_name.Value;
NotLabel.Text = (name ==)? ¡Bienvenido! ;;
}
</script>
<html>
<Body>
<Form de runat = servidor>
<h1> dlltest -ex2 (ejemplo 2) </h1>
<hr>
<ASP: etiqueta runat = servidor ID = noLABEL style = color: rojo;
<input runat = servidor id = f_name size = 8>
<Button runat = Server onServerClick = onnamesubmit> ok </boton>
</form>
</body>
</html>
/* Archivo de origen: EX2.aspx End*/
Si el "Código de trampa" comenta o elimina, entonces EX2.aspx es un archivo ASP.NET simple.
Ahora abramos la "trampa" y veamos qué ha devuelto el ASP.NET.
Devolvió una página de "error de compilación", y los archivos de origen del informe no se pueden compilar. Lo que es interesante para estar interesado es el hipervínculo llamado "Mostrar la fuente de compilación completa" en la parte inferior de la página Haga clic en algunos enlaces para ver este archivo de origen CS convertido desde ex2.aspx ("fuente de compilación completa"). Elimine esta parte de la "fuente de compilación completa" y elimine la información del número de línea anterior y algunos otros interruptores de compilación (principalmente # #Comandos de compilación) y cierre la linda "trampa de código" que elimina también), y después de terminar, guárdelo como ex2_aspx .cs:
/* Archivo de origen: ex2_aspx.cs start*/
/*
De la descripción a continuación, se puede ver que de hecho hay una herramienta ininterrumpida para completar el archivo ASPX de conversión en un archivo fuente de CS
*/
// ------------------------------------------------ -------------------------------------------------- -------------------------------------------------- ----------------- --------------------------------- -------------------------------------------
// <emutogenerate>
// Este código fue generado por A también.
// Versión de tiempo de ejecución: 1.0.3705.0
//
// Chinges a este archivo puede importar un comportamiento incorrecto y se perderá si
// El código está regenerado.
// </autogenerate>
// ------------------------------------------------ -------------------------------------------------- -------------------------------------------------- ----------------- --------------------------------- -------------------------------------------
/*
Extrañamente: el espacio de nombres es en realidad ASP en lugar de ASPX
Se recomienda cambiar el nombre al nombre adecuado para las solicitudes para evitar el conflicto de nombres, como para este artículo, puede cambiar a DllTest
No cambié aquí para dejar que todos vean su apariencia original.
*/
espacio de nombres ASP {
usando el sistema;
usando System.Collections;
Usando System.Collections.pecialized;
utilizando System.Configuración;
usando System.Text;
Usando System.Text.RegulAxpressions;
usando System.web;
usando System.Web.Caching;
usando System.Web.SessionState;
Usando System.Web.Security;
usando System.web.ui;
usando System.Web.UI.WebControls;
usando System.Web.UI.HTMLControls;
/*
1. Presta atención a la composición del nombre de la clase.
2. Presta atención a su clase base. System.web.ui.Page implementa la interfaz Ihttphandler.
*/
Clase pública ex2_aspx: system.web.ui.page, system.web.sessionstate.irequiressenerationState {
Estática privada int __autoHandler;
System.web.ui.webcontrols.label Notelabel;
System.web.ui.htmlControls.htmlinputText f_name;
System.web.ui.htmlControls.htmlButton __control3;
System.web.ui.htmlcontrols.htmlform __control2;
Bool estático privado __intializado = falso;
System static privado.collections.ArrayList __fileDependences;
/* Ahora puedes apagar la "trampa"*/
// abcdefg
void page_load (objeto src, eventArgs args)
{{
if (! ispostback) nolabel.text = Por favor ingrese su nombre:;
}
nulo onnamesubmit (objeto src, eventargs args)
{{
name de cadena = f_name.Value;
NotLabel.Text = (name ==)? ¡Bienvenido! ;;
}
/* Función de construcción*/
public ex2_aspx () {
System.Collections.ArrayList Dependencias;
if (asp.ex2_aspx .__ intialize == false) {{
dependencias = new System.Collections.ArrayList ();
/*
Las siguientes líneas deben anotarse para que DLL se convierta en un archivo independiente independiente
Evite el nuevo y antiguo de sus archivos de "dependencia" cuando la DLL se ejecuta
*/
//Dependences.Add (w: //wwwroot/dlltest/ex2.aspx);
ASP.EX2_ASPX .__ FileDependences = Dependencias;
ASP.EX2_ASPX .__ intialized = true;
}
}
Anulación protegida int autohandler {
conseguir {
Return asp.ex2_aspx .__ autohandler;
}
colocar {
ASP.ex2_aspx ._ autohandlers = valor;
}
}
System.web.httpage ApplicationInstance {
conseguir {
Return ((system.web.httpapplication) (this.context.applicationInstance));
}
}
Public Anulación String TemplateSourCedirectory {
conseguir {
Return /dlltest;
}
}
System.web.ui.control __BuildControlNotelabel () {
System.web.ui.webcontrols.label __ctrl;
__ctrl = new System.web.ui.webcontrols.label ();
this.notLabel = __ctrl;
__Ctrl.id = Notelabel;
(System.web.ui.iattributeAcCessor) (__ ctrl).
Return __ctrl;
}
System.web.ui.control __BuildControlf_Name () {
System.web.ui.htmlcontrols.htmlinputText __ctrl;
__ctrl = new System.web.ui.htmlControls.htmlinputText ();
this.f_name = __ctrl;
__ctrl.id = f_name;
__ctrl.size = 8;
Return __ctrl;
}
System.web.ui.control __BuildControl__Control3 () {{)
System.web.ui.htmlcontrols.htmlButton __ctrl;
__ctrl = new System.web.ui.htmlControls.htmlButton ();
este .__ control3 = __ctrl;
System.web.ui.iparserAccessor __parser = (system.web.ui.iparserAccessor) (__ctrl));
__parser.addparsedSubObject (new System.web.ui.literalControl (OK));
__Ctrl.ServerClick += new System.EventHandler (this.onnamesubmit);
Return __ctrl;
}
sistema privado.web.ui.control
System.web.ui.htmlcontrols.htmlform __ctrl;
__ctrl = new System.web.ui.htmlControls.htmlform ();
este .__ control2 = __ctrl;
System.web.ui.iparserAccessor __parser = (system.web.ui.iparserAccessor) (__ctrl));
__Parser.addparsedSubObject (new System.web.ui.literalControl (/r/n <h1> dlltest -ex2 (ejemplo 2) </h1>/r/n <hr>/r/n))))
this .__ buildControlnotelabel ();
__parser.addparsedSubObject (this.notelabel);
__Parser.addparsedSubObject (new System.web.ui.literalControl (/r/n));
this .__ buildControlf_name ();
__parser.addparsedSubObject (this.f_name);
__Parser.addparsedSubObject (new System.web.ui.literalControl (/r/n));
this .__ buildControl__Control3 ();
__Parser.addparsedSubObject (this .___ control3);
__Parser.addparsedSubObject (new System.web.ui.literalControl (/r/n));
Return __ctrl;
}
Void privado __BuildControltree (system.web.ui.control __ctrl) {
System.web.ui.iparserAccessor __parser = (system.web.ui.iparserAccessor) (__ctrl));
__parser.addparsedSubObject (new System.web.ui.literalControl (/r/n/r/n <html>/r/n << body>/r/n));
this .__ buildControl__Control2 ();
__Parser.addparsedSubObject (this .___ control2);
__Parser.addparsedSubObject (new System.web.ui.literalControl
}
Anulación protegida void frameWorkInitialize () {
this .__ buildControltree (esto);
this.fileDependences = ASP.EX2_ASPX .__ FileDependences;
this.enableViewStateMac = true;
}
public anulación int getTypeHashCode () {) {)
Retorno -11574299;
}
}
}
/* Archivo de origen: EX2_ASPX.CS End*/
Creo que después de analizar este archivo, tendrá una comprensión adicional del principio de la operación ASP.NET (no tener nada que ver con este artículo, irrazonable).
En el estado de línea de comando, los siguientes comandos de compilación compilan ex2_aspx.cs en ex2.dll y guárdelo en el directorio bin.
CSC /T: biblioteca /xin/ex2.dll ex2_aspx.cs
Agregue aspx-> dll asignación al archivo de configuración web.config, es decir, agregue las siguientes líneas en httphandlers en la sección System.web:
<Derb =* path = dlltest2.aspx type = asp.ex2_aspx, ex2 />
Ahora, cuando el navegador visita http: //localhost/dlltest/dlltest2.aspx, es como acceder a ex2.aspx. Por supuesto, incluso si ex2.aspx no existe, o se ha actualizado, no tendrá ningún impacto en el acceso a la página, a menos que bin/ex2.dll se vuelva a generar.
Cuarto, compile el archivo ASPX de CodeBehind en DLL
Para compilar el archivo ASPX de CodeBehind en DLL, el principio de convertir el archivo ASPX en un archivo fuente CS es el mismo que el anterior. como un archivo fuente de CS. La diferencia son los pasos cuando se compilan en DLL: (por conveniencia de la narrativa, suponiendo que el archivo de interfaz es ex3.aspx, el archivo de código de código es ex3.aspx.cs y la "fuente de compilación completa" de Ex3.aspx se almacena como ex3_aspx.cs))
Paso 1: Primero use el siguiente comando para compilar ex3.aspx.cs en bin/ex3.aspx.cs.dll
Csc /t: biblioteca /xin/ex3.aspx.cs.dll ex3.aspx.cs
Paso 2: use el siguiente comando para compilar ex3_aspx.cs en bin/ex3.dll
Csc /t: biblioteca /r:bin/ex3.aspx.cs.dll /out:bin/ex3.dll ex3_aspx.cs
Luego agregue aspx-> dll asignación al archivo de configuración web.config, es decir, agregue las siguientes líneas en httphandlers en la sección System.web:
<Agregar verb =* ruta = dllTest3.aspx type = asp.ex3_aspx, ex3 />
Ahora abra el navegador y visite http: //localhost/dlltest/dlltest3.aspx.
Cinco, un pequeño truco
Al configurar la "trampa" para convertir el archivo ASPX en un archivo fuente de CS, generalmente use el método Copiar y pegar para guardar la "fuente de compilación completa" en el bloc de notas o vs.net u otro entorno de desarrollo ASP.NET, y luego guardar Después de terminar la preservación de los archivos de origen CS.
La organización es eliminar la información del número de línea de la pasta y la instrucción de compilación "#line". Si esta información se elimina manualmente, será demasiado problemático.
Uno de los trucos que uso es: en el cuaderno, use el método de reemplazo para organizarse rápidamente. Use/* línea para reemplazar todas las líneas, use:*/para reemplazar todas:, usar // #line líneas para reemplazar todo #line, después de completar el reemplazo, anotar la "trampa de código", establecer la configuración de la función de estructura de clase principal , Establezca la configuración de la función del constructor principal Las oraciones de los "archivos de dependencia" se anotan, por lo que incluso si el acabado está completo.