Sviluppare web app con ASP.Net

Da qualche anno Microsoft ha lanciato sul mercato una nuova tecnologia di sviluppo denominata .NET (che si legge dot NET e non punto NET), la quale unisce in un unico ambiente vari tipi di programmazione per diversi processi informativi: dalla programmazione WUI (Windows User Interface) alla programmazione Web a quella per dispositivi mobili (palmari, cellulari, PDA, ecc…), inglobando in questo unico ambiente più di trenta differenti linguaggi, alcuni proprietari della tecnologia stessa (come il C#, che si legge C sharp), altri proprietari di casa Microsoft con alcune migliorie (come il VB.NET, il JScript.NET) ed altri ancora sono stati adattati al nuovo ambiente (come il Cobol.NET).

La bellezza e l’utilità di questo ambiente è che consente davvero di interagire tra applicazioni di varia natura con estrema facilità e versatilità: al contrario delle vecchie (ma non superate nè inefficaci) tecnologie Microsoft come Classic ASP e Visual Basic, in .NET è possibile far comunicare un’applicazione stand-alone con un’applicazione Web, magari condividendo la stessa banca dati, fornendo informazioni anche a dispositivi mobili e viceversa. La cosa sconvolgente è che vari pezzi di una stessa applicazione possono essere scritti utilizzando più linguaggi supportati dalla piattaforma, senza causare allo sviluppatore particolari problemi di compatibilità. Una classe o semplicemente una variabile scritta in C# può essere utilizzata in VB.NET e viceversa, o da altri linguaggi. Sconvolgente? non ancora abbastanza!

Nei prossimi capitoli affronteremo in concreto questa tecnologia, dando spazio principalmente ad ASP.NET utilizzando come linguaggio il VB.NET, essendo più semplice rispetto ad altri e, sicuramente, già più familiare agli sviluppatori ASP, ai quali do un consiglio: per imparare ed utilizzare ASP.NET non fate confronti con ASP e non date nulla per simile o scontato, perchè non è cosi! ASP.NET non è una evoluzione di ASP, è un linguaggio diverso, totalmente diverso.

Requisiti ed installazione

Nel primo capitolo abbiamo parlato di piattaforma e tecnologia senza scendere nello specifico. Il supporto di tutto ciò che fa parte di .NET è dato dal Framework che in gergo tecnico altro non è che l’ambiente di run-time (esecuzione) degli script.

Detta in questi termini è un po riduttivo… prendiamo come paragone Java, a cui, per altro, Microsoft si è ispirata in termini di portabilità. Tutti abbiamo sulle nostre macchine la cosiddetta Virtual Machine che permette di eseguire script Java, Javascript ed Applet e di controllarne il flusso e l’affidabilità. Esiste poi l’ambiente di sviluppo separato dalla VM, il JDK (Java Development Kit) per poter sviluppare e compilare le classi Java; esistono poi decine e decine di editor di sviluppo sia freeware che a pagamento, messi a disposizione da diverse case produttrici interessate alla tecnologia.

Il Framework .NET è tutto questo in un’unica soluzione open-source! Nel capitolo che segue analizzeremo i principali software di sviluppo, scegliendo quello che più si addice alle nostre esigenze in rapporto qualità/economia 🙂

Vediamo cosa ci serve per costituire il nostro ambiente .NET; in primo luogo do una brutta notizia agli amanti del Windows 98: purtroppo il Framework non è supportato 🙁

E’ necessario disporre almeno di una versione 2000 o XP del sistema operativo di casa Microsoft. Per la verità è possibile lavorare anche su ME, ma mi rifiuto di considerarlo un sistema operativo!

Per chi dispone di un server dedicato, oppuro la sua attività è tale da richiederne uno, è consigliabile Windows Server 2003 che carica per default il Framework ed IIS 6, molto più affidabile e sicuro di IIS 5.* nonchè più veloce, essendo configurato all’80% in XML.

Ricapitolando, ci serve:

• Sistema operativo – Windows 2000, XP, ME, Server 2003, Server 2008
• Server Web – IIS 5.*, 6
• Framework .NET – scaricabile cliccando qui

L’installazione del Framework è di una semplicità infinita, dovendo semplicemente seguire le maschere proposte, cliccare Avanti o Next quando richiesto e riavviare il sistema anche se non richiesto.

Software di sviluppo

Microsoft mette a disposizione un ambiente di sviluppo fenomenale, il Visual Studio .NET che altro non è che la versione 7 del Visual Studio, adattato alla piattaforma .NET. I suoi costi sono particolarmente elevati e non accessibile a tutti ma… posso assicurarvelo… è sbalorditivo!

L’installazione è semplice: il pacchetto MSDN che vi sarà consegnato all’atto dell’acquisto è composto da 6 CD, uno di prerequisiti del sistema (il Framework e vari aggiornamenti – Attenzione: è necessaria la previa installazione di IIS *) tre di installazione di Visual Studio e due di guida in linea (sempre detta MSDN – Microsoft Development Network), sempre indispensabile per qualsiasi sviluppatore, specialmente .NET, data la sua complessità.

Per coloro che non hanno intenzione di affrontare un simile investimento esistono diversi software open-source le cui caratteristiche sono meno performanti del Visual Studio (intelisence, completamento automatico sia del codice .NET che dell’HTML!!! controllo semantico degli errori, interfaccia GUI, ecc…) ma pur sempre valide alternative, adatte soprattutto in fase didattica e di apprendimento.

Il progetto più noto è messo a disposizione da Microsoft stessa in modalità open-source e si chiama Web Matrix, software scritto in C# per il peso di 1.3 Mb in continuo aggiornamento, scaricabile gratuitamente in un unico file .msi dal sito www.asp.net seguendo il link Web Matrix e seguendo pochi suggerimenti e registrandosi semplicemente lasciando il proprio indirizzo email, oppure iscrivendosi alla Community.

Introduzione ad Asp.NET

Entriamo finalmente nel pratico!

Qualunque sia stata la vostra scelta di un software di sviluppo, sappiate che il file ASP.NET hanno estensione .aspx e, naturalmente, vanno caricati su IIS nella cartella

C:Inetpubwwwroot

A differenza di un file ASP classico, i file .aspx sono compilati a run-time dal Framework: non è quindi possibile effettuare modifiche di natura programmatica (non stilistica o di semplice HTML) e vederle in esecuzione col refresh della pagina.

Il linguaggio che si è scelto di utilizzare in questa guida, come già detto, è il VB.NET che sarà introdotto nel prossimo capitolo.

Iniziamo a creare il nostro primo file ASP.NET, e chiamiamolo, ad esempio, primo.aspx. Carichiamolo su IIS in una cartella che utilizzeremo come prova per i nostri esempi, assegnandole i permessi in lettura e scrittura all’utente con cui stiamo lavorando, oppure, a mali estremi, all’utente generico Everyone (anche se i sistemisti che leggono mi picchierebbero a sangue per questo…)

Di seguito il codice del file primo.aspx:

<%@ Page Language="VB" %>
<script runat="server">
    Private Sub Page_Load(sender As Object, e As EventArgs)
        Messaggio.Text = "Hello World!"
    End Sub
</script>
<html>
    <head>
        <title>La mia prima pagina ASP.NET</title>
    </head>
<body>

<form id="Modulo" runat="server">
    <asp:Label id="Messaggio" runat="server"></asp:Label>
</form>

</body>
</html>

Eseguite il file primo.aspx… il risultato in output sulla pagina dovrebbe essere il seguente codice html:

<span id="Messaggio">Hello World</span>

La struttura del nostro primo esempio credo sia abbastanza chiara e, ne sono certo, tra qualche lezione la troverete davvero banale.

Passiamo ora, prima di prosegire, a qualche considerazione generica sul linguaggio.

Una pagina ASP.NET inizia sempre con la dichiarazione:

<%@ Page Language="VB" %>

la quale, oltre ad identificare il linguaggio (nel nostro caso "VB") accetta anche altri attributi come codebehind (utilizzato per includere un file di solo codice, ad esempio primo.aspx.vb), ValidateRequest (booleano, accetta come valori true o false per la gestione degli errori sui moduli).

In genere in ASP.NET non si utilizzano i Tag di render <% e %> ma si usa includere tutto il codice (in questo caso VB) al di sopra del codice HTML della pagina in una coppia di Tag <script> e </script> con l’attributo obbligatorio runat="server" e l’attributo facoltativo language.

Nota: l’attributo language è facoltativo nel senso che andrà utilizzato qualora non si sia specificato un linguaggio di default nell’intestazione della pagina (cosa possibile ma sconsigliata) o se si desidera implementare una porzione di codice in un linguaggio differente da quello di default, ad esempio in C#.

Altra caratteristica di ASP.NET che vedremo nelle prossime lezioni è l’utilizzo dei namespace, ovvero inclusione di riferimenti a classi e librerie messe a disposizione degli sviluppatori dal Framework stesso. La sintassi per l’inclusione è:

<%@ Import Namespace="..." %>

La classe più comune è System che possiede una serie di interessanti sottoclassi quali Web, Xml, IO e tante altre, alcune delle quali verranno utilizzate negli esempi di questa guida. Una lista completa dei namespace di .NET è reperibile sul sito www.microsoft.com effettuando una ricerca nell’MSDN.

Concludo con una considerazione importante: non è possibile aggiungere codice in un punto qualsiasi della pagina e/o al di fuori di una funzione o di una sub-routine; anche ciò che dev’essere gestito al caricamento della pagina va incluso in una sub-routine proprietaria di ASP.NET chiamata Page_Load che gestisce, tra l’altro, anche il sub-evento post back della pagina, che studieremo nel capitolo 7 introducendo i Web Form.

Introduzione a VB.NET

Tenterò di non dare per scontato pressocchè nulla in merito all’implementazione di codice VB, ma presumo che il lettore abbia almeno un’infarinatura di VBScript client-side o server-side, o meglio ancora di Visual Basic, da cui il VB.NET in realtà deriva.

Come visto e accennato negli esempi del capitolo precedente, la programmazione .NET è orientata agli eventi oltre che agli oggetti: ad esempio in Visual Studio .NET è possibile fare doppia click su un pulsante di un form ed accedere direttamente all’evento onClick (meglio detto onServerClick) di quell’elemento. Discuteremo di questi dettagli in maniera più esaustiva nel capitolo 7.

Iniziamo con le variabili e la loro tipizzazione. Un cruccio dei programmatori ASP è che non è possibile tipizzare direttamente una variabile ma è necessario convertirla in fase di inizializzazione e non è possibile nemmeno valorizzarla in fase di dichiarazione. In VB.NET questo bug / limitazione / rottura di scatole è stato by-passata!

Possiamo dichiarare una variabile di tipo stringa in questo modo:

Dim testo As String = "Hello World!"

oppure un numerico intero in questo modo

Dim numero As Integer = 1

E’ molto importante, nonchè consigliato da Microsoft stessa, tipizzare gli oggetti, data la vasta quantità e qualità messa a disposizione dalla piattaforma .NET; ipotizziamo di voler instanziare un componente COM+ o un oggetto qualsiasi, anche un semplice Recordset ADO; possiamo dichiararlo a livello globale (al di fuori di qualsiasi funzione e sub-routine) in una pagina rendendolo visibile a tutte le funzioni e sub-routine di quella pagina stessa, utilizzando la forma

Private rs As New ADODB.Recordset

insomma, scordiamoci di utilizzare una CreateObject 🙂

Le istruzioni condizionali If – Else e Select Case sono praticamente identici al VB tradizionale

Dim a As Integer = 1
Dim b As Integer = 2

If a = b Then
    Response.Write("FALSE")
Else
    Response.Write("VERO")
End If

Colgo l’occasione per accennare agli oggetti built-in che in VBScript possono omettere le parentesi per i metodi, mentre in VB.NET sono obbligatori:

Response.Write "Hello World!"  ' SBAGLIATO
Response.Write("Hello World!") ' CORRETTO

In ASP.NET, comunque, il Response.Write() non è molto utilizzato, dando priorità alla stampa a video, come visto nel capitolo precedente, ad oggetti lato server come le asp:Label, che si traducono in HTML in Tag <span> e </span>.

Concludo questo accenno agli oggetti built-in con una brutta notizia: una variabile di tipo Session e/o Application in ASP.NET non è visibile in ASP classico 🙁

Stesso discorso per le istruzioni di Iterazione: i cicli For e While sono identici al VBScript tradizionale, con la differenza che per il ciclo While è consigliata la chiusura utilizzando l’istruzione End While piuttosto che Wend

While condizione
    istruzione
End While

For condizione To condizione
    istruzione
Next

Anche gli Array funzionano in maniera identica a VB tradizionale.

Tra le altre cose belle che vi ho annunciato, il VB.NET ha esteso il controllo e la gestione degli errori fino al costrutto Try – Catch – Finally, dove in Try viene indicata l’istruzione e o una serie di istruzioni da seguire; in Catch l’istruzione alternativa o la gestione dell’errore con un messaggio; in Finally viene indicata l’istruzione da eseguire in ogni caso, ad esempio la chiusura di una connessione in caso di errore del database

Try
    ' istruzioni errate e/o che non possono essere eseguite
Catch (ex As Exeption)
    ' messaggio di errore o istruzione alternativa
    ' ad esempio
    ' Response.Write("Errore: " & ex.Message)
Finally
    ' istruzione che verrà eseguita in ogni caso
End Try

Con questo concludo questa breve panoramica sul VB.NET e aggiungo che gli esempi dei prossimi capitoli vedranno coinvolti questi elementi e ne introdurranno di nuovi (per chi non conosce il VB) come le funzioni Replace(), Split(), Len(), Trim(), Left() ecc.

Gli HTML controls

Gli HTML Controls sono oggetti lato server di ASP.NET che riproducono elementi HTML classico, con la potenzialità di interagire direttamente ed attivamente con gli script lato server, secondo il principio già espresso nei capitoli precedenti che ASP.NET è orientato agli eventi. Questi oggetti fanno parte del namespace System.Web.UI.HtmlControls implicitamente utilizzato da un file ASP.NET una volta compilato dal Framework ed in esecuzione sul server Web.

Un esempio di HTML Controls è stato già fatto nel capitolo 4 utilizzando l’oggetto asp:Label; questi oggetti necessitano di degli attributi obbligatori id (univoco, specifica il nome dell’oggetto e permette agli script lato server di fargli riferimento, ed esempio utilizzando la proprietà Text per la stampa a video, come visto stesso nel capitolo 4) e runat="server" per specificare che si tratta di un elemento lato server. E’ possibile implementare anche proprietà stilistiche per gli HTML Controls, ma salto questo aspetto a piè pari, consigliando l’utilizzo dei classici CSS e sconsigliando l’abuso di questi elementi che, essendo elaborati dal server e restituiti come HTML al client, tendono a rallentare l’esecuzione ed il relativo caricamento della pagina.

La loro sintassi, come già visto, è la seguente:

<asp:Label id="Messaggio" runat="server"></asp:Label>

con la possibilità di omettere il Tag di chiusura aggiungendo una slash (/) finale, secondo i principi dell’XHTML

<asp:Label id="Messaggio" runat="server" />

Di seguito un elenco di tutti i namespace degli HTML Controls:

• HtmlAnchor
• HtmlButton
• HtmlContainerControl
• HtmlControl
• HtmlForm
• HtmlGenericControl
• HtmlImage
• HtmlInputButton
• HtmlInputCheckBox
• HtmlInputControl
• HtmlInputFile
• HtmlInputHidden
• HtmlInputImage
• HtmlInputRadioButton
• HtmlInputText
• HtmlSelect
• HtmlTable
• HtmlTableCell
• HtmlTableCellCollection
• HtmlTableRow
• HtmlTableRowCollection
• HtmlTextArea

Nel prossimo capitolo vedremo all’opera gli HTML Controls che fanno parte della categoria Web Form, ovvero controlli che generano in automatico componenti di un form HTML classico, con la particolarità di poter essere gestiti direttamente da script lato server.

I Web form

Siamo arrivati alla parte più importante ed interessante della guida, almeno fino a questo momento: l’interazione con i moduli lato server, i Web Form. Come già accennato, si tratta di oggetti lato server che generano in automatico elementi HTML di tipo input (caselle di testo, pulsanti di opzione e/o di seleziona multipla, bottoni), select e textarea.

Di seguito un elenco degli oggetti server per la realizzazione di un modulo HTML lato server:

• asp:Button bottone a cui risponde per default l’evento onClick lato server
• asp:CheckBox casella di scelta a selezione multipla
• asp:DropDownList la classica selectbox, conosciuta anche come combobox o menu a tendina
• asp:ImageButton bottone che permette di inserire un’immagine
• asp:RadioButton casella di scelta a selezione singola
• asp:TextBox (*)

(*) Le asp:TextBox, in più agli altri oggetti appena elencati, godono di una particolarità: l’attributo TextMode di default, se omesso, assume il valore Single, restituendo in output la classica casella di testo. Se impostato su Multiline restituisce una textarea; se impostato su Password restituisce una casella di testo che cripta il contenuto, visualizzando degli asterischi (*) al posto dei caratteri effettivamente digitati.

Nel primo degli esempi di questo capitolo ci limiteremo a stampare a video il contenuto di una casella di testo in una asp:Label, alla quale fa riferimento la variabile che recupera il valore della casella di testo. Si crei il file secondo.aspx e lo si inserisca nella directory di prova creata in precedenza per testare gli esempi della guida:

<%@ Page Language="VB" ValidateRequest="false" %>
<script runat="server">
    Private Sub Invia(sender As Object, e As EventArgs)
        Messaggio.Text = Testo.Text
    End Sub
</script>
<html>
    <head>
        <title>I Web Form - Esempio # 1</title>
    </head>
<body>

<form id="Modulo" runat="server">
    <asp:Textbox id="Testo" runat="server" />
    <asp:Button runat="server" Text="Invia" OnClick="Invia" />
    <br><br>
    <asp:Label id="Messaggio" runat="server" />
</form>

</body>
</html>

L’esempio è davvero banale e sono certo risulterà immediatamente chiaro a chi ha un minimo di dimestichezza con la programmazione, sia Web che WUI. Da notare, come visto anche nel capitolo 4, che tutti gli elementi lato server vanno inclusi in un form anch’esso lato server.

Attenzione: una pagina può contenere uno ed un solo form runat="server".

All’asp:Button abbiamo associato esplicitamente l’evento OnClick in cui è richiamata la sub-routine Invia che si limita ad assegnare alla asp:Label con ID Messaggio il valore della casella di testo con ID Testo.

Come avete visto abbiamo aggiunto alla dichiarazione iniziale, come annunciato, l’attributo ValidateRequest="false": ASP.NET non permette di gestire l’inserimento di caratteri particolari come il minore ed il maggiore (< e >) perchè ritenuti pericolosi in quanto potrebbero venire inseriti da un modulo Tag HTML che potrebbero potenzialmente eseguire degli split. E’ dunque opportuno sostituire almeno il simbolo minore (<) con i caratteri ASCII associati:

Messaggio.Text = Replace(Testo.Text, "<", "&lt;")

L’esempio che segue, invece, vede la popolazione di una selectbox, utilizzando l’oggetto asp:DropDownList. Si crei il file terzo.aspx nella directory degli esempi della guida:

<%@ Page Language="VB" ValidateRequest="false" %>
<script runat="server">
    Private Sub Page_Load(sender As Object, e As EventArgs)
        If Page.IsPostBack = False Then
            Nomi.Items.Add("Pippo")
            Nomi.Items.Add("Pluto")
            Nomi.Items.Add("Paperino")
        End If
    End Sub
</script>
<html>
    <head>
        <title>I Web Form - Esempio # 2</title>
    </head>
<body>

<form id="Modulo" runat="server">
    <asp:DropDownList id="Nomi" runat="server" />
</form>

</body>
</html>

Per popolare una selectbox si utilizza il metodo Add() associato alla proprietà Items. Approfittiamo per vedere il funzionamento del post back della pagina, gestito dall’istruzione proprietaria di ASP.NET Page.IsPostBack: settando il controllo su False possiamo eseguire al caricamento della pagine le istruzioni contenute nel controllo una sola volta, evitando, in questo caso, di popolare la selectbox tante volte quanti gli eventi post back della pagina.

Un altro sistema per evitare che quanto detto accada, nel caso di una selectbox, è l’utilizzo del metodo Clear(), come nell’esempio che segue:

Nomi.Items.Clear()
Nomi.Items.Add("Pippo")
Nomi.Items.Add("Pluto")
Nomi.Items.Add("Paperino")

in modo da ripulire la selectbox ogni volta che la pagina viene ricaricata o subisce un post.

Di seguito un esempio di utilizzo degli asp:RadioButton nel file quarto.aspx, come sempre da creare nella directory degli esempi della guida:

<%@ Page Language="VB" ValidateRequest="false" %>
<script runat="server">
    Private Sub Scegli(sender As Object, e As EventArgs)
        If A.Checked Then
            Messaggio.Text = "Pippo"
        ElseIf B.Checked Then
            Messaggio.Text = "Pluto"
        ElseIf C.Checked Then
            Messaggio.Text = "Paperino"
        Else
            Messaggio.Text = "Non hai selezionato nessun nome"
        End If
    End Sub
</script>
<html>
    <head>
        <title>I Web Form - Esempio # 3</title>
    </head>
<body>

<form id="Modulo" runat="server">
    <asp:RadioButton id="A" GroupName="Nomi" runat="server" Text="Pippo" />
    <br>
    <asp:RadioButton id="B" GroupName="Nomi" runat="server" Text="Pluto" />
    <br>
    <asp:RadioButton id="C" GroupName="Nomi" runat="server" Text="Paperino" />
    <br>
    <br>
    <asp:Button runat="server" Text="Scegli" OnClick="Scegli" />
    <br><br>
    <asp:Label id="Messaggio" runat="server" />
</form>

</body>
</html>

Nel codice di scripting ASP.NET utilizziamo un controllo condizionale in base alla proprietà Chacked associata al singolo ID di ogni pulsante di opzione. Nel codice HTML, invece, evidenziamo la modalità di creazione e gestione di un gruppo di radiobutton: Ultimo esempio

<asp:RadioButton id="A" GroupName="Nomi" runat="server" Text="Pippo" />
<br>
<asp:RadioButton id="B" GroupName="Nomi" runat="server" Text="Pluto" />
<br>
<asp:RadioButton id="C" GroupName="Nomi" runat="server" Text="Paperino" />
<br>

Assegniamo ad ogni pulsante un ID differente e l’attributo GroupName (utilizzando lo stesso valore per i pulsanti di uno stesso gruppo) per renderli parte di un gruppo, in modo che alla selezione di un’opzione si deseleziona quella selezionata. Per lasciare un’opzione selezionata per default si utilizza la proprietà

checked="checked"

Concludiamo questa panoramica sui Web Form dando un’occhiata all’oggetto asp:CheckBox, creando il file quinto.aspx nella directory dei nostri esempi:

<%@ Page Language="VB" ValidateRequest="false" %>
<script runat="server">
    ' nessuno script per questo esempio
</script>
<html>
    <head>
        <title>I Web Form - Esempio # 4</title>
    </head>
<body>

<form id="Modulo" runat="server">
    <asp:CheckBox id="A" runat="server" Text="Pippo" /><br>
    <asp:CheckBox id="B" runat="server" Text="Pluto" /><br>
    <asp:CheckBox id="C" runat="server" Text="Paperino" /><br>
</form>

</body>
</html>

Nei prossimi capitoli avremo modo di esaminare gli Web Form di ASP.NET con esempi concreti, interagendo con database, file XML e moduli per la gestione di posta elettronica.

I Validation controls

ASP.NET mette a disposizione dello sviluppatori una serie di oggetti customizati per effettuare controlli e validazione sui campi di un Web Form, ovvero i Validation Controls. Non farei a cambio con un tradizionale controllo che fa uso di istruzioni condizionali lato server (visto che lato client, ad esempio con Javascript, non è possibile realizzarne) ma questi componenti, nel loro essere, sono davvero utili e completi.

Di seguito un elenco dei Validation Controls:

• asp:RequiredFieldValidator controlla che un campo, in genere di tipo casella di testo, non sia vuoto
• asp:RangeValidator controlla che in un campo venga inserito un valore numerico compreso in un intervallo definito
• asp:CompareValidator controlla che un valore inserito in un campo sia uguale ad un altro valore definito
• asp:RegularExpressionValidator controlla che un campo sia compilato seguendo un’espressione regolare
• asp:CustomValidator controllo definito dall’utente
• asp:ValidationSummary restituisce un elenco di tutti gli errori riscontrati nella compilazione

Ognuno dei Validation Controls dispone di una serie di attributi in cui vengono identificati il campo da controllare ed il messaggio di errore da restituire; a seconda del singolo controllo, poi, esistono una serie di attributi proprietari, atti a stabilire un controllo efficace. In ultimo c’è da dire che i Validation Controls rispondono all’evento onChange dall’elemento del Web Form selezionato in quel momento dall’utente che sta compilando il modulo.

Di seguito un esempio di utilizzo del Validation Controls nel file sesto.aspx da creare nella directory degli esempi base della guida:

<%@ Page Language="VB" ValidateRequest="false" %>
<script runat="server">
    ' nessuno script per questo esempio
</script>
<html>
    <head>
        <title>I Validation Controls</title>
    </head>
<body>

<form id="Modulo" runat="server">
    <asp:Textbox id="testo" runat="server" /><br>
    <asp:RequiredFieldValidator
        id="controllo"
        runat="server"
        ControlToValidate="testo"
        ErrorMessage="Campo obbligatorio" />
</form>

</body>
</html>

Si provi a posizionare il cursore nella casella di testo e a uscire dalla casella stessa senza aver immesso alcun valore. Non mi dilungo troppo su questo argomento perchè, come detto, preferisco implementare esempi con controlli direttamente da codice, per due motivi: primo, i controlli da codice sono di certo più efficaci, versatili e veloci; secondo, approfittiamo per scrivere codice e fare maggior pratica.

Asp.NET e Database

Iniaizmo col dire che ASP.NET lavora con qualsiasi database (di casa Microsoft e non) che supporti gli standard ODBC, quindi Access, SQL Server, MySQL, Oracle, Basis, ecc…

Gli sviluppatori ASP e Visual Basic hanno di certo familiarità con l’accesso ai dati mediante ADO ed i suoi oggetti Connection, Recordset e Command, ma non è tutto. Il Framework mette a disposizione degli sviluppatori una versione di ADO riveduta, corretta ed ampliata, chiamata (guarda caso…) ADO.NET la cui gestione avviene attraverso oggetti proprietari del Framework, che affronteremo più nel dettaglio nel prossimo capitolo.

ADO e ADO.NET … quale usare? La maggior parte degli sviluppatori e delle persone/organizzazioni coinvolte in .NET non hanno dubbi: ADO.NET! Personalmente concordo, perchè il suo utilizzo è davvero semplice ed efficace, ma non per questo condanno l’utilizzo di ADO in .NET.

Tenterò di mettere a vostra disposizione la mia personale esperienza in ASP.NET legata all’interazione con i database, analizzando i pro ed i contro che ho potuto constatare, oltre a darvi delle informazioni di carattere generale che anc’io ho preso (per ora!..) come atto di fede.

ADO.NET è di sicuro più adatto per ASP.NET e non richiede, al contrario di ADO, l’importazione di referenze della libreria ADO all’interno del progetto. Le tecniche di accesso e manipolazione dei dati con ADO.NET sono di sicuro avanzate rispetto ad ADO, ma non è garantita l’integrità dei dati in caso di accesso concorrenziale ad uno stesso record. Una sua peculiarità è che è possibile lavorare in disconnesso su di un database grazie ad una gestione interna di ADO.NET in XML, controllata a run-time dal Framework.

Detto questo, vi rimando al prossimo capitolo in cui affronteremo degli esempi di gestione dei dati con entrambe le versioni del noto ActiveX.

Utilizzo di ADO e ADO.NET

Nel capitolo precedente abbiamo visto le differenze sostanziali (soprattutto concettuali) tra ADO e ADO.NET nell’interazione tra ASP.NET ed i database. Non do per scontato che tutti abbiano particolare esperienza nell’interfacciarsi con un database da una pagina Web, ma che abbiano almeno un minimo di dimestichezza. Ad ogni modo tutti gli esempi sono commentati e spiegati, pur nella loro semplicità.

Partiamo con ADO tradizionale. Per prima cosa è necessario creare la cartella bin all’interno di

C:Inetpubwwwroot

e copiarvi il file adodb.dll che si trova nel vostro computer nel percorso

C:ProgrammiMicrosoft.NETPrimary Interop Assemblies

In secondo luogo vanno importati in una pagina .aspx i namespace ADODB e System.Data ed il resto del codice somiglia ad ASP tradizionale; si crei ora il database Access database.mdb con la tabella utenti composta dai campi nome e cognome (entrambi di tipo Testo); popolatela di dati e copiate nel vostro nuovo file ado.aspx il codice che segue:

<%@ Page Language="VB" ValidateRequest="false" %>
<%@ Assembly Name="ADODB" %>
<%@ Import Namespace="ADODB" %>
<%@ Import Namespace="System.Data" %>
<script runat="server">
    ' Creo la connessione ed il recordset rendendo i due oggetti
    ' visibili a livello globale in tutta la pagina
    Private cn As New ADODB.Connection
    Private rs As New ADODB.Recordset

    Private Sub Page_Load(sender As Object, e As EventArgs)
        ' Apro la connessione ed il recordset lanciando una semplice query
        cn.Open("driver={Microsoft Access Driver (*.mdb)};dbq=" _
        & Server.MapPath("database.mdb"))
        rs.Open("SELECT * FROM utenti", cn, 1)
        ' Controllo che ci siano dati
        If rs.EOF Then
            Utenti.Text = "Nessun dato presente"
        Else
        ' Se ci sono dati li stampo a video in una asp:Label
            While rs.EOF = False
                Utenti.Text += rs("nome").Value & _
                & " " rs("cognome").Value & "<br>"
                rs.MoveNext()
            End While
        End If
       ' Un po di pulizia...
        rs.Close()
        cn.Close()
    End Sub
</script>
<html>
    <head>
        <title>Utilizzo di ADO tradizionale</title>
    </head>
<body>

<form id="Modulo" runat="server">
    <asp:Label id="Utenti" runat="server" />
</form>

</body>
</html>

Nulla di nuovo per gli sviluppatori ASP e/o Visual Basic, eccetto una piccola differenza legata a VB.NET: è stato importato dai linguaggi derivanti dal C la possibilità di concatenare due stringhe (o di ripetere la stessa stringa su se stessa, come in questo caso) l’operatore +=.

Passiamo ora ad un esempio (più dettagliato dal punto di vista teorico) di utilizzo di ADO.NET. Esistono diversi oggetti e componenti proprietari di ASP.NET che lavorano con i database, sostituendo gli oggetti classici di ADO; in questo esempio utilizzeremo il namespace System.Data.OleDb; di seguito il codice che esegue una query sullo stesso database e sulla stessa tabella dell’esempio precedente, utilizzando il nuovo file adonet.aspx:

<%@ Page Language="VB" ValidateRequest="false" %>
<%@ Import Namespace="System.Data" %>
<%@ Import Namespace="System.Data.OleDb" %>
<script runat="server">
    Private Sub Page_Load(sender As Object, e As EventArgs)
        ' Creo un oggetto connection, command  e datareader del namespace OleDB
        Dim cn As OleDbConnection
        Dim cmd As OleDbCommand
        Dim dr As OleDbDataReader
        ' Apro la connessione
        Dim str As String = "Provider=Microsoft.Jet.OLEDB.4.0; Data Source=" _
        & Server.MapPath("database.mdb")
        cn = New OleDbConnection(str)
        cn.Open()
        ' Lancio una query nell'oggetto commando di OleDB
        cmd = New OleDbCommand("SELECT * FROM utenti", cn)
        ' Eseguo la query in un datareader
        dr = cmd.ExecuteReader()
        ' Mostro i dati a video
        While (dr.Read())
            Utenti.Text += dr("nome") & " " & dr("cognome") & "<br>"
        End While
        ' Un po di pulizia...
        dr.Close()
        cn.Close()
    End Sub
</script>
<html>
    <head>
        <title>Utilizzo di ADO.NET</title>
    </head>
<body>

<form id="Modulo" runat="server">
    <asp:Label id="Utenti" runat="server" />
</form>

</body>
</html>

ASP.NET mette a disposizione diversi sistemi anche per la visualizzazione dei dati, ovvero oggetti tipo HTML Controls che permettono una gestione veloce dei dati a video, anche se, personalmente, la trovo poco personalizzabile a livello stilistico. Affronteremo tali oggetti in una versione avanzata di questa guida.

Interazione con XML

Anche nell’interazione con XML è possibile utilizzare più di un metodo per leggere e scrivere in questo formato. Utilizzeremo per questo esempio un oggetto asp:DataGrid in lettura, importando il namespace System.Data in cui creeremo un nuovo oggetto DataSet(). Si crei il file database.xml con la seguente struttura:

<?xml version="1.0"?>
<database>
    <utente>
        <nome>Luca</nome>
        <cognome>Ruggiero</cognome>
    </utente>
</database>

magari popolandolo con qualche dato in più. Di seguito il codice ASP.NET da utilizzare nel file xml.aspx da posizionare, insieme al file XML, nella directory dei nostri esempi:

<%@ Page Language="VB" ValidateRequest="false" %>
<%@ Import Namespace="System.Data" %>
<script runat="server">
    Private Sub Page_Load(sender As Object, e As EventArgs)
       <strong>' Creo il dataset</strong>
        Dim ds As New DataSet()
       <strong>' Richiamo e leggo il file XML</strong>
        ds.ReadXml(Server.MapPath("database.xml"))
       <strong>' Associo il file XML al datagrid</strong>
        DatiXml.DataSource = ds.Tables(0).DefaultView
       <strong>' Leggo materialmente il file</strong>
        DatiXml.DataBind()
    End Sub
</script>
<html>
    <head>
        <title>Interazione con XML</title>
    </head>
<body>

<form id="Modulo" runat="server">
    <asp:DataGrid id="DatiXml" runat="server" />
</form>

</body>
</html>

Vedremo altri esempi di interazione con XML in specifici tutorial oppure in una futura guida avanzata dedicata ad ASP.NET.

Asp.NET ed i server SMTP (spedire una email)

Con ASP.NET è possibile inviare email sfruttando i servizi attivi di un server di posta in uscita, ovvero SMTP ed implicitamente il componente CDOSYS presente per default su tutti i sistemi operativi Windows dalla versione 2000 in poi. Dico implicitamente perchè non c’è alcun richiamo diretto alla libreria: se ne occupa il namespace System.Web.Mail che consente di instanziare un oggetto MailMessage.

L’esempio che segue vede un modulo costruito con i Web Form di ASP.NET mediante il quale si fa riferimento alla sub-routine Invia costruita prima del codice HTML della pagina. Oltre al namespace indicato in precedenza, includiamo anche System.Text.RegularExpressions per dichiarare un oggetto Regex per verificare la struttura semantica dell’indirizzo email del mittente. Il codice è commentato e va creato nel file email.aspx da inserire nella directory dei nostri esempi sul server Web:

<%@ Page Language="VB" ValidateRequest="false" %>
<%@ Import Namespace="System.Web.Mail" %>
<%@ Import Namespace="System.Text.RegularExpressions" %>
<script runat="server">
    Private Sub Invia(sender As Object, e As EventArgs)
        <strong>' Espressione regolare di un indirizzo email per ASP.NET</strong>
        Dim re As New Regex("(?<user>[^@]+)@(?<host>.+)")

        <strong>' Controllo che il campo Nome venga compilato</strong>
        If Len(Trim(Nome.Text)) = 0 Then
            Messaggio.Text = "Inserisci il tuo nome"
            Exit Sub
        End If

        <strong>' Controllo che il campo Email venga compilato correttamente</strong>
        If re.IsMatch(Email.Text) = False Then
            Messaggio.Text = "Inserisci il tuo indirizzo email"
            Exit Sub
        End If

        <strong>' Controllo che il campo Commento venga compilato</strong>
        If Len(Trim(Commento.Text)) = 0 Then
            Messaggio.Text = "Inserisci un commento"
            Exit Sub
        End If

        <strong>' Formatto la mail in un oggetto MailMessage</strong>
        Dim mail As New MailMessage
            mail.To = "[email protected]" ' INSERISCI QUI IL TUO INDIRIZZO
            mail.From = Email.Text
            mail.Subject = "Messaggio da " & Nome.Text
            mail.Body = Commento.Text

        <strong>' Invio la mail (*)</strong>
        SmtpMail.SmtpServer = "smtp.fastwebnet.it"
        SmtpMail.Send(mail)

        Messaggio.Text = "Email inviata con successo"
    End Sub
</script>
<html>
    <head>
        <title>Contattami via email</title>
    </head>
<body>

<form id="Modulo" runat="server">
    Nome<br>
    <asp:Textbox id="Nome" runat="server" /><br>
    Email<br>
    <asp:Textbox id="Email" runat="server" /><br>
    Commento<br>
    <asp:Textbox id="Commento" runat="server" TextMode="MultiLine" 
    Cols="30" Rows="10" /><br><br>
    <asp:Button runat="server" Text="Invia" OnClick="Invia" /><br><br>
    <asp:Label id="Messaggio" runat="server" />
</form>

</body>
</html>

(*) In riferimento al richiamo nel commento del codice appena proposto: ho fatto riferimento al server SMTP di Fastweb in quanto la macchina su cui ho effettuato il test non ha il server SMTP di Windows configurato; avete due possibilità per inviare una mail: settare il server SMTP di Windows sulla vostra macchina o assicurarvi che il server remoto lo abbia configurato (scrivete al vostro Hoster) quindi omettere la riga

SmtpMail.SmtpServer = "smtp.fastwebnet.it"

oppure specificare un server SMTP a cui potervi appoggiare.

Di seguito un elenco di tutte le proprietà a disposizione di un oggetto MailMessage:

• From Indica il mittente della mail
• To Indica il destinatario della mail
• Subject Indica l’oggetto della mail
• Body Indica il corpo (messaggio) della mail
• Cc Indica i destinatari per conoscenza visibili della mail
• Bcc Indica i destinatari per conoscenza NON visibili della mail
• Priority Indica il grado di importanza della mail – Low, High, Normal (di default)
• BodyEncoding Tipo di codifica del messaggio – Base64, UUencode
• BodyFormat Formato del corpo del messaggio – Html, Text (di default)
• Attachments Allega un file che dev’essere già presente sul server, oppure inviato tramite Upload