Archivi categoria: ADO.NET

Programmazione con le basi dati

[ADO.NET 2.0] Screencast “Primo Contatto” parte 2

Ho ricevuto molte richieste via e-mail e anche attraverso i commenti alla prima parte dello screencast “Primo contatto” su “ADO.NET 2.0”. Così tante che ho deciso di terminare l’argomento anche se devo lasciare da parte la ultimazione del mio libro su SQL Server 2008.

Nello screencast che potete vedere o scaricare in locale ho mostrato come si fa ad aggiornare i dati visualizzati attraverso una DataGridView. Ho cercato di spiegare anche perché funziona con una semplice istruzione che richiama il metodo Update del TableAdapter.

MDG002_ADONET20_2

Il video può anche essere scaricato tramite il seguente link:

http://www.deghetto.it/blog/download/screencast/MDG002_ADONET20_2.wmv

Spero che anche questo breve video (circa 11 minuti) sia di vostro gradimento.

#45: ADO.NET Leggere la chiave del record appena inserito in SQL Server

Uno dei problemi che più frequentemente mi vengono posti riguarda la possibilità di inserire un nuovo record in una tabella e di conoscere il valore assegnato dal DBMS al campo auto incrementante.

Questo problema è solitamente risolto, peraltro in modo brillante ed elegante, con una specifica stored procedure (SP) di SQL Server. Qualcuno, però, chiede come si può fare direttamente da codice, senza “scomodare” una stored procedure.

Ad un primo esame, non abbiamo la possibilità di inserire il record e subito dopo leggere il valore del campo IDENTITY, perché nel frattempo, tra la nostra scrittura del record e la nostra lettura della chiave, qualche altro utente potrebbe aver inserito un nuovo record.

Queste due operazioni, invece, devono essere fatte in un unico blocco, cioè devono essere eseguite in un’unica transazione (principio di “atomicità” della transazione).

A questo proposito c’è una particolarità di SQL Server che possiamo utilizzare per risolvere questo problema: in T-SQL possono essere eseguite più istruzioni in sequenza, senza soluzione di continuità, semplicemente separando ciascuna istruzione con un punto e virgola (;).

In questo modo le singole istruzioni saranno eseguite una dopo l’altra senza interrompere la transazione e restituendo, così, il corretto valore della colonna IDENTITY.

Un esempio di codice di questa tecnica è il seguente:

      Dim cn As System.Data.SqlClient.SqlConnection
      Dim cnStr = "Data Source = HP\SQL2008EXPRESS;" & _
         "Initial Catalog=NOMEDATABASE;" & _
         "Password=PIPPO;" & _
         "User ID=sa;" & _
         "Persist Security Info=True"
      cn = New System.Data.SqlClient.SqlConnection(cnStr)
      cn.Open()
      Dim cmd As New System.Data.SqlClient.SqlCommand( _
         "SET NOCOUNT ON; INSERT INTO Tabella (ANAnome) " & _
         "VALUES ('De Ghetto Mario'); " & _
         "SELECT SCOPE_IDENTITY() AS ANAID;", cn)
      Dim risultato = cmd.ExecuteScalar()
      MessageBox.Show("Il nuovo ID inserito è " & risultato)
      cn.Close()
      cn = Nothing

Attenzione a impostare correttamente i parametri della stringa di connessione (nome dell’istanza, nome del database, utente e password), altrimenti non potrete collegarvi correttamente alla fonte dati.

[VB.NET] Proposte di argomenti da sviluppare

Con questo post vorrei aprire una sperimentazione un po’ al di fuori dell’uso normale di un blog: ho visto nelle statistiche di WordPress.com (che ospita questo blog) che molti visitatori cercano in questo blog argomenti ai quali potrei rispondere in modo agevole, altri probabilmente meno (o addirittura, in alcuni casi, non c’entrano nulla).

Mi piacerebbe quindi aprire un dialogo con voi per verificare se posso aiutarvi meglio, ma naturalmente voi dovete aiutarmi ad aiutarvi!   :-)

