Modello di codice di pagine Web ASP.NET
Aggiornamento: novembre 2007
Una pagina Web ASP.NET è costituita da due parti:
Elementi visivi, che comprendono markup, controlli server e testo statico.
Logica di programmazione della pagina, che comprende gestori eventi e altro codice.
ASP.NET fornisce due modelli per la gestione degli elementi visivi e del codice: il modello di pagina a file singolo e il modello di pagina code-behind. Il funzionamento dei due modelli è analogo e per entrambi è possibile utilizzare gli stessi controlli e lo stesso codice.
In questo argomento verranno illustrate le modalità di funzionamento di ciascun modello e saranno forniti consigli per eseguire una scelta appropriata.
Modello di pagina a file singolo
Nel modello di pagina a file singolo, il markup della pagina e il relativo codice di programmazione si trovano nello stesso file fisico ASPX. Il codice di programmazione si trova in un blocco script che contiene l'attributo per contrassegnarlo come codice che dovrebbe essere eseguito da ASP.NET.
Nel seguente esempio di codice viene illustrata una pagina a file singolo contenente un controllo Button e un controllo Label. Nella parte evidenziata viene illustrato il gestore eventi Click del controllo Button all'interno di un blocco script.
<%@ Page Language="VB" %>
<script >
Protected Sub Button1_Click(ByVal sender As Object, _ ByVal e As System.EventArgs) Label1.Text = "Clicked at " & DateTime.Now.ToString() End Sub
</script>
<html>
<head id="Head1" >
<title>Single-File Page Model</title>
</head>
<body>
<form id="form1" >
<div>
<asp:Label ID="Label1"
Text="Label">
</asp:Label>
<asp:Button ID="Button1"
OnClick="Button1_Click" Text="Button">
</asp:Button>
</div>
</form>
</body>
</html>
<%@ Page Language="C#" %>
<script >
void Button1_Click(Object sender, EventArgs e){ Label1.Text = "Clicked at " + DateTime.Now.ToString();}
</script>
<html>
<head>
<title>Single-File Page Model</title>
</head>
<body>
<form >
<div>
<asp:Label id="Label1"
Text="Label">
</asp:Label>
<br />
<asp:Button id="Button1"
onclick="Button1_Click"
Text="Button">
</asp:Button>
</div>
</form>
</body>
</html>
Il blocco script può contenere qualsiasi quantità di codice richiesta dalla pagina. Il codice può consistere in gestori eventi per i controlli nella pagina (come illustrato nell'esempio), metodi, proprietà e qualsiasi altro codice utilizzato normalmente in un file di classe. In fase di esecuzione, una pagina a file singolo viene considerata come una classe che deriva dalla classe Page. La pagina non contiene una dichiarazione di classe esplicita. Il compilatore genera invece una nuova classe che contiene i controlli come membri. Non tutti i controlli sono esposti come membri della pagina; alcuni sono figli di altri controlli. Il codice nella pagina diventa parte della classe; ad esempio, i gestori eventi creati diventano membri della classe Page derivata.
Per ulteriori informazioni, vedere Cenni preliminari sulla classe delle pagine ASP.NET.
Modello di pagina code-behind
Il modello di pagina code-behind consente di mantenere il markup in un file, ovvero nel file ASPX, e il codice di programmazione in un altro file. Il nome del file di codice varia in base al linguaggio di programmazione che si sta utilizzando.
.gif "Nota") Nota: |
|---|
Non tutti i linguaggi di programmazione .NET consentono di creare file code-behind per le pagine Web ASP.NET. I linguaggi devono supportare le classi parziali. Ad esempio, J# non supporta le classi parziali e, pertanto, non supporta la creazione di file code-behind per le pagine ASP.NET. |
Se, ad esempio, viene utilizzata una pagina denominata SamplePage, il markup si troverà nel file SamplePage.aspx mentre il codice si troverà in un file denominato SamplePage.aspx.vb (per Visual Basic), SamplePage.aspx.cs (per C#) e così via.
| Nota: |
|---|
Il modello code-behind utilizzato in .NET Framework versione 2.0 è diverso dal modello utilizzato nelle versioni precedenti. |
Nel modello code-behind, l'esempio utilizzato nella precedente sezione per la pagina a file singolo verrebbe suddiviso in due parti: il markup si troverebbe in un file (in questo esempio, nel file SamplePage.aspx) e sarebbe simile alla pagina a file singolo, come illustrato nel seguente esempio di codice.
<%@ Page Language="VB" CodeFile="SamplePage.aspx.vb"
Inherits="SamplePage" AutoEventWire="false" %>
<html>
<head >
<title>Code-Behind Page Model</title>
</head>
<body>
<form id="form1" >
<div>
<asp:Label id="Label1"
Text="Label" >
</asp:Label>
<br />
<asp:Button id="Button1"
onclick="Button1_Click"
Text="Button" >
</asp:Button>
</div>
</form>
</body>
</html>
<%@ Page Language="C#" CodeFile="SamplePage.aspx.cs"
Inherits="SamplePage" AutoEventWireup="true" %>
<html>
<head >
<title>Code-Behind Page Model</title>
</head>
<body>
<form id="form1" >
<div>
<asp:Label id="Label1"
Text="Label" >
</asp:Label>
<br />
<asp:Button id="Button1"
onclick="Button1_Click"
Text="Button" >
</asp:Button>
</div>
</form>
</body>
</html>
Nella pagina ASPX si riscontrano due differenze tra i modelli a file singolo e code-behind. Nel modello code-behind, non è presente alcun blocco script con l'attributo . La pagina può contenere blocchi script senza l'attributo se si desidera scrivere script lato client nella pagina. La seconda differenza è che la direttiva @ Page nel modello code-behind contiene attributi che fanno riferimento a un file esterno (SamplePage.aspx.vb o SamplePage.aspx.cs) e a una classe. Tali attributi collegano la pagina ASPX al relativo codice.
Il codice si trova in un file separato. Nel seguente esempio di codice viene illustrato un file code-behind che contiene lo stesso gestore eventi Click dell'esempio relativo alla pagina a file singolo.
Partial Class SamplePage
Inherits System.Web.UI.Page
Protected Sub Button1_Click(ByVal sender As Object, _
ByVal e As System.EventArgs) Handles Button1.Click
Label1.Text = "Clicked at " & DateTime.Now.ToString()
End Sub
End Class
using System;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
public partial class SamplePage : System.Web.UI.Page
{
protected void Button1_Click(object sender, EventArgs e)
{
Label1.Text = "Clicked at " + DateTime.Now.ToString();
}
}
Il file code-behind contiene le dichiarazioni di classe complete nello spazio dei nomi predefinito. Tuttavia, la classe viene dichiarata con la parola chiave partial, che indica che la classe non è contenuta interamente in un file. Pertanto, in fase di esecuzione della pagina, il compilatore leggerà la pagina ASPX e il file a cui questa fa riferimento nella direttiva @ Page, le assemblerà in una classe singola, quindi le compilerà compila come una unità in una classe singola.
Il file di classe parziale eredita dalla classe Page della pagina. Per ulteriori informazioni, vedere Cenni preliminari sulla classe delle pagine ASP.NET.
Scelta di un modello di pagina
I modelli di pagina a file singolo e code-behind hanno funzionalità analoghe. In fase di esecuzione, i modelli vengono eseguiti nello stesso modo e non si riscontrano differenze sostanziali nelle prestazioni. Pertanto, la scelta di un modello di pagina dipende da altri fattori: ad esempio, dalle modalità di organizzazione del codice nell'applicazione, dalla necessità di separare la progettazione della pagina dalla codifica e così via.
| Nota: |
|---|
Gli esempi riportati nella documentazione sono spesso presentati come pagine a file singolo, in modo da agevolare la lettura ed evitare di dover illustrare due file per ogni esempio. L'utilizzo degli esempi a file singolo nella documentazione non deve essere interpretato come una scelta preferenziale della pagina a file singolo rispetto a quella code-behind o come prova del fatto che le pagine a file singolo offrono alcuni vantaggi intrinseci. |
Vantaggi delle pagine a file singolo
Di norma, il modello a file singolo è adatto per le pagine in cui il codice è costituito principalmente da gestori eventi per i controlli sulla pagina.
I vantaggi offerti dal modello della pagina a file singolo comprendono quanto segue:
Nelle pagine in cui non è presente una quantità eccessiva di codice, la praticità di mantenere il codice e il markup nello stesso file può compensare altri vantaggi offerti dal modello code-behind. Ad esempio, potrebbe risultare più semplice lo studio di una pagina a file singolo, in quanto è possibile visualizzare il codice e il markup in un'unica posizione.
Le pagine scritte utilizzando il modello a file singolo sono leggermente più semplici da distribuire o inviare a un altro programmatore, in quanto sono costituite solamente da un singolo file.
Poiché non esiste alcuna dipendenza tra i file, è più facile rinominare una pagina a file singolo.
La gestione dei file in un sistema di controllo del codice sorgente è leggermente più semplice, in quanto la pagina è indipendente all'interno di un file singolo.
Vantaggi delle pagine code-behind
I vantaggi offerti dalle pagine code-behind le rendono adatte per le applicazioni Web caratterizzate da una quantità notevole di codice e in cui più sviluppatori creano un sito Web.
I vantaggi offerti dal modello code-behind comprendono quanto segue:
Le pagine code-behind offrono una netta separazione tra markup (interfaccia utente) e codice. Una interessante conseguenza pratica di queste caratteristiche è che il progettista può creare il markup mentre, contemporaneamente, il programmatore scrive il codice.
Il codice non viene esposto ai progettisti della pagina o ad altri che lavorano solo sul markup della pagina.
Il codice può essere utilizzato nuovamente per più pagine.
Compilazione e distribuzione
Le attività di compilazione e distribuzione per le pagine a file singolo e code-behind sono analoghe. Nella modalità più semplice, è sufficiente copiare la pagina sul server di destinazione. Se si utilizzano le pagine code-behind, è sufficiente copiare la pagina ASPX e il file di codice. Alla richiesta iniziale della pagina, questa viene compilata ed eseguita da ASP.NET. Si noti che in entrambi gli scenari il codice sorgente viene distribuito con markup.
In alternativa, è possibile precompilare il sito Web. In questo caso, ASP.NET produce un codice oggetto per le pagine che è possibile copiare sul server di destinazione. La precompilazione funziona sia per i modelli a file singolo che per quelli code-behind e l'output è lo stesso per entrambi i modelli. Per ulteriori informazioni, vedere la classe Cenni preliminari sulla precompilazione in ASP.NET.