Archivi categoria: ASP.NET

Programmazione per il web

[ASP.NET 2.0] Protezione del codice sorgente VB e C#

Con la pubblicazione di un’applicazione web ci si pone il problema di proteggere il codice sorgente dell’applicazione stessa, dato che l’applicazione è interamente accessibile all’amministratore del sito Internet.

Infatti, per un’applicazione commerciale non è auspicabile che chi ha accesso alle cartelle dell’applicazione possa in qualche modo modificare l’applicazione (soprattutto nella parte relativa al sorgente, più che nella parte relativa alla presentazione delle pagine) o, peggio, utilizzare direttamente il codice sorgente per costruire un’applicazione commerciale analoga.

Con Visual Studio 2005 e ASP.NET 2.0 questo obiettivo è facilmente raggiungibile, come evidenziato dalle seguenti istruzioni:

  • dal menu “Genera” scegliere la voce “Pubblica sito web”; comparirà una maschera per la scelta della destinazione di pubblicazione e di altre informazioni;
  • è possibile pubblicare il sito in una cartella locale (ad esempio per test, prima della pubblicazione definitiva), semplicemente cambiando il percorso di destinazione. Si consiglia di creare una cartella vuota appositamente per lo scopo di depositare i file destinati alla pubblicazione;
  • in alternativa è possibile fare click sul pulsante “…” e scegliere se pubblicare in una cartella locale (scegliendo la cartella stessa), su IIS locale, in FTP o su un sito remoto (richiede le estensioni del server di FrontPage);
  • dopo aver inserito le informazioni sulla destinazione, attivare la casella relativa a “Attiva nome sicuro su assembly precompilati”, poi selezionare “Utilizza un contenitore di chiavi” e inserire un nome a scelta (es. “chiavi”), poi confermare con OK.

Nella finestra di output verranno visualizzate le varie fasi di pubblicazione. Nel caso in cui i file siano già presenti nella cartella di destinazione, comparirà una richiesta di conferma di eliminazione dei file già presenti.

Verificando i risultati, si troverà che tutti i file con estensione “.vb” (destinati a mantenere “in chiaro” il codice sorgente in Visual Basic delle pagine) sono spariti, così come è sparita la cartella App_Code, preposta a contenere tutte le classi generali (analoghe ai moduli globali di VB6).

Al loro posto è comparsa invece una cartella “bin” contenente le DLL che sono il risultato della compilazione dei file di codice sorgente di Visual Basic di tutte le pagine del sito.
Ovviamente non è possibile compilare le pagine “.aspx” il cui sorgente, costituito da tag HTML, rimane visibile.

Certamente, però, la compilazione del codice VB permette di nascondere all’utente e all’amministratore del sito tutte quelle funzionalità più importanti che caratterizzano il comportamento dell’applicazione web.

Oltre alle tecniche finora spiegate, native di Visual Studio, mi è stato segnalato da Antonio Catucci (aka “tdj”) un suo post relativo a un add-in per Visual Studio, scaricabile gratuitamente: Visual Studio 2005 Web Deployment Project. Per approfondimenti, inoltre, è possibile consultare l’articolo MSDN “Using Web Deployment Projects with Visual Studio 2005“.

[ASP.NET 2.0] Controllo per includere un documento PDF

Su CodeProject è stato pubblicato un articolo che spiega come utilizzare un controllo per pubblicare file PDF su una pagina web.
L’articolo è corredato dai sorgenti scaricabili dalla pagina stessa. Il codice presentato è scritto in C#.

[ASP.NET 2.0] Templates già pronti per l’uso

Segnalo un link dal quale è possibile scaricare ben 9 templates di siti in ASP.NET 2.0, ognuno dei quali è corredato da un documento Word che ne spiega il contenuto:
http://msdn2.microsoft.com/en-us/asp.net/aa336613.aspx

Chi volesse leggere un’introduzione ai Template può trovare un articolo qui (in inglese).

[ASP.NET 2.0] Creare report con ReportViewer

Un articolo di Code Project mostra come realizzare dei report con ReportViewer in un’applicazione ASP.NET 2.0.
Anche in questo caso è fornito un esempio visuale molto dettagliato, basato sulla progettazione con Visual Studio 2005 e su SQL Server 2005.

[ASP.NET 2.0]: user control in VB e in C# nello stesso sito

