Una recensione su DotNetHell:
http://blogs.dotnethell.it/ciupaz/Visual-Basic-2008-spiegato-a-mia-nonna__13267.aspx
Grazie! 🙂
Una recensione su DotNetHell:
http://blogs.dotnethell.it/ciupaz/Visual-Basic-2008-spiegato-a-mia-nonna__13267.aspx
Grazie! 🙂
A puro titolo di curiosità, pubblico qualche numero sul libro “Visual Basic 2008 spiegato a mia nonna“:
– capitoli: 14 + 4 appendici
– tabelle: 17
– immagini: 140
– esempi con sorgente: 155
– pagine: 576
– parole: 120.032
– caratteri (compresi gli spazi): 834.965
Il mio libro precedente, invece (tra parentesi i dati del 12° capitolo inedito pubblicato da me):
– capitoli: 11 (+ 1)
– immagini: 130 (+3)
– caratteri (compresi gli spazi): 438.407 (+ 44.820)
– pagine: 246 (+25)
– esempi con sorgente: 52 (+1)
Ovviamente quantità non è uguale a qualità, o perlomeno non esiste una relazione diretta di questo tipo, ma le differenze dovrebbero dare una misura quantitativa degli argomenti presentati nel nuovo libro anche a chi aveva comprato il primo libro su VB 2005.
Per maggiori dettagli, precisazioni e link, potete andare qui: https://deghetto.wordpress.com/tag/libro/.
Mi è stato chiesto di precisare se gli esempi del libro “Visual Basic 2008 spiegato a mia nonna” siano utilizzabili anche con Visual Studio 2005.
Gli esempi sono stati scritti direttamente in VS 2008 e quindi, in teoria, bisognerebbe utilizzare VS 2008. In realtà è possibile convertire quasi tutti gli esempi in VS 2005 semplicemente modificando il file della soluzione (con estensione .sln), come ho indicato in questo post: https://deghetto.wordpress.com/2008/01/12/conversione-di-soluzioni-da-visual-studio-2005-a-2008-e-viceversa/
Per l’unico esempio in XAML (Windows Presentation Foundation) occorre aver installato il Framework .NET 3.0 e le estensioni per Visual Studio 2005.
Gli esempi del capitolo 14 riguardanti LINQ, invece, possono essere eseguiti solo su VS 2008 con il Framework .NET 3.5, perché non è prevista un’estensione per VS 2005.
Ho concordato con l’editore la pubblicazione di un capitolo di esempio del mio nuovo libro “Visual Basic 2008 spiegato a mia nonna”. Il capitolo di esempio è il 10° e riguarda menu, finestre di dialogo, stampa e così via: Capitolo 10 di esempio (PDF 2 Mb), (ZIP 1,4 Mb).
Ricordo a chi fosse interessato che ho annunciato l’uscita del libro proprio ieri con il post https://deghetto.wordpress.com/2008/04/01/e-uscito-il-mio-nuovo-libro-su-visual-basic-2008/, dove potete trovare la scheda del libro, il booksite, tutti gli esempi del libro liberamente scaricabili e l’elenco degli argomenti trattati, nonché l’indice completo del libro.
Ho il piacere di annunciare che è iniziata la distribuzione del mio nuovo libro su Visual Basic 2008, dal titolo “Visual Basic 2008 spiegato a mia nonna“, 576 pagine, edito da FAG Milano, prezzo 39,00 Euro.
Il libro sarà disponibile on-line dal sito www.fag.it e nelle librerie specializzate con la seguente tempistica:
Alcuni link utili sono i seguenti:
Ecco l’elenco dettagliato degli argomenti trattati nel libro:
Cap. 1 – Il primo capitolo è introduttivo, per avvicinare gradualmente il lettore alla programmazione senza spaventarlo dai nuovi concetti a cui andrà incontro. Ecco perché, quindi, abbiamo adottato uno stile molto discorsivo e amichevole (in informatica diremmo user friendly) in grado di mostrare al lettore cos’è la programmazione, basandoci su oggetti comunemente usati. Potranno anche avere una piccola simpatica sorpresa tutti coloro che pensano che il computer non possa fare il caffè!
Cap. 2 – Il secondo capitolo introduce le caratteristiche principali del Framework .NET e del linguaggio Visual Basic, con un breve cenno su tutte le più importanti tecnologie correlate.
Cap. 3 – Nel terzo capitolo iniziamo a vedere l’ambiente di sviluppo realmente in azione. Potrete quindi vedere quali strumenti visuali principali troverete all’avvio del software e alcune indicazioni sul loro uso.
Cap. 4 – Il quarto capitolo potremmo definirlo un male necessario: non si può parlare di un linguaggio di programmazione senza prima capire cosa sono le variabili e i tipi di dato. In questo capitolo esamineremo quindi tutti i tipi di dato elementari e vedremo come si utilizzano.
Cap. 5 – Nel quinto capitolo continuiamo il discorso dei tipi di dati elementari introducendo le matrici. Anche in questo capitolo ci sarà molto codice per vedere l’uso pratico di queste strutture.
Cap. 6 – Con il sesto capitolo iniziamo a vedere le istruzioni del linguaggio Visual Basic e molti esempi sulle istruzioni condizionali e sulla programmazione strutturata.
Cap. 7 – Finalmente, nel settimo capitolo, tratteremo in modo esteso la programmazione orientata agli oggetti. Come vedrete, la programmazione in .NET è completamente orientata agli oggetti: in .NET tutto è un oggetto, anche l’utente! Vedremo quindi molti esempi per scrivere delle buone classi e per gestire correttamente gli oggetti.
Cap. 8-9 – I capitoli ottavo e nono riguardano rispettivamente i form e i controlli basati sulla tecnologia Windows Forms. Questi argomenti fanno parte della programmazione visuale e, tutto sommato, sono forse la parte più divertente della programmazione. Alla fine di ciascun capitolo abbiamo inserito dei brevi cenni sulla nuova tecnologia emergente per la programmazione visuale: Windows Presentation Foundation (WPF).
Cap. 10 – Il decimo capitolo illustra l’uso di tutte le finestre comuni di dialogo e dei menu. Con questo obiettivo, abbiamo realizzato un’applicazione di esempio perfettamente funzionante che ci permette di gestire i file di testo.
Cap. 11 – Nel capitolo undicesimo trattiamo un argomento molto importante: la gestione degli errori o, come si dice in .NET, la gestione delle eccezioni. Sebbene questo argomento compaia in una posizione molto avanzata del libro, è un argomento che va sempre tenuto presente tra le principali attenzioni del programmatore.
Cap. 12 – Il capitolo dodicesimo fornisce numerose informazioni per la gestione delle stringhe e dei file di testo.
Cap. 13 – Nel tredicesimo capitolo abbiamo spiegato in modo approfondito l’uso dell’oggetto My, disponibile solo agli sviluppatori di Visual Basic e non a quelli di C#. My è un oggetto che mette a disposizione del programmatore numerosi oggetti e proprietà più comunemente utilizzati, con una semplicità disarmante.
Cap. 14 – Il quattordicesimo e ultimo capitolo introduce la più recente tecnologia per l’accesso ai dati e precisamente LINQ. Vengono spiegate le novità apportate al linguaggio e alla gestione delle classi e degli oggetti quale presupposto per l’utilizzo di LINQ e vengono mostrati alcuni esempi della sintassi di quest’ultimo per la gestione dei dati.
Appendici – Ho messo a disposizione anche quattro appendici: la prima illustra passo per passo le installazioni delle versioni Espress e Professional e della documentazione di MSDN Library, mentre le altre tre forniscono alcune tabelle accessorie che talvolta è utile avere a portata di mano.
Ovunque troverete anche molto codice Visual Basic: mini-programmi di prova per spiegare in modo semplice una tecnica e qualche programma completo e funzionante.
Tutti gli elementi dell’interfaccia grafica e dell’ambiente di sviluppo (nomi di finestre, voci di menu, ecc.) sono tratti dalla versione in lingua italiana e, tra parentesi, dalla versione in lingua inglese. Questa scelta è stata fatta per accontentare sia chi vuole utilizzare il software nella nostra lingua, sia per chi ritiene più opportuno utilizzarlo nella lingua originale. Questa impostazione è altresì utile per facilitare le ricerche nella documentazione MSDN, dato che i documenti migliori sono sempre espressi in lingua inglese.
FEEDBACK: spero che il libro vi piacerà. In ogni caso, come ho già più volte affermato, sono graditi consigli, suggerimenti, critiche e segnalazioni di errori (e-mail mario@deghetto.it). Qualunque cosa possa aiutarmi a migliorare, sarà ben accetto. Gli insulti saranno immediatamente cestinati
Specialmente quando studiamo una nuova tecnologia o una nuova tecnica di programmazione, in Visual Basic o in C#, può esserci utile evitare di salvare il progetto.
Infatti quello che vorremmo fare, dato che siamo persone ordinate (!), è semplicemente aprire un nuovo progetto senza salvarlo alla creazione, provare il codice e poi chiudere il progetto eliminando ogni sua traccia. In questo modo possiamo evitare di avere l’hard disk pieno di progetti di prova che provocano solo una grande confusione.
Possiamo realizzare tutto questo semplicemente modificando un’opzione di Visual Studio 2008, di Visual Basic 2008 Express o di Visual C# 2008 Express:
LINQ to Objects permette di eseguire interrogazioni su oggetti presenti in memoria.
Questa tecnica può essere applicata anche a un array, come possiamo vedere dal seguente esempio:
Public Class Form1 Private Sub Button1_Click(ByVal sender _ As System.Object, _ ByVal e As System.EventArgs) _ Handles Button1.Click ' variabili per composizione ' del messaggio finale: Dim messaggio As String = "" Dim NL As String = Environment.NewLine ' dichiarazione array: Dim frutti() As String = _ {"mela", "pera", "banana", "mandarino"} ' dichiarazione della variabile che conterrà ' l'insieme delle stringhe restituite dalla ' query. La query è dichiarata nella stessa ' istruzione: Dim fruttiPreferiti = _ From f In frutti _ Where f.StartsWith("m") _ Select f ' scorrimento dell'insieme delle stringhe ' per la composizione del messaggio: For Each frutto In fruttiPreferiti messaggio &= "Frutto: " & frutto & NL Next MessageBox.Show(messaggio) End Sub End Class
Le stringhe restituite dalla query sono “mela” e “mandarino”.
Per convertire un dato di tipo DateTime in stringa formattata, possiamo utilizzare una delle forme del metodo ToString. Il seguente esempio mostra come è possibile ricavare la data e ora corrente, solo la data corrente e solo l’ora corrente:
Dim dt As DateTime
dt = DateTime.Now
‘ data e ora:
Dim dataOra As String = dt.ToString
‘ solo data in formato GG/MM/AAAA:
Dim data As String = dt.ToString(“dd/MM/yyyy”)
‘ solo ora in formato HH.MM.SS (ore da 0 a 23):
Dim ora As String = dt.ToString(“T”)
‘ stampa i tre valori:
Dim s As String = dataOra & Environment.NewLine & _
data & Environment.NewLine & ora
MessageBox.Show(s)
Il risultato sarà simile al seguente:
27/02/2008 20.36.23
27/02/2008
20.36.23
Per trovare i limiti superiore e inferiore di un array monodimensionale (vettore), in VB6 avevamo le funzioni UBound() e LBound().
Con VB.NET dobbiamo invece utilizzare due metodi messi a disposizione dall’array, cioè GetUpperBound e GetLowerBound, come nel seguente esempio:
Dim a() As Integer = {1, 2, 3} Dim limiteSuperiore As Integer = a.GetUpperBound(0) Dim limiteInferiore As Integer = a.GetLowerBound(0)
Per cancellare tutti i file contenuti in una cartella, possiamo utilizzare una semplice routine come questa:
Public Sub SvuotaDir(ByVal cartella As String)
Dim di As IO.DirectoryInfo = _
New IO.DirectoryInfo(cartella)
For Each oFile As IO.FileInfo In di.GetFiles()
oFile.Delete()
Next
End Sub
E’ necessario passare alla Sub una stringa contenente il percorso della cartella da svuotare (compreso l’identificativo del drive). Ecco un esempio di utilizzo, con un pulsante nel form per avviare la cancellazione dei file:
Public Class Form1
Private Sub Button1_Click(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles Button1.Click
Dim cartella As String = “”
cartella = “C:prova”
SvuotaDir(cartella)
MessageBox.Show(“Fatto!”)
End Sub
Public Sub SvuotaDir(ByVal cartella As String)
Dim di As IO.DirectoryInfo = _
New IO.DirectoryInfo(cartella)
For Each oFile As IO.FileInfo In di.GetFiles()
oFile.Delete()
Next
End Sub
End Class
Nell’attesa di completare il mio libro su Visual Basic 2008 (ormai mancano solo un paio di capitoli) pubblico il progetto di esempio del capitolo 10.
Il progetto consiste in un semplice editor di file di testo che ho utilizzato per mostrare l’uso di tutte le finestre comuni di dialogo. Nell’esempio sono inclusi tutti i seguenti controlli:
OpenFileDialog
SaveFileDialog
FolderBrowserDialog
FontDialog
ColorDialog
PageSetupDialog
PrintPreviewDialog
PrintDialog
PrintDocument
PrintPreviewControl
MenuStrip
StatusStrip (StatusLabel e ProgressBar)
Ovviamente la spiegazione dettagliata della creazione del progetto passo-passo la troverete nel libro che sarà pubblicato prossimamente (probabilmente verso fine marzo 2008).
Premesso che il progetto è solamente dimostrativo, è comunque perfettamente funzionante ed è possibile estenderlo con altre funzionalità non previste da questo esempio (per esempio ricerca e sostituzione di testo).
AGGIORNATO (sostituiti i link non funzionanti)
Ecco un progetto, con sorgenti e demo, per creare delle barre di progressione circolari come troviamo su SQL Server 2005:
http://www.codeproject.com/KB/cpp/sql2005circularprogress.aspx
Un effetto speciale secondo me veramente simpatico (vedi immagine qui sotto):
http://www.codeproject.com/KB/cpp/sql2005circularprogress/sql2005circularprogress.jpg
Il progetto è scritto in VB 2005.
Visual Studio 2008 Team System in italiano (Trial 90 giorni) è disponibile al download a questo indirizzo:
E’ possibile scaricare un’unica ISO per DVD, tramite un gestore di download installabile direttamente da Internet Explorer, oppure n. 6 ISO per CD-ROM.
Per le modalità di masterizzazione del DVD/CD con il file di immagine, consultate il link “FAQ” presente nella stessa pagina.
Microsoft ha reso disponibile al download il Code snippet editor per Visual Basic 2008, analogamente al prodotto che era disponibile per la versione 2005.
Molto interessante è l’organizzazione dei frammenti di codice in cartelle che, come si può vedere dallo screenshot, permette di inserire frammenti di codice scritti anche per altri linguaggi.
Il link “download” inserito nella pagina citata permette di accedere alla pagina di download vera e propria, nella quale troviamo (oltre a una simpatica immagine di un messaggio in bottiglia):
Tutte le versioni scaricabili necessitano di Framework .NET 3.5, quindi Visual Basic 2008 Express (almeno) è d’obbligo.
Ricordo che in Visual Basic e Visual Studio 2008 è possibile inserire un frammento di codice selezionando il menu Modifica > IntelliSense > Inserisci frammento di codice…
A questo punto viene visualizzato un elenco di cartelle che rappresenta le varie categorie secondo le quali sono raggruppati i vari frammenti di codice. Con un doppio click sulla cartella che ci interessa, verrà presentato un elenco di ulteriori cartelle e di frammenti di codice. Con un doppio click sullo snippet che desideriamo, verrà inserito il frammento di codice direttamente nella nostra finestra di codice, nel punto dove si trova il cursore.
Quella degli snippet è una funzionalità molto interessante e utile e quindi vi consiglio di dare un’occhiata a tutti gli snippet disponibili perché prima o poi vi serviranno.
Se volete creare i vostri snippet e distribuirli in file .vsi, vi segnalo che Alessandro Del Sole ha creato un tool gratuito, VSI Builder, che serve proprio a questo scopo.
Per chi non conoscesse l’add-in gratuito “Interop Forms Toolkit 2.0“, voglio sottolineare una sua caratteristica fondamentale: permette di estendere un progetto VB6, permettendo di utilizzare dei form di Visual Basic.NET direttamente da un’applicazione VB6.
Questo agevola sicuramente chi ha sviluppato un’applicazione “enorme” in VB6 e non si può permettere di perdere molto tempo nell’effettuare la migrazione dell’intero progetto sotto .NET. In questo modo viene garantita la produttività, almeno a breve termine, con una facile estensione del progetto iniziale con nuove funzionalità che VB.NET offre nativamente.
E’ uscita l’edizione italiana di Visual Studio 2008 Professional (Trial 90 giorni) e di Visual Studio 2008 Express:
http://blogs.msdn.com/italy/archive/2008/01/31/visual-studio-2008-in-italiano.aspx
Le ISO possono essere scaricate da questi link:
Visual Studio 2008 Professional in italiano (Trial 90 giorni):
http://download.microsoft.com/download/1/6/c/16c93170-97f2-462c-b96f-36c5e6202e81/VS2008ProEdition90DayTrialITAX1435987.iso
Visual Studio 2008 Express in italiano:
http://download.microsoft.com/download/1/9/0/1908ea18-221b-4d9a-985f-941e5e9b0ae4/VS2008ExpressITAX1428546.iso
Un aggiornamento a questo argomento che preme a molti programmatori italiani: in questo articolo, Gabriele Castellani (nel blog di MSDN Italia), preannuncia che stanno per essere pubblicate tutte le versioni di Visual Studio 2008 in italiano:
http://blogs.msdn.com/italy/archive/2008/01/29/visual-studio-2008-in-italiano.aspx
In particolare è interessante notare che sono già state rese disponibili delle versioni Trial, dei Service Pack e dei Language Pack già scaricabili in italiano.
In un’intervista pubblicata su PuntoInformatico, Francesca Longoni di Microsoft ha riferito che la versione italiana di Visual Studio 2008 uscirà a metà Febbraio:
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:
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:
Questo dimostra che va distribuito tutto il contenuto della cartella release e non solo il file eseguibile.
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:
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:
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:
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:
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:
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 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:
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.
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.
Premessa
Alla domanda “conviene migrare da VB6 a VB 2005?” oppure “quando migrare?” o ancora “perché migrare?“, posta a 100 programmatori diversi, riceverete 100 risposte diverse e forse anche di più. Sono domande che spesso compaiono nei forum, nei newsgroup e nelle mailing list fin dal primo momento in cui è comparsa la prima versione di VB.NET e che, dopo il rilascio di varie versioni fino all’attuale versione 2005, sono ancora qui a disturbare i nostri sonni e le nostre giornate lavorative.
Le valutazioni “pro” e “contro” su VB.NET e sul framework .NET sono le più svariate e spesso in contrasto tra di loro, in funzione della preparazione tecnica di chi le esprime e delle preferenze di ognuno. Infatti, pur esistendo delle motivazioni tecniche reali che spingono verso i “pro”, ci sono anche molte motivazioni soggettive altrettanto reali che spingono verso i “contro” e viceversa.
Con questo articolo vorrei esprimere in modo possibilmente completo il mio pensiero su questo problema per cercare di mettere ordine ai vari “pro” e “contro”, alla ricerca di argomenti oggettivi che possano orientare il potenziale programmatore “migratore”.
Questo articolo è anche un articolo “anomalo”, rispetto agli standard degli altri articoli pubblicati sul sito http://www.visual-basic.it. Infatti non contiene una-dico-una riga di codice in qualsivoglia linguaggio di programmazione.
Non ho la presunzione di riuscire a proporre un testo “definitivo”, riassuntivo di tutte le voci che ne parlano, né di scrivere qualcosa che possa rispecchiare il pensiero di tutti.
Questo articolo è semplicemente il mio pensiero e vuole essere una base per una utile riflessione che ciascuno può esercitare privatamente, come compito per casa, o pubblicamente nelle liste tecniche.
(sottotitolo: Un monologo esistenziale dovuto (forse) ad un eccesso di caffè?)
La volpe e l’uva
Partiamo dalla prima domanda: “conviene migrare da VB6 a VB 2005?“. La risposta è: dipende. Potrà sembrare semplicistica come risposta, ma ad una domanda del genere non si può rispondere sì o no in modo assoluto, bisogna valutare tutti gli aspetti della questione.
Prima di tutto, un po’ di storia personale. Mi viene in mente la mia carriera di programmatore, a partire da quando ancora non osavo nemmeno dire che ero un programmatore, dato che non ero in grado di esserlo. Nel 1984 ho comprato il mio primo Commodore VIC-20. Ancora oggi ricordo con orgoglio la prima accensione di quel piccolo “mostro”:
Al termine del servizio militare (nell’86) ormai i 3500 byte mi stavano stretti e quindi ho deciso di sostituire quella piccola creatura con qualcosa di più: un Commodore 128-D. Allora non mi ero posto il problema se conveniva migrare dal VIC-20 al C-128-D, era ovvio che fosse qualcosa da fare. Le caratteristiche del nuovo mostro erano:
E’ stato un grosso passo in avanti, poi, quando nell’87 ho potuto mettere le mani su un PC compatibile, perché l’Ente dove avevo iniziato a lavorare aveva deciso di comprarne uno, ero il primo, nell’Ente, ad essere il felice utilizzatore di un Olivetti M-24 del costo approssimativo (a quei tempi) di circa 7 milioni di Lire…
Da allora ne è passata tanta di acqua sotto i ponti, così come è stata grande la mia scalata ad hardware e software di maggiore potenza. Ad ogni cambiamento non ho mai pensato “conviene farlo?”. Non ho mai messo in dubbio la sostituzione di hardware vecchio con hardware più potente.
Non ho dubitato di fare la cosa giusta quando ho iniziato ad abbandonare la vecchia interfaccia a caratteri di MS-DOS per quella più gradevole di Windows 3.1. Eppure il “salto” tecnologico anche allora è stato drammatico. Ci si cominciava a scontrare con un tipo di programmazione diversa, non più programmazione di tipo “spaghetti-code” oppure “programmazione strutturata” ma “programmazione ad eventi” con “Visual Basic 1.0 per MS-DOS” (versione a caratteri) e con “Visual Basic per Windows” (versione grafica).
E’ allora che ho cominciato a capire quale fosse la mia vera vocazione: da grande volevo fare il programmatore!
Via via che passava il tempo, la tecnologia ha continuato ad avanzare in modo sempre più veloce e frenetico. Le reti diventavano sempre più grandi, i software più complessi, le macchine più potenti, Internet che iniziava ad espandersi, tutto diventava sempre più complicato.
La passione, però, mi ha sempre spinto avanti ad imparare cose nuove, ad abbandonare tecnologie o tecniche vecchie per quelle nuove, senza mai un dubbio o un ripensamento.
Ora si presenta un altro “salto tecnologico”: la vera programmazione orientata agli oggetti (OOP) viene offerta in grande scala a tutti i programmatori, anche a chi proviene da linguaggi non-C++.
Improvvisamente la grande massa critica di programmatori dell’intero mondo si interroga: faccio la cosa giusta? Devo imparare di nuovo tutto da zero? Devo spendere dei soldi (tanti soldi) per provare una tecnologia che non so se mi sarà congeniale? E se non riesco a capire l’OOP, ho speso i soldi per niente? Adesso che ho lavorato tanto per crearmi tutte le mie applicazioni commerciali, le mie librerie di codice e la mia base di conoscenza, devo ricominciare da capo e buttare via tutto il lavoro fatto? Ma chi si crede di essere la Microsoft per essere così prepotente nei miei confronti? Non le sono stato forse un programmatore fedele fino ad oggi? Devo forse cambiare linguaggio, cambiare lavoro?
E’ difficile dare una risposta chiara a tutte queste domande, perché non esiste una risposta che possa soddisfare chiunque. Le motivazioni per adottare o per ripudiare il nuovo mondo .NET sono tante e sarà possibile citarne solo alcune. Cominciamo a ragionare sulle domande e a cercare di trovare una risposta.
Devo imparare di nuovo tutto da zero?
In effetti c’è molto da imparare da zero:
Per il resto, l’esperienza nella programmazione fatta in precedenza non è mai da buttare via e non richiede di iniziare di nuovo da zero all’arrivo di una nuova tecnologia o di un nuovo linguaggio. Questo pensiero lo condividono molti studiosi di lingue straniere: è difficile imparare la prima lingua straniera, ma quando ne conosci 2 o 3, la quarta è più facile da imparare.
Devo spendere dei soldi (tanti soldi) per provare una tecnologia che non so se mi sarà congeniale?
Questa domanda sta iniziando a vacillare, dato che la Microsoft ha dato una grande svolta alla propria politica commerciale: ha reso disponibili gli ambienti di sviluppo .NET gratuitamente per permettere un più facile avvicinamento di programmatori indecisi. Le limitazioni imposte dai software gratuiti sono ampiamente tollerabili e ripagate dal costo zero e dalla possibilità di “mettere mano” ai nuovi linguaggi .NET.
E se non riesco a capire l’OOP, ho speso i soldi per niente?
Con le nuove versioni Express, gratuite, anche questa domanda non ha più senso. Forse andrebbe riproposta diversamente, cioè: “E se non riesco a capire l’OOP, ho perso TEMPO per niente?”. Il tempo è denaro e quindi la domanda è ancora sensata…
La capacità di comprensione, ovviamente, dipende dalle capacità mentali dei singoli soggetti e quindi non è prevedibile quantificare il grado di successo di ciascuno. La comprensione, però, dipende anche fortemente dalla volontà e dall’impegno profuso da ciascuno nello studiare e nel capire questa nuova realtà. Non c’è molto spazio all’improvvisazione, cosa che c’era invece nei vecchi linguaggi (es. Commodore Basic, GW Basic ecc.).
Forse l’impegno che richiede questo nuovo “salto” permetterà una maggiore selezione dei migliori programmatori sul mercato. Non c’è molto spazio per i programmatori improvvisati.
Adesso che ho lavorato tanto per crearmi tutte le mie applicazioni commerciali, le mie librerie di codice e la mia base di conoscenza, devo ricominciare da capo e buttare via tutto il lavoro fatto?
Questa è una delle parti più spinose della questione. Il lavoro dedicato negli anni a creare le proprie librerie, le proprie applicazioni, viene brutalmente messo in discussione e soffre di una grave perdita di valore.
Il fatto che la Microsoft abbia fatto di tutto per creare strumenti di conversione da VB6 a VB.NET (conversione automatica dei progetti, namespace Microsoft.VisualBasic, ecc.), per fornire le conoscenze, per incentivare la migrazione in molte maniere (fornendo software gratuito, seminari tecnici gratuiti, documentazione on line ecc.), allevia leggermente il danno ma non risolve completamente il problema.
In effetti la “reingegnerizzazione” delle nostre librerie potrebbe però portare ad un beneficio reale. Infatti, si può ragionevolmente pensare che le nostre nuove librerie saranno costruite con una caratteristica che le vecchie librerie non avevano: il codice sarà ampiamente riutilizzabile per evitare di reinventare sempre “l’acqua calda”.
Questo lavoro di rifacimento, quindi, può essere visto come una perdita di tempo e di denaro, ma può anche essere visto come un’opportunità per costruirci degli strumenti che ci possono realmente far fare un grosso salto di qualità al nostro software.
Ma chi si crede di essere la Microsoft per essere così prepotente nei miei confronti? Non le sono stato forse un programmatore fedele fino ad oggi? Devo forse cambiare linguaggio, cambiare lavoro?
Questo è un atteggiamento vittimistico che poco ha a che fare con la passione del programmatore, con lo spirito di innovazione che dovrebbe avere un tecnico il cui primo pensiero dovrebbe essere “l’innovazione” e il “miglioramento”.
Ovviamente Microsoft è un’azienda, e come tale deve raggiungere un utile per “sopravvivere” (e far sopravvivere i propri dipendenti). Non le si può quindi imputare una colpa se per prima tende ad una innovazione generale dei propri prodotti.
Certo, Microsoft può anche aver fatto qualche errore di valutazione, ma nessuno è perfetto.
Conclusione
Alla domanda: “faccio la cosa giusta?” ognuno avrà una sua risposta personale, dal “si assoluto” al “no assoluto” con le migliaia di sfumature intermedie. Per orientare la propria risposta un po’ più verso il “si”, bisognerebbe fare alcune considerazioni:
Premessa
Pur programmando da diversi anni con VB e con VBA (soprattutto con Access) riesco comunque a cogliere le opportunità che si prospettano con i nuovi linguaggi che implementano il paradigma della programmazione orientata agli oggetti (OOP). Nei miei studi universitari ho avuto anche a che fare con JAVA e quindi anche in questo caso con la programmazione ad oggetti (nota: C# ha una sintassi molto simile a quella di JAVA). Ho studiato, ho sperimentato e mi sono impegnato parecchio anche nelle mailing list nel cercare di capire questo nuovo modo di programmare.
Nonostante tutto l’interesse, tutta la passione e tutto l’impegno profuso per padroneggiare questo nuovo mondo, non sono ancora riuscito ad avere la “situazione in pugno”. Mi sento ancora come una vecchia locomotiva che non riesce ad andare in pressione e quindi ad iniziare il suo viaggio lungo i binari sicuri della programmazione ad oggetti.
A questo punto non resta che esplorare altre possibilità e cioè utilizzare degli strumenti che almeno mi permettano di capire quali sono le parti di codice che fanno parte del “passato” VB6 e che non hanno una corrispondenza diretta nel nuovo VB.NET.
VB6 Code Advisor: download e installazione
Prima di tutto è necessario scaricare dal sito Microsoft questo “add-in” per l’IDE di VB6. L’indirizzo esatto da cui è possibile scaricarlo è il seguente:
Una volta scaricato il file “Code Advisor for Visual Basic 6_ITA.msi” è possibile avviarlo per far partire l’installazione. Le prime opzioni potranno essere tutte confermate così come sono.
Appena comparirà la seguente schermata, invece, consiglio di scegliere l’opzione “Completa“, perché così installerete anche la documentazione e gli altri componenti necessari per estendere “Code Advisor“.
Infatti “Code Advisor” è un prodotto estendibile con nuove regole per avere ulteriori consigli sul codice che non erano previsti nella versione iniziale del prodotto. Alcune di queste nuove regole sono pubblicate anche su articoli MSDN.
Dopo un altro paio di click di conferma, avrete l’add-in installato. A questo punto facciamo partire VB6.
Nell’IDE di VB6 troviamo già un paio di differenze: nel menu “Aggiunte” c’è il nuovo menu “Code Advisor” e tra le barre strumenti ce ne sarà una nuova di nome “Code Advisor per Visual Basic 6“. Entrambe presentano alcune voci identiche e quindi siamo liberi di utilizzare l’una o l’altra modalità, a nostra preferenza.
Le voci sono:
Nel menu, poi, c’è anche la voce “Visualizza report FixIt” che però al momento è disattivata, non avendo ancora utilizzato le funzionalità di questo add-in.
Gettiamo carbone nella caldaia della locomotiva…
A questo punto apriamo un progetto VB6, uno qualsiasi, per fare una prima prova “al volo” delle funzionalità offerte dall’add-in.
Per iniziare l’analisi del nostro progetto, scegliamo la voce “Aggiungi FixIt“. Diventerà subito visibile una barra di avanzamento per farci capire a che punto è l’analisi del codice. Al termine dell’analisi, nel lato destro della barra degli strumenti di “Code Advisor” comparirà un pulsantino con l’unica funzione di indicarci quanti sono i “FixIt“, cioè i suggerimenti inseriti nel codice (nel mio caso sono stati 13, molti dei quali dello stesso tipo).
I suggerimenti (FixIt) sono inseriti come commenti nel codice, secondo il seguente schema:
'FIXIT: questo è un suggerimento
Premendo il pulsante “Rimuovi FixIt“, tutti i suggerimenti saranno rimossi dal codice come se non fossero mai stati inseriti.
Il pulsante “Trova FixIt successivo” serve a spostarsi “in avanti”, da un suggerimento all’altro. Questa funzionalità permette di trovare subito i suggerimenti senza dover guardare tutto il codice.
Il pulsante “Filtri FixIt” svolge un’importante funzione: apre una finestra di dialogo dalla quale è possibile selezionare sia la versione VB.NET alla quale vogliamo migrare, sia i singoli suggerimenti, uno per uno, che vogliamo attivare o disattivare. Riporto qui di seguito un’immagine che può chiarire il concetto.
Il pulsante “Visualizza Report FixIt“, che è diventato attivo dopo l’aggiunta dei suggerimenti, apre il browser Internet per mostrare un report piuttosto dettagliato e contenente:
Il report si presenta in questa forma:
Il pulsante “Guida in linea di Code Advisor” apre appunto la guida in linea, mentre l’ultimo pulsante “Definizione ambito“, che può assimere due diversi valori (“Ambito: progetto attivo” oppure “Ambito: file attivo“) specifica appunto se le regole vanno applicate all’intero progetto o al solo file attivo. In quest’ultimo caso, i suggerimenti vengono applicati solo al file attivo e anche il “Report” viene prodotto solo sulla base dei risultati ottenuti dall’analisi del file attivo.
Una nota a margine: utilizzando questo add-in, improvvisamente mi è comparsa questa finestra di avviso di Norton AntiVirus:
Norton AntiVirus ha interpretato le azioni di questo script come quelle di uno “script maligno”. Ritenendo che non ci fossero particolari dubbi sul fatto che fosse il NAV ad aver avuto un “abbaglio”, ho scelto la voce “Autorizza questo script“, ho confermato e ho quindi potuto continuare il lavoro 😉
Come ultima parte di questo articolo e ad esemplificazione dei suggerimenti che questo add-in produce, ne riporto uno auto-esplicativo:
Utilizzare Option Explicit per impedire la creazione implicita di variabili di tipo Variant.
Conclusione
Non è tra gli obiettivi di questo articolo elencare e spiegare per filo e per segno tutti i “problemi” riscontrati nell’esperimento. L’obiettivo, infatti, era quello di fornire uno sprone all’uso di uno strumento che può aiutarci nel capire meglio come migliorare il nostro codice e i nostri progetti per prepararli adeguatamente nell’ottica di una migrazione a VB.NET / VB 2005.
https://deghetto.wordpress.com/2008/04/01/e-uscito-il-mio-nuovo-libro-su-visual-basic-2008/
In questa prima fase, ho preso una soluzione sviluppata con la versione 2005 e l’ho aperta con la versione 2008.
Visual Studio 2008 ha immediatamente avviato la procedura di conversione e, dopo alcuni semplici passi, ha mostrato un messaggio informativo nel quale indicava che le soluzioni basate sul Framework .NET 2.0 restano invariate.
A dimostrazione di ciò, il report delle operazioni di conversione (file UpgradeLog.xml) ha riportato che non è stato convertito alcun file, ma sono stati adeguati solo il file della soluzione (estensione .sln) e il file del progetto (estensione .proj).
Ho provato anche l’operazione contraria: ho creato una nuova soluzione con Visual Studio 2008 (utilizzando il Framework .NET 2.0) e l’ho aperta con Visual Studio 2005.
Il risultato è negativo: Visual Studio 2005 ha indicato che è impossibile aprire il file di soluzione selezionato perché è stato creato con una versione più recente dell’applicazione.
Sembrerebbe quindi impossibile aprire il progetto, ma non è detta l’ultima parola. Infatti, ho già specificato che il nuovo progetto Visual Basic 2008 è stato creato sulla base del Framework .NET 2.0, quindi non dovrebbero esistere incompatibilità con la precedente versione di Visual Studio.
Ho quindi aperto il file della soluzione con il classico Notepad (Blocco note) e ho modificato semplicemente questa riga:
Microsoft Visual Studio Solution File, Format Version 10.00
facendola diventare
Microsoft Visual Studio Solution File, Format Version 9.00
Dopo aver salvato il file di soluzione modificato, ho riprovato ad aprirlo con Visual Studio 2005: questa volta la soluzione si apre senza alcun problema e premendo F5 viene anche regolarmente eseguita.
Nota
La procedura di conversione descritta può funzionare solo se vengono utilizzate funzionalità presenti sia in Visual Studio 2008 che in Visual Studio 2005, ecco perché il nuovo progetto è stato creato sulla base del Framework .NET 2.0. Se avessimo utilizzato, per esempio, il Framework .NET 3.5, potremmo aver introdotto delle funzionalità non presenti nella versione 2005 e quindi incompatibili.