Vi chiedo quindi di inserire dei commenti a questa pagina con delle richieste di suggerimenti di programmazione, chiarimenti, segnalazioni di articoli, avvisi e quant’altro potrebbe aiutarmi a preparare del materiale da mettere a disposizione di tutti i visitatori. Non garantisco, al momento, di poter rispondere a tutti i quesiti, ma conoscendo le vostre necessità posso cercare di organizzarmi in tal senso.

Non è una proposta di una nuova Community: ce ne sono tante che trattano argomenti di Visual Basic (per esempio le principali sono Visual Basic Tips&Tricks e ASP Italia) e quindi non avrebbe senso. L’obiettivo è invece quello di rendere questo blog più interessante e utile per chi viene a visitarlo.

Proviamo a crescere insieme…  Happy coding!   :-)

[VB.NET] Salvare la stringa di connessione al database

In alcuni articoli che ho pubblicato in questo blog ho spiegato come sia possibile utilizzare una stringa per connettersi a un database e come sia possibile e doveroso salvarla in un file di configurazione dell’applicazione.

Qualche lettore mi ha chiesto come sia possibile modificare a runtime la stringa di connessione memorizzata nel file di configurazione, visto che con My.Settings non è possibile farlo, dato che è a sola lettura.

Cercando su CodeProject ho trovato questo articolo interessante che risolve proprio questo problema: “How to persist changes to My.Settings.ConnectionStrings“.

Le tecniche illustrate non sono particolarmente complesse e quindi possono essere agevolmente utilizzate da chiunque, senza particolari problemi.

Alla fine dell’articolo, l’autore si raccomanda di verificare che nelle proprietà dell’applicazione sia impostata la proprietà “Salva My.Settings alla chiusura“.

[ADO.NET 2.0] Accesso dati con VB 2005

Un iscritto a VB T&T (Antonio1981) ha segnalato il seguente articolo che tratta l’accesso ai dati ad un database in Access con Visual Basic 2005 e ADO.NET 2.0: http://www.ilsoftware.it/articoli.asp?ID=3219&pag=0.

L’articolo spiega in modo abbastanza dettagliato le operazioni da fare per:
- creare un nuovo progetto
- effettuare una connessione con la procedura “Configurazione guidata origine dati”
- creare un DataSet
- visualizzare dei dati
- utilizzare il “generatore di query”
- visualizzare i dati con “DataGridView”
- creare e utilizzare query SQL con parametri.

Nella pagina segnalata c’è inoltre un link (con l’icona di una stampante) che apre l’articolo in una forma più comodamente stampabile.

VB 2005/2008: connessione a database con ADO.NET 2.0 (2)

Sollecitato da un lettore che mi ha chiesto chiarimenti sul mio primo articolo (https://deghetto.wordpress.com/2008/01/13/vb-20052008-connessione-a-database-con-adonet-20/), mi accingo a spiegare una questione riguardante il file di configurazione dell’applicazione, cioè il famigerato file “Settings.settings“.

Prima di tutto ho creato un esempio completo che potete scaricare all’indirizzo http://www.deghetto.it/blog/download/mdgADONET20connectionString.zip e che deve essere decompresso nella cartella di prova C:\VB2005\. Chissà perché non l’ho pubblicato prima?    :-)

Veniamo ora alla spiegazione in merito ai dubbi che l’articolo ha sollevato in merito al file “Settings.settings”: questo file non è necessario nel file compilato! Come vedrete nel progetto di prova, nella cartella “bin” ci sono due sottocartelle:

  • il programma compilato nella versione “debug”, che è la compilazione classica in ambiente di sviluppo, perché include anche i simboli di debug, utili appunto nel momento dell’esecuzione controllata dall’ambiente di sviluppo;
  • il compilato nella versione “release”, nella quale i simboli di debug sono stati eliminati (migliorando le prestazioni finali del programma).

Per impostare la compilazione della release bisogna modificare un’opzione nel menu “Genera > Gestione configurazione…” e poi cambiare “Configurazione soluzione attiva” da debug a release oppure modificando la stessa opzione a livello di singolo progetto, nella parte inferiore della stessa finestra. Nel nostro caso lo facciamo a livello di soluzione.

Dopo aver cambiato questa impostazione, scegliendo il menu “Genera > Genera mdgADONET20connectionString” ci troviamo con il compilato nella cartella .\bin\release.

In questa cartella c’è un file di nome mdgADONET20connectionString.exe.config che non è altro che il file di configurazione dell’applicazione. E’ un file di testo e, precisamente, in formato XML e contiene la stringa di connessione che avevamo definito a livello di ApplicationSettings

Per verificare che effettivamente viene utilizzato quel file di configurazione, potete provare questa sequenza di operazioni:

  • cambiare il nome al database DBprova.mdb in (per esempio) prova.mdb;
  • eseguire il file .\bin\release\mdgADONET20connectionString.exe epremere il pulsante “ApriDBaccess”: l’applicazione solleverà un’eccezione e potrete solo chiuderla;
  • modificare il file mdgADONET20connectionString.exe.config con NotePad (Blocco note), cambiando la stringa di connessione nel punto dove è indicato il nome del database (da DBprova.mdb a prova.mdb) e salvare il file;
  • eseguire nuovamente il programma .\bin\release\mdgADONET20connectionString.exe e cliccare di nuovo sul pulsante di apertura del database: a questo puntoriceverete il messaggio di conferma di apertura del file.

Questo dimostra che va distribuito tutto il contenuto della cartella release e non solo il file eseguibile.

[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.

[VB.NET] Finestra di dialogo per scelta e salvataggio della stringa di connessione

Su CodeProject c’è un articolo interessante, corredato dal codice sorgente, che definisce una finestra di dialogo per consentire la composizione e il salvataggio della connection string:

http://www.codeproject.com/useritems/SQL_Connection_Dialog.asp 

Non male, davvero!

#8 Leggere un singolo valore con una query

In certe occasioni è necessario leggere un singolo valore da una tabella o comunque ottenere un singolo valore calcolato da una query.

Prima di vedere in pratica questa semplice tecnica, sono opportune due precisazioni:

  1.  bisogna importare il namespace Imports System.Data.Oledb
  2.  per quanto riguarda le tecniche di connessione ad un database si faccia riferimento al mio articolo su ADO.NET 2.0.

Ecco finalmente il codice:

     Dim stringaConnessione As String = "una stringa di connessione valida" 
     ' apertura connessione 
     Dim Cn As New Data.OleDb.OleDbConnection(stringaConnessione) 
     Cn.Open() 
     ' preparazione ed esecuzione della richiesta 
     Dim SQL As String = "SELECT CodiceFiscale FROM Anagrafica " & _ 
         "WHERE IDcliente = 'PK425';" 
     Dim comando As New Data.OleDb.OleDbCommand(Sql, Cn) 
     Dim ID As Integer = comando.ExecuteScalar() 
     ' chiusura connessione 
     Cn.Close()   

VB 2005/2008: connessione a database con ADO.NET 2.0

Questo articolo è stato integrato con un secondo articolo: vedi link alla fine dell’articolo! 

Premessa
Questo articolo tratta un argomento fondamentale per la gestione dei dati: la connessione ai database.
Dapprima si proverà, in modo molto empirico e molto poco teorico, a creare, aprire e chiudere una connessione a un database. Saranno utilizzati un database Access e un database SQL Server per fornire delle linee guida adatte a entrambi i casi.
In seguito, verrà esposto un modo migliore per memorizzare la stringa di connessione. Verrà fatto qualche nuovo suggerimento e si considererà l’esigenza di svincolare il codice dalla stringa di connessione.
In questo articolo non si farà alcun uso effettivo delle connessioni: l’obiettivo è solamente quello di svelare un modo semplice per creare una connessione ai due DBMS Microsoft in commercio (Access e SQL Server).

ConnectionString
Prima di tutto è necessario avere a disposizione due database di prova per creare la stringa di connessione (ConnectionString) corretta.
Cos’è la “stringa di connessione”? E’ una stringa che raccoglie tutti i parametri necessari alla impostazione di una connessione, definiti dalla coppia “nome parametro”=”valore parametro”.
Nel seguito del presente articolo si potrà vedere un esempio concreto.
La procedura per creare una stringa di connessione a un database Access è la seguente:

  1. si crei un database Access vuoto di nome “DBprova.mdb” nella cartella C:\VB2005\ (una cartella di prova). All’interno di tale database potranno essere create una o più tabelle, ma in questo momento non è molto importante;
  2. in un’area vuota del desktop o in una cartella, fare clic con il tasto destro del mouse, scegliere “Nuovo” e poi “Documento di testo“. Verrà creato un file di nome “Nuovo documento di testo.txt“;
  3. rinominare il file assegnandogli il nome, per esempio, “DBprova.udl“. Non è necessario comunque utilizzare lo stesso nome del database: anche il nome “pippo.udl” va benissimo;
  4. con un doppio clic su tale file, verrà aperta una finestra di dialogo per l’impostazione della connessione. La finestra mostrerà automaticamente la scheda “Connessione“;
  5. spostarsi prima di tutto nella scheda “Provider” e scegliere la voce “Microsoft Jet 4.0 OLE DB Provider“;
  6. fare click sul pulsante “Avanti“; questo attiverà la scheda “Connessione“, nella quale bisognerà scegliere il database DBprova.mdb creato in precedenza;
  7. inserire il nome utente “Admin“, disattivare la casella di spunta “Nessuna password” e poi fare click sul pulsante “Verifica connessione“, per testare la connessione appena creata. Se tutto si è svolto correttamente, comparirà un messaggio “Verifica connessione effettuata“, altrimenti comparirà un messaggio di errore “Verifica connessione non riuscita” e altri elementi utili, come il percorso e il nome del file;
  8. confermare facendo click sul pulsante “OK“.

Ora che si dispone di un file .UDL, che a dispetto della sua estensione è un normale file di testo, si può procedere alternativamente come segue:

  • rinominare il file “DBprova.udl” in “DBprova.txt” e fare doppio click sull’icona del file;
  • fare click con il tasto destro del mouse sul nome “DBprova.udl” e scegliere “Apri con…“, selezionando poi il programma Notepad per aprire il file.

Il contenuto del file sarà pressappoco il seguente (potrà variare in qualche dettaglio, a seconda del nome e della posizione del database Access):

[oledb] ; Everything after this line is an OLE DB initstring 
Provider=Microsoft.Jet.OLEDB.4.0; 
Data Source=C:\VB2005\DBprova.mdb; 
Persist Security Info=False

I parametri, indicati secondo lo schema “chiave=valore”, sono i seguenti:

Provider=Microsoft.Jet.OLEDB.4.0 
Data Source=C:\VB2005\DBprova.mdb 
Persist Security Info=False

A questo punto il file DBprova.udl non è più necessario e può essere archiviato o cancellato. Ovviamente sarà necessario tenere nota di quanto indicato sopra per continuare l’esercizio.

Per ottenere una stringa di connessione per un database SQL Server si dovrà invece procedere come segue:

  1. creare un database SQL Server, indicando il nome “SQLprova” e una posizione per i file rispettivamente per i dati e per il log;
  2. procedere come ai punti 2, 3 e 4 dell’esempio precedente, creando (ad es.) il file “SQLprova.udl”;
  3. spostarsi nella scheda “Provider” e scegliere la voce “Microsoft OLE DB Provider for SQL Server”;
  4. fare click sul pulsante “Avanti”; questo attiverà la scheda “Connessione”, nella quale bisognerà indicare il server o il nome del PC sul quale è installato SQL Server;
  5. attivare la voce “utilizza password e nome utente specifici” e inserire le credenziali per l’accesso (utente/password), attivare la casella di spunta “consenti salvataggio password” (fortemente sconsigliato: qui viene fatto solo per verificare cosa viene inserito nel file .UDL) e selezionare il database al quale si desidera effettuare la connessione;
  6. fare click sul pulsante “Verifica connessione”, per testare la connessione appena creata. Come nell’esempio precedente, tutto si sarà svolto correttamente se comparirà un messaggio “Verifica connessione effettuata”;
  7. confermare facendo click sul pulsante “OK”.

Aprendo il file SQLprova.udl si troverà la seguente stringa di connessione:

[oledb]; Everything after this line is an OLE DB initstring 
Provider=SQLOLEDB.1; 
Password=miapassword; 
Persist Security Info=True; 
User ID=sa; 
Initial Catalog=SQLprova; 
Data Source=PC01

In questo caso i parametri sono i seguenti:

Provider=SQLOLEDB.1Password=miapassword 
Persist Security Info=True 
User ID=sa 
Initial Catalog=SQLprova 
Data Source=PC01

Ecco quindi il motivo per cui il salvataggio della password è fortemente sconsigliato: il file di testo contiene la password in chiaro e quindi perfettamente leggibile anche per chi non dovrebbe conoscerla.
Premesso che, per motivi di sicurezza, la password deve essere sempre richiesta all’utente tramite una form, si procederà in questo esempio senza applicare questa cautela solo per comodità espositiva.

Il progetto di esempio
A questo punto è possibile creare un progetto di esempio in Visual Basic 2005.
Sarà mostrato un programma molto semplice che mostrerà una form contenente tre pulsanti: uno per attivare una connessione al database Access, uno per la connessione al database SQL Server e uno per chiudere entrambe le connessioni.
Creare un nuovo progetto e inserire sulla form (dal nome di default Form1) tre pulsanti da ridenominare rispettivamente ApriDBAccess, ApriDBSQL e ChiudiDB.

Per procedere con questo esempio c’è la necessità di inserire due oggetti: OLEDBConnection e SQLConnection. Tali oggetti non sono presenti per default nella casella degli strumenti ed è quindi necessario aggiungerli con la seguente procedura:

  1. fare click con il tasto destro del mouse sulla casella degli strumenti (non importa se lo si fa su un componente o sul nome di un gruppo di componenti) e scegliere la voce “Scegli elementi…”;
  2. dopo qualche istante comparirà una finestra con l’elenco di tutti i componenti di .NET Framework, con le caselle di spunta attivate o disattivate per ciascun componente;
  3. cercare i componenti OLEDBConnection e SQLConnection e attivare per entrambi la casella: questa azione aggiungerà tali componenti alla casella degli strumenti;
  4. chiudere la finestra di selezione e fare doppio click una volta su OLEDBConnection e una volta su SQLConnection: i due componenti saranno inseriti nell’area dei componenti “non visuali” che si trova al di sotto del Form Designer.

A questo punto, fare doppio click su uno dei pulsanti e, all’interno della classe Form1, inserire il seguente codice:

 Public Class Form1 
    Private Sub ApriDBAccess_Click(ByVal sender As System.Object, _ 
            ByVal e As System.EventArgs) Handles ApriDBAccess.Click 
      Me.OleDbConnection1.ConnectionString = _ 
            "Provider=Microsoft.Jet.OLEDB.4.0;" & _ 
            "Data Source=C:\VB2005\DBprova.mdb;" & _ 
            "Persist Security Info=False" 
      Me.OleDbConnection1.Open() 
      MessageBox.Show("Database Access aperto!") 
    End Sub 
    Private Sub ApriDBSQL_Click(ByVal sender As System.Object, _ 
            ByVal e As System.EventArgs) Handles ApriDBSQL.Click 
      Me.SqlConnection1.ConnectionString = _ 
            "Password=miapassword;" & _ 
            "Persist Security Info=False;User ID=sa;" & _ 
            "Initial Catalog=SQLprova;Data Source=PC01" 
      Me.SqlConnection1.Open() 
      MessageBox.Show("Database SQL Server aperto!") 
    End Sub 
    Private Sub ChiudiDB_Click(ByVal sender As System.Object, _ 
            ByVal e As System.EventArgs) Handles ChiudiDB.Click       
       Dim messaggio As String = ""       
       Dim flag As Integer = 0 
       If Me.SqlConnection1.State = 0 _ 
             And Me.OleDbConnection1.State = 0 Then 
          ' Me.SqlConnection1.Close()   --> istruzione ignorata 
          ' Me.OleDbConnection1.Close() --> istruzione ignorata 
          messaggio = "Nessun database da chiudere!" 
       Else 
          messaggio = "Eseguita chiusura di " 
          If Me.SqlConnection1.State = 1 Then 
             Me.SqlConnection1.Close() 
             messaggio &= "Database SQL Server" 
             flag = 1     ' --> per composizione messaggio 
          End If 
          If Me.OleDbConnection1.State = 1 Then 
             Me.OleDbConnection1.Close() 
             If flag = 1 Then 
                messaggio &= ", " 
             End If 
             messaggio &= "Database Access" 
          End If 
       End If 
       MessageBox.Show(messaggio) 
    End Sub 
 End Class

E’ importante osservare che:

  • la stringa di connessione per il database SQL Server ha perso la prima parte (parametro Provider) in quanto, ovviamente, SqlConnection è già il provider predefinito per il collegamento ad una fonte dati SQL Server e quindi il parametro Provider della ConnectionString è implicito;
  • per il collegamento al database Access, invece, il parametro Provider è necessario per definire esattamente quale provider OLEDB è necessario utilizzare per connettersi correttamente al database;
  • le variabili messaggio e flag sono semplicemente un espediente per visualizzare un messaggio di conferma comprendente anche il database o i database che sono stati chiusi. Se non è necessario un messaggio dettagliato è possibile utilizzare direttamente le due istruzioni che nell’esempio sono state “commentate” [Me.SqlConnection1.Close() e Me.OleDbConnection1.Close()] perché anche nel caso in cui non vi fosse una connessione aperta non verrebbe comunque generata alcuna eccezione.

ConnectionString 2, la vendetta
Nella prima parte dell’articolo è stato esposto il modo più semplice per generare una stringa di connessione precisa, utilizzando un file .UDL. Sebbene questo sia il modo più semplice ed efficiente, non è l’unico metodo.

Gli sviluppatori più “arditi” possono anche scrivere direttamente la stringa di connessione, anche se non avranno a disposizione la comoda interfaccia grafica, né la possibilità di testare immediatamente la connessione.

Per ottenere un elenco di “template” di stringhe di connessione per i più diffusi DBMS, è possibile visitare il sito http://www.connectionstrings.com/. L’elenco di stringhe di connessione che vi si possono trovare è veramente impressionante. Tutti i template forniti devono poi essere opportunamente adattati in base alla specificità della connessione da attivare: nome del server, del database, utente e password ecc. sono tutti parametri indispensabili che devono essere indicati correttamente, pena un mancato funzionamento della connessione.

Dove salvare la stringa di connessione?
Ad un occhio attento, il programma di esempio presentato nella prima parte ha un difetto o perlomeno una limitazione: la stringa di connessione è memorizzata direttamente nel codice. Ne consegue che è sufficiente installare il nostro programma (e relativo database, Access per esempio) in una posizione diversa da quella prevista, per far sì che non funzioni più alcunché. Basti pensare all’installazione del database sul disco D: oppure una modifica al nome del server sul quale è installato SQL Server.

Un metodo migliore è sicuramente quello di memorizzare la stringa di connessione esternamente al codice, in un “contenitore” più facilmente modificabile anche dall’esterno. Ecco quindi che in passato sono state utilizzate varie alternative: file .INI, voci nel registro di sistema o file di testo.

Con Visual Studio 2005 la posizione più naturale per salvare questo tipo di informazioni è il file di configurazione dell’applicazione, normalmente denominato app.config.
E’ possibile accedere al file di configurazione in due modi:

  • in modalità design: selezionare il menu Progetto > Proprietà di > scheda Impostazioni;
  • in esecuzione: utilizzando My.Setting (oppure la classe Settings in C#).

In questo esempio proveremo a memorizzare la proprietà ConnectionString direttamente nel file di configurazione dell’applicazione, utilizzando la finestra Proprietà.

Riprendiamo quindi l’esempio, semplificando un po’ il progetto per evidenziare meglio le peculiarità delle modifiche che saranno fatte in seguito: nella figura si può vedere il form con i soli pulsanti di apertura e chiusura del database Access e, nel seguito, anche il codice sottostante, dal quale partiremo per effettuare le modifiche previste.

  Public Class Form1 
    Private Sub ApriDBAccess_Click(ByVal sender As System.Object, _ 
            ByVal e As System.EventArgs) Handles ApriDBAccess.Click 
      Me.OleDbConnection1.ConnectionString = _ 
            "Provider=Microsoft.Jet.OLEDB.4.0;" & _ 
            "Data Source=C:\VB2005\DBprova.mdb;" & _ 
            "Persist Security Info=False" 
      Me.OleDbConnection1.Open() 
      MessageBox.Show("Database Access aperto!") 
    End Sub 
    Private Sub ChiudiDB_Click(ByVal sender As System.Object, _ 
            ByVal e As System.EventArgs) Handles ChiudiDB.Click 
      If Me.OleDbConnection1.State = 0 Then 
        MessageBox.Show("Nessun database da chiudere!") 
      Else 
        Me.OleDbConnection1.Close() 
        MessageBox.Show("Eseguita chiusura di Database Access") 
      End If 
    End Sub 
  End Class

La procedura per memorizzare la ConnectionString nel file di configurazione dell’applicazione è la seguente:

  1. selezionare il controllo OleDbConnection1 presente nella barra dei componenti del Form Designer;
  2. selezionare tutta la stringa di connessione presente nel codice di cui sopra (cioè tutto quanto è contenuto tra i doppi apici, alla riga che contiene l’istruzione Me.OleDbConnection1.ConnectionString = “Provider=…”) e copiarla negli appunti con la combinazione CTRL+C;
  3. eliminare o commentare (inserendo un singolo apice all’inizio della riga) l’intera istruzione che assegna la stringa di connessione alla proprietà ConnectionString;
  4. sempre nella finestra delle proprietà, espandere la sezione ApplicationSettings, cliccare su PropertyBinding e ancora sul pulsante coi tre puntini;
  5. visualizzare l’elenco ConnectionString e cliccare su Nuova…;
  6. quando apparirà la finestra “Nuova impostazione applicazione“, inserire nella cella DevaultValue la stringa di connessione (con la combinazione CTRL+V);
  7. inserire nella cella Name il nome OleDbConnectionString e confermare con OK sia la finestra “Nuova impostazione applicazione” che la finestra “Impostazioni applicazione“;
  8. avviando l’applicazione con F5 si potrà constatare che funziona correttamente.

Il particolare più interessante di questa procedura è che il file app.config è un semplice file di testo (scritto in XML) che è possibile aprire e modificare con Notepad o altri editor similari.
Dove si trova questo file? Il file si chiama “Settings.settings” e si trova nella sottocartella “My project” della cartella principale del progetto. L’estensione “settings” non è riconosciuta da Windows e, pertanto, sarà necessario scegliere dall’elenco delle applicazioni disponibili (“Apri con...”) un editor di testo a propria scelta.
Il contenuto di Settings.settings, nel caso specifico, è il seguente (per esigenze espositive, alcune righe troppo lunghe sono mandate a capo):

<?xml version='1.0' encoding='utf-8'?> 
<SettingsFile xmlns=http://schemas.microsoft.com/VisualStudio/2004/01/settings 
   CurrentProfile="(Default)" 
   GeneratedClassNamespace="My" 
   GeneratedClassName="MySettings" 
   UseMySettingsClassName="true"> 
   <Profiles /> 
   <Settings> 
      <Setting Name="OleDbConnectionString" Type="System.String" Scope="User"> 
         <Value Profile="(Default)" 
            Provider=Microsoft.Jet.OLEDB.4.0; 
            Data Source=C:\VB2005\DBprova.mdb; 
            Persist Security Info=False 
         </Value> 
      </Setting> 
   </Settings> 
</SettingsFile>

A questo punto, se si dovesse rendere necessario modificare la stringa di connessione, lo si potrebbe fare direttamente su questo file, senza modificare il progetto e ricompilarlo.

Conclusioni
In questo articolo abbiamo illustrato un modo semplice per ottenere una stringa di connessione e una soluzione professionale per svincolare questo dato dal codice.

AGGIORNAMENTO: Articolo integrativo QUI!

Nell’articolo integrativo ho precisato meglio dove trovare il file delle impostazioni dell’applicazione (che nel progetto si chiama Settings.settings, mentre compilato si chiama “qualcosa di diverso”  :-) ). Inoltre, con tale articolo integrativo ho fornito anche un file compresso con il progetto di esempio scaricabile, valido anche per questo articolo.

Iscriviti

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

Unisciti agli altri 846 follower