Cenni preliminari sulla classe delle pagine ASP.NET
Aggiornamento: novembre 2007
Quando una pagina ASP.NET viene richiesta ed effettua il rendering dei tag in un browser, il codice eseguito non è solo quello creato per la pagina. In fase di esecuzione, invece, ASP.NET genera e compila una o più classi che eseguono effettivamente le attività necessarie per l'esecuzione della pagina. In questo argomento viene fornita una panoramica del codice generato in fase di esecuzione.
Generazione ed esecuzione del codice della classe delle pagine
Una pagina ASP.NET viene eseguita come unità, combinando gli elementi sul lato server in una pagina, ad esempio i controlli, con il codice di gestione degli eventi scritto dall'utente. Non è necessario precompilare le pagine in assembly. ASP.NET compila dinamicamente le pagine e le esegue la prima volta che vengono richieste da un utente. Se sono state apportate modifiche alle pagine o alle risorse da cui dipende la pagina, quest'ultima viene ricompilata automaticamente. La classe o le classi create dal compilatore dipendono dal fatto che la pagina utilizzi il modello a file singolo o il modello code-behind.
ASP.NET supporta anche la precompilazione di un sito Web per migliorare le prestazioni ed eseguire il controllo degli errori oltre che per supportare la distribuzione del sito. Per ulteriori informazioni, vedere Cenni preliminari sulla precompilazione di siti Web ASP.NET. La precompilazione funziona sia per i modelli di pagina a file singolo che per quelli code-behind e l'output del compilatore è lo stesso per entrambi i modelli.
Pagine a file singolo
In una pagina a file singolo, il codice, gli elementi sul lato server e il codice di gestione degli eventi si trovano tutti in un unico file aspx. Quando la pagina viene compilata, viene generata e compilata una nuova classe che deriva dalla classe base Page o una classe base personalizzata definita con l'attributo Inherits della direttiva @ Page. Se, ad esempio, si crea una nuova pagina Web ASP.NET denominata SamplePage1 nella directory principale dell'applicazione, una nuova classe denominata ASP.SamplePage1_aspx viene derivata dalla classe Page. Per le pagine all'interno delle sottocartelle dell'applicazione, il nome della sottocartella viene utilizzato come parte della classe generata. La classe generata include dichiarazioni per i controlli nella pagina aspx, i gestori eventi e il resto del codice personalizzato.
Dopo la generazione della pagina, la classe generata viene compilata in un assembly, l'assembly viene caricato nel dominio applicazione e viene creata ed eseguita un'istanza della classe della pagina per eseguire il rendering dell'output nel browser. Se nella pagina vengono apportate modifiche che influirebbero sulla classe generata, attraverso l'aggiunta di controlli o la modifica del codice, il codice della classe compilata viene invalidato e viene generata una nuova classe. Per ulteriori informazioni sulla compilazione in ASP.NET, vedere Cenni preliminari sulla compilazione in ASP.NET.
Nell'illustrazione seguente viene mostrato il modello di ereditarietà per la classe delle pagine in una pagina Web ASP.NET a file singolo:
.gif)
Pagine code-behind
Nel modello code-behind, il codice e gli elementi sul lato server della pagina, incluse le dichiarazioni dei controlli, si trovano in un file aspx, mentre il codice della pagina si trova in un file di codice distinto. Il file di codice include una classe parziale, ovvero una dichiarazione di classe con la parola chiave partial (Partial in Visual Basic) che indica che esso contiene solo parte del codice che forma la classe completa per la pagina. Nella classe parziale viene aggiunto il codice richiesto dall'applicazione per la pagina. Esso è composto generalmente dai gestori eventi, ma può includere proprietà o metodi eventualmente necessari.
Il modello di ereditarietà per le pagine code-behind è leggermente più complesso di quello per le pagine a file singolo. Il modello è il seguente:
Il file code-behind contiene una classe parziale che eredita da un classe delle pagine di base. La classe delle pagine di base può essere la classe Page o essere un'altra classe derivata da Page.
Il file aspx contiene un attributo Inherits nella direttiva @ Page che punta alla classe parziale code-behind.
Quando la pagina viene compilata, in ASP.NET viene generata una classe parziale basata sul file aspx. Si tratta di una classe parziale del file di classe code-behind. Il file della classe parziale generato include dichiarazioni per i controlli della pagina. Questa classe parziale consente l'utilizzo di file code-behind come parte di una classe completa senza necessità di dichiarare i controlli in modo esplicito.
Infine ASP.NET genera un'altra classe che eredita dalla classe generata nel passaggio 3. La seconda classe generata contiene il codice necessario per creare la pagina. La seconda classe generata e la classe code-behind vengono compilate in un assembly in esecuzione per eseguire il rendering dell'output nel browser.
Nell'immagine seguente viene mostrato il modello di ereditarietà per la classe delle pagine in una pagina Web ASP.NET code-behind:
.gif)