Introduzione
Fin dall’uscita di Visual Studio 2005, mi ha affascinato la possibilità di utilizzare diversi linguaggi nello stesso progetto.
Il principio è semplice, ma allo stesso tempo geniale: dato che ogni parte del codice di un linguaggio viene tradotta in un linguaggio intermedio (MSIL), è possibile combinare sorgenti di linguaggi differenti, per esempio VB e C#, per creare un progetto unico.
Questo fatto agevola soprattutto i team composti da programmatori con diverse competenze e conoscenze, dove alcuni conoscono meglio C# e altri conoscono meglio VB, ma agevola anche il programmatore “solitario”, facilitandogli l’uso dei molti esempi e componenti già pronti disponibili su Internet.In questo articolo vedremo in modo estremamente semplice come si possono applicare questi principi anche alla programmazione web. Infatti in un sito web si possono utilizzare pagine scritte in linguaggi diversi, ma anche user control con la stessa caratteristica.

Il progetto è in sé banale: creiamo due user control, uno scritto in VB e uno, sostanzialmente identico, scritto in C# per la visualizzazione della data e ora del server web. Questi user control sono utili per verificare l’ora del server, magari quando il nostro sito è in hosting all’estero.

Creazione del progetto
Naturalmente la prima cosa da fare è creare una normale applicazione web:

  1. File/Nuovo sito web
  2. Selezionare “Sito web ASP.NET“, scegliere la cartella dove posizionare il progetto (per esempio C:\VB2005\UserControl) e scegliere il linguaggio predefinito (in questo articolo preferisco cominciare con VB);
  3. Alla conferma avremo la nostra pagina Default.aspx vuota: aggiungiamo alcune stringhe di testo, giusto per vedere qualcosa.

A questo punto la pagina web sarà così formata:

<%@ Page Language="VB" AutoEventWireup="false" CodeFile="Default.aspx.vb" 
Inherits="_Default" %> 
<!DOCTYPE html PUBLIC 
"-//W3C//DTD XHTML 1.0 Transitional//EN" 
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> 
<html xmlns="http://www.w3.org/1999/xhtml" > 
<head runat="server"> 
    <title>Pagina senza titolo</title> 
</head> 
<body style="font-size: 12pt"> 
    <form id="form1" runat="server"> 
    <div> 
        <span style="color: darkorange; font-family: Verdana"> 
        <strong>HOME PAGE<br /> 
        </strong><span style="color: black"> 
            <br /> 
            Prova di controllo personalizzato con VB<br /> 
            <br /> 
            <br /> 
            <br /> 
            Prova di controllo personalizzato con C#<br /> 
            <br /> 
            <br /> 
        </span></span> 
    </div> 
    </form> 
</body> 
</html>

Creazione di uno User Control in VB
Procediamo ora alla creazione di uno user control con il linguaggio VB:

  1. nella finestra “Esplora Soluzioni“, fare clic con il tasto destro del mouse sul nome del progetto e selezionare “Aggiungi Nuovo Elemento…”;
  2. nella finestra di dialogo scegliere “Controllo utente web“, modificare il nome in “TimeVB.ascx” e, lasciando invariato il linguaggio (VB), confermare;
  3. fare doppio clic su “TimeVB.ascx” e inserire un controllo Label nella finestra di progettazione del controllo e modificare il suo ID in “LabelVB“.
  4. Nel file “TimeVB.ascx.vb“, invece, inserire il seguente codice:
Partial Class TimeVB 
    Inherits System.Web.UI.UserControl 
    Protected Sub Page_Load(ByVal sender As Object, _ 
            ByVal e As System.EventArgs) Handles Me.Load 
        Dim dt As DateTime = DateTime.Now 
        LabelVB.Text = String.Concat("Ora del server: ", dt.ToString) 
    End Sub 
End Class

Come è possibile vedere, abbiamo dichiarato una variabile dt di tipo DateTime, assegnandole la data e ora attuale. Subito dopo abbiamo assegnato alla proprietà Text della LabelVB la stringa composta da una stringa letterale e la data e ora convertita in testo con il metodo ToString.

Aggiungiamo ora il controllo nella pagina web: torniamo alla pagina Default.aspx, prendiamo con il mouse il file TimeVB.ascx e lo trasciniamo nella posizione voluta (cioè dopo la stringa “Prova di controllo personalizzato con VB” presente nella pagina).

Se a questo punto eseguiamo il progetto con F5, otterremo l’effetto voluto: abbiamo la nostra data e ora visualizzati nella pagina.

Creazione di uno User Control in C#
Procediamo nello stesso modo per creare lo user control in C#:

  1. nella finestra “Esplora Soluzioni“, fare clic con il tasto destro del mouse sul nome del progetto e selezionare “Aggiungi Nuovo Elemento…”;
  2. nella finestra di dialogo scegliere “Controllo utente web“, modificare il nome in “TimeCS.ascx” e, dopo aver modificato il linguaggio in “Visual C#“, confermare;
  3. fare doppio clic su “TimeCS.ascx” e inserire un controllo Label nella finestra di progettazione del controllo e modificare il suo ID in “LabelCS“;
  4. nel file “TimeCS.ascx.cs“, invece, inserire il seguente codice:
using System; 
using System.Data; 
using System.Configuration; 
using System.Collections; 
using System.Web; 
using System.Web.Security; 
using System.Web.UI; 
using System.Web.UI.WebControls; 
using System.Web.UI.WebControls.WebParts; 
using System.Web.UI.HtmlControls; 
public partial class TimeCS : System.Web.UI.UserControl 
{ 
  protected void Page_Load(object sender, EventArgs e) 
  { 
    DateTime dt = DateTime.Now; 
    LabelCS.Text = string.Concat("Ora del server: ", dt); 
  } 
}

Anche questa volta aggiungiamo il controllo nella pagina web: torniamo alla pagina Default.aspx, prendiamo con il mouse il file TimeCS.ascx e lo trasciniamo nella posizione voluta (cioè dopo la stringa “Prova di controllo personalizzato con C#” presente nella pagina).

Eseguiamo nuovamente il progetto con F5 per verificare che entrambi i controlli, scritti in VB e in C#, funzionino correttamente.

Per differenziare le due versioni del controllo possiamo anche cambiare qualche proprietà dei controlli Label inseriti nei due controlli, magari cambiandone i colori, il font e quant’altro si desideri, così come ho fatto nell’esempio allegato a questo articolo.

La pagina default.aspx finale
Diamo ora uno sguardo alla pagina Default.aspx finale, dopo l’aggiunta dei due controlli utente:

<%@ Page Language="VB" AutoEventWireup="false" CodeFile="Default.aspx.vb" 
Inherits="_Default" %><%@ Register src="TimeCS.ascx" 
mce_src="TimeCS.ascx" TagName="TimeCS" TagPrefix="uc2" %> 

<%@ Register src="TimeVB.ascx" mce_src="TimeVB.ascx" TagName="TimeVB" TagPrefix="uc1" %> 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" 
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> 
<html xmlns="http://www.w3.org/1999/xhtml" > 
<head id="Head1" runat="server"> 
    <title>Pagina senza titolo</title> 
</head> 
<body style="font-size: 12pt"> 
    <form id="form1" runat="server"> 
    <div> 
        <span style="color: darkorange; font-family: 
        Verdana"><strong>HOME PAGE<br /> 
        </strong><span style="color: black"> 
            <br /> 
            Prova di controllo personalizzato con VB<br /> 
            <uc1:TimeVB ID="TimeVB1" runat="server" /> 
            <br /> 

            <br /> 
            <br /> 
            Prova di controllo personalizzato con C#<br /> 
            <uc2:TimeCS ID="TimeCS1" runat="server" /> 
            <br /> 
            <br /> 
        </span></span> 
    </div> 
    </form> 
</body> 
</html>

Ci sono due elementi da notare: il primo è che sono state aggiunte due direttive per la registrazione dei due controlli che abbiamo aggiunto alla pagina:

<%@ Register src="TimeCS.ascx" mce_src="TimeCS.ascx" 
    TagName="TimeCS" TagPrefix="uc2" %> 
<%@ Register src="TimeVB.ascx" mce_src="TimeVB.ascx" 
    TagName="TimeVB" TagPrefix="uc1" %>

mentre il secondo è costituito dai due tag che inseriscono ciascun controllo utente nella posizione della pagina che abbiamo stabilito:

<uc1:TimeVB ID="TimeVB1" runat="server" /> <uc2:TimeCS ID="TimeCS1" runat="server" />

Conclusioni
I controlli utente che abbiamo creato sono estremamente banali, ma l’obiettivo di questo articolo era quello di mostrare come si crea e si inserisce un controllo utente e come possono essere create delle parti dell’applicazione web scritte in linguaggi differenti.

Un’altra particolarità interessante dei controlli utente è il fatto che nella finestra di progettazione del controllo stesso possono essere inseriti più “controlli-base”. Per esempio possono essere inseriti una Label, una Textbox e un ListBox: in questo caso il controllo utente sarà un controllo composto da tutti i controlli che sono stati inseriti al suo interno, semplificando il riutilizzo di componenti complessi (per esempio un controllo per inserire in un colpo solo un “form” di login). Questa possibilità, estremamente semplice da provare, non è mostrata in questo esempio ma viene lasciata come esercizio al lettore.

L’esempio è scaricabile da qui.

[Controlli free] Flash Control for ASP.NET 2.0

Ho letto qualche richiesta, in passato, sulla possibilità di inserire un file .SWF (animazione Flash) in una pagina ASP.NET.

Il controllo scaricabile dalla pagina http://www.flash-control.net/ risolve questo problema. Le versioni disponibili sono tre:

  • free: ovviamente con molte limitazioni, come la mancanza del supporto AJAX, l’esclusione dal supporto tecnico e altro
  • a pagamento: con 29 Dollari portiamo a casa tutto, esclusi i sorgenti. Questa versione elimina anche il fastidioso messaggio “Fare clic per attivare e utilizzare il controllo”
  • con i sorgenti: versione completa di sorgenti, al costo di 399 Dollari.

In alternativa è possibile inserire un file .SWF (per esempio di nome “FileFlashDaEseguire.swf“) anche con il seguente script ASP.NET che esegue anche il “redirect” al sito Macromedia se non si ha Flash installato:

<OBJECT classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" 
codebase="http://download.macromedia.com/pub/shockwave/cabs/ 
flash/swflash.cab#version=6,0,0,0" 
WIDTH="100%" HEIGHT="100%" id="EW" ALIGN="" 
VIEWASTEXT> 
<PARAM NAME="movie" VALUE="EW.swf"> 
<PARAM NAME="quality" VALUE="high"> 
<PARAM NAME="bgcolor" VALUE="#7299BD"> 
<EMBED src="FileFlashDaEseguire.swf" quality="high" bgcolor="#7299BD" 
WIDTH="100%" HEIGHT="100%" NAME="EW" 
  ALIGN="" 
TYPE="application/x-shockwave-flash" 
PLUGINSPAGE="http://www.macromedia.com/go/getflashplayer"></EMBED> 
</OBJECT>

[ASP.NET 2.0] Gestione di un contatore accessi

Premessa
Questo articolo riprende gli argomenti trattati nell’articolo “VB 2005: connessione a database con ADO.NET 2.0“, ma da un altro punto di vista. Infatti qui si parlerà ancora di connessione a database con ADO.NET 2.0 e di stringhe di connessione, ma l’ambito di sviluppo è questa volta il web con ASP.NET 2.0.
Per rendere la spiegazione più interessante, inoltre, si mostrerà anche come è possibile creare un contatore degli accessi in tre modi diversi:

  • 1. con un file di testo (quindi senza database),
  • 2. con un database Access e stringa di connessione inserita nel codice e
  • 3. con un database Access, ma con la stringa di connessione inserita nel file di configurazione del sito.

Esempio 1: contatore con file di testo
Questo esempio è costituito da cinque file:

  • index.aspx
  • index.aspx.vb
  • Web.Config
  • contatore.txt
  • Utilita.vb

Vediamo ora in dettaglio i contenuti dei vari file per comprendere pienamente le tecniche utilizzate.

contatore.txt
E’ un file di testo contenente solo una riga di testo, inizialmente impostata, per semplicità, al valore “1” (uno).
Questo file contiene l’ultimo aggiornamento del contatore degli accessi al sito ed è posto nella cartella “public“, secondo le convenzioni adottate dal provider Internet Aruba.it. Ovviamente con un provider diverso la posizione può essere diversa.

Web.Config
Questo file costituisce il file di configurazione del sito che stiamo creando.
In questo primo esempio il file Web.Config non è stato modificato e quindi non serve per la spiegazione di questa parte, ma tornerà utile per la spiegazione dell’esempio n. 3.

Utilita.vb
Questo file contiene una classe che a sua volta contiene la funzione incrementaContatore() che viene utilizzata… indovinate per cosa? Ovviamente per incrementare il contatore!
Il codice è il seguente:

  Imports System.Web.Hosting 
  Public Class Utilita 
    Public conta As Long = 0 
    Public Function incrementaContatore() 
      Dim a As String = "" 
      Dim path As String = _ 
          HostingEnvironment.ApplicationPhysicalPath() 
      My.Response.Expires = 0 
      ' leggo variabile di sessione (contatore visite) 
      conta = HttpContext.Current.Session.Item("conta") 
      ' controllo gli aggiornamenti di pagina 
      a = My.Computer.FileSystem.ReadAllText(path & _ 
          "/public/contatore.txt") 
      If conta <> a Then 
        conta = a 
        ' Incremento di 1 il valore presente nel file di testo 
        conta += 1 
        ' scrivo sul file di testo il nuovo valore 
        My.Computer.FileSystem.WriteAllText(path & _ 
            "/public/contatore.txt", conta, False) 
      End If 
      HttpContext.Current.Session.Item("conta") = conta 
      Return conta 
    End Function 
  End Class

In questo codice è possibile vedere alcune cose interessanti:

  • HostingEnvironment.ApplicationPhysicalPath():restituisce il percorso fisico dell’applicazione;
  • Imports System.Web.Hosting:importazione richiesta dall’uso di HostingEnvironment;
  • x = HttpContext.Current.Session.Item(“conta”):legge la variabile di sessione “conta“;
  • HttpContext.Current.Session.Item(“conta”) = x:imposta la variabile di sessione “conta“;
  • My.Computer.FileSystem.ReadAllText(path & “/public/contatore.txt”):legge il file contatore.txt;
  • My.Computer.FileSystem.WriteAllText(path & “/public/contatore.txt”, conta, False):scrive il file contatore.txt.

Inoltre, all’interno della funzione è stato inserito un test:

      If conta <> a Then

che serve a confrontare il valore “conta” (uguale alla variabile di sessione “conta“) e il valore “a” (uguale al contenuto del file di testo contatore.txt).
Perché viene eseguito questo test? E’ piuttosto semplice: per evitare che venga incrementato il contatore degli accessi ad ogni “refresh” della pagina da parte dell’utente (pressione del pulsante “Aggiorna” o del tasto F5). Se non si impedisse l’aggiornamento continuo, si avrebbe un contatore degli accessi troppo… generoso! In questo modo, invece, viene contato un nuovo accesso al sito se e solo se è appena stata aperta una nuova sessione. In caso contrario il contatore rimane invariato.

index.aspx
Questa è la pagina principale (l’unica) del nostro sito.
Contiene due label per la presentazione di testo fisso e una textbox per la visualizzazione del contatore degli accessi che viene aggiornata automaticamente ad ogni prima apertura di sessione.

index.aspx.vb
Infine questo è il file contenente il codice associato alla pagina index.aspx e precisamente il seguente:

  Partial Class index 
    Inherits System.Web.UI.Page 
    Protected Sub form1_Load(ByVal sender As Object, _ 
            ByVal e As System.EventArgs) _ 
            Handles form1.Load 
      Dim conta As Long 
      Dim util As New Utilita 
      conta = util.incrementaContatore() 
      Me.VisitatoreN.Text = String.Format(conta, "#####") 
    End Sub 
  End Class

Come si può vedere, tutto il codice è contenuto nella procedura che costituisce il gestore di evento Load della pagina (form1.Load).
Vengono dichiarate una variabile di tipo numerico (Long) e una variabile di tipo Utilita (istanza della classe Utilita presentata poc’anzi).
Il risultato del metodo util.incrementaContatore viene assegnato alla variabile “conta” che, opportunamente formattata, va ad aggiornare l’unica textbox della pagina che a questo punto viene automaticamente visualizzata all’utente.

Esempio 2: contatore con database Access

Anche in questo caso abbiamo cinque file, denominati come nel primo esempio.
C’è però una differenza sostanziale: al posto di un file contatore.txt contenuto nella sottocartella public, abbiamo un file database di Access denominato Contatore.mdb, posto nella cartella mdb-database.
Anche in questo caso sono state seguite le convenzioni del provider Aruba.it che prevede che i database Access siano depositati in una cartella predefinita di nome mdb-database.

Anche in questo caso analizziamo il contenuto di questo esempio, evidenziando le differenze con l’esempio precedente.

Contatore.mdb
Questo database (la versione utilizzata nell’esempio è Access 2000-2003) contiene un’unica tabella, di nome “Contatore“, con un unico campo di nome “Accessi” di tipo Numerico (Intero Lungo).
Prima di mettere “in produzione” questo esempio bisogna ricordarsi di creare (se non già fatto) un unico record in questa tabella con il valore 0 (zero).

Web.Config e index.aspx
Questi file non sono stati modificati dal primo esempio.

utilita.vb
Questo è l’unico file che è stato drasticamente modificato in questo nuovo esempio.
La funzione incrementaContatore() è stata integralmente sostituita dalla funzione incrementaContatoreDB().
Ecco il codice completo di questa classe:

  Imports System.Web.Hosting 
  Imports System.Data.OleDb 
  Public Class Utilita 
    Dim conta As Long = 0 
    Public Function incrementaContatoreDB() As Long 
      Dim path As String = _ 
          HostingEnvironment.ApplicationPhysicalPath() & _ 
          "\mdb-database\" 
      My.Response.Expires = 0 
      ' crea connessione 
      Dim cn As OleDbConnection 
      Dim ConnectionString As String = _ 
          "Provider=Microsoft.Jet.OLEDB.4.0;" & _ 
          "Data Source=" & path & "\Contatore.mdb;" & _ 
          "User ID=Admin;" & _ 
          "Password=" 
      cn = New Data.OleDb.OleDbConnection(ConnectionString) 
      cn.Open() 
      Dim SQL As String 
      ' leggo variabile di sessione (contatore visite) 
      conta = HttpContext.Current.Session.Item("conta") 
      ' controllo gli aggiornamenti di pagina 
      If conta = 0 Then 
        ' incremento del campo "Accessi" della tabella "Contatore" 
        SQL = "UPDATE Contatore SET Contatore.Accessi = [Accessi]+1;" 
        Dim comando As New OleDbCommand(SQL, cn) 
        comando.ExecuteNonQuery() 
      End If 
      ' recupero numero accessi attuale 
      SQL = "SELECT Contatore.Accessi FROM Contatore;" 
      Dim selezione As New OleDbCommand(SQL, cn) 
      conta = selezione.ExecuteScalar 
      ' scrivo variabile di sessione (contatore visite) 
      HttpContext.Current.Session.Item("conta") = conta 
      ' chiusura connessione 
      cn.Close() 
      Return conta 
    End Function 
  End Class

Alcuni commenti su questo codice:

  • anche in questo esempio si utilizza HostingEnvironment, rendendo necessaria l’import di System.Web.Hosting;
  • dato che viene effettuata una connessione ad un database Access, viene importato anche il namespace System.Data.OleDb;
  • la connessione al database viene realizzata con una stringa di connessione inserita direttamente nel codice;
  • viene utilizzata una variabile di sessione di nome “conta” come nel precedente esempio: se la variabile di sessione “conta” è uguale a zero, allora non è ancora stata impostata. Di conseguenza viene incrementato il contatore di una unità mediante un’istruzione SQL di tipo UPDATE. Tale istruzione è eseguita mediante il metodo ExecuteNonQuery di un oggetto di tipo OleDbCommand;
  • dopo l’eventuale incremento del campo Accessi della tabella Contatore del database Contatore.mdb, si recupera il valore aggiornato dello stesso campo con un’istruzione SQL di tipo SELECT;
  • a questo proposito, dato che si deve recuperare un unico valore (detto “scalare“), possiamo utilizzare un metodo ExecuteScalar, anche questa volta di un oggetto di tipo OleDbCommand;
  • infine viene aggiornata anche la variabile di sessione e chiusa la connessione.

index.aspx.vb
Questo file è stato modificato in minima parte, dato che cambia solamente la chiamata a incrementaContatoreDB, anziché a incrementaContatore.

Esempio 3: memorizzazione della stringa di connessione

Applichiamo ora le tecniche viste nel mio articolo precedente su ADO.NET 2.0 e precisamente la memorizzazione della stringa di connessione nel file di configurazione.
Trattandosi di un progetto per un sito, in questo caso non abbiamo un file app.config, bensì un file Web.Config. Cambia il nome, non di molto la sostanza.

Vediamo anche in questo caso le differenze rispetto all’esempio 2.

Contatore.mdb, index.aspx e index.aspx.vb
Questi file non sono stati modificati.

Web.Config
Questo file viene modificato con l’aggiunta della sezione come segue:

  <configuration> 
    <appSettings /> 
      <connectionStrings> 
        <clear /> 
          <add 
            name="Contatore" 
            connectionString="Provider=Microsoft.Jet.OLEDB.4.0; 
              Data Source= 
              AspNet2_GestioneContatoreAccessi/modo3/mdb-database/Contatore.mdb; 
              User ID=Admin;Password=" 
            providerName="Microsoft.Jet.OLEDB.4.0" /> 
      </connectionStrings> 
      <system.web> 
      ... (segue)

Per ragioni di leggibilità la riga “connectionString” è stata mandata a capo. Inoltre, è stata omessa parte del percorso del database. Per seguire l’esempio è opportuno che essa venga completata, ovviamente.

Utilita.vb
Questa classe è stata modificata con l’aggiunta della funzione GetConnectionString che serve a recuperare la stringa di connessione dalla sezione del file Web.Config.
Il codice aggiunto è un adattamento di un codice di esempio preso dalla documentazione di Visual Studio 2005, alla quale si rimanda per i dettagli implementativi:

Shared Function GetConnectionString(ByVal ConnectionStringName _ 
        As String) As String 
    ' Get the default connectionStrings section, 
    Dim connectionStringsSection As ConnectionStringsSection = _ 
        Web.Configuration.WebConfigurationManager.GetWebApplicationSection( _ 
            "connectionStrings") 
    ' Get the connectionStrings key,value pairs collection. 
    Dim connectionStrings As ConnectionStringSettingsCollection = _ 
        connectionStringsSection.ConnectionStrings 
    ' Get the collection enumerator. 
    Dim connectionStringsEnum As IEnumerator = _ 
        connectionStrings.GetEnumerator() 
    ' Loop through the collection and 
    ' display the connectionStrings key, value pairs. 
    Dim i As Integer = 0 
    Dim cs As String = "" 
    While connectionStringsEnum.MoveNext() 
        Dim nome As String = connectionStrings(i).Name 
        If nome = ConnectionStringName Then 
            cs = connectionStrings(i).ConnectionString 
            Exit While 
        End If 
        i += 1 
    End While 
    Return cs 
End Function

Una importante considerazione su questo codice: la funzione prende come parametro il nome assegnato alla stringa di connessione, corrispondente alla proprietà “name” indicata nel file Web.Config.
Inoltre all’interno del ciclo While viene effettuato un test sulla corrispondenza tra il nome cercato e il nome trovato in Web.Config e solo se corrisponde viene presa la stringa di connessione corrispondente e restituita al chiamante.
Cosa significa questo? E’ molto semplice: è possibile memorizzare più stringhe di connessione nel file Web.Config assegnando loro nomi diversi ed è possibile estrarre la stringa di connessione che ci serve in un dato momento con un codice molto pulito ed elegante.

Conclusioni
Come abbiamo visto, non è difficile implementare un contatore degli accessi nel nostro sito Internet.
Abbiamo visto anche come in Visual Studio 2005 molti dei concetti che abbiamo imparato per un’applicazione tradizionale valgano anche per un’applicazione web: dopo tutto ADO.NET 2.0 è implementato in uno strato applicativo comune ai due modelli di programmazione.
Il codice relativo a questi esempi e scaricabile qui.

[ASP.NET 2.0] Tutorial sulla gestione dati

Segnalo la pagina di http://www.asp.net/ dalla quale possono essere scaricati vari tutorial sulla gestione dati con ASP.NET 2.0. I tutorial, disponibili sia per VB che per C#, possono essere consultati on-line o scaricati in comodi PDF (compressi), già pronti per la stampa.

Working with Data in ASP.NET 2.0
http://www.asp.net/Learn/DataAccess/default.aspx?tabid=63

Un “must” per chi vuole cimentarsi sulla gestione dati in ASP.NET 2.0.

Iscriviti

Ricevi al tuo indirizzo email tutti i nuovi post del sito.

Unisciti agli altri 846 follower