Visual Basic - Net 2019 Partendo Da Zero - Giuseppe Scozzari

Copyright © EDIZIONIFUTURA.
COM®
Copyright © Giuseppe Scozzari
Versione Cartacea: ISBN-13: 978-88-89600-82-5

Versione Digitale: ISBN-13: 978-88-89600-85-6
Tutti i diritti riservati. Nessuna parte di questo libro può essere riprodotta o inserita in un
sistema di riproduzione o trasmessa in qualsiasi forma e con qualsiasi mezzo in formato
elettronico, meccanico, su fotocopia, come registrazione o altro per qualsiasi scopo senza
il permesso scritto dell’autore e dell’editore.
Per motivi didattici in questo libro e nelle sue versioni successive vengono utilizzati i pro-
grammi più aggiornati disponibili al momento della stampa.
Autore: Giuseppe Scozzari
Marchi Registrati.
Tutti i marchi registrati appartengono ai legittimi proprietari.
Microsoft©, MS-DOS©, Windows©95, Windows©98, Windows© ME, Windows© NT, Win-

dows©2000, Windows© XP, Windows© Vista, Windows©7, Windows©8, Windows©10, Of-
fice©, PowerPoint©, Word©, Excel©, Access©, sono marchi registrati della Microsoft© Corpo-
ration negli Stati Uniti e/o negli altri paesi.
Altri nomi di prodotti e società citati nel presente libro possono essere marchi dei rispettivi
proprietari. Le informazioni contenute nel presente documento, inclusi gli URL e i riferimenti
a siti Web su Internet possono essere soggetti a modifiche senza preavviso. Se non speci-
ficato espressamente ogni riferimento a società, nomi, dati, indirizzi utilizzati nelle riprodu-
zioni è puramente casuale ed ha il solo scopo di illustrare con esempi pratici il funziona-
mento e le procedure da seguire per acquisire un certo grado di conoscenza del computer.
Né l’Autore né l’Editore possono assumersi alcuna responsabilità derivante dall’implemen-
tazione dei programmi contenuti in questo libro, ne possono fornire alcuna garanzia sulle
prestazioni e sui risultati derivanti dall’utilizzo di detti programmi. Lo stesso vale per ogni
persona o società coinvolta nella produzione o nella distribuzione di questo libro.
EDIZIONIFUTURA.COM®
Via Castelfidardo, 62 – 50137 FIRENZE - ITALY
tel. (+39)055.52.75.869 – fax. (+39)055.52.75.869
cell. 388.89.20.665
Sito web: www.edizionifutura.com
e-mail: edizionifutura@gmail.com
Terza Edizione
Aggiornamento edizione digitale: Maggio 2020
Sommario
Introduzione .................................................................................................................................... 9
Installare Visual Studio .................................................................................................................. 10
Personalizziamo l’ambiente di lavoro. ............................................................................................ 18
Creare un Progetto ......................................................................................................................... 20
Salviamo il Progetto ................................................................................................................................ 29
MaximizeBox e MinimizeBox .................................................................................................................. 30
ControlBox .............................................................................................................................................. 32
FormBorderStyle ..................................................................................................................................... 32
Creiamo l’eseguibile di un progetto ............................................................................................... 33
Aggiungere altre finestre (form) al progetto. ......................................................................................... 38
Primi passi nel mondo della programmazione ............................................................................... 45
Errori nella selezione dell’evento ........................................................................................................... 47
Ritornare alla progettazione ................................................................................................................... 48
Gli elementi del Linguaggio di Programmazione ............................................................................ 52
Introduzione ................................................................................................................................... 52
Psicologia del programmatore ................................................................................................................ 52
Come si scrive il codice ........................................................................................................................... 52
Le istruzioni ............................................................................................................................................. 56
Gli eventi ................................................................................................................................................. 56
Righe Vuote ............................................................................................................................................ 57
Note alla programmazione o commenti ................................................................................................. 57
Le variabili ............................................................................................................................................... 57
Le costanti............................................................................................................................................... 59
Assegnazione di valori ............................................................................................................................ 59
Dichiarazioni Esplicite ............................................................................................................................. 60
Tipi di dati ............................................................................................................................................... 61
Operazioni matematiche ........................................................................................................................ 61
Altre funzioni matematiche .................................................................................................................... 66
Funzioni trigonometriche ....................................................................................................................... 68
Operazioni sulle stringhe ................................................................................................................ 69
Format .................................................................................................................................................... 70
InStr ........................................................................................................................................................ 72
LCase ....................................................................................................................................................... 72
Len .......................................................................................................................................................... 73
Mid.......................................................................................................................................................... 73
Space....................................................................................................................................................... 73
StrConv ................................................................................................................................................... 73
StrComp .................................................................................................................................................. 74
StrReverse ............................................................................................................................................... 75
Trim, LTrim, RTrim. ................................................................................................................................. 75
UCase ...................................................................................................................................................... 75
Data e Ora ............................................................................................................................................... 75
Date ........................................................................................................................................................ 75
DateAdd .................................................................................................................................................. 76
DateDiff................................................................................................................................................... 77
DatePart .................................................................................................................................................. 78
DateSerial ............................................................................................................................................... 79
DateValue ............................................................................................................................................... 80
Hour ........................................................................................................................................................ 80
Minute .................................................................................................................................................... 81
Month ..................................................................................................................................................... 81
MonthName ............................................................................................................................................ 81
Now ......................................................................................................................................................... 82
Second..................................................................................................................................................... 82
TimeSerial ............................................................................................................................................... 82
Weekday ................................................................................................................................................. 83
WeekdayName ........................................................................................................................................ 83
Year ......................................................................................................................................................... 84
Altre funzioni ................................................................................................................................... 84
IsDate ...................................................................................................................................................... 85
IsEmpty ................................................................................................................................................... 85
IsNumeric ................................................................................................................................................ 86
IsNull ....................................................................................................................................................... 87
Funzioni di conversione di tipo. ...................................................................................................... 87
Asc ........................................................................................................................................................... 87
CBool ....................................................................................................................................................... 87
CByte ....................................................................................................................................................... 87
CDate ...................................................................................................................................................... 88
CDbl ......................................................................................................................................................... 88
CDec ........................................................................................................................................................ 88
Chr ........................................................................................................................................................... 88
CInt .......................................................................................................................................................... 89
CLng......................................................................................................................................................... 89
CSng ........................................................................................................................................................ 89
CStr.......................................................................................................................................................... 90
FormatCurrency ...................................................................................................................................... 90
FormatDateTime ..................................................................................................................................... 91
FormatNumber ....................................................................................................................................... 91
FormatPercent ........................................................................................................................................ 92
Hex .......................................................................................................................................................... 93
Val ........................................................................................................................................................... 94
Riepilogo operazioni su data e ora. ......................................................................................................... 94
Riepilogo operazioni sulle stringhe ......................................................................................................... 95
Concatenazione di stringhe ..................................................................................................................... 95
Routine .................................................................................................................................................... 96
Etichette e GoTo. .................................................................................................................................... 97
Le funzioni ............................................................................................................................................... 98
L’ Istruzione If ........................................................................................................................................ 100
If, Then ed Else annidati. ....................................................................................................................... 101
AND e OR .............................................................................................................................................. 102
Ciclo FOR … NEXT .................................................................................................................................. 104
DO … Loop ............................................................................................................................................. 106
DO While …loop .................................................................................................................................... 107
DO Until…. Loop .................................................................................................................................... 107
Uscita anticipata da un ciclo Loop ......................................................................................................... 107
Select Case ............................................................................................................................................ 108
Numeri casuali ...................................................................................................................................... 109
ARRAY ................................................................................................................................................... 109
Gli Strumenti a disposizione del programmatore ......................................................................... 115
I controlli .......................................................................................................................................115
Il pulsante di comando o Button ........................................................................................................... 117
Il TextBox............................................................................................................................................... 126
Impostazioni iniziali ............................................................................................................................... 132
Campo password................................................................................................................................... 134
La Label o etichetta ............................................................................................................................... 135
Il CheckBox o casella di controllo .......................................................................................................... 136
Il RadioButton o Pulsante di Opzione ................................................................................................... 139
GroupBox .............................................................................................................................................. 140
DateTimePicker ..................................................................................................................................... 142
NumericUpDown .................................................................................................................................. 147
ComboBox o Casella Combinata ........................................................................................................... 148
ListBox................................................................................................................................................... 150
Le finestre di dialogo .................................................................................................................... 153
Message Box, Le finestre di Messaggio ................................................................................................ 153
InputBox ............................................................................................................................................... 156
OpenFileDialog...................................................................................................................................... 158
OpenFileDialog & PictureBox ................................................................................................................ 158
SaveFileDialog e File di Testo ................................................................................................................ 162
FontDialog............................................................................................................................................. 167
ColorDialog ........................................................................................................................................... 168
PrintDialog ............................................................................................................................................ 169
Operazioni sui Form e sui Menu ................................................................................................... 175
Form MDI ...................................................................................................................................... 175
Il Menu Principale ......................................................................................................................... 181
Separatore ............................................................................................................................................ 184
Personalizzare un menu ........................................................................................................................ 185
Combinazioni di tasti da tastiera. ......................................................................................................... 187
Scorciatoie da tastiera .......................................................................................................................... 189
ToolTip .................................................................................................................................................. 190
Attiva e disattiva un menu .................................................................................................................... 191
Assegnare un’icona ad un menu ........................................................................................................... 192
Richiamare un Form da un Form MDI. .................................................................................................. 194
ToolStrip o Barra degli Strumenti ......................................................................................................... 197
StatusStrip o Barra di stato (StatusBar) ................................................................................................ 202
Timer..................................................................................................................................................... 205
Trascina e Rilascia ......................................................................................................................... 208
Eventi comuni. .............................................................................................................................. 211
I Database .................................................................................................................................... 213
Le tabelle. ............................................................................................................................................. 213
Query .................................................................................................................................................... 213
Maschera. ............................................................................................................................................. 213
Report. .................................................................................................................................................. 213
Microsoft ACCESS......................................................................................................................... 214
Le tabelle .............................................................................................................................................. 214
Passiamo all’azione ............................................................................................................................... 216
Tipi di campo......................................................................................................................................... 227
Le relazioni ............................................................................................................................................ 228
Inserire i dati nelle tabelle. ................................................................................................................... 234
Modificare se necessario la struttura di una tabella. ............................................................................ 236
Mettiamo un po’ d’ordine al layout delle relazioni............................................................................... 242
Le Query o Viste. ........................................................................................................................... 244
Query di raggruppamento. ................................................................................................................... 250
Altri esempi ........................................................................................................................................... 255
Access e il linguaggio SQL ..................................................................................................................... 255
Perfezioniamo il database..................................................................................................................... 256
Importare dati dall’esterno .......................................................................................................... 260
Importare dati da altri database di Access............................................................................................ 266
Collegare le tabelle ............................................................................................................................... 269
Importare dati da un file di testo. ......................................................................................................... 270
Esportare i dati ..............................................................................................................................273
Esportare dati in un file di Excel ............................................................................................................ 273
Esportare dati in un file di Access ......................................................................................................... 275
ACCESS & Visual Basic .................................................................................................................. 278
Accedere al database Access ................................................................................................................ 278
database mdb ....................................................................................................................................... 279
Database accdb ..................................................................................................................................... 284
Accesso ai dati da Visual Basic. ............................................................................................................. 287
Adattatore dei dati (OleDbDataAdapter) .............................................................................................. 288
DataSet.................................................................................................................................................. 288
OleDbCommand .................................................................................................................................... 288
DataGridView ........................................................................................................................................ 289
Eliminare un record ............................................................................................................................... 291
ComboBox ............................................................................................................................................. 292
Aggiungere un record............................................................................................................................ 293
Modificare un Record............................................................................................................................ 296
Stampare con Visual Basic..................................................................................................................... 299
MySQL .......................................................................................................................................... 304
Installare MySQL ................................................................................................................................... 304
Configurare MySQL ............................................................................................................................... 310
Connetti al database ............................................................................................................................. 314
Il database. ............................................................................................................................................ 316
Tabelle................................................................................................................................................... 316
Query o View......................................................................................................................................... 316
Utenti .................................................................................................................................................... 317
Progettare un database .................................................................................................................317
Utilizziamo uno strumento grafico per MySQL ..................................................................................... 317
Utilizzare Workbench ....................................................................................................................317
Creare e rimuovere database. ............................................................................................................... 319
Eliminare un database........................................................................................................................... 321
Creare le tabelle .................................................................................................................................... 321
Modificare le tabelle ............................................................................................................................. 326
Gli indici ................................................................................................................................................ 327
Relazioni fra tabelle .............................................................................................................................. 329
Inserire i dati in una tabella. ................................................................................................................. 331
Le Views ................................................................................................................................................ 335
Collegare due tabelle ............................................................................................................................ 337
Altre utilità ............................................................................................................................................ 338
Linguaggio SQL ............................................................................................................................. 339
SELECT ................................................................................................................................................... 343
WHERE .................................................................................................................................................. 345
AND ....................................................................................................................................................... 345
OR ......................................................................................................................................................... 345
LIKE e NOT LIKE ..................................................................................................................................... 345
Operatori di Confronto ..................................................................................................................345
IS NULL .................................................................................................................................................. 346
IN e NOT IN ........................................................................................................................................... 346
Colonne Calcolate ................................................................................................................................. 347
Operazioni matematiche....................................................................................................................... 347
GROUP BY ............................................................................................................................................. 348
Combinazione di dati su più tabelle. ..................................................................................................... 348
Creare un Database .............................................................................................................................. 349
Creare una Tabella ................................................................................................................................ 349
Modificare una tabella. ......................................................................................................................... 349
Eliminare una tabella ............................................................................................................................ 349
Inserire i dati in una tabella .................................................................................................................. 350
Elencare i record ................................................................................................................................... 350
Modificare un record ............................................................................................................................ 350
Eliminare un record .............................................................................................................................. 350
Utilizzare Visual Basic con MySQL ................................................................................................ 351
Accedere ai dati con Visual Basic. ................................................................................................. 354
Accedere ai dati. ................................................................................................................................... 355
Connessione a un Database MySQL ...................................................................................................... 355
Inserire nuovi record............................................................................................................................. 359
Modificare un record ............................................................................................................................ 362
Eliminare un record .............................................................................................................................. 366
Ricercare un dato .................................................................................................................................. 367
Controllare l’immissione dei dati da parte dell’utente ................................................................. 371
IsNumeric .............................................................................................................................................. 373
Convalidare un indirizzo di posta elettronica ....................................................................................... 373
DBNULL ................................................................................................................................................. 376
Moduli di codice ........................................................................................................................... 377
ComboBox & DataGridView.......................................................................................................... 381
Creazione di un database MySQL con Visual Basic. ...................................................................... 390
Visualizzare gli oggetti di un database MySQL con Visual Basic. .................................................. 397
Il Backup dei dati con MySQL. ...................................................................................................... 403
Restore.................................................................................................................................................. 404
Migrazione dei dati. .............................................................................................................................. 405
Gli errori in Visual Basic ............................................................................................................... 412
Trappole per errori ............................................................................................................................... 416
Informazioni sul sistema ....................................................................................................................... 417
Disegnare con Visual Basic. .......................................................................................................... 419
Disegnare una Linea...................................................................................................................... 419
Disegnare un Rettangolo .............................................................................................................. 421
Disegnare un Poligono. ................................................................................................................. 422
Ellisse ............................................................................................................................................ 423
Stringa ........................................................................................................................................... 424
Icona ............................................................................................................................................. 426
Immagine ...................................................................................................................................... 427
Altri Controlli utili. ....................................................................................................................... 429
MaskedTextBox ............................................................................................................................ 429
RichTextBox .................................................................................................................................. 433
FolderBrowserDialog .................................................................................................................... 437
PageSetupDialog ........................................................................................................................... 438
ImageList ....................................................................................................................................... 439
TreeView ....................................................................................................................................... 444
Creare controlli personalizzati ..................................................................................................... 453
Aggiungere Proprietà al controllo utente. .................................................................................... 458
Informazioni e operazioni su File e Cartelle .................................................................................. 468
Copiare una Directory ........................................................................................................................... 469
Verifica dell’esistenza di una cartella .................................................................................................... 470
Cambiare nome a una cartella. ............................................................................................................. 470
Operazioni sui File .........................................................................................................................471
Copia di File ........................................................................................................................................... 471
Spostare un file ..................................................................................................................................... 471
Rinominare un file ................................................................................................................................. 472
Informazioni sui File .............................................................................................................................. 472
Progetto FileInfo. ...........................................................................................................................473
Visual Basic & Word ..................................................................................................................... 482
Visual Basic & Excel ...................................................................................................................... 492
La Stampa con Visual Basic ........................................................................................................... 500
Stampa di un documento in PDF ...................................................................................................508
Stampa documento XPS ................................................................................................................510
XML .............................................................................................................................................. 511
Distribuire un’applicazione ........................................................................................................... 523
Appendici ..................................................................................................................................... 526
Le parole chiave in Visual Basic. ....................................................................................................526
Parole chiave non riservate ................................................................................................................... 527
Risorse ......................................................................................................................................... 528
Indice ........................................................................................................................................... 529
Introduzione
9
Introduzione
Finalmente un libro che tratta come diventare programmatori partendo “quasi” da zero o
qualcosa di simile. Lo scopo di questo testo è mettere in grado, chi si avvicina per la prima
volta alla programmazione, di entrare in un mondo tutt’altro che semplice e prendere con-
fidenza con i nuovi strumenti che il mercato mette a disposizione, acquisire tutta una serie
di conoscenze soprattutto pratiche e non solo teoriche, permettergli di creare interessanti
programmi e di fornirgli gli strumenti necessari per poter andare avanti da solo documen-
tandosi un domani su testi più impegnativi o linguaggi di programmazione diversi.
Gli argomenti presenti abbracciano i tempi più “caldi” che un programmatore di solito si
trova ad affrontare, cercando di mettere in evidenza tutto quello che può essere necessario
scartando volutamente argomenti inutili, troppo specifici o di nicchia.
Per iniziare l’avventura è necessario essere in possesso di requisiti minimi, ovvero avere
almeno la conoscenza degli argomenti che sono stati presentati sui volumi 1 e 2 de “Il
Computer Partendo da Zero”, che è possibile reperire in commercio nelle librerie o attra-
verso il sito www.edizionifutura.com, giusto per capirsi durante l’esposizione dei vari argo-
menti, anche se vengono utilizzati termini intenzionalmente semplificati per evitare di sca-
dere in quelle perifrasi incomprensibili nelle quali spesso ci si imbatte quando consultiamo
“certi” testi di programmazione. Meglio ancora se avete dimestichezza con il “pacchetto”
Office, ovvero con programmi come Word, Excel ecc.
Innanzitutto, mettetevi comodi perché la strada è molto lunga e soprattutto questo è un
mestiere che non si improvvisa. Diffidate da situazioni come: “diventa programmatore in
cinque comode lezioni” oppure “Programmare subito” perché se così fosse il mondo sarebbe
pieno di “Programmatori”.
La quantità tale di argomenti e di conoscenze necessarie per utilizzare gli strumenti che
vedremo in questo libro e a dir poco sbalorditiva, quindi il percorso va affrontato un poco
alla volta con calma e tranquillità, spesso trascorrendo intere giornate a documentarsi per
risolvere un problema che all’apparenza sembrava semplice.
Ho volutamente utilizzato un linguaggio semplice evitando spiegazioni scientifiche incom-
prensibili come quelle che spesso appaiono in altri testi e anche astrusi voli pindarici per
permettere all’aspirante programmatore di essere produttivo da subito, senza impazzire
scontrandosi con un codice che non funzionerà mai solo perché copiato così com’è da altre
parti e completamente decontestualizzato.
Ho cercato di riportare esempi realistici che provengono dalla mia esperienza lavorativa
quindi ho evitato quegli argomenti che sono a dir poco inutili e non applicabili alle necessità
e ai bisogni delle aziende che richiedono che un programma sia soprattutto funzionale. Per
fare ciò è bene tenere a mente che il programmatore per sviluppare un programma “vin-
cente” deve mettersi nei panni dell’utente meno abile e ragionare come ragionerebbe lui
durante l’utilizzo.
Il codice che appare in questo libro può essere utilizzato anche nelle versioni di Visual Basic,
2017 e 2019 per permettere anche a chi è un felice possessore di una versione precedente
di utilizzarlo per le proprie necessità salvo qualche caso dove è stato inserito del codice che
funziona nella versione 2019 che comunque è scaricabile gratuitamente dal sito della Mi-
crosoft.
Inoltre, questo libro non vuole essere una guida completa, come invece si fregia qualcuno,
al linguaggio Visual Basic in quanto sarebbe impossibile in un solo libro anche se partico-
larmente voluminoso mettere in evidenza solo una minima parte di quello che questo lin-
guaggio di programmazione può fare, e sono sicuro che ve ne renderete conto anche da
soli. Quindi gli argomenti utilizzati in questo libro sono stati scelti per fare in modo che
anche il principiante sia produttivo da subito affrontando argomenti di sicuro interesse.
Non mi resta che augurarvi buon lavoro.
L’autore: Giuseppe Scozzari

VisualBasic.NET 2019 – Partendo da Zero
10
Installare Visual Studio
La prima cosa da fare, per iniziare la nostra avventura nel mondo della programmazione, è
procurarsi l’ambiente di sviluppo Visual Basic, che si trova integrato in un più vasto am-
biente conosciuto come Visual Studio. Il pacchetto comprende tutta una serie di linguaggi
di programmazione più famosi ma sicuramente meno adatti chi “inizia da zero”.
Per iniziare dovete scaricare la versione Community dal sito ufficiale di Microsoft all’indi-
rizzo www.visualstudio.com/downloads, oppure sul sito www.microsoft.it.
Questa versione offre tutte le funzionalità delle versioni destinate all’utilizzo professionale
a costo zero, purché ovviamente non venga impiegata per l’utilizzo professionale di sviluppo
del software, ma solo per quello personale. La versione inoltre, previa registrazione (ovvero
dovete registravi sul sito Microsoft) offre una durata illimitata, contrariamente a quelle pre-
cedenti che scadevano dopo 30 o 60 giorni come periodo di valutazione. Terminato questo
tempo era necessario acquistare il prodotto.
Cercate il collegamento che, come nella figura qui sotto, vi permette di scaricare e installare
il software sul vostro computer. Fate click su Download gratuito. Ricordate però che le
pagine Internet sono spesso sottoposte a revisione grafica, e dunque è probabile che anche
questa pagina di download potrà apparire leggermente diversa da come la vedete nella
figura sottostante. Guardatevi intorno e cercate il collegamento per prelevare il programma
in questione.
Al momento della pubblicazione di questo libro la versione più “moderna” è la 2019. Tenete
presente che nell’ambito programmazione gli ambienti di sviluppo sono soggetti a continui
aggiornamenti ma, una volta che avrete sviluppato “l’occhio del programmatore”, riuscirete
facilmente a muovervi in qualunque situazione.
Nella parte bassa dello schermo compare una finestra che mostra tre opzioni. Per avviare
l’installazione del prodotto fate click sul pulsante Esegui come mostra la figura successiva.
11
Per far partire l’installazione del prodotto fate click sul pulsante Continua.
La figura successiva vi prega di avere un po’ di pazienza mentre viene scaricato l’ambiente
di sviluppo. Attendete fiduciosi…
12
Durante questa fase compare una finestra che vi permette di scegliere i componenti neces-
sari per iniziare la nostra avventura nel mondo della programmazione. Dato che l’ambiente
di sviluppo è particolarmente complesso, e presenta molti linguaggi di programmazione,
dato che siamo alle prime armi è meglio iniziare da dove viene indicato nella figura succes-
siva. È possibile aggiungere in un secondo tempo altre opzioni o altri linguaggi di program-
mazione. Questo per evitare di installare programmi che potrebbero non servirvi mai. Fate
click sul pulsante Installa in basso a destra nella finestra.
13
A questo punto vengono installati i componenti scelti. Questa fase può durare diversi minuti
quindi non vi resta che attendere.
Quando compare la finestra che vedete nella figura sottostante, fate click sul pulsante Riav-
via per completare l’installazione e riavviare il vostro computer.
Una volta eseguita l’operazione di riavvio, come si vede nella figura successiva, fate click
con il tasto SX del mouse sul Pulsante del menu di Avvio (Start) in basso a sinistra nello
schermo. L’icona di Visual Studio 2019 dovrebbe essere presente nella lista dei pro-
grammi. Nella prima parte di questo libro utilizzerò un linguaggio non troppo tecnico in
quanto il testo è appunto dedicato a chi parte da zero.
14
Fate click con il tasto DX del mouse in corrispondenza dell’icona del programma, e dal menu
scegliete Aggiungi a Start per posizionarlo sul Menu di avvio, in modo da averlo sempre
a portata di mano invece di stare a scorrere, tutte le volte che lo vogliamo avviare, la lista
dei programmi.
Quando un programma viene aggiunto al menu Start, è probabile che non venga collocato
nella posizione desiderata. Dovete quindi provvedere a spostarlo dove desiderate con il
metodo trascina e rilascia, (drag & drop nel linguaggio dei programmatori) fino a trovargli
la posizione più consona alle vostre necessità.
15
Quindi avviate con in click del tasto SX del mouse. Vi consiglio di iscrivervi sul sito della
Microsoft per sbloccare il programma e per renderlo di durata illimitata, altrimenti qualche
caratteristica potrebbe risultare bloccata e, sicuramente dopo 30 giorni di prova, il pro-
gramma stesso verrà disattivato. Se non l’avete già fatto, creando un Account Microsoft,
prima di proseguire fate click sul collegamento fare click qui per crearne uno che vedete
nella figura sottostante.
16
Per portare correttamente a termine questa procedura è necessario disporre di un indirizzo
di posta elettronica personale che utilizzerete per creare un Account, come si dice in gergo,
ovvero creare qualcosa dove potrete accedere con le vostre credenziali, che di solito sono
il vostro indirizzo di posta elettronica e una password. La creazione di un account è una
semplice registrazione delle vostre credenziali, in modo che la Microsoft possa identificarvi
come utilizzatore regolarmente registrato. Questa operazione di registrazione è analoga alla
creazione di una casella di posta elettronica.
Una volta che vi siete registrati il programma vi chiede con quale ambiente desiderate
sviluppare le vostre applicazioni. Per semplificarvi la vita partite con le impostazioni di svi-
luppo a Visual Basic.
La scelta di questo linguaggio non è casuale. Per chi parte da zero è impensabile addentrarsi
in linguaggi come C# (detto anche C Sharp), C++ o cose di questo genere, perché si tratta
di ambienti di sviluppo ben più complicati del nostro glorioso Visual Basic, che è stato ap-
positamente creato e modificato negli anni per risolvere cose complicate in modo relativa-
mente semplice.
Scegliete il tema dei colori per l’ambiente di sviluppo. Quindi dopo aver scelto dalla lista il
nostro linguaggio di programmazione fate click sul pulsante Avvia Visual Studio in basso
nella finestra.
Le immagini che vedete in questo libro sono state concepite per migliorarne la vi-
sibilità, per intenderci sul vostro computer le icone compariranno sicuramente più
piccole e le Barre degli strumenti o le Barre multifunzione sicuramente mostreranno
più comandi di quanto non ne siano visibili nel libro. Questo dipende anche da tipo
di schermo che avete a disposizione, ma se riportavamo le immagini che compaiono
sugli schermi attuali sarebbe stato impossibile apprezzarne i dettagli perché troppo
piccoli.
A questo punto iniziamo a prendere confidenza con l’ambiente di sviluppo per vedere cosa
ci offre, e di personalizzarlo in modo di avere sottomano quello di cui abbiamo bisogno.
17
Contrariamente ad altri testi che si trovano in commercio questo libro si propone innanzi-
tutto di mettere a proprio agio il principiante iniziando da subito a fare conoscenza con
l’ambiente di lavoro, presentandogli gli strumenti e, poi in un secondo tempo, presentargli
il codice che permetterà al programma di funzionare.
La situazione iniziale potrebbe essere quella che vedete nella figura sottostante.
Tenete presente che lo scopo di questo libro non è illustrare le ultime ed avanzatissime
funzioni di VisualStudio2019, ma semplicemente di avviarvi alla programmazione illustran-
dovi quelle componenti del linguaggio, la filosofia della programmazione e quant’altro non
sia soggetto a continui aggiornamenti, che spesso e volentieri non servono a nulla se non
a movimentare il mercato.
Chi si dedica alla programmazione non può cambiare ogni settimana o ogni mese l’ambiente
di sviluppo, altrimenti non sarà mai in grado di essere produttivo. Ad esempio, in giro esi-
stono ottimi programmi che originariamente sono stati sviluppati con Visual Basic 6 (anno
1998 circa). Fate click sul collegamento Continua senza codice.
La finestra iniziale mostra tutta una serie di altre finestre che non tutte sono di solito uti-
lizzate durante la fase di progettazione. Le finestre più importanti sono:
• La finestra Esplora Soluzioni, dove vengono visualizzate tutti le parti che com-
pongono il progetto e che vedremo descritte nel dettaglio in seguito,
• La Casella degli strumenti che mostra i controlli e quei componenti che realizzano
la parte grafica del nostro progetto.
La pagina iniziale presenta, a volte anche in lingua inglese, le novità riguardanti l’ambiente
di sviluppo, la guida introduttiva e altre notizie oltre ai comandi per aprire un progetto
salvato. Può essere utile una volta che avrete preso confidenza con l’ambiente di sviluppo
per vedere se sono disponibili delle novità o degli aggiornamenti.
18
Personalizziamo l’ambiente di lavoro.
Non è che dovete prendere quello che dico io come oro colato, in quanto ognuno di voi
potrebbe avere preferenze diametralmente opposte alle mie nella complicata arte della per-
sonalizzazione del proprio ambiente di lavoro, però vi garantisco che le finestre costante-
mente presenti sullo schermo durante lo sviluppo sono veramente poche (per fortuna).
Fate click con il tasto SX del mouse (tenete presente che da qui in poi quando si dirà di fare
click senza specificare con quale tasto del mouse si intenderà quello SX) sul riquadro che
rappresenta la Casella degli strumenti, nella parte sinistra dello schermo.
Fate click sulla piccola icona che somiglia ad una puntina da disegno per ancorare la finestra.
Come mostra la figura seguente la Casella degli strumenti può, come una qualsiasi finestra,
essere trascinata in una posizione a piacere se portate il puntatore nell’area del titolo della
finestra (i nomi delle parti che compongono le parti di una finestra vanno conosciuti bene).
Per ancorarla in una determinata posizione dello schermo è sufficiente fare coincidere il
19
trascinamento con l’icona del lato dello schermo che desiderate, in questo caso a sinistra,
quindi rilasciate.
Una volta posizionata la Casella degli strumenti dal lato desiderato è possibile ridimensio-
narla come una normale finestra, come si vede nella figura sottostante.
Chiudete invece le finestre, se eventualmente dovessero comparire sullo schermo, oppure

sul lato sinistro, che al momento non servono a nulla.
Se per errore avete chiuso qualche finestra oppure desiderate far comparire sullo schermo
altre finestre potete tranquillamente operare dal menu Visualizza in alto a sinistra nello
schermo.
20
Non riempite lo schermo di finestre inutili piene di informazioni che vi distolgono

dal lavoro. Utilizzate solo le impostazioni consigliate.
La Casella degli Strumenti è tristemente vuota in quanto ancora non siamo entrati
nella fase di sviluppo vero e proprio, cosi come la finestra Esplora Soluzioni.
A questo punto è tutto pronto per iniziare l’avventura nel mondo della programmazione.
Creare un Progetto
Iniziamo a muovere i primi passi nell’ambiente di lavoro creando un nuovo progetto. Fate
click sul menu File in alto a sinistra nella finestra e scegliete la voce Nuovo progetto,
come mostra la figura sottostante, oppure eseguite da tastiera la combinazione CRTL+N.
La posizione di questo menu è in continua evoluzione perciò qualora non corrispondesse
esattamente alla figura qui sotto non meravigliatevene.
Selezionate dalla prima lista la voce Visual Basic, dalla seconda la voce Windows e dalla
terza Desktop, come mostra la figura successiva. Quindi se necessario scorrete la lista fino
a trovare la voce App Windows Forms.
21
Fate click sul pulsante Avanti che si trova nella finestra in basso a destra.
Dato che con Visual Studio è possibile creare praticamente di tutto, partiamo dunque dalla
madre di tutti i progetti: l’applicazione Windows Form ovverosia un progetto basato
sulle finestre di Windows, o meglio ancora un programma che sullo schermo comparirà
sotto forma di finestra. Quindi come potete immaginare praticamente tutto dato che oggi
qualsiasi programma di Windows ha l’aspetto di una finestra.
Date un nome accattivante al vostro primo progetto in modo da poterlo riconoscere da tutti
gli altri, digitandolo nell’apposito spazio in basso a sinistra nella finestra, e fate click sul
pulsante Crea in basso a destra.
Dato che questo libro è espressamente dedicato a coloro che la programmazione

l’hanno vista solo in sogno, a mio parere questo è il miglior punto di partenza per
essere subito produttivi senza attendere anni di ragionamenti che riempiono solo
la testa, senza raggiungere poi nessun risultato tangibile. Perciò quando avete una
buona base in questo tipo di progetto potrete affrontare senza grossi problemi lo
studio di altri linguaggi di programmazione o lo sviluppo di altri tipi di progetti.
A questo punto verrà presentato l’ambiente di progettazione Visual Basic che attenzione,
potrebbe non essere identico a quello che vediamo nella figura successiva. Ma niente paura,
vi spiegherò nel dettaglio come fare apparire o scomparire quelle parti dello schermo che
possono essere utili oppure no, in uno specifico momento della programmazione.
Nella parte destra in alto dello schermo, ma non è una regola, di solito si trova la finestra
Esplora soluzioni che mostra tutti i file che fanno parte del nostro progetto.
Qualora la finestra non dovesse comparire per un motivo qualunque fate click sulla scheda
Visualizza in alto e selezionate la voce Esplora Soluzioni, oppure effettuate dalla tastiera
la combinazione CRTL+ALT+L.
22
Nella parte centrale della finestra di solito compare come prima cosa quando si crea un
nuovo progetto quello che è la rappresentazione di una finestra di Windows etichettata
come Form1.
Quando si crea un programma o applicazione l’oggetto principale è una finestra dove an-
dremo in seguito a posizionare Controlli come Pulsanti, Griglie, spazi dove è possibile scri-
vere e tante altre cose che concorreranno a creare il programma finito. Tutte queste cose
per funzionare hanno bisogno di sapere come si devono comportare in determinate occa-
sioni, e questo dovrete dirglielo voi, attraverso quello che si chiama Codice, che poi sarebbe
il programma vero e proprio.
La figura successiva mostra la finestra delle Proprietà, che nient’altro sono che le carat-
teristiche del controllo selezionato in quel momento. Ad esempio, se fate click all’interno
della finestra Form1, nella finestra delle proprietà appariranno le proprietà del controllo
elencate a gruppi, anche se è conveniente almeno a mio modo di vedere che l’elenco delle
proprietà venga presentato in ordine alfabetico. (anche questo dipenderà in futuro dal vo-
stro modo di lavorare)
Qualora la finestra delle proprietà non dovesse comparire sullo schermo, fate click con il
tasto SX del mouse all’interno dell’area del Form1 (figura successiva) e dalla tastiera pre-
mete il tasto F4.
Sul vostro schermo sicuramente c’è molto più spazio di quanto non ce ne sia in
queste immagini. Per questo tipo di lavoro è consigliato uno schermo da almeno 19
pollici utilizzato alla risoluzione 1280x1024. Ottimo anche se disponete di uno
schermo Wide da 20 o più pollici.
23
La risoluzione dello schermo è semplicemente un parametro che indica da quanti
puntini chiamati pixel (picture elements) è composta l’immagine che può visualiz-
zare il vostro schermo. Questo è anche in rapporto a quanto è grande lo schermo
stesso. Maggiore sono le sue dimensioni e maggiore sarà la risoluzione che potrà
sopportare.
La finestra delle proprietà riassume le caratteristiche di un oggetto o controllo in modo da

poterle variare a seconda nelle nostre necessità, come ad esempio la grandezza del Form
(finestra), oppure la posizione nella quale dovrà comparire sullo schermo in fase di funzio-
namento del programma (Runtime), il colore che dovrà assumere e tante altre caratteristi-
che.
Ad esempio, la proprietà Size serve per impostare la dimensione che il form dovrà assu-
mere al momento che il programma verrà eseguito.
Vi consiglio di ordinare in ordine alfabetico la lista delle proprietà in modo da riconoscerle
più velocemente, cosa molto importante per risparmiare tempo durante il lavoro. Fate click
sul pulsante che vedete nella figura sottostante.
24
All’interno di un progetto ogni componente deve avere un nome per poter essere ricono-
sciuto in maniera univoca, senza dubbi. Tenete presente che il nome dell’oggetto compare
comunque per primo nonostante la lista sia alfabetica per agevolare il riconoscimento del
controllo.
Innanzitutto, è buona norma dare un nome personalizzato all’oggetto o al controllo che
popola il nostro progetto in modo che venga da noi riconosciuto velocemente, specie quando
un progetto è costituito da decine o centinaia di oggetti e form. Selezionate con un click del
mouse l’oggetto Form1 e dalla lista identificate la proprietà Name.
La lista delle proprietà in alcuni casi è molto lunga, per questo ho messo in evidenza la
barra di scorrimento per accedere ad altre voci della lista. Inoltre, dato che lo spazio sullo
schermo è poco, ho chiuso temporaneamente la finestra Esplora Risorse.
Normalmente accanto alla proprietà nel caso di una finestra troverete la dicitura Form1.
Fate click nello spazio e digitate un nuovo nome ad esempio FormPrincipale.
25
La proprietà “Name” di qualsiasi controllo deve essere digitata senza spazi, ad
esempio FormPrincipale e non Form Principale.
Attraverso la proprietà Size (dovete scorrere la lista per trovarla) è possibile impostare la
dimensione iniziale della nostra finestra, cioè la dimensione che assume quando il pro-
gramma verrà avviato. Al momento della creazione di un Form il computer propone una
dimensione di 300x300 Pixel. Con l’esperienza vi farete un’idea dell’area occupata sullo
schermo. Fate click sul segno (+) che compare alla sinistra del nome della proprietà per
accedere alle singole componenti, in quanto potrebbe essere composta da più parametri.
Ad esempio, impostiamo una nuova dimensione facendo click nello spazio accanto alla pro-
prietà Width (larghezza) e Height (Altezza) digitando dalla tastiera un altro valore. Vedrete
la finestra assumere queste nuove dimensioni.
26
È possibile modificare la dimensione di una finestra anche manualmente portando il punta-
tore del mouse a sovrapporsi ad uno dei quadratini che si trovano agli angoli e al centro dei
lati di una finestra, e trascinando come chissà quante volte avete già fatto in altri casi.
Al momento del rilascio del tasto del mouse vedrete comparire in corrispondenza delle pro-
prietà i nuovi valori assunti da Width e Height.
Il risultato finale ad esempio può essere come quello che mostra la figura sottostante.
27
Per adattare la finestra delle proprietà in modo da ottimizzare la lettura dei valori di pro-
prietà di un controllo ridimensionate con la tecnica del trascina e rilascia (drag & drop), in
modo che i valori siano chiaramente leggibili. In alcuni casi i valori sono particolarmente
lunghi e quindi la dimensione della finestra delle proprietà necessita di un ritocchino da
parte nostra.
La proprietà StartPosition indica la posizione di partenza della finestra (form) quando si

avvia il programma.
28
Se desiderate che la vostra finestra compaia nel centro dello schermo dalla lista selezionate
il valore CenterScreen. Altre caratteristiche saranno illustrate più avanti.
Con la proprietà Text è possibile modificare il titolo della finestra, ovvero quella dicitura
che apparirà in alto a sinistra nella finestra.
Ad esempio, come mostra la figura sottostante, digitate un testo nel valore della proprietà
al posto di Form1.
Procedete con tranquillità senza cambiare all’impazzata tutti i valori delle Proprietà
che vi capitano a tiro…
29
Salviamo il Progetto
Prima di andare avanti con le operazioni salviamo il nostro primo progetto. Fate click sulla
scheda File in alto a sinistra nella finestra e dal menu scegliete la voce Salva Tutto, oppure
dalla tastiera eseguite la combinazione CTRL+MAIUSC+S, come suggerito anche dalla
voce del menu.
Il comando è anche disponibile sulla barra degli strumenti.
Continuiamo quindi a prendere confidenza con nostro nuovo ambiente di lavoro dando uno
sguardo alle altre caratteristiche che può avere un’oggetto Form, e quale utilità possono
avere ai fini del nostro lavoro. Altra proprietà di un certo interesse è WindowState.
Se il valore di proprietà viene impostato su Maximized al momento dell’avvio del pro-

gramma la vostra finestra occuperà l’intero schermo indipendentemente dai valori impostati
nella proprietà Size.
Per provare questa impostazione fate click sul pulsante Avvia che si trova in posizione
centrale sulla barra degli strumenti.
30
A questo punto, dopo qualche secondo, sullo schermo comparirà solo una grande finestra
vuota. Per interrompere l’esecuzione del programma fate click sulla (X) in alto a destra, che
si utilizza di solito per chiudere una qualsiasi finestra.
Così facendo si torna all’ambiente di sviluppo pronti per proseguire con la nostra prima
avventura di programmatori.
MaximizeBox e MinimizeBox
Queste due proprietà servono ad abilitare, quando sono impostate su True, o disabilitare
quando sono impostate su False, rispettivamente il comando di ingrandimento della fine-
stra (quello alla sinistra del comando di chiusura) e quello di riduzione a Icona (-) che
appaino in quasi tutte le finestre di Windows. Sarà quindi disponibile in alto soltanto il
comando per chiudere la finestra e nient’altro.
31
Impostando le due proprietà su False, al momento dell’avvio del programma, si verificherà

una situazione simile a quella della figura qui sotto. Impostate nuovamente il valore della
proprietà WindowState a Normal.
32
ControlBox
La proprietà ControlBox fa scomparire, se impostata su False, il gruppo dei tre comandi
che vedete in alto a destra di una qualsiasi finestra di Windows.
FormBorderStyle
Determina lo stile di una finestra. Normalmente è impostato su Sizable (ovvero che è
possibile modificarle le dimensioni) ma sono disponibili altri stili che per maggior chiarezza
vi prego di provare, in modo da rendervi conto voi stessi che tipo di modifiche applicano
alla finestra. Il valore None ad esempio crea una finestra senza bordi né comandi di chiu-
sura.
33
Creiamo l’eseguibile di un progetto
A questo punto, prima di passare a cose più impegnative, trattiamo un argomento molto
importante. Le operazioni che vedremo in questo capitolo servono esclusivamente a pren-
dere confidenza con l’ambiente di lavoro, in modo da acquisire quella manualità che vi
permetta di trovare al volo tutti i comandi che solitamente vengono utilizzati centinaia di
volte durante lo sviluppo di un progetto. Approfondimenti su questi ed altri temi verranno
esposti più avanti. Quando un programma viene completato e abbiamo appurato che fun-
ziona correttamente dobbiamo distribuirlo, o meglio installarlo su altri computer per te-
starne il funzionamento, per passarlo ad un amico o per distribuirlo al cliente che ce l’ha
commissionato per proprio lavoro. In gergo si chiama “creare l’eseguibile di un programma”
perché il codice sorgente (come vedremo nei prossimi capitoli) non è di nessuna utilità per
chi deve utilizzare il programma nel suo lavoro quotidiano.
Fate click sula scheda Compilazione in alto e dal menu selezionate la voce Compila Primo
Progetto.
Sullo schermo non accade niente di trascendentale, e viene generato il file eseguibile del
nostro programma, ovvero quel file formato EXE che non ha bisogno dell’ambiente di svi-
luppo (Visual Studio) per funzionare in maniera autonoma.
Uscite per il momento dall’ambiente di sviluppo chiudendo con l’apposito comando in alto a
destra nella finestra, e vediamo dove è possibile trovarlo nei meandri del vostro computer.
Se vi trovate sul Desktop fate doppio click sulla cartella che contiene i File dell’utente,
quella simpatica icona con la testina di un omino, che molto probabilmente ha il vostro
nome e si trova in alto a sinistra sul Desktop.
Quindi fate doppio click sulla cartella Source.

34
Una volta sicuri di essere nella cartella Source fate doppio click sulla cartella Repos dove
troverete le cartelle dei vostri progetti.
All’interno di questa cartella cercate la cartella del progetto che nel nostro caso si chiama
Primo Progetto. Se per ogni progetto avete utilizzato dei nomi descrittivi allora rintracciarli
sarà un gioco da ragazzi.
All’interno della cartella del nostro progetto se ne trova un’altra che ha lo stesso nome.
35
Fate doppio click e identificate la cartella bin.
All’interno di bin trovate la cartella Debug come mostra la figura successiva.
Dalla Barra multifunzione alla scheda Visualizza scegliete la voce Dettagli per visualizzare
i dettagli connessi ai file nella finestra.
Da quanto visto fin qua è inutile aggiungere che è necessaria una buona manualità
con i file e le cartelle e tutte le operazioni annesse e connesse a tale argomento,
come ad esempio taglia, copia e incolla, la regolazione della grandezza delle icone
all’interno di una finestra come in questo esempio. Facendo parte della manualità
di base in questo libro cercheremo ovviamente di non dare nulla per scontato, ma
può capitare che se siete a conoscenza di alcuni argomenti vi conviene consultare
anche i due volumi “Il Computer Partendo da Zero”.
36
In questo modo potrete scoprire la tipologia di un file. In questo caso si tratta di un’appli-
cazione ovvero qualcosa che è in grado di eseguire in maniera indipendente una serie di
istruzioni in essa contenute senza bisogno dell’ambiente di sviluppo (Visual Basic).
Se fate doppio click parte l’esecuzione del programma che ovviamente per il momento si
limita ad una solo finestra tristemente vuota.
Chiudete tutte le finestre e tornate sul Desktop. Riavviate Visual Studio facendo click sul
Pulsante del menu di Avvio in basso a sinistra sul Desktop e dalla lista scegliete Visual
Studio 2019.
37
Il progetto verrà visualizzato nell’elenco dei progetti recenti, quindi, per poterne tornare in
possesso, è sufficiente fare click sul nome del progetto come mostra la figura sottostante.
38
Aggiungere altre finestre (form) al progetto.
Come avete potuto appurare, qualsiasi programma in cui vi siete imbattuti non era compo-
sto da una singola schermata, ma da più finestre ognuna con le sue caratteristiche e fun-
zioni. Vediamo come è possibile aggiungere o eliminare Form, che poi saranno le nostre
finestre, in un progetto. Come già detto in precedenza questa prima parte è strutturata in
modo da permettervi di acquisire pratica durante lo sviluppo dei vostri programmi, e da
non perdere due ore di tempo quando non trovate un comando, magari anche di utilizzo
ricorrente.
L’elenco di questi oggetti form (finestre) che compongono il nostro progetto è visibile come
mostrato nella figura successiva nella finestra Esplora Soluzioni. Nel nostro caso il pro-
getto è costituito da un unico oggetto form che riporta la dicitura Form1.VB
Quando il progetto diventa più impegnativo, come nel caso di un programma che ha una
decina di finestre, questi nomi Form1, Form2 ecc. non sono affatto descrittivi e rendono
difficile il riconoscimento di uno di questi oggetti all’interno del progetto. Per questo, ad
esempio, è meglio assegnare nomi descrittivi anche alle finestre in modo da poterle facil-
mente identificare.
Fate click con il tasto DX del mouse su Form1.vb come mostrato nella figura successiva e
dal menu che appare scegliete la voce Rinomina
39
Dalla tastiera digitate il nome identificativo per l’oggetto nel nostro caso ad esempio For-
mPrincipale.
Per aggiungere un nuovo oggetto Form al progetto fate click con il tasto DX del mouse nella
finestra Esplora soluzioni sul nome che abbiamo assegnato al nostro Progetto, in questo
caso Primo Progetto, che di solito si trova come primo elemento della lista come mostra
la figura successiva. Dal menu scegliete la voce Aggiungi e dal sottomenu selezionate la
voce Form (Windows Form).
40
Come mostra la figura successiva, compare una finestra che desidera sapere che tipologia
di oggetto inserire. Selezionate Windows Form, qualora non lo fosse già, e quindi asse-
gnate un nome al form come nel nostro esempio FormSecondario.vb Ricordate di non
omettere o cancellare il .vb finale per evitare errate interpretazioni da parte del computer.
Concludete l’operazione facendo click sul pulsante Aggiungi in basso a destra nella fine-
stra.
41
Il nostro nuovo form comparirà nella lista della finestra Esplora Soluzioni.
Per eliminare un form fate click son il tasto DX del mouse sul form da rimuovere dal progetto
e dalla lista scegliete la voce Elimina (non eliminate per il momento il file, ma fate click
all’esterno del menu per chiuderlo senza effettuare nessuna operazione in lista).
Un’altra operazione di un certo interesse è quella di escludere, senza eliminare da un pro-

getto, uno o più oggetti form che non risultano utilizzati al momento ma che magari con-
tengono delle impostazioni o informazioni utili al programmatore che potrebbe riutilizzarle
in un secondo momento. Per escludere temporaneamente dal progetto un form fate click
42
col tasto destro del mouse sul form in questione e dal menu scegliete la voce Escludi dal
progetto.
I file momentaneamente esclusi dal progetto si possono visualizzare solamente se si fa click

sul pulsante Mostra tutti i file sulla barra degli strumenti della finestra Esplora Soluzioni
come in figura sottostante.
Fate click con il tasto DX del mouse sull’oggetto da includere nel progetto, come nel nostro
esempio il FormSecondario.vb, e dal menu scegliete la voce Includi nel Progetto (que-
sta volta eseguite pure l’operazione). Come noterete le icone dei file non inclusi sono eva-
nescenti per ribadire che non fanno parte del progetto.
43
Quindi agite nuovamente sul pulsante Mostra tutti i file, come in precedenza, in modo da
nascondere i file del progetto che non devono essere modificati dal programmatore. I file
che sono nascosti infatti non devono essere modificati per nessun motivo.
Non includete nel progetto cose strane che vedete nella lista. Limitatevi ad esclu-
dere o includere solo quegli oggetti da voi creati e non eseguite per nessun motivo
operazioni su eventuali altri file presenti nella lista.
44
Per passare da un form ad un altro basta fare doppio click sull’icona del form.
Nella finestra di progettazione appariranno tante schede quanti sono gli oggetti che avete
aperto. In fase di programmazione spesso si tiene aperto solo la finestra dell’oggetto sul
quale stiamo lavorando, quindi se siamo concentrati sul FormPrincipale, e per il momento
non dobbiamo eseguire nessuna operazione sul FormSecondario, potete tranquillamente
chiuderlo con gli appositi comandi anche per evitare di riempire la testata con tante schede
che non servono a nulla creandovi solo confusione.
Primi passi nel mondo della programmazione
45
Per il momento abbiamo preso confidenza con l’ambiente di lavoro giusto per capire come
muoverci, ma adesso passeremo alla programmazione vera e propria. Dalla finestra
Esplora Soluzioni fate doppio click con il tasto SX del mouse su quello che è il FormPrin-
cipale per selezionarlo.
Fate doppio click con il tasto SX all’interno del form. Comparirà quella che in gergo viene
chiamata Finestra del codice.
Per il momento non modificate quelle cose strane che vedete scritte dentro la finestra del
codice. In caso di modifiche arbitrarie il programma potrebbe non funzionare generando
una serie di errori che creerebbero non pochi problemi al programmatore principiante.
Concentriamoci invece su quelle liste che vedete in alto indicate nella figura sottostante.
46
La lista di sinistra ci permette di selezionare gli oggetti che fanno parte di quel form (nel
nostro caso ancora non ce ne sono perché non abbiamo inserito nulla nella finestra Form-
Principale, a parte il FormPrincipale stesso perché anch’esso è un oggetto). La lista di destra
invece mostra gli Eventi associati a quello specifico oggetto che è stato selezionato nella
lista di sinistra.
Gli eventi nient’altro sono che azioni che il computer deve intraprendere quando si verifica
appunto un certo evento, come ad esempio un click del mouse, due click del mouse oppure
anche il semplice passaggio del mouse sopra un determinato controllo che poi piano piano
andremo a conoscere andando avanti nel corso della programmazione.
Ad esempio, se voglio che accada qualcosa di specifico quando faccio doppio click all’interno
del form (finestra) devo scrivere nel linguaggio di programmazione quello che voglio che
accada nell’evento DoubleClick dell’oggetto FormPrincipale.
In questo modo quando si verifica quel tipo di evento, ad esempio un doppio click all’interno
del FormPrincipale, il computer eseguirà tutte le istruzioni che troverà scritte all’interno
delle parole Private Sub e End Sub.
Quando il cursore si trova nella posizione indicata nella figura successiva (di solito è la
posizione che assume quando viene fatto doppio click in un punto vuoto del form) la lista
di destra mostra tutti gli eventi disponibili per quell’oggetto (nel nostro caso il FormPrinci-
pale.)
Cercate nella lista l’evento DoubleClick e selezionatelo.

Come mostra la figura successiva abituatevi a scorrere la lista con gli appositi comandi in
quanto gli eventi sono tanti e non tutti compaiono al primo colpo.
47
Comparirà, quindi non spaventatevi, il codice iniziale quando si genera quell’evento. Il cur-
sore si posiziona automaticamente quindi a noi non resta che scrivere il codice, ovverosia
le istruzioni che deve eseguire il computer per fare una determinata cosa al verificarsi di
quell’evento, nel nostro caso quando viene fatto doppio click sul form.
Errori nella selezione dell’evento

Prima di passare alla programmazione è d’uopo mostrarvi come agire quando per sbaglio
viene selezionato un evento non desiderato dalla lista, e quindi automaticamente viene
generato il codice iniziale per quell’evento.
Avete in realtà due possibilità: Ignorare il codice e lasciarlo dove si trova tanto non crea
problemi all’esecuzione del programma oppure cancellarlo.
Per cancellarlo basta selezionarlo come fareste per un brano su Word ed eliminarlo con
CANC dalla tastiera.
Come mostra la figura successiva selezionate il codice dell’evento indesiderato che inizia
sempre con Private Sub e termina con End Sub, e dalla tastiera premete CANC.
Meglio non cancellare il codice relativo all’evento FormPrincipale_Load.

48
Non chiedetemi per favore come si fa a selezionare un brano perché vi rimando al libro: “Il
Computer partendo da Zero”.
Ritornare alla progettazione

La progettazione è quella parte che riguarda la visione grafica del programma, ovvero tutti
gli oggetti come pulsanti, spazi per il testo e tutte quelle componenti, che sicuramente
avete avuto a che fare migliaia di volte, che si possono trovare dentro la finestra di un
qualsiasi programma. Per ritornare alla zona di progettazione fate click con il tasto SX del
mouse sulla scheda etichettata [Progettazione].
Qualora abbiate chiuso la scheda [Progettazione] di un form per aprirla nuovamente basta
fare doppio click con il tasto SX del mouse sul form in questione nella finestra Esplora
Soluzioni.
49
Tenete sempre sott’occhio quali schede si trovano aperte in alto nella finestra.
Quando il progetto si farà più complesso è probabile che ve ne siano aperte
molte, creando spesso confusione nel rintracciare quella giusta. Per chiudere
una specifica scheda basta fare click sulla piccola (x) che si trova nella parte
destra di ogni scheda, proprio come il comando di chiusura di una normale fi-
nestra di Windows.
Torniamo adesso alla parte codice facendo click sulla scheda FormPrincipale.vb
Le schede il cui nome finisce con .vb sono schede di codice cioè che contengono le istruzioni
nel linguaggio di programmazione.
Se la scheda [.VB] non fosse aperta fate doppio click nell’area del Form.
Adesso portiamo a termine il primo esempio di programma per poi proseguire con una
panoramica del linguaggio di programmazione Visual Basic.
Come mostra la figura successiva all’interno dell’evento DoubleClick scrivete:
MsgBox("Bravo hai fatto doppio click")

50
Per migliorare la leggibilità del codice potete inserire tutte le righe vuote che
desiderate.
Ignorate per il momento tutti quei suggerimenti che compaiono in automatico

quando digitate dalla tastiera il codice, in quanto per il momento non sono di
nessun aiuto. Ci avvarremo dei loro servigi più avanti quando avremo preso un
po’ più di confidenza con l’ambiente di sviluppo.
Avviate il progetto con il pulsante Avvia sulla barra degli strumenti.
Dopo qualche istante comparirà sullo schermo la finestra del programma. Fate doppio click
con il tasto SX del mouse nell’area della finestra.
51
Ed ecco il risultato dell’operazione. Il primo programma funziona perfettamente.
Fate click sul pulsante OK del messaggio e quindi sul comando di chiusura della finestra
per interrompere l’esecuzione del programma. Passiamo adesso ad illustrare il linguaggio
di programmazione che vi permetterà di dare libero sfogo alla vostra creatività.
52
Gli elementi del Linguaggio di Programmazione
Introduzione
Il linguaggio di programmazione è quella cosa che permette al programmatore di dare
istruzioni al computer su quello che deve fare o come comportarsi quando avviene qualcosa
di specifico, come ad esempio un click da parte dell’utente e un’infinità di altre cose che
analizzeremo un poco alla volta. Le istruzioni che il computer deve trasformare in azioni a
dire la verità sono piuttosto complesse, ma un po’ per volta affronteremo la situazione per
renderla più semplice possibile.
Innanzi tutto, non mi dilungherò su questo perché fa parte di quella teoria che viene inse-
gnata sui banchi di scuola, quando si vuol creare un programma bisogna avere ben chiaro
o quasi quello che deve essere il risultato finale. È vero che le idee vengono sul momento
lì per lì, ma bisogna prima di partire per l’avventura, avere più che una mezza idea di quello
che il programma andrà a fare, altrimenti vi perderete nei meandri del programma stesso.
I vecchi programmatori facevano pagine e pagine di diagrammi di flusso, ovvero uno
schema di massima su come di deve comportare il computer in certe situazioni, in modo da
programmare più agevolmente o affrontare un problema in modo più chiaro. Noi non af-
fronteremo questa cosa se non in modo semplice quando faremo conoscenza delle parole
chiave del linguaggio Visual Basic.
Inoltre, ricordate che il computer fa una cosa sola: calcoli matematici ed è con quelli che in
realtà dovrete fare tutto. Questo non vuol dire che se a scuola avevate cinque in matematica
non diventerete mai programmatori perché il segreto del successo non è solo quello, ma la
capacità di mettere insieme questo e quel suggerimento, trovato su internet o avuto da un
amico, in modo da risolvere agevolmente un problema al momento insuperabile.
Psicologia del programmatore

Su questo argomento si può scrivere libri su libri. Il programmatore è un mestiere non certo
facile e che spesso e volentieri diventa frustrante. Può accadere, per quanto ci fondiamo le
meningi, di non riuscire a trovare la soluzione di un problema, oppure che un pezzo del
programma proprio non ne vuole sapere di funzionare. In questo caso non forzate la mano
cercando in tutti i modi di farvi venire quelle idee che proprio non ne vogliono sapere di
saltare fuori, oppure non insistete fino all’esaurimento nel cercare quel bug nel codice che,
nonostante siano delle ore che state sul pezzo, non riuscite a districare.
A volte la soluzione è lì a portata di mano sotto i nostri occhi ma la stanchezza ci impedisce
di arrivare alla risoluzione del problema. Se si verifica una tale eventualità, tutto sommato
è meglio fare una lunga pausa oppure meglio ancora decidere di rinviare il problema al
giorno dopo con la mente più fresca. Anche i neuroni hanno bisogno di un po’ di relax ogni
tanto, e in questo modo eviterete lo stress da frustrazione che ogni programmatore che si
rispetti ha provato almeno una volta in vita sua.
Inoltre, non lavorate al computer troppo a lungo, rispettate i tempi di riposo consigliati da
medici altrimenti potrebbero verificarsi diversi problemini non trascurabili.
Come si scrive il codice

Alcuni di questi argomenti li abbiamo già incontrati nel capitolo precedente, ma verranno
riproposti nella versione estesa in modo che al principiante (speriamo) risultino più chiari
che a prima vista.
A questo punto chiudete e salvate il progetto precedente e uscite da Visual Studio.
Rientrate in Visual Studio dal menu Start del computer e fate click sul menu File che si
trova nella parte sinistra dello schermo e dalla lista scegliete Nuovo – Progetto, oppure
eseguite dalla tastiera la combinazione CTRL+MAIUSC+N.
53
Selezionate qualora non lo fosse la voce App Windows Forms all’inizio della lista dei mo-
delli di progetto recenti, e confermate l’operazione con il pulsante Avanti in basso a destra
nella finestra.
Date un nome al progetto come nel nostro caso SecondoProgetto
Quindi fate click sul pulsante Crea in basso a destra nella finestra.
54
Fate doppio click con il tasto SX del mouse nella posizione dove vedete il puntatore nell’im-
magine qui sopra. Sullo schermo si propone una situazione analoga alla figura successiva.
In alto viene aperta una scheda che di solito richiama il nome dell’oggetto a cui stiamo
lavorando, mentre la scheda con il nome dell’oggetto in questo caso Form1, seguito dalla
scritta [Progettazione] si riferisce alla parte che riguarda la parte grafica dell’oggetto ciò
la progettazione di quello che dovrà poi apparire sullo schermo dell’utilizzatore del pro-
gramma. Per passare dalla Progettazione al codice basta fare click con il tasto SX del mouse
sulla scheda dove dovete lavorare.
Quando sarete più esperti nell’ambito della programmazione è probabile che le schede vi-
sibili in alto siano molte di più di quelle di questo esempio, quindi fate attenzione su quale
cliccate per essere sicuri che state lavorando a quella desiderata. Sbagliare è molto facile
anche per un esperto e questo comporta spesso una perdita di tempo.
55
Quando passate dal lato codice avrete già notato nell’esempio precedente che la pagina
non è proprio vuota, come se qualcuno avesse già digitato qualcosa come si vede nella
figura successiva. Per quanto riguarda una finestra o form troverete qualcosa di simile a ciò
che vedete qui di sotto:
Queste parti non vanno assolutamente modificate dell’utente perché servono al programma
per funzionare. Il significato di questo codice misterioso nel dettaglio verrà illustrato più
avanti in questo capitolo ci limiteremo a dare una spiegazione di massima per introdurre la
tecnica di scrittura del codice.
Ogni controllo che utilizziamo a livello di codice appartiene ad una classe di oggetti, quindi
il computer genera automaticamente il codice necessario per il funzionamento di massima
dato che senza una dichiarazione esplicita qualsiasi l’oggetto non esisterebbe. Nel caso di
un Form (quello che poi è una finestra di Windows) e appunto il codice che vediamo in
figura.
Quindi come prima cosa troveremo:
Public Class Form1
End Class
Dove Form1 è il nome della finestra. Ogni dichiarazione inizia con il nome del form e termina
con l’istruzione End Class. Quindi tutto il codice che troveremo fra queste due istruzioni
serve al funzionamento dell’oggetto in questione.
Come nei primi linguaggi di programmazione, il computer esegue le istruzioni in modo li-
neare ovvero una dopo l’altra fino a quando non trova altre istruzioni, allora si ferma l’ese-
cuzione di un programma. Ovviamente esistono delle istruzioni che possono spostare l’ese-
cuzione in un altro punto di un programma o cose di questo genere qui, quindi consultate
il capitolo che tratta delle routine e delle funzioni per capire meglio questo meccanismo.
La dichiarazione Public sta a significare che questo oggetto è pubblico ovvero può essere
richiamato da qualsiasi parte del programma.
La dichiarazione Private significa che quella parte di codice può essere richiamata solo
dall’interno dell’oggetto principale che contiene quel codice, ovvero in questo caso il Form1.
Inoltre, ogni classe ha le sue caratteristiche di base. Le Finestre o Form essendo una classe
di oggetti hanno delle caratteristiche che le diversificano da tutte le altre classi e quindi
dispongono di funzioni proprie diverse da altri oggetti come ad esempio un pulsante di
comando, una lista combinata ecc.
Per il programmatore è praticamente impossibile ricordare a memoria tutte le caratteristi-
che di ogni oggetto, ma con la pratica quelle salienti restano comunque abbastanza semplici
da ricordare.
Per quanto riguarda le nostre finestre o form, quando viene avviato il programma, il com-
puter va a cercare se ci sono istruzioni da eseguire dopo la parte di codice:
56
Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
End Sub
Se non avete capito un tubo fregatevene. Tutto sarà più chiaro quando met-
teremo in pratica quando detto.
Le istruzioni
È chiamata generalmente istruzione quello che possiamo definire un “comando” che diamo
al computer sotto forma di codice in modo che esegua un’operazione. Le istruzioni possono
essere formate da parole chiave del linguaggio, nel nostro caso Visual Basic, e da assegna-
zioni che effettua il programmatore.
Il linguaggio con il quale ci si rivolge alla macchina è composto da una serie di parole chiave
e da una sintassi generica che si metabolizza meglio con l’esperienza. Visual Basic è un
ottimo compromesso fra velocità di esecuzione e quantità di codice da scrivere per poter
arrivare allo scopo.
Gli eventi
Il computer per eseguire le istruzioni comincia certamente dal punto dove inizia il pro-
gramma, ma reagisce anche e soprattutto in virtù degli eventi che si verificano durante
l’esecuzione del programma stesso. Per evento si intende ad esempio quando l’operatore
fa click su uno specifico pulsante di comando, oppure fa passare semplicemente il mouse
al di sopra ad un’immagine, o trascina un oggetto ecc. ecc.
Ogni controllo, form, pulsante di comando e via dicendo, dispone tutta una serie di eventi
già programmati che possono verificarsi in seguito ad un’operazione da parte di chi utilizza
il programma come ad esempio un click su un pulsante di comando.
Nel caso di un oggetto form il primo evento che si verifica all’avviamento del programma è
la sua apparizione sullo schermo che in gergo si chiama caricamento in memoria (Load) e
da qui viene, in fase di scrittura del codice dal computer viene generata una zona nella
quale dovranno essere inserite le istruzioni che devono essere eseguite quando si genera
quello specifico evento.
Quindi, se volete che quando compare la finestra form1 sullo schermo al momento dell’avvio
del programma accada qualcosa, dovete scrivere il codice corrispondente per far accadere
questo qualcosa fra queste due istruzioni.
Lo spazio fra le due istruzioni può essere allargato a piacimento anche semplicemente por-
tando il cursore fra le due istruzioni e premendo il tasto Invio dalla tastiera.
57
Righe Vuote
Durante l’esecuzione di un programma le righe lasciate vuote dal programmatore vengono
ignorate. È quindi possibile ordinare il codice in modo che sia leggibile con facilità.
Per maggior chiarezza il codice può essere scritto con rientri da sinistra diversificati (inden-
tazione) per rendere al programmatore più chiaro il flusso del programma. Inoltre, lo spazio
fra un’istruzione ed un’altra può essere variabile a piacimento senza regole restrittive.
Note alla programmazione o commenti

Una caratteristica molto utile al programmatore è quella di poter lasciare dei commenti in
qualunque parte del programma che migliorano la leggibilità dello stesso. È infatti abba-
stanza difficile ricordare quello che avviene in un determinato punto del programma se per
diverso tempo non ci mettiamo le mani. Una nota nel punto giusto può facilitare non poco
il lavoro per rendere più agevoli eventuali modifiche. Per lasciare una nota come nell’esem-
pio precedente basta far precedere da un apostrofo. I commenti di solito sullo schermo
appaiono di color verde.
Le variabili
Una variabile è semplicemente un’area di memoria alla quale assegnate voi un nome di
fantasia come ad esempio “Pippo” dove avete la possibilità di memorizzare tutto quello che
volete, come ad esempio numeri o lettere. Durante un programma per rientrare in possesso
del contenuto della variabile basta semplicemente richiamarla.
Per una migliore gestione esistono diversi tipi di variabile a seconda di quello che avete
intenzione di metterci dentro. In pratica il computer vuole sapere se la variabile che avete
creato deve contenere del testo, dei numeri o chissà quale altra diavoleria proprio perché
durante l’esecuzione del programma è probabile che debba eseguire delle operazioni su
queste variabili.
Una variabile che contiene testo in gergo si chiama stringa. Quindi una qualsiasi frase per
il computer è una stringa di caratteri. Le variabili possono anche essere numeriche, quindi
contenere dei numeri che magari successivamente verranno utilizzati per fare delle opera-
zioni matematiche, e anche di altri tipi che ho riassunto nella tabella successiva.
Una variabile prima di essere utilizzata è meglio che sia dichiarata come nell’esempio qui
sotto con l’istruzione Dim.
Dim a As Integer La variabile “a” potrà contenere nel suo interno numeri interi.
Dim b As Double In questo caso “b” potrà contenere numeri a precisione doppia
Dim Stringa As String Questa invece è una stringa di caratteri, ovvero una parola o una
frase
Dim DataOdierna As Date Questa variabile contiene una data.
58
Ignorate per il momento il fatto che il computer sottolinea in verde il nome delle nostre
variabili in quanto le considera inutili perché non utilizzate in operazioni nel programma
(che ancora dovete scrivere!!).
Il nome di una variabile non deve presentare spazi al suo interno quindi, ad esempio, una
variabile che conterrà un totale generale dovrebbe essere chiamata totalegenerale. Nes-
suno vi vieta comunque di dare un altro nome di fantasia solo che durante la fase di crea-
zione di un programma quel nome è più facile da ricordare di altri. Inoltre, in un programma
ci possono essere, a secondo della sua complessità, molte centinaia di variabili che se non
hanno un nome ben chiaro risulta poi difficile avere una panoramica completa dell’insieme.
Un’altra cosa da tenere presente è che le variabili non possono avere come nome una parola
chiave riservata come ad esempio sub.
È possibile anche assegnare un valore al momento della dichiarazione come ad esempio:
Dim A as Integer = 50
Nella figura sottostante troverete un esempio di assegnazione.

59
Che ovviamente è uguale a quella che vedete nella figura successiva.
Le costanti
La costante, come dice la parola stessa, è un valore che resta identico durante tutta l’ese-
cuzione del programma e quindi non può essere soggetta a variazioni.
La parola chiave per definire una costante è Const, quindi l’istruzione per creare una co-
stante è:
Const Pippo As String = “Pippo”
In questo caso “Pippo” è la costante che assumerà lo stesso valore durante tutta l’esecu-
zione del programma e non può essere cambiata. Ovviamente non confondete il nome di
una costante o di una variabile con il suo contenuto.
Assegnazione di valori
Come avete visto nelle figure precedenti per assegnare un valore ad una variabile si utilizza
il segno = (uguale) come ad esempio:
60
A = 50
se la variabile è di valore numerico. Oppure:
A = “PIPPO”
Se la variabile è una stringa.
Dichiarazioni Esplicite
Come standard di programmazione in Visual Basic non esiste l’obbligo di dichiarare una
variabile affinché esista effettivamente, ad esempio è possibile anche ad un certo punto di
un programma scrivere a=10 senza nessuna dichiarazione dim in precedenza.
Quando però operiamo ad un programma complesso dove vi sono molte righe di codice
(praticamente sempre) è facile dimenticarsi di una variabile e quindi e meglio utilizzare
l’istruzione Option Explicit On in modo da evitare errori di digitazione o dimenticanze da
parte nostra.
Anche se questa funzione oggi è automatica in quanto inclusa nei criteri di pro-
tezione, meglio utilizzarla ugualmente. Quanto tratta questo libro vale anche
per le versioni precedenti di Visual Basic.
Ad esempio, se durante la stesura di un programma chiamiamo una variabile sommatotale

e in un altro punto del programma chiamiamo la stessa variabile commettendo un errore
di ortografia, per il computer si tratta di due variabili distinte e quindi diverse. È facile intuire
che se su queste varabili eseguiremo delle operazioni matematiche queste non torneranno
mai perché, senza rendercene conto, stiamo operando su due variabili diverse.
Ad esempio, sommatotale è diverso da somatotale. Per evitare questo problema è meglio
dichiarare sempre:
Option Explicit On
All’inizio di ogni codice come mostra la figura sottostante. In questo modo il computer ac-
cetta un’assegnazione solo se la variabile è stata correttamente dichiarata altrimenti picche.
Altamente consigliata l’attivazione.
61
Tipi di dati
Esistono molti tipi di dati che è possibile elaborare con Visual Basic e la tabella che vedete
qui sotto li riassume:
Tipo Visual Basic Quali dati possono contenere

Boolean True o False
Byte Da 0 a 255 (senza segno)
Char (carattere Da 0 a 65535 (senza segno)

singolo)
Date Dalle 0.00.00 (mezzanotte) dell'1 gennaio 0001 alle 23.59.59 del 31
dicembre 9999
Decimal Da 0 a +/-79.228.162.514.264.337.593.543.950.335 (+/-7,9...E+28)

senza decimali;
da 0 a +/-7,9228162514264337593543950335 con 28 posizioni decimali;
il numero più piccolo diverso da zero è +/-
0,0000000000000000000000000001 (+/-1E-28)
Double (virgola mobile Da -1,79769313486231570E+308 a -4,94065645841246544E-324 per i

a precisione doppia) valori negativi;
Da 4,94065645841246544E-324 a 1,79769313486231570E+308 per i valori
positivi
Integer Da -2.147.483.648 a 2.147.483.647 (con segno)
Long (valore long Da -9.223.372.036.854.775.808 a 9.223.372.036.854.775.807

integer) (9,2...E+18) (con segno)
Object In una variabile di tipo Object è possibile memorizzare qualsiasi

tipo
SByte Da -128 a 127 (con segno)
Short (valore short Da -32.768 a 32.767 (con segno)

integer)
Single (virgola mobile Da -3,4028235E+38 a -1,401298E-45 per i valori negativi;

a precisione singola) Da 1,401298E-45 a 3,4028235E+38 per i valori positivi
String Da 0 a circa 2 miliardi di caratteri

(lunghezza variabile)
UInteger Da 0 a 4.294.967.295 (senza segno)
ULong Da 0 a 18.446.744.073.709.551.615 (1,8...E+19) (senza segno)
UShort Da 0 a 65.535 (senza segno)
Operazioni matematiche
Quello che vediamo in questo capitolo serve come guida alle operazioni che Visual Basic è
capace di fare, e soprattutto per mostrare la sintassi delle operazioni. Non è necessario
impararle a memoria né creare un progetto ad arte per il momento. Serve solo come rife-
rimento futuro se non vi ricordate come si fa a fare la radice quadrata di qualcosa o cose di
questo genere qui, e troverà il suo utilizzo durante la progettazione dei vostri programmi.
Come ben sapete il computer è nato per fare solo ed esclusivamente calcoli matematici
benché al semplice utilizzatore non possa sembrare vero. Quindi vediamo come utilizzare
le operazioni di base.
62
+ Addizione
- Sottrazione
* Moltiplicazione
/ Divisione (quoziente)
% Divisione (resto)
^ Elevamento a potenza
Prima di andare avanti con la nostra avventura inserite per favore nello spazio dei nomi il
codice che vedete nella figura sottostante.
Per maggior chiarezza.
Option Explicit On
Option Strict Off
Imports System.Math
Altrimenti alcune di queste funzioni potrebbero non comportarsi come si conviene o rifiutarsi
addirittura di collaborare. Nell’esempio seguente vedremo alcune possibilità matematiche
di Visual Basic.
Creo tre variabili di tipo Double (precisione doppia) e assegno dei valori a due di esse.
Utilizzo la variabile “Totale” per memorizzare il risultato delle operazioni fra a e b.
Dim a As Double = 50
Dim b As Double = 35
Dim Totale As Double
Totale = a + b Somma algebrica

Totale = a * b Moltiplicazione
Totale = a – b Sottrazione
Totale = a / b Divisione
Totale = a ^ b Elevamento a potenza
Se siete curiosi e vedere dal vivo quello che accade in pratica, create un progetto nuovo
come si vede nella figura successiva. Fate click sul menu File dell’ambiente di sviluppo e
63
dalla lista scegliete la voce Nuovo – Progetto oppure eseguendo la combinazione da ta-
stiera CTRL+MAIUSC+N.
Adesso cercate nella lista di sinistra la voce Visual Basic e Desktop Classico di Win-
dows, quindi dalla lista centrale scegliete App Windows Forms.
Assegnategli un nome così sarà più facile rintracciarlo nei meandri dei vostri progetti e
confermate con un click sul pulsante Avanti in basso a destra nella finestra.
Assegnate un nome al progetto e fate click sul pulsante Crea in basso a destra nella fine-
stra.
64
Quando il progetto è generato fate doppio click portando il puntatore del mouse all’interno
del Form per accedere al codice come mostrato in figura successiva.
A questo punto inserite il codice di cui parlavamo prima nel posto giusto altrimenti si veri-
ficheranno malfunzionamenti.
Quindi dichiarate le variabili che utilizzeremo per prova

65
Inventiamoci un’operazione matematica di una certa complessità e aggiungete una bella
istruzione Stop, altrimenti il programma terminerà senza mostrare nulla di che.
Fate click sul pulsante Avvia in alto nella finestra oppure premete F5 dalla tastiera. Atten-
dete che il programma si arresti sullo Stop, poi portate il puntatore del mouse senza fare
nessun click a sovrapporsi con la variabile Totale, e un’etichetta ci mostrerà il risultato della
complessa operazione matematica. Questa tecnica può risultare utile per controllare
nell’arco del programma se le variabili assumono un valore corretto oppure abbiamo sba-
gliato qualcosa.
Arrestate l’esecuzione del programma.
Provate con altre espressioni e controllatene il risultato

Supponiamo adesso che sia necessario scrivere un’espressione del genere…
𝑎+𝑏
+ √𝑎 2 + 𝑏 2
𝑎∗𝑏
…e visualizzarne il totale.
66
Va chiarito innanzitutto che non è possibile scrivere un’espressione del genere come appare
qui sopra, ma è necessario effettuare uno sviluppo lineare utilizzando le parentesi ad esem-
pio:
Totale = ((a+b)/(a*b)) + Sqrt((a^2) + (b^2))
Quindi vanno utilizzate le parentesi per isolare le singole operazioni tenendo presente le
regole di base delle espressioni matematiche, ovvero prima le moltiplicazioni e le divisioni
poi le somme e le sottrazioni. Alcune parentesi possono anche essere soppresse ad esempio
così:
Totale = ((a + b) / (a * b)) + Sqrt(a ^ 2 + b ^ 2)
Però state attenti altrimenti può cambiare il risultato dell’espressione anche non di poco.
Questa ad esempio va ancora bene:
Totale = (a + b) / (a * b) + Sqrt(a ^ 2 + b ^ 2)
Questa assolutamente no:
Totale = a + b / a * b + Sqrt(a ^ 2 + b ^ 2)
E neanche questa:
Totale = (a + b / a * b) + Sqrt(a ^ 2 + b ^ 2)
Non vuole essere una lezione di matematica, ma va ricordato che un pro-

grammatore non può essere scarso in questa materia o per lo meno deve
sviluppare la capacità di orientarsi nei meandri di questa disciplina. D'al-
tronde il diavolo non è così brutto come lo si dipinge. Inoltre non dovete
necessariamente ricordarvi tutto a memoria oppure studiare adesso questi
aspetti, però ricordatevi a che punto si trovano nel libro per consultazioni
future.
Altre funzioni matematiche

In questo riepilogo delle funzioni principale la variabile a di tipo double è un valore numerico
qualsiasi che potete assegnare a piacere come nel caso precedente.
Restituisce il valore assoluto di un’espressione, ovvero

Totale = Abs(a) se il numero è negativo toglie il segno (-) e mi visua-
lizza il risultato come se fosse positivo.
Restituisce la parte intera di un numero ovvero se il
Totale = Int(a) numero è 61,112548 nella variabile totale va a finire
solo 61.
Fa la stessa cosi di Int con la differenza che se il
numero è negativo restituisce come risultato il numero
Totale = Fix(a) negativo maggiore o uguale a numero negativo ovvero se
il numero è -5.3 Fix restituisce -5 mentre Int restitui-
sce -6
Restituisce la radice quadrata del numero o della varia-
Totale = Radq(a)
bile fra parentesi
Restituisce un numero che rappresenta il logaritmo in
Totale = log(a)
base naturale (e) della variabile a
67
Restituisce un numero che rappresenta il logaritmo in
Totale = Log10(a)
base 10 della variabile a
Eleva un valore a un altro
Totale = Pow(a, b)
Totale = Pow(Valore, esponente)
Arrotonda al numero intero o decimale più vicino a se-
Round
condo dei parametri che vengono passati alla funzione.
Arrotonda la variabile a tre cifre decimali. Aggiungere
Totale = Round(a, 3)
la libreria System.Math alle dichiarazioni.
Nessuno ovviamente mi vieta di scrivere così:
Totale = Int((a + b) / (a * b) + Sqrt(a ^ 2 + b ^ 2)
O per estrarre la sola parte frazionaria di un risultato:
Totale = (a + b) / (a * b) + Sqrt(a ^ 2 + b ^ 2)
Totale = Totale - Int(Totale)
Quando l’esecuzione dei un programma arriva all’istruzione Stop, è possibile visionare i

valori dei vari parametri, o lanciare altri comandi dalla Finestra di comando, che è visualiz-
zabile sullo schermo dal menu Visualizza e dalla lista scegliete la voce Altre Finestre –
Finestra di comando o attraverso la combinazione da tastiera CTRL+ALT+A.
Da questa finestra è possibile vedere quale valore assumono le variabili in quel momento
semplicemente anteponendo il simbolo ? (punto interrogativo) al nome della variabile ad
esempio ? Totale e quindi premendo Invio dalla tastiera.
68
Come mostra la figura successiva il totale non tarda ad apparire sullo schermo.
È possibile anche creare espressioni ad esempio ? a * b per moltiplicare la variabile a per

la variabile b.
Funzioni trigonometriche
Anche la trigonometria ha un suo posto al sole con Visual Basic. L’unica cosa che va tenuta
presente è che il computer utilizza per variabili che rappresentano un angolo espresso in
radianti e non in gradi come siamo abituati a fare. Per passare da un angolo in gradi ad un
o in radianti basta applicare la seguente formula.
𝜋 ∗ 𝐴𝑛𝑔𝑜𝑙𝑜 𝑖𝑛 𝐺𝑟𝑎𝑑𝑖
𝐴𝑛𝑔𝑜𝑙𝑜 𝑖𝑛 𝑅𝑎𝑑𝑖𝑎𝑛𝑡𝑖 =
180
Ovvero:
Dim Risultato As Double
Dim AngoloGradi As Double = 75 'Ad esempio utilizzo un angolo di 75°
Dim AngoloRadianti As Double = PI * AngoloGradi / 180
Risultato = Sin(AngoloRadianti) Seno

69
Risultato = Cos(AngoloRadianti) Coseno
Risultato = Tan(AngoloRadianti) Tangente
Risultato = Sinh(AngoloRadianti) seno iperbolico
Risultato = Cosh(AngoloRadianti) coseno iperbolico
Risultato = Tanh(AngoloRadianti) tangente iperbolica
Non è assolutamente necessario imparare a memoria tutti gli argomenti che verranno
esposti nella prossima parte di questo capitolo. Alla termine dello stesso si trova un
riepilogo delle operazioni più importanti. Tenetelo presente però come punto di riferi-
mento per consultazioni future perché quando si sviluppa un programma, è difficile
ricordare la sintassi di quei comandi che non utilizziamo proprio troppo spesso.
Operazioni sulle stringhe

Le stringhe sono un’importante tipologia di variabili che il programmatore non può fare a
meno di conoscere. Una Stringa può contenere qualsiasi tipo di carattere alfanumerico. Per
assegnare un valore ad una variabile di questo tipo, seguite l’esempio sottostante:
Dichiarazione di Stringhe:
Dim Nome As String

Dim Cognome As String
Dim Indirizzo As String
Dim Citta As String
Assegno il valore alle stringhe:
Nome = "Pinco"
Cognome = "Pallino"
Indirizzo = "Piazza della Vittoria, 41"
Citta = "Firenze"
Aggiungo il contenuto di una variabile tipo stringa ad un’altra.
Dim Utente As String
'concatena una stringa con un'altra

'e manda accapo quindi inserisce l'indirizzo a riga nuova
Utente = Nome & " " & Cognome & vbLf & Indirizzo & " - " & Citta
Ovviamente non esiste la necessità di mandare accapo quando concateno delle stringhe.
Serve come esempio nel caso abbiate la necessità di visualizzare sullo schermo il contenuto
di una stringa, in una finestra di messaggio, su più righe. Questa riga serve solo per visua-
lizzare sullo schermo il risultato.
MsgBox(Utente, vbOKOnly + vbExclamation, "Messaggio")
Quindi per concatenare due stringhe basta una & (e commerciale).

70
Format
È una funzione piuttosto complessa, viste le tante di possibilità che ci offre. Di solito resti-
tuisce un valore a cui è stato applicato un formato scelto dal programmatore. Attenzione al
fatto che il computer, quando deve fare i calcoli, non può utilizzare una variabile tipo stringa,
ma utilizza una variabile numerica. Quindi l’istruzione Format è utile per visualizzare infor-
mazioni sullo schermo in modo da facilitare l’utente nella lettura dei dati. Un numero for-
mattato è a tutti gli effetti una stringa e non un numero per il computer. Esempio:
Dim Stringaformattata As String
Dim Numero As Double

Numero = 98542.036497 'numero da formattare
'separatore delle migliaia

' e due posizioni decimali
Stringaformattata = Format(Numero, "##,##.00")
'oppure separatore delle migliaia e Tre posizioni decimali

Stringaformattata = Format(Numero, "##,##.000")
MsgBox(Stringaformattata, vbOKOnly + vbExclamation, "Messaggio")
Trasformare in minuscolo il testo in una stringa:
Dim Stringa As String

Dim Stringaformattata As String
Stringa = "Pinco Pallino"
Stringaformattata = LCase(Stringa)
MsgBox(Stringaformattata, vbOKOnly + vbExclamation, "Risultato")
Se invece volete trasformarlo in maiuscolo
Stringaformattata = UCase(Stringa)
Questa riga serve per visualizzare a schermo il risultato.
MsgBox(Stringaformattata, vbOKOnly + vbExclamation, "Risultato")
La funzione Format oltre che sui numeri può lavorare anche sulle date. Acquisisce la data e
l’ora attuali provenienti dall’orologio del computer e la inserisce nella variabile DataOdierna.
Ad esempio:
Dim DataOdierna As Date

Dim DataFormattata As String
DataOdierna = Now
DataFormattata = Format(DataOdierna, "dd/MM/yyyy")
MsgBox(DataFormattata, vbOKOnly + vbExclamation, "Risultato")

71
Questo esempio mostra il giorno/mese/anno tipico dell’utilizzo più frequente.
DataFormattata = Format(DataOdierna, "dd/MM/yyyy")
Altri esempi:
DataFormattata = Format(DataOdierna, "dddd dd/MM/yyyy")
Visual Basic è un linguaggio particolarmente flessibile quindi, se non avete necessità di

memorizzare la data o l’ora per utilizzi futuri ma solo per mostrare un messaggio sullo
schermo, potete scrivere una sola riga di codice:
MsgBox(Format(DataOdierna, "dddd dd/MM/yyyy"), vbOKOnly + vbExclamation, "Risultato")
O meglio ancora:
MsgBox(Format(Now, "dd/MM/yyyy"), vbOKOnly + vbExclamation, "Risultato")
Simboli utilizzabili per formattare le date.

Simbolo Valori risultanti
d 1-31 (Visualizza il numero del giorno, senza zero di riempimento)
dd 01-31 (Visualizza il numero del giorno, con zero di riempimento)
ddd Indica il giorno della settimana (ad esempio lun = lunedì)
dddd Indica il giorno della settimana per esteso (es: lunedì)
M 1-12 Mese dell’anno, senza zero di riempimento, inizia con gennaio = 1)
MM 01-12 (Mese dell’anno, con zero di riempimento, inizia con gennaio = 01)
MMM Mostra il nome del mese abbreviato es: mar = marzo
MMMM Visualizza il nome completo del mese
yyyy 100-9999 (Visualizza l’anno a tre o quattro cifre)
Simboli utilizzabili per formattare l’ora.

Simbolo Valori risultanti
hh 00-12 (ora del giorno, con zero di riempimento)
HH 00-23 (ora del giorno, con zero di riempimento)
m 0-59 (Minuti, senza zero di riempimento).
mm 00-59 (con zero di riempimento).
s 0-59 (Secondi, senza zero di riempimento)
ss 00-59 (Secondi, con zero di riempimento)
Esempio: visualizza in una finestra di messaggio l’ora attuale.
MsgBox("Sono le: " & Format(Now, "HH:mm:ss"), vbOKOnly + vbExclamation, "Risultato")
Visualizza l’ora e la data completi

72
MsgBox("Sono le: " & Format(Now, "HH:mm:ss dd/MM/yyyy"), vbOKOnly + vbExclamation,
"Risultato")
InStr
Restituisce un valore numerico Integer che specifica la posizione della prima occorrenza di
una stringa all'interno di un'altra, in pratica ricerca una stringa dentro un’altra.
Sintassi del comando:

InStr (inizio, stringa1, stringa2, confronto)
La funzione presenta questi argomenti:
Argomento Descrizione
Opzionale. Valore numerico che imposta la posizione di partenza per ogni
ricerca. Se omesso, la ricerca inizia dalla prima posizione del carattere. Se
Inizio
Inizio contiene Null, si verifica un errore. L'argomento di avvio è obbliga-
torio se viene specificato il confronto tipo di confronto.
stringa1 Parametro obbligatorio, rappresenta la stringa nella quale ricercare.
stringa2 Parametro obbligatorio, rappresenta la stringa da ricercare.
Specifica il tipo di confronto delle stringhe. Se compare è Null, si verifica
confronto un errore. Se compare omesso, l'opzione Confronta opzione determina il tipo
di confronto.
L’argomento Confronto può assumere i seguenti valori:
Costante Descrizione
CompareMethod.Binary Esegue una comparazione tipo binario.
CompareMethod.Text Esegue una comparazione testuale.
Valori risultanti della funzione
Condizione Risultato del confronto

stringa1 è di lunghezza 0 caratteri 0
stringa2 è di lunghezza 0 caratteri Inizio
stringa2 non viene trovata 0
stringa2 viene trovata nella stringa1 La posizione dove si verifica la condizione
Inizio > lunghezza stringa2 0
Esempio:
Dim Stringa As String = "AbcDeFgHilMnoPqRstUvXyZ"

Dim StringaCercata = "X"
Dim Risultato As Integer
Risultato = InStr(4, Stringa, StringaCercata, CompareMethod.Text)
MsgBox("Carattere trovato in posizione: " & Risultato, vbOKOnly + vbExclamation,

"Risultato")
LCase
Questa funzione trasforma una stringa in caratteri minuscoli.

Stringa = "Per FavoRe Metti TuttO iN MinuScOlo"
Stringa = LCase(Stringa)
73
MsgBox("Tutto minuscolo: " & Stringa, vbInformation, "Messaggio")
Len
Restituisce un valore contenente il numero di caratteri presenti in una stringa.

Stringa = "Visual Basic 2019 per chi parte da zero"
Dim Caratteri As Integer
Caratteri = Len(Stringa)
MsgBox(Caratteri, vbInformation, "Messaggio")
Mid
Prende un certo numero di caratteri contenuti in una stringa partendo da una posizione. Ad
esempio Mid(Stringa,13,5) prende 5 caratteri contenuti nella stringa a partire dal carattere
13. Provate il codice qui di seguito:
Dim Stringa, Stringa1, Stringa2, Stringa3 As String
Stringa = "Visual Basic 2019 per chi parte da zero"

Stringa1 = Mid(Stringa, 13, 5)
Stringa2 = Mid(Stringa, 1, 12)
Stringa3 = Mid(Stringa, 13)
MsgBox(Stringa & vbLf & Stringa1 & vbLf & Stringa2 & vbLf & Stringa3,
vbOKOnly, "Messaggio")
Space
Questa funzione restituisce una stringa contenente un numero specificato di spazi vuoti.
Esempio di utilizzo:

'Crea una stringa contenente 20 spazi vuoti
Stringa = Space(20)
'inserisce 20 spazi vuoti fra 2 stringhe
Stringa = "Ciao" & Space(20) & "Pinco pallino"
MsgBox(Stringa, vbOKOnly, "messaggio")
StrConv
Restituisce una stringa convertita in un modo specifico. Sintassi:
StrConv (stringa, conversione)
La funzione StrConv presenta i seguenti argomenti:
stringa Rappresenta la stringa da convertire.
Il valore o la somma di valori che specifica il tipo di conversione da
conversione
eseguire.
74
Le impostazioni dell’argomento Conversione sono:
vbUpperCase Converte la stringa in maiuscolo.
vbLowerCase Converte la stringa in minuscolo.
vbProperCase Converte la prima lettera di ogni parola in maiuscolo.
In questo esempio viene utilizzata la funzione StrConv per convertire il testo contenuto in
una stringa in un testo tutto maiuscolo.
Dim Stringa, Stringa1 As String

Stringa = "Programmare in Visual basic.NET 2019 Partendo da Zero"
Stringa1 = StrConv(Stringa, vbUpperCase)
MsgBox(Stringa1, vbOK, "Messaggio")
StrComp
Questa funzione viene utilizzata per comparare il contenuto di due stringhe di caratteri.
Restituisce un valore (di tipo Variant o Integer) che indica il risultato della comparazione
fra stringhe. Sintassi:
StrComp (stringa1, stringa2, Comparazione)
Argomenti della Funzione:
stringa1 Prima Stringa di caratteri
stringa2 Stringa da comparare
Opzionale. Specifica la tipologia di comparazione. Se questo argomento
assume il valore NULL, si verifica un errore.
Comparazione
Se è omesso la comparazione è determinata dall’impostazione Option Com-
pare nella sezione dichiarazioni.
Gli argomenti per la comparazione sono:
vbBinaryCompare Esegue una comparazione binaria.
vbTextCompare Esegue una comparazione di testo.
La funzione restituisce i seguenti valori:
Condizione: Valore Restituito

stringa1 è minore di stringa2 -1
stringa1 è uguale to stringa2 0
stringa1 è più grande di stringa2 1
Esempi: Questo esempio utilizza la funzione StrComp per restituire i risultati di un con-
fronto di stringhe. Se l’argomento comparazione è VbTextCompare, viene eseguito un con-
fronto testuale; se l’argomento comparazione è VbBinaryCompare o omesso, viene eseguito
un confronto binario.
Dim Stringa1, Stringa2 As String

Dim Risultato As Integer
Stringa1 = "ABCDEFGHI"
Stringa2 = "abcdefghi"
75
Risultato = StrComp(Stringa1, Stringa2, vbTextCompare)
Risultato = StrComp(Stringa1, Stringa2, vbBinaryCompare)
StrReverse
Inverte la sequenza dei caratteri in una stringa.
Dim Stringa1, StringaRovesciata As String

Stringa1 = InputBox("Inserisci una frase", "Inserimento dati")
StringaRovesciata = StrReverse(Stringa1)
MsgBox(StringaRovesciata, vbOKOnly, "Messaggio")
Trim, LTrim, RTrim.

Restituisce una stringa contenente una copia di una stringa passata come argomento senza
spazi iniziali (LTrim), spazi finali (RTrim) o spazi iniziali e finali (Trim). In pratica ripulisce
le stringhe da spazi vuoti iniziali, finali o entrambi. Utile per ripulire l’immissione di dati da
parte dell’utente.
Dim Stringa1, StringaRipulita As String

Stringa1 = InputBox( "Inserisci una frase" , "Inserimento dati" )
StringaRipulita = Trim(Stringa1)
MsgBox(StringaRipulita, vbOKOnly, "Messaggio")
UCase
Questa funzione trasforma una stringa in caratteri maiuscoli.

Stringa = "Per FavoRe Metti TuttO iN MaiuSColo"
Stringa = UCase(Stringa)
MsgBox("Tutto maiuscolo: " & Stringa, vbInformation, "Messaggio")
Data e Ora
Visual Basic dispone di tutta un serie di funzioni che eseguono le più disparate operazioni
su date e ore e rivestono una certa importanza nel flusso del programma, ad esempio se
devo calcolare una data futura aggiungendo un certo numero di giorni, oppure calcolare la
differenza in giorni fra due date ecc. ecc.
Iniziamo quindi la nostra rassegna delle funzioni più importanti:
Date
Questa funzione restituisce la Data attuale del sistema. Esempio:
Dim Dataodierna As Date

Dataodierna = Now
MsgBox("Data odierna " & Dataodierna, vbOKOnly, "Messaggio")
76
DateAdd
Restituisce una variabile tipo Data contenente una data a cui è stato aggiunto un intervallo
di tempo specificato dall’argomento intervallo.
DateAdd(Intervallo, Numero, Data)
Argomento descrizione
Argomento obbligatorio. Espressione di stringhe che è l'intervallo di tempo
Intervallo
che vuoi aggiungere.
Argomento obbligatorio. Espressione numerica che corrisponde al numero di
Numero intervalli che si desidera aggiungere. Può essere positivo (per ottenere
date future) o negativo (per ottenere date passate).
Argomento obbligatorio. Variante (data) o letterale che rappresenta la data
Data
alla quale viene aggiunto l'intervallo.
L’argomento Intervallo può avere queste impostazioni:
Impostazione Comando Descrizione

yyyy DateInterval.Year Anno
q DateInterval.Quarter Trimestre
m DateInterval.Month Mese
y DateInterval.DayOfYear Giorno dell’anno
d DateInterval.Day Giorno
w DateInterval.WeekDay Giorno della settimana
ww DateInterval.WeekOfYear Settimana
h DateInterval.Hour Ora
n DateInterval.Minute Minuto
s DateInterval.Second Secondo
È possibile utilizzare la funzione DateAdd per aggiungere o sottrarre un intervallo di tempo

specificato da una data. Ad esempio, è possibile utilizzare DateAdd per calcolare una data
a 50 giorni da oggi o a 35 minuti da ora. Per aggiungere giorni fino ad oggi, puoi utilizzare
Giorno dell'anno ("y"), Giorno ("d") o Giorno della settimana ("w").
La funzione DateAdd non restituisce date non valide. Nel codice di esempio che segue viene
aggiunto un mese alla data che l’utente inserirà dalla tastiera. Ad esempio, se inserisco la
data 31/05/2021 aggiungendo un mese il risultato della funzione sarà: 30/06/2021
Dim DataUtente, DataRisultante As Date

DataUtente = InputBox("Inserisci la data", "Messaggio")
DataRisultante = DateAdd(DateInterval.Month, 1, DataUtente)
MsgBox("Data calcolata " & DataRisultante, vbOKOnly, "Messaggio")
Oppure è possibile scrivere la riga di codice che converte il valore così:
DataRisultante = DateAdd("m", 1, DataUtente)
Tenete presente che il codice per il momento non contempla gli eventuali errori che possono
derivare da un’immissione errata da parte dell’utente, oltre ad eventuali errori in fase di
esecuzione (run time) che invece affronteremo nel capitolo che tratta della gestione degli
errori con Visual Basic.
Se il parametro numero non è un valore Long, viene arrotondato al numero intero più vicino
prima di essere valutato. Inoltre, il formato del valore restituito è determinato dalle impo-
stazioni del Pannello di controllo, non dal formato passato nell'argomento della data.
L’esempio che segue utilizza una data inserita dall’operatore e aggiunge un numero di mesi
a piacere e visualizza la data risultante.
77
Dim DataImmessa As String = InputBox("Inserisci una data",

DefaultResponse:=Date.Now.ToShortDateString)
Dim MeseImmesso As String = InputBox("Inserisci il numero dei mesi
da aggiungere", DefaultResponse:="12")
Dim ValoreData As Date = Date.Parse(DataImmessa)
Dim ValoreMese As Integer = Integer.Parse(MeseImmesso)
Dim NuovaData As Date = DateAdd(DateInterval.Month, ValoreMese, ValoreData)
MessageBox.Show("Data Calcolata: " & NuovaData.ToShortDateString)
La funzione Date.Parse converte la rappresentazione di stringa di una data nell’oggetto Date

equivalente. Allo stesso modo la funzione Integer.Parse converte una stringa nell’equiva-
lente Integer con segno a 32 bit.
DateDiff
Restituisce un valore Long che specifica il numero di intervalli di tempo tra due date speci-
ficate.
DateDiff(intervallo, data1, data2, primogiornodellasettimana, primasettimanadellanno)
Argomento obbligatorio. Espressione di stringa che corrisponde
Intervallo all'intervallo di tempo utilizzato per calcolare la differenza
tra date1 e date2.
Argomento obbligatorio; Variant (o Data). Le due date da uti-
data1, data2
lizzare nel calcolo.
Argomento facoltativo. Una costante che specifica il primo
primogiornodellasettimana giorno della settimana. Se non specificato, la domenica è presa
come punto di partenza.
Argomento facoltativo. Una costante che specifica la prima set-
primasettimanadellanno timana dell'anno. Se non specificato, si presume che la prima
settimana sia la settimana in cui si verifica il 1 ° gennaio.
L’argomento intervallo può assumere i seguenti valori.

y DateInterval.DayOfYear Giorno dell’anno
w DateInterval.WeekDay Giorno della settimana
ww DateInterval.WeekOfYear Settimana
L’argomento primogiornodellasettimana può assumere i seguenti valori.
Impostazione Valore Descrizione

FirstDayOfWeek.System 0 Utilizza le impostazioni del sistema
FirstDayOfWeek.Sunday 1 Domenica (impostazione predefinita)
FirstDayOfWeek.Monday 2 Lunedì
FirstDayOfWeek.Tuesday 3 Martedì
FirstDayOfWeek.Wednesday 4 Mercoledì
FirstDayOfWeek.Thursday 5 Giovedì
FirstDayOfWeek.Friday 6 Venerdì
FirstDayOfWeek.Saturday 7 Sabato
78
L’argomento primasettimanadellanno può assumere i seguenti valori.
Impostazione Val. Descrizione

FirstWeekOfYear.System 0 Utilizza le impostazioni di sistema.
FirstWeekOfYear.Jan1 1 Inizia con la settimana dove si trova il 1° gennaio.
Inizia con la settimana che ha almeno quattro giorni
FirstWeekOfYear.FirstFourDays 2
nel nuovo anno.
FirstWeekOfYear.FirstFullWeek 3 Parte dalla prima settimana completa dell’anno.
È possibile utilizzare la funzione DateDiff per determinare quanti intervalli di tempo specifici
esistono tra due date. Ad esempio, è possibile utilizzare DateDiff per calcolare il numero di
giorni tra due date o il numero di settimane tra oggi e la fine dell'anno.
Codice di esempio: Questo esempio utilizza la funzione DateDiff per visualizzare il numero
di giorni tra una determinata data e oggi. Versione semplice:
Dim DataUtente As Date

DataUtente = InputBox("Inserisci una data", "Messaggio")
MsgBox("Giorni da oggi: " & DateDiff("d", Now, DataUtente),

vbOKOnly, "messaggio")
Versione completa. Il codice contiene anche il controllo degli errori in caso di digitazione
errata da parte dell’utente. Per maggiori informazioni consultate il capitolo che tratta delle
trappole per errori.
Dim DataImmessa As String = InputBox("Inserisci una data")
Try
Dim Data2 As Date = Date.Parse(DataImmessa)
Dim Data1 As Date = Now
' Calcola il numero di giorni fra tue date.
Dim Giorni As Long = DateDiff(DateInterval.Day, Data1, Data2)
' Trappola per errori
MessageBox.Show("Giorni da oggi: " & Giorni.ToString)
Catch ex As Exception
MessageBox.Show("Data Errata: " & ex.Message)
End Try
DatePart
Restituisce un valore Integer contenente la parte specificata di una determinata data.
DatePart(Intervallo, Data, primogiornodellasettimana, primasettimanadellanno)
Obbligatorio. Espressione stringa che corrisponde all'in-
Intervallo
tervallo di tempo che si desidera restituire.
Data Obbligatorio. Valore che si desidera valutare.
Facoltativo. Una costante che specifica il primo giorno
primogiornodellasettimana della settimana. Se non specificato, la domenica è presa
come riferimento.
Facoltativo. Una costante che specifica la prima settimana
primasettimanadellanno dell'anno. Se non specificato, si presume che la prima set-
timana sia la settimana in cui si verifica il 1 ° gennaio.
79
L’argomento intervallo può assumere questi valori:

y DateInterval.DayOfYear Giorno dell’anno (1-366)
w DateInterval.WeekDay Giorno della settimana (1-7)
ww DateInterval.WeekOfYear Settimana (1-53)
L’argomento facoltativo primogiornodellasettimana può assumere questi valori:

L’argomento facoltativo primasettimanadellanno può assumere questi valori:
Impostazione Val. Descrizione

FirstWeekOfYear.System 0 Utilizza le impostazioni di sistema.
FirstWeekOfYear.Jan1 1 Inizia con la settimana dove si trova il 1° gennaio.
Inizia con la settimana che ha almeno quattro giorni
FirstWeekOfYear.FirstFourDays 2
nel nuovo anno.
FirstWeekOfYear.FirstFullWeek 3 Parte dalla prima settimana completa dell’anno.
Esempio di codice:
Dim StringaData, Messaggio As String

Dim DataOdierna As Date
StringaData = InputBox("Inserisci una data:")
DataOdierna = CDate(StringaData)
Messaggio = "Data: " & DataOdierna & vbLf

Messaggio = Messaggio & "Trimestre: " &
DatePart(DateInterval.Quarter, DataOdierna) & vbLf
Messaggio = Messaggio & "Giorno del Mese: " &
DatePart(DateInterval.Day, DataOdierna) & vbLf
Messaggio = Messaggio & "Settimana dell'anno: " &
DatePart("ww", DataOdierna) & vbLf
Messaggio = Messaggio & "Giorno della settimana: "
& DatePart("w", DataOdierna)
MsgBox(Messaggio, vbOKOnly, "Messaggio")
DateSerial
Restituisce una data specificando un anno un mese e un giorno in formato numerico.
80
DateSerial(anno, mese, giorno)
year Obbligatorio: Numero intero che rappresenta l’anno.
month Obbligatorio; Numero intero che rappresenta il mese.
day Obbligatorio; Numero intero che rappresenta il giorno.
Esempio:
Dim Data1 As Date

Data1 = DateSerial(1965, 6, 11)
MsgBox(Data1, vbOKOnly, "Messaggio")
DateValue
Trasforma una stringa di caratteri in una data.
DateValue(data)
Nota bene: L'argomento della data richiesto è normalmente una stringa che rappresenta
una data dal 1° gennaio dell’anno 1 fino al 31 dicembre 9999. La data può anche essere
qualsiasi espressione che può rappresentare una data, un'ora o una data e un'ora.
Se data è una stringa che include solo numeri separati da separatori di date validi, DateVa-
lue riconosce l'ordine per mese, giorno e anno in base al formato Data breve specificato
nelle impostazioni del sistema Windows.
Riconosce anche date non ambigue che contengono i nomi dei mesi, sia in forma lunga che
abbreviata. Ad esempio, oltre a riconoscere 30/10/1999 e 10/30/99, DateValue riconosce
anche il 30 ottobre 1999 e il 30 ottobre 1999.
Se viene omessa la parte dell'anno della data, DateValue utilizza l'anno corrente dalla data
di sistema del computer.
Se l'argomento della data include informazioni sull'ora, DateValue non lo restituisce. Se la
data include informazioni sull'ora non valide (come "78:89"), si verifica un errore.
Esempio:
Dim Data1 As Date

Data1 = DateValue("15 marzo 1995")
MsgBox(Data1, vbOKOnly, "Messaggio")
Hour
Restituisce un valore Integer compreso tra 0 e 23, incluso, che rappresenta l'ora del giorno.
Hour(Orario)
L'argomento Orario richiesto è qualsiasi Variant, numero, stringa di caratteri o qualsiasi
combinazione che può rappresentare un orario. Come nella funzione precedente se Orario
contiene Null viene restituito Null.
Dim Orario As DateTime

Dim Ora As Integer
81
Orario = #6:45:17 PM# 'in questo formato va specificato AM/PM
Orario = "18:43"
Ora = Hour(Orario) 'Estrae la sola ora del giorno

MsgBox(Ora, vbOKOnly, "Messaggio")
Minute
Restituisce un Integer compreso fra 0 and 59 che rappresenta i minuti di un orario.
Minute(Orario)
Per quanto riguarda l’argomento da passare alla funzione vale quanto detto per le funzioni
Day e Hour.
Dim Orario As DateTime

Dim Minuti As Integer
Orario = #6:43:17 PM# 'Esempio 1

Orario = "18:43" 'Esempio 2
Minuti = Minute(Orario)
MsgBox(Minuti, vbOKOnly, "Messaggio")
Month
Restituisce un valore Integer compreso tra 1 e 12 che rappresenta il mese dell'anno.
Month(date)
L’argomento da passare alla funzione è qualsiasi numero o stringa di caratteri o qualsiasi

combinazione che può rappresentare una data.
Dim Data1 As String

Dim Mese As Integer
Data1 = #4/14/2019# 'Esempio 1

Data1 = "14 Aprile 2019" 'Esempio 2
Data1 = "14/04/2019" 'Esempio 2
Mese = Month(Data1)
MsgBox(Mese, vbOKOnly, "Messaggio")
MonthName
Restituisce una stringa di caratteri che rappresenta il nome del mese specificato come ar-
gomento.
MonthName(Mese, [Abbreviazione])
Mese: Obbligatorio. Un numero da 1 a 12 che rappresenta un mese.
Abbreviazione: Facoltativo. Valore booleano che indica se il nome del mese deve essere
abbreviato. Se omesso, il valore predefinito è False, ovvero il nome del mese non è abbre-
viato.
82
Dim Data1 As String

Dim Mese As String
Data1 = #4/14/2019#
Data1 = "14 Aprile 2019"
Data1 = "14/04/2019"
Mese = MonthName(Month(Data1), True) & vbLf ' abbreviato

Mese = Mese & MonthName(Month(Data1), False) ' non abbreviato
MsgBox(Mese, vbOKOnly, "Messaggio")
Now
Restituisce una oggetto DateTime che specifica la data e l'ora correnti in base alla data e
all'ora del vostro computer. Questo esempio di codice mostra l’ora corrente formattata in
quattro differenti modi.
Dim Adesso As String
Adesso = Now & vbLf

Adesso = Adesso & Format(Now, "dd/MM/yyyy") & vbLf
Adesso = Adesso & Format(Now, "hh:mm") & vbLf
Adesso = Adesso & Format(Now, "HH:mm") & vbLf
MsgBox(Adesso, vbOKOnly, "Messaggio")
Second
Restituisce un valore Variant (intero) che specifica un numero intero compreso tra 0 e 59,
che rappresenta i secondi del valore passato come argomento.
Second(tempo)
L'argomento è qualsiasi espressione numerica, espressione di stringa o qualsiasi combina-
zione che può rappresentare un tempo.
Dim Secondi As Integer

Secondi = Second(Now)
MsgBox(Secondi, vbOKOnly, "Messaggio")
TimeSerial
Restituisce un valore tipo Date che contiene un Orario specificando l’ora, i minuti ed i se-
condi.
TimeSerial(Ora, Minuti, Secondi)
Obbligatorio; Variant (Integer). Un numero compreso fra 0 (12:00 A.M.) and
Ora
23 (11:00 P.M.).
Minuti Obbligatorio; Variant (Integer). Qualsiasi espressione numerica.
Secondi Obbligatorio; Variant (Integer). Qualsiasi espressione numerica.
Per specificare un orario, ad esempio 11:59:59, l'intervallo di numeri per ciascun argomento
TimeSerial deve essere compreso nell'intervallo normale per l'unità; ovvero, 0-23 per ore
83
e 0-59 per minuti e secondi. È possibile inoltre specificare i tempi relativi per ciascun argo-
mento utilizzando qualsiasi espressione numerica che rappresenti un numero di ore, minuti
o secondi prima o dopo un determinato intervallo di tempo.
Nell'esempio seguente vengono utilizzate espressioni anziché numeri di tempo assoluti. La
funzione TimeSerial restituisce un orario per 15 minuti prima (-15) sei sette prima di mez-
zogiorno (12 - 7) o 4:45:00 A.M
TimeSerial(12 - 7, -15, 0)
Quando uno degli argomenti supera l'intervallo normale per quell'argomento, viene incre-
mentata l’unità successiva. Ad esempio, 75 minuti, viene valutato come un'ora e 15 minuti.
Se un singolo argomento non rientra nell'intervallo da -32.768 a 32.767, si verifica un
errore. Se il tempo specificato dai tre argomenti fa sì che la data non rientri nell'intervallo
accettabile di date, si verifica un errore.
Dim Orario As String

Dim Ora, Minuti, Secondi As Integer
Ora = 17
Minuti = 45
Secondi = 16
Orario = TimeSerial(Ora, Minuti, Secondi)
MsgBox(Orario, vbOKOnly, "Messaggio")
Weekday
Restituisce un Integer contenente un numero che rappresenta il giorno della settimana.
Weekday(Data, Primogiornodellasettimana)
Parametro obbligatorio: Variant, espressione numerica, Stringa
Data o qualsiasi combinazione che possa rappresentare una data va-
lida.
Parametro facoltativo: una costante che specifica quale deve
Primogiornodellasettimana essere il primo giorno della settimana. Se non è specificato
per convenzione viene impostata domenica.
L’argomento facoltativo Primogiornodellasettimana può avere se le seguenti impostazioni:

Dim Giorno As Integer

Giorno = Weekday(Now)
MsgBox(Giorno, vbOKOnly, "Messaggio")
WeekdayName
Restituisce una Stringa di caratteri che rappresenta il nome del giorno della settimana del
numero del giorno della settimana passato come argomento.
WeekdayName(GiornodellaSettimana, Abbreviato, Primogiornodellasettimana)
84
Obbligatorio. Un numero che rappresenta il giorno della set-
GiornodellaSettimana timana. Il risultato dipende dalle impostazioni dell’argomento
Primogiornodellasettimana.
Facoltativo. Valore tipo Boolean (True o False) che indica se
il nome del giorno della settimana deve essere restituito ab-
Abbreviato
breviato oppure no. Se viene omesso il giorno della settimana
viene restituito non abbreviato.
Facoltativo. Un valore numerico che rappresenta il primo giorno
primogiornodellasettimana
della settimana. Consultate la tabella successiva.
primogiornodellasettimana può assumere i seguenti valori:

FirstDayOfWeek.Sunday 1 Domenica
Dim Giorno As String
'per estrapolare il giorno della settimana utilizza

anche la funzione Weekday insieme a WeekdayName.
Giorno = WeekdayName(Weekday(Now), False, FirstDayOfWeek.Sunday)
MsgBox(Giorno, vbOKOnly, "Messaggio")
Year
Restituisce un valore Integer contenente un numero intero che rappresenta l'anno.
Year(data)
L'argomento data richiesto è qualsiasi Variant, espressione numerica, stringa o qualsiasi

combinazione, che può rappresentare una data. Se la data contiene Null la funzione resti-
tuisce Null.
Dim Anno As Integer

Anno = Year(Now)
MsgBox("Anno corrente: " & Anno, vbOKOnly, "Messaggio")
Altre funzioni
Può accadere che sia necessario verificare la validità di dati immessi dall’utente attraverso
la tastiera, per impedire che il programma restituisca un errore, oppure sincerarsi che il
risultato di un’operazione matematica rientri in una specifica tipologia di dati. Per questo
Visual Basic mette a disposizione del programmatore tutta una serie di funzione dette di
Ispezione.
85
IsDate
Questa funzione restituisce il valore True (Vero) se l'espressione passata come argomento
è una data o è riconoscibile come una data o un'ora valida, altrimenti restituisce False
(Falso).
IsDate(espressione)
L'argomento di espressione obbligatorio è un valore contenente un'espressione stringa ri-
conoscibile come data o ora. L'intervallo di date valide è il 1° gennaio dell’anno 1, fino al
31 dicembre 9999. È possibile passare come argomento una data in uno dei modi mostrati
nel codice sottostante.
Dim Data As Date, Verifica As Boolean
Data = "05/30/2018"
Verifica = IsDate(Data) 'Restituisce VERO
Data = "30/05/2018"
Data = "Maggio 30, 2018"

Data = "11/36/2018"
Verifica = IsDate(Data) 'Restituisce FALSO
Data = "05.30.18"
Data = "05.30.2018"
Verifica = IsDate(Data) 'Restituisce FALSO
Data = #5/30/2018#
Verifica = IsDate(Data) 'Restituisce Vero
MsgBox Verifica
Esempio di codice per il controllo dell’immissione da parte dell’utente:
Dim DataInserita As String

DataInserita = InputBox("Inserisci una data", "Messaggio")
If IsDate(DataInserita) = True Then
MsgBox("La data è corretta", vbOKOnly + vbExclamation, "Messaggio")

Else
MsgBox("La data è errata", vbOKOnly + vbExclamation, "Messaggio")
End If
IsEmpty
Restituisce un valore booleano (Vero o Falso) che indica se una variabile è stata inizializzata
oppure è vuota.
IsEmpty(espressione)
L'argomento di espressione richiesto può essere un'espressione numerica o di stringa. Dato
che IsEmpty viene utilizzato per determinare se le singole variabili sono inizializzate, ovvero
86
che gli sia stato già assegnato un valore, l'argomento espressione è solitamente il nome
della variabile.
Dim Variabile As String, Verifica As Boolean

Verifica = IsEmpty(Variabile) ' Vero.
Variabile = Null
Verifica = IsEmpty(Variabile) ' Falso.
Variabile = Empty
Verifica = IsEmpty(Variabile) ' Vero.
Variabile = 50
Verifica = IsEmpty(Variabile) ' Falso
MsgBox Verifica
IsNumeric
Restituisce un valore booleano (Vero o Falso) che indica se un'espressione può essere con-
siderata come un tipo di dato numerico.
IsNumeric(espressione)
L'argomento di espressione richiesto è qualcosa che contiene un'espressione numerica o
una stringa. La funzione restituisce Vero (True) solo se l’intera espressione viene ricono-
sciuta come un numero, altrimenti restituisce False. Se come argomento viene passata
un’espressione che rappresenta una data, la funzione restituisce Falso (False).
Dim Variabile As String, Verifica As Boolean
Variabile = "64"
Verifica = IsNumeric(Variabile) 'Vero
Variabile = "Prova 5478"

Verifica = IsNumeric(Variabile) ' Falso
Variabile = "384.251"
Verifica = IsNumeric(Variabile) ' Vero
MsgBox Verifica
Esempio di codice:
Dim NumeroInserito As String
NumeroInserito = InputBox("Inserisci un numero", "Messaggio")
If IsNumeric(NumeroInserito) = True Then
MsgBox("E' un numero valido", vbOKOnly + vbExclamation, "Messaggio")
Else
MsgBox("Non è un numero", vbOKOnly + vbExclamation, "Messaggio")
End If
87
IsNull
Restituisce un valore booleano che indica se un'espressione non contiene dati validi (Null).
IsNull(espressione)
L'argomento di espressione richiesto è qualcosa che contiene un'espressione numerica o
un'espressione di stringa. Viene restituito True (Vero) se l’espressione passata come argo-
mento è Null; in caso contrario restituisce False. Se l’espressione è costituita da più di una
variabile, Null in qualsiasi variabile che fa parte dell’espressione fa sì che True vengo resti-
tuito per l'intera espressione.
Il valore Null indica che la variabile non contiene dati validi. Null non è uguale a Empty, che
indica che una variabile non è stata ancora inizializzata.
Non è uguale a una stringa di lunghezza zero ("") che a volte viene definita stringa nulla.
Funzioni di conversione di tipo.

Asc
Questa funzione restituisce un valore tipo Integer che rappresenta il valore ASCII del primo
carattere della stringa passata come argomento della funzione.
Asc(Stringa)
Dim Stringa As String, Valore As Integer
Stringa = InputBox("Inserisci un carattere dalla tastiera", "Messaggio")
Valore = Asc(Stringa)
MsgBox("Il Valore ASCII del carattere è: " & Valore,

vbOKOnly + vbExclamation, "Messaggio")
CBool
Questo esempio utilizza la funzione CBool per convertire un'espressione in valore tipo boo-
leano. Ad esempio, viene verificato le due variabili A e B sono uguali.
Nell’ultimo esempio se l'espressione restituisce un valore diverso da zero, CBool restituisce
Vero, altrimenti restituisce Falso.
L’argomento può essere qualsiasi stringa o valore numerico.
Dim A As Integer, B As Integer, Verifica As Boolean
A = 25 : B = 25
Verifica = CBool(A = B) 'Restituisce True
MsgBox(Verifica, vbOKOnly, "Messaggio")
A = 24 : B = 25
Verifica = CBool(A = B) 'Restituisce False
A = 0 : B = 25
Verifica = CBool(A) 'Restituisce False
CByte
Converte l'espressione passata come argomento in un byte. Restituisce valori compresi fra
0 e 255.
88
Dim Numero As Double, Valore As Byte
Numero = InputBox("Inserisci un Numero 0-255", "Numero")

Valore = CByte(Numero) 'Esempio Numero = 216.5214 Restituisce 217
MsgBox(Valore, vbOKOnly, "Messaggio")
CDate
Questo esempio utilizza la funzione CDate per convertire una stringa in una data. In gene-
rale, non è consigliato passare le date e le ore come stringhe (come mostrato in questo
esempio).
Meglio utilizzare il formato letterale, ad esempio # 3/15/1982 # e # 7:44:32 PM #
Dim Data1 As String, DataBreve As Date, Ora As String, OraBreve As Date,

Messaggio As String
Data1 = "15 Marzo 1982"

DataBreve = CDate(Data1)
Ora = "7:44:32 PM"

OraBreve = CDate(Ora)
Messaggio = "Data = " & Data1 & " " & "Data Breve = " & DataBreve & vbLf &
"Ora = " & Ora & " OraBreve = " & OraBreve
CDbl
questa funzione converte un'espressione in un numero tipo Double.
Dim NumeroDecimale As Decimal, Numero As Double
NumeroDecimale = "325,2145"
Numero = CDbl(NumeroDecimale * 5.21 * 0.6) 'esempio di calcolo con coversione a Double
MsgBox("Numero decimale = " & NumeroDecimale & " - Numero " & Numero,
vbOKOnly, "risultato")
CDec
Trasforma un numero in formato valuta in un numero in formato decimale. Per maggiori
informazioni consultate il capitolo che tratta dei tipi di dati in Visual Basic.
Dim Decimale As Decimal, Valuta As Double
Valuta = 1254.52478
Decimale = CDec(Valuta)
MsgBox("Valuta = " & Valuta & " Decimale = " & Decimale, vbOKOnly, "Messaggio")
Chr
Restituisce una stringa contenente il carattere associato al codice carattere specificato.
Chr(codicecarattere)
89
I numeri da 0 a 31 sono uguali ai codici ASCII standard non stampabili. Ad esempio, Chr
(10) restituisce un carattere di avanzamento riga. L'intervallo normale per codicecarattere
è 0-255. Tuttavia, nei sistemi DBCS, l'intervallo effettivo per codicecarattere è -32768-
65535.
Dim Carattere As String, j As Integer, Messaggio As String
For j = 65 To 92
Carattere = Chr(j)
Messaggio = Messaggio & "Valore = " & j & " " & "Carattere = " & Carattere & vbLf
Next
CInt
Questo esempio utilizza la funzione CInt per convertire un numero a precisone doppia in
un intero. La parte intera viene arrotondata per eccesso.
Dim Numero As Double, Intero As Integer
Numero = 3487.5459
Intero = CInt(Numero)
MsgBox("Numero = " & Numero & " Parte Intera = " & Intero,
vbOKOnly, "Messaggio")
CLng
La funzione CLng trasforma un numero a precisione doppia in un intero lungo.
Dim Valore1 As Double, Valore2 As Double, InteroLungo1 As Long, InteroLungo2 As Long

Dim Messaggio As String
Valore1 = 65125.45 : Valore2 = 14756.55

InteroLungo1 = CLng(Valore1)
InteroLungo2 = CLng(Valore2)
Messaggio = "Valore1 = " & Valore1 & " " & "Intero 1 = " & InteroLungo1 & vbLf &
"Valore2 = " & Valore2 & " " & "Intero 2 = " & InteroLungo2
CSng
Converte un numero a precisione doppia in uno a precisione singola.
Dim Valore1 As Double, Valore2 As Double, Singolo1 As Single, Singolo2 As Single

Valore1 = 125.5678912541 : Valore2 = 35.5412896547

Singolo1 = CSng(Valore1)
Singolo2 = CSng(Valore2)
90
Messaggio = "Valore1 = " & Valore1 & " " & "Singolo 1 = " & Singolo1 & vbLf &
"Valore2 = " & Valore2 & " " & "Singolo 2 = " & Singolo2
CStr
Converte un valore numerico in una stringa di caratteri.
CStr(Numero)
Dim Numero As Double, Stringa As String
Numero = 1854.3254
Stringa = CStr(Numero) ' la stringa contiene "1854.3254".
MsgBox(Stringa, vbOKOnly, "Messaggio")
FormatCurrency
Restituisce un'espressione formattata come Stringa utilizzando il simbolo di valuta definito
nel pannello di controllo del computer. Sintassi del comando:
FormatCurrency(Espressione, NumeroCifreDecimali, InclusoLaPrimaCifra, UsaParentesi-

PerNumeriNegativi, RaggruppaCifre)
Espressione Obbligatorio. L’espressione da formattare.
Facoltativo. Valore numerico che indica il numero di cifre
NumeroCifreDecimali decimali visualizzate. Il valore predefinito è -1, che in-
dica che vengono utilizzate le impostazioni del computer.
Facoltativo. Costante che indica se uno zero iniziale viene
InclusoLaPrimaCifra visualizzato o meno per i valori frazionari. Vedi la ta-
bella successiva.
Facoltativo. Costante che indica se posizionare o meno va-
UsaParentesiPerNumeriNegativi
lori negativi tra parentesi. Vedi la tabella successiva.
Facoltativo. Costante che indica se i numeri sono raggrup-
pati utilizzando il delimitatore di gruppo specificato
RaggruppaCifre
nelle impostazioni internazionali del computer. Vedi ta-
bella successiva
Gli argomenti InclusoLaPrimaCifra, UsaParentesiPerNumeriNegativi, e RaggruppaCifre pos-

sono assumere i seguenti valori:
Costante Valore Descrizione

True -1 Vero
False 0 Falso
Utilizza le impostazioni regionali del computer
UseDefault -2
presenti nel pannello di controllo
Dim Valore As String

Dim Importo As Double
Importo = -12345.647854595
Valore = FormatCurrency(Importo, 3, TriState.True, TriState.True, TriState.True)

MsgBox(Valore, vbOKOnly, "Messaggio")
91
FormatDateTime
Restituisce un’espressione formattata come data o come orario.
FormatDateTime(Data, Formato)
Data Obbligatorio. Una data da formattare.
Facoltativo. Valore numerico che indica il formato di data / ora
Formato
utilizzato. Se omesso, viene utilizzato vbGeneralDate.
L’argomento Formato può avere le seguenti impostazioni:

Mostra una data e / o un orario. Se è presente una parte di
data, visualizzarla come una data breve. Se c'è una parte del
vbGeneralDate 0
tempo, visualizzala per un lungo periodo. Se presente, vengono
visualizzate entrambe le parti.
Visualizza una data utilizzando il formato di data estesa spe-
vbLongDate 1
cificato nelle impostazioni internazionali del computer.
Visualizza una data utilizzando il formato di data breve spe-
vbShortDate 2
cificato nelle impostazioni internazionali del tuo computer.
Visualizza un'ora utilizzando il formato dell'ora specificato
vbLongTime 3
nelle impostazioni internazionali del tuo computer.
Visualizza un orario utilizzando il formato di 24 ore (hh:
vbShortTime 4
mm).
L’esempio sottostante mostra l’utilizzo della funzione FormatDateTime, visualizzando sullo

schermo diversi tipi di formato della data attuale.
Dim Data1, Formato1, Formato2, Formato3, Formato4 As String

Data1 = Now
Formato1 = FormatDateTime(Data1, vbLongDate)

Formato2 = FormatDateTime(Data1, vbShortDate)
Formato3 = FormatDateTime(Data1, vbLongTime)
Formato4 = FormatDateTime(Data1, vbShortTime)
Messaggio = Formato1 & vbLf & Formato2 & vbLf & Formato3 & vbLf & Formato4
FormatNumber
Restituisce un’espressione formattata come numero.
FormatNumber(Espressione, NumeroCifreDecimali, InclusoLaPrimaCifra, UsaParentesi-

Facoltativo. Valore numerico che indica il numero di cifre
NumeroCifreDecimali decimali visualizzate. Il valore predefinito è -1, che in-
dica che vengono utilizzate le impostazioni del computer.
Facoltativo. Costante che indica se uno zero iniziale viene
InclusoLaPrimaCifra visualizzato o meno per i valori frazionari. Vedi la ta-
bella successiva.
Facoltativo. Costante che indica se posizionare o meno va-
UsaParentesiPerNumeriNegativi
lori negativi tra parentesi. Vedi la tabella successiva.
92
Facoltativo. Costante che indica se i numeri sono raggrup-
pati utilizzando il delimitatore di gruppo specificato
RaggruppaCifre
nelle impostazioni internazionali del computer. Vedi ta-
bella successiva


True -1 Vero
False 0 Falso
Utilizza le impostazioni regionali del com-
UseDefault -2
puter presenti nel pannello di controllo
Dim Valore As Double, Messaggio As String
Valore = -15241.3256
Messaggio = FormatNumber(Valore, 3) & vbLf 'esempio1

Messaggio = Messaggio & FormatNumber(Valore, 3, TriState.True, 'esempio2
TriState.True, TriState.True) 'esempio2
FormatPercent
Restituisce un'espressione formattata come percentuale (moltiplicata per 100) con un ca-
rattere % finale.
FormatPercent(Espressione, NumeroCifreDecimali, InclusoLaPrimaCifra, UsaParentesi-

Facoltativo. Valore numerico che indica il numero di
cifre decimali visualizzate. Il valore predefinito è -
NumeroCifreDecimali
1, che indica che vengono utilizzate le impostazioni
del computer.
Facoltativo. Costante che indica se uno zero iniziale
InclusoLaPrimaCifra viene visualizzato o meno per i valori frazionari. Vedi
la tabella successiva.
Facoltativo. Costante che indica se posizionare o meno
UsaParentesiPerNumeriNegativi valori negativi tra parentesi. Vedi la tabella succes-
siva.
Facoltativo. Costante che indica se i numeri sono rag-
gruppati utilizzando il delimitatore di gruppo specifi-
RaggruppaCifre
cato nelle impostazioni internazionali del computer.
Vedi tabella successiva


True -1 Vero
False 0 Falso
Utilizza le impostazioni regionali del com-
UseDefault -2
puter presenti nel pannello di controllo
93
Dim Valore As Double, Messaggio As String
Valore = -0.41
Messaggio = FormatPercent(Valore, 2) & vbLf 'esempio1

Messaggio = Messaggio & FormatPercent(Valore, 3, TriState.True, 'esempio2
TriState.True, TriState.True) 'esempio2
Hex
Restituisce una stringa che rappresenta il valore esadecimale di un numero.
Hex(numero)
L'argomento richiesto è qualsiasi espressione numerica valida o stringa. Se il numero non
è un numero intero, viene arrotondato al numero intero più vicino.
Argomento Risultato
-2,147,483,648 to 2,147,483,647 Fino a otto caratteri esadecimali
NULL Null
VUOTO Zero (0)
Per l’operazione inversa, fate precedere ad un valore esadecimale &H. Ad esempio, Hex
(255) restituisce la stringa FF e &HFF restituisce il numero 255.
Dim Esadecimale, Messaggio As String, Numero As Integer
For J = 1 To 10
Numero = Int(Rnd() * 1000) ' Genera un numero casuale da 0 a 1000

Esadecimale = Hex(Numero) ' Lo trasforma in esadecimale
Messaggio = Messaggio & "Numero = " & Numero & " Valore esadecimale = " &
Esadecimale & vbLf
Next J
Passaggio inverso ovvero da esadecimale a decimale:
Dim Decimale, Messaggio, Esadecimale As String
For J = 1 To 10
'Genera un numero casuale in esadecimale

Esadecimale = Hex(Int(Rnd() * 1000))
Decimale = Convert.ToInt32(Esadecimale, 16) 'Lo trasforma in decimale
Messaggio = Messaggio & "Valore Esadecimale = " & Esadecimale &

" Valore Decimale = " & Decimale & vbLf
Next J

94
Val
Restituisce i numeri contenuti in una stringa di caratteri come valore numerico.
Val(stringa)
La funzione Val smette di leggere la stringa al momento in cui trova il primo carattere che
non riconosce come parte di un numero. I caratteri che sono spesso considerati parti di
valori numerici, come i simboli di valuta e le virgole non vengono riconosciuti.
La funzione Val riconosce i prefissi O (per ottale) e &H (per esadecimale). Tabulazioni,
Spazi vuoti e caratteri di accapo vengono rimossi dall'argomento.
La funzione Val riconosce solo il punto (.) Come separatore decimale valido. Quando ven-
gono utilizzati separatori decimali diversi, come nelle applicazioni internazionali, utilizzare
invece la funzione CDbl per convertire una stringa in un numero.
Dim Messaggio As String, Numero As String
Numero = Val("325.69") ' Risultato = 325,69
Messaggio = Numero & Space(5) & "325.69" & vbLf
Numero = Val("32569") ' Risultato = 32569

Messaggio = Messaggio & Numero & Space(5) & "32569" & vbLf
Numero = Val("32 56 9") ' Risultato = 32569

Messaggio = Messaggio & Numero & Space(5) & "32 56 9" & vbLf
Numero = Val("785 aiuto!! 32") ' Risultato = 785

Messaggio = Messaggio & Numero & Space(5) & "785 aiuto!! 32" & vbLf
Numero = Val(" 23652 541fcvgtydfbh") 'Risultato 23652541

Messaggio = Messaggio & Numero & Space(5) & " 23652 541fcvgtydfbh" & vbLf
Riepilogo operazioni su data e ora.

Come mostra il codice seguente inserisce nella variabile Ora (ma potevate dargli anche un
altro nome) la data odierna completa di tutto. Attenzione perché le date vengono presentate
in formato americano ovvero mese/giorno/anno invece che con il nostro formato
(giorno/mese/anno)
Dim Ora As Date = Now()
Dim Anno As Integer = Year(Now) Inserisce nella variabile Anno l’anno corrente. Ri-
cordate che la funzione Now prende i dati dall’oro-
logio del computer.
Dim Orario As String Formato orario a 12 ore
Orario = Format(Now, "hh:mm")
Orario = Format(Now, "HH:mm") Formato orario a 24 ore
Orario = Format(Now, "HH:mm:ss") Include anche i secondi
Inoltre alcuni esempi:
Dim DataOdierna As String = Format(Now, "dd/MM/yyyy") 'formato Italiano della data
Dim Giorno As String = Format(Now, "dd") 'viene recuperato il numero del giorno
95
Dim Mese As String = Format(Now, "MMMM") 'viene visualizzato il nome del mese
Dim Mese As String = Format(Now, "MM") 'viene visualizzato il numero del mese
Dim DataCompleta As String = Format(Now, "dddd dd/MM/yyyy") 'viene visualizzata la data e il

giorno della settimana.
Riepilogo operazioni sulle stringhe

Una variabile definita come stringa di caratteri può contenere qualsiasi carattere presente
sulla tastiera e oltre e viene considerata come testo.
Concatenazione di stringhe
Come se sommassi i testi contenuti nelle stringhe. Ad esempio:
Dim a as String = “Pippo” ‘assegnazione

Dim b as String = “Ciao”
Dim c as String = b & a ‘concatenzazione
La concatenazione di due o più stringhe si ottiene attraverso il segno & (e commerciale).
Mid Restituisce la parte di una stringa a partire da un certo numero di caratteri
Ad esempio:
Stringa = Mid(Stringa, 5, 8)
Restituisce i caratteri di una stringa a partire dal quinto e prendendone altri
otto.
Val Converte una stringa in un numero ammesso che contenga qualcosa che possa essere
interpretata come numero. Ricordate che il separatore dei decimali è un punto e
non un virgola.
Dim a as Double
Dim Stringa as String
a = Val(Stringa)
Len Indica quanti caratteri è lunga una stringa
a = Len(Stringa)
UCase Trasforma la stringa di caratteri in maiuscolo
Stringa = UCase(Stringa)
LCase Trasforma la stringa di caratteri in minuscolo
Trim Rimuove gli spazi vuoti all’inizio e alla fine di una stringa.
96
Routine
È così detto un insieme di istruzioni delimitato da una dichiarazione come nell’esempio sot-
tostante:
Private Sub Pippo
End Sub
Una routine deve avere necessariamente un nome così è possibile richiamarla in ogni mo-
mento (nel nostro esempio è stata chiamato “Pippo”. La parola chiave Private intende il
fatto che la routine può essere chiamata solo dall’interno della classe di appartenenza (an-
che la classe ha un nome in questo caso Form1) mentre Public sta ad intendere che possa
essere richiamata da qualsiasi punto dell’intero programma. Quindi quando viene chiamato
Pippo il computer esegue tutte le istruzioni che trova fra Private Sub Pippo e End Sub e poi
torna all’istruzione successiva.
Le frecce indicano il percorso che il programma segue nella sua elaborazione. In questo
modo è possibile eseguire più volte uno stesso gruppo di istruzioni senza ripeterle più volte
nel codice del programma.
Inoltre, è possibile inviare ad una routine un valore che il computer dovrà elaborare.
Le variabili TotaleGenerale e TotaleParziale sono state inserite in quel punto del programma
in modo che siano riconosciute in tutta la Classe, altrimenti sarebbero state valide solo nelle
Routine di appartenenza, ad esempio se le avessi dichiarate nella Routine Form1_Load
avrebbero avuto valore solo in quella Routine, oppure se le avessi dichiarate nella Ruotine
Pippo, non sarebbero state accessibili al di fuori di tale routine.
Quindi è molto importante in quale posizione vengono fatte le dichiarazioni.
97
Nella figura sottostante viene passata alla routine Pippo il valore della variabile Aliquota per
eseguire delle operazioni che avverranno all’interno della routine stessa. In questo caso fra
parentesi va inviato un parametro che tale routine utilizzerà per calcoli interni ad essa.
Etichette e GoTo.
Anche se poco utilizzate al giorno d’oggi, queste caratteristiche erano molto importanti nei
programmi di qualche annetto fa, in quanto permettono di passare da un punto ad un altro
di una serie di istruzioni. L’etichetta consiste nell’assegnare un nome al punto dove volete
arrivare seguito da due punti come si vede nella figura sottostante.
98
Per questo nome non potete utilizzare dei nomi riservati di Visual Basic come ad esempio
le parole chiave. I personaggi dei cartoni animati vanno benissimo.
Per far “saltare” l’esecuzione di un programma ad una specifica etichetta basta utilizzare le
parole chiave GoTo seguito del nome dell’etichetta stessa.
In questo caso, se si verifica una certa condizione (Volume >=150), allora il programma va
verso l’etichetta saltando le istruzioni che si trovano fra il salto e l’etichetta stessa.
Le funzioni
Le funzioni sono molto simili alle routine con la differenza che una funzione restituisce un
valore da impiegare in eventuali altre operazioni.
Quindi alla funzione viene inviato un valore e questa ve ne restituisce un altro dopo gli
opportuni ragionamenti del caso. Nella figura successiva è visibile un esempio di funzione.
Intanto definisco la funzione come Private se desidero che sia richiamabile solo dall’interno
della classe dove si trova, in questo caso dal Form1, mentre definisco Public se questa
funzione deve essere accessibile da tutto il programma quindi anche da altre classi.
Nel nostro esempio alla funzione vengono passati due parametri, Raggio e altezza. Questi
parametri vanno dichiarati come variabili all’interno della funzione attraverso la parola
chiave ByVal e vanno messi fra parentesi.
Ogni parametro dichiarato va separato dall’eventuale altro da una virgola.
All’esterno della parantesi va dichiarato quale tipo di valore la funzione deve restituire, in
questo caso Double ma poteva essere anche String.
Nella funzione vanno inserite tutte le istruzioni necessarie per il calcolo, e quindi al termine
o dove necessario va posta la parola chiave Return seguita dalla variabile da restituire.
Quindi le parole End Function.
99
Private Function CalcolaVolume(ByVal Raggio As Double, ByVal altezza As Double) As
Double
Volume = PI * (Raggio ^ 2) * altezza
Return Volume
End Function
Per utilizzare la funzione in un punto del programma e sufficiente richiamarla passando fra
parentesi separatati da virgole i parametri da inviare per avere la risposta.
CalcolaVolume(Raggio, Altezza)
In questo modo la variabile Volume può essere utilizzata nelle righe successive in quanto è
stata calcolata dalla funzione
Totale = Volume * PI
Oppure è anche possibile scrivere:
Totale = CalcolaVolume(Raggio, Altezza) * PI
Qualora fosse coinvolta in qualche calcolo successivo, utilizzandola come variabile parte di
un’espressione. Nella figura successiva potete vedere un esempio di utilizzo dei una fun-
zione. È chiaro che una simile tecnica è molto efficace per evitare di riscrivere diverse volte
la stessa sequenza di istruzioni quando in un programma viene richiamata da diversi punti
una stessa funzione.
100
L’ Istruzione If
In generale questa istruzione esegue determinate operazioni se si verifica una determinata
condizione altrimenti può eseguirne altre. L’esempio più semplice e quello del confronto fra
due variabili che può essere espresso come si vede nel riquadro sottostante. Il risultato in
questo caso è ovvio ma serve solo per comprende il meccanismo.
Si fa seguire alla parola If il confronto fra due variabili a e b. Qualora a risultasse maggiore
di b il computer dovrà eseguire determinate istruzioni mentre se la condizione non si veri-
ficasse, ovvero se a non risultasse maggiore di b, allora dovrà eseguirne altre.
If a > b Then
Totale = sqrt(a / b)
Else
Totale = a * b
End If
Se a è maggiore di b esegui:
Totale = sqrt(a / b)
Quindi continua l’elaborazione del programma da dopo End If. Altrimenti esegui:
Totale = a * b
E continua l’elaborazione del programma da dopo End If

La figura sottostante mostra la posizione del codice dell’esercizio.
101
In alcuni casi si omette l’istruzione Else se, non verificandosi la condizione, non c’è necessità
di eseguire altre istruzioni ma di continuare l’esecuzione del programma da dopo End If.
Qualora si verificasse la condizione ma dovesse essere eseguita una sola istruzione il blocco
If diverrebbe semplicemente:
If a > b Then Totale = Sqrt(a / b)
In questo caso il programma riprende dall’istruzione successiva all’istruzione If.

Gli operatori di confronto utilizzabili sono riassunti nella tabella sottostante.
Operatore di Confronto Sintassi

Uguale a =
Maggiore di >
Minore di <
Diverso da <>
Maggiore o uguale >=
Minore o uguale <=
If, Then ed Else annidati.

Supponiamo che in un determinato punto di un programma il computer deve prendere una
decisione a seconda di un valore di una variabile ad esempio:
- se questa variabile è maggiore di 1000 esegui un determinato gruppo di istruzioni
- se questa variabile è minore di 1000 esegui un altro gruppo di istruzioni
e fin qui nulla di nuovo questo problema può essere risolto semplicemente utilizzando
l’esempio precedente.
If a > 1000 Then
Totale = Sqrt(a / b)
Else
Totale = a * b
End If
Ma se invece il programma deve eseguire un gruppo di istruzioni se il valore è maggiore di

2000 e altre se è fra 1500 e 2000 allora tutto si complica.
Una soluzione potrebbe essere questa:
If a >= 2000 Then
Else
' Istruzioni da eseguire se a < 2000
If a >= 1500 Then
'istruzioni da eseguire se a è compreso fra 1500 e 2000
Totale = (a ^ 2) * b
102
Else
'istruzioni da eseguire se a < 1500
Totale = (a * b) / (a - b)
End If
End If
Ricordate il testo in verde indica le note inserite dal programmatore. Abituatevi a utilizzarle
perché potrebbero essere di fondamentale importanza, quando ad esempio, dopo del tempo
andate ad analizzare un programma e non vi ricordate che soluzione avevate adottato per
un determinato problema. Se invece dovete eseguire diversi gruppi di istruzioni se ad esem-
pio se la variabile supera i 2000 oppure fra 1500 e 2000 e anche fra 1000 e 1500 e magari
se è minore di 1000 allora gli annidamenti diventano tre.
If a >= 2000 Then
Else
'istruzioni da eseguire se a <2000
If a >= 1500 Then
'istruzioni da eseguire se a >=1500 ma minore di 2000

Totale = a * b
Else
'istruzioni da eseguire se a < 1500
If a >= 1000 Then
' Istruzioni da seguire se a >= a 1000 ma minore di 1500

Totale = (a ^ 2) * b
Else
'Istruzioni da eseguire se a < 1000
Totale = (a * b) / (a - b)
End If
End If
End If
Ovviamente si tratta solo di un esempio per capire come si annidano i blocchi If, Then, Else.
AND e OR
Queste parole chiave del linguaggio Visual Basic servono se inserite in un blocco If se una
o più condizioni sono vere nello stesso momento oppure no.
Se utilizzo la parola AND due o più condizioni devono risultare entrambe vere altrimenti il
computer salta il blocco di istruzioni che si trovano tra If e End If e prosegue oltre oppure
va al blocco Else.
Ad esempio:
103
If a > 1000 And b < 700 Then
'inserisco qui il codice che devo eseguire se si verificano entrambe le condizioni
Else
'inserisco qui il codice che devo eseguire se non si verifica una o nessuna
delle condizioni
Totale = (a * b) / (a - b)
End If
In questo caso devono verificarsi entrambe le condizioni, ovvero a deve risultare maggiore
di 1000 e b deve risultare minore di 700. Allora il computer eseguirà le istruzioni che si
trovano subito sotto e poi al termine proseguirà dopo le parole End If.
Se una delle due condizioni o entrambe non si verificano allora il computer eseguirà il codice
che troverà sotto il blocco Else e alla fine andrà dopo le parole End If.
Nel caso della parola chiave OR invece basta che si verifica una delle condizioni o entrambe
per eseguire il codice che si trova sotto l’istruzione If.
If a > 1000 Or b < 700 Then

'inserisco qui il codice da eseguire se si verifica una o entrambe le
condizioni
Else
'inserisco il codice che devo eseguire se non si verifica nessuna delle due
condizioni
Totale = (a * b) / (a - b)
End If
Le istruzioni AND e OR possono essere utilizzate anche in confronti multipli ad esempio
If a > 1000 Or b < 700 Or Totale > 1500 Then

'inserisco qui il codice da eseguire se si verifica una, due o tutte le condizioni
Else
'inserisco qui il codice che devo eseguire se non si verifica nessuna condizione
Totale = (a * b) / (a - b)
End If
Un altro esempio può essere l’utilizzo contemporaneo di AND e OR purché sia abbia bene
in mente quello che si vuole realizzare, utilizzando all’occorrenza le parentesi per separare
le istruzioni, onde evitare di avere dei risultati che non coincidono con ciò che vi eravate
proposto.
Nell’esempio successivo le parentesi sono state utilizzate in modo che, per passare l’espres-
sione come vera (come in gergo dicono i programmatori) è necessario innanzitutto che si
verifichi che a sia > di 1000 e che si verifichi anche una sola delle altre due.
104
If a > 1000 And (b < 700 Or Totale > 1500) Then

'inserisco qui il codice da eseguire se si verifica una o entrambe le
condizioni
Else
'inserisco il codice che devo eseguire se non si verifica nessuna condizione
Totale = (a * b) / (a - b)
End If
Quindi attenzione a come utilizzate le parentesi perché il risultato può cambiare anche
molto.
Consultate il capitolo che tratta degli errori in Visual Basic in modo da stop-
pare il programma in fase di esecuzione dove volete per poi verificare in
tempo reale il valore assunto dalle variabili e che “strada” prende il pro-
gramma in modo che non ci siano dubbi sul suo funzionamento.
L’istruzione If inoltre può assumere anche questa forma.
Dim StringadiTesto As String = "1250"

Dim a As Double
If IsNumeric(StringadiTesto) = True Then
'è stato riconosciuto come valore numerico

a = Val(StringadiTesto)
Else
'non è stato riconosciuto come valore numerico
End If
In questo caso valuta se il contenuto di una stringa di testo può essere considerato un
numero oppure no. Se la risposta è affermativa inserisce il contenuto della stringa in una
variabile numerica. Ricordate solo che nei linguaggi di programmazione il punto (.) è in
realtà il separatore dei decimali e non la virgola come siamo abituati di solito a fare.
Ciclo FOR … NEXT

Sicuramente il più utilizzato fra tutte le strutture di controllo questo ciclo ripete una se-
quenza di istruzioni finché non si verifica una determinata condizione.
Un semplice ciclo For …Next è visibile nell’esempio successivo. Viene utilizzata una varia-
bile (j) utilizzata come contatore per eseguire tutte le istruzioni che si trovano fra For e
Next fino a che questa incrementandosi uno alla volta non arriva ad esempio ad un valore
che nel nostro caso è 50 ma poteva essere a sua volta una variabile.
Dim Totale As Double = 0

Dim a As Double = 0
105
Dim j As Integer
For j = 1 To 50
'esegue tutte le istruzioni che trova fra For e Next fino a quando il valore
di j partendo da 1 e incrementandosi di 1 arriva a 50.
Totale = Totale + a
a = a + 5
Next
Un altro esempio è quello che vedete nel riquadro successivo. In questo caso avanza a passi
di 5 invece che di uno.
Dim Totale As Double = 0

Dim a As Double = 0
Dim j As Integer
For j = 1 To 50 Step 5
'esegue tutte le istruzioni che trova fra For e Next fino a quando il
valore di j partendo da 1 e incrementandosi di 1 arriva a 50.
Totale = Totale + a
a = a + 5
Next
Se per qualsiasi motivo è necessario uscire anticipatamente da un ciclo For

…Next perché nel frattempo si è verificata un’altra condizione strategica uti-
lizzate la parola chiave Exit For.
Anche i cicli For …Next possono essere nidificati, ma si tratta solo di un esempio nel riquadro
successivo.
Dim totale As Double = 0

Dim a As Double = 0
Dim j As Integer
Dim k As Integer
For j = 1 To 50
a = a + 3
For k = 1 To 20
totale = totale + a
106
a = a + 5
Next k
Next j
Io sono alla vecchia maniera e accanto a ogni Next metto sempre in nome della variabile
che sto incrementando per evitare di perdermi nei meandri delle nidificazioni.
In parole povere il programma entra nel ciclo (j) e ripete 20 volte il ciclo (k). Quindi ogni
volta che ripete un ciclo (j) ripete 20 volte il ciclo (k) fino a quando non ha ripetuto il ciclo
(j) 50 volte.
DO … Loop
Questo ciclo viene ripetuto fino a che non si verifica una condizione che può essere posta
prima o dopo il ciclo, quindi nel secondo caso il ciclo viene eseguito almeno una volta.
Un esempio è riportato nel riquadro sottostante. Il programma entra nel ciclo Do ed esegue
le istruzioni finché non trova le parole chiave Loop Until seguite da una condizione. Fino a
che questa condizione non di verifica continua imperterrito a eseguire le istruzioni che trova
sotto la parola chiave Do. Quando j > 10 è verificata salta all’istruzione seguente uscendo
dal Loop.

Dim j As Integer = 0
Do
j = j + 1
totale = totale + 5
Loop Until j > 10
Un altro esempio è riportato nel riquadro successivo. Il ciclo Do viene ripetuto fin quando
la variabile (j) risulta minore o uguale a 10 altrimenti, quando questo non si verifica più
perché il valore è maggiore di 10 esce dal Loop ed esegue un eventuale istruzione succes-
siva.

Do While j <= 10
j = j + 1
totale = totale + 5
Loop
Consultate il capitolo che tratta degli errori in Visual Basic inserendo quelli
che si chiamano punti d’interruzione nel programma in modo da visualizzare
i valori assunti dalle variabili nelle varie fasi del Loop. Con questo strumento
potete avanzare passo per passo e vedere come si comporta il programma.
Per maggiori informazioni consultate il capitolo che tratta degli errori in Visual
Basic.
107
DO While …loop
Questa istruzione ripete un ciclo fino a quando una condizione resta Vera (True). Nel caso
dell’esempio sottostante, fino a quando la variabile totale risulta minore di 1500, il computer
ripeterà il ciclo di istruzioni.

Dim Risposta As String
Do While totale < 1500
j = j + 1
totale = totale + 5
Loop
Risposta = "Hai ripetuto il ciclo:" & j & " volte "
MsgBox(Risposta, vbOKOnly + vbExclamation, "Risultato")
DO Until…. Loop
Questa istruzione ripete un ciclo finché la condizione diventa Vera (True) quindi per avere
lo stesso risultato del loop precedente dovremmo scrivere:

Do Until totale >= 1500
j = j + 1
totale = totale + 5
Loop
Uscita anticipata da un ciclo Loop

Come nel caso For… Next per uscire anticipatamente da un ciclo Loop utilizzate la parola
chiave Exit Do.

Do Until totale >= 1500
j = j + 1
totale = totale + 5
108
If j > 100 Then Exit Do
Loop
Select Case
Prende decisioni diverse a seconda del valore assunto dalla variabile. Nel nostro esempio
controlla quale valore assume la variabile NumeroCasuale. Se questa risulterà minore o
uguale a 200 allora eseguirà le istruzioni che trovano sotto l’istruzione Case Is corrispon-
dente e quindi continuerà l’esecuzione del programma da dopo l’istruzione End Select.
Lo stesso si può dire per gli altri valori. Le condizioni Case Is possono essere tutte quelle
di cui abbiamo bisogno.
In questo esempio abbiamo tre possibilità: la prima se il valore della variabile è minore o
uguale a 200, la seconda se risulta fra 201 e 500, in quanto se assumesse un valore minore
di 200 eseguirebbe le istruzioni che trovano sotto Case Is = 200.
Il terzo caso, se la variabile assume un valore fra 750 e 501. Si tratta di un possibile esem-
pio tra le molte applicazioni che questa funzione può avere.
Dim NumeroCasuale As Double

Dim Totale As Double
NumeroCasuale = Int(Rnd() * 1000)
Select Case NumeroCasuale
Case Is <= 200
Totale = Totale + NumeroCasuale
Case Is <= 500
Totale = Totale - NumeroCasuale
Case Is <= 750
Totale = Totale + NumeroCasuale / 2
End Select
Risposta = "Numero Casuale= " & NumeroCasuale & vbLf & "Totale = " & Totale
MsgBox(Risposta, vbOKOnly, "Risultato")
Questa riga fa apparire sullo schermo un messaggio di risposta. Il comando vbLf serve a
mandare a capo il testo dentro un messaggio di risposta.
Risposta = "Numero Casuale= " & NumeroCasuale & vbLf & "Totale = " & Totale
109
Genera un numero casuale fra zero e mille.
NumeroCasuale = Int(Rnd() * 1000)
Numeri casuali
Questa routine serve per generare un numero pseudo-casuale intero fra un valore massimo
e minimo impostabili a piacere.
La funzione Floor restituisce il valore intero del numero decimale più basso, ad esempio, se
il numero è 8,65 Floor restituisce 8, mentre la funzione Ceiling restituirebbe 9. Per i numeri
negativi il concetto si rovescia ovvero -8.65 Floor restituisce -9 mentre Ceiling -8.
Dim NumeroCasuale As Integer

Dim ValoreMinimo As Integer = 150
Dim Valoremassimo As Integer = 650
Randomize()
NumeroCasuale = CInt(Math.Floor((Valoremassimo - ValoreMinimo + 1) * Rnd())) +

ValoreMinimo
Risposta = "Numero Casuale= " & NumeroCasuale
MsgBox(Risposta, vbOKOnly, "Risultato")
La funzione CInt converte i dati nel tipo Integer troncando la parte frazionaria e arroton-
dando al valore più vicino secondo la convenzione degli arrotondamenti (ad esempio 99.5
diventa 100 e 99.4 diventa 99)
Randomize invece avvia il generatore di numeri casuali.
ARRAY
Lo scopo del libro è quello di rendervi produttivi da subito senza complicarvi troppo la vita,
ma in questo caso non se ne può fare a meno… o quasi. Diciamo che un Array, o matrice
per utilizzare un termine magari più familiare, è un insieme di dati, come potrebbe essere
la tabella delle tabelline che studiavamo a scuola quando eravamo alle elementari, ma con
qualche complicazione in più, tipo che gli Array possono essere monodimensionali, bidi-
mensionali, tridimensionali e oltre.
Un Array monodimensionale può essere simile ad una tabella che ha una sola colonna e più
righe, mentre le tabelline possono essere paragonate a un Array bidimensionale come ad
esempio una tabella che ha più di una colonna.
Chiaramente un Array deve avere un nome che lo identifica ad esempio matrice (che fan-
tasia…)
Quindi supponiamo che abbia bisogno di una Array monodimensionale che ha 10 elementi
devo scrivere:
Dim Matrice(9) As Integer
Purtroppo per voi il computer considera lo zero come primo numero e quindi per creare una
matrice a 10 elementi basta scrivere (9). Da 0 a 9 ovvio no!
Quindi portando avanti il paragone con una tabella avremo:
110
Matrice(0)
Matrice(1)
Matrice(2)
Matrice(3)
Matrice(4)
Matrice(5)
Matrice(6)
Matrice(7)
Matrice(8)
Matrice(9)
Quindi se voglio assegnare un valore all’elemento 3 di questa tabella scriverò:
Matrice(3) = 50
Se voglio riempire la matrice con dei numeri pseudo-casuali devo scrivere:
For j = 0 To 9
Matrice(j) = Int(Rnd() * 1000)
Next j
Questa parte di codice: Matrice(j) si legge – Matrice di indice J

Se per sbaglio scrivessi così:
For j = 0 To 15
Next j
Si genererebbe un errore in quanto la matrice non è così grande, avrei dovuto definirla in
anticipo come si vede nella figura successiva.
Come detto in precedenza questi argomenti possono essere anche evitati per il momento e
proseguire oltre per prendere la mano alla parte pratica della cosa, però dategli ugualmente
un’occhiatina per quando si presenterà la necessità di utilizzare un Array.
D’altra parte spesso c’è una fretta tremenda di arrivare ad un traguardo, magari bruciando
le tappe e saltando gli argomenti meno allettanti, dimenticando il fatto che purtroppo sia la
parte del linguaggio che riguarda la sintassi, sia quella che riguarda gli argomenti che un
programmatore deve necessariamente conoscere, non vanno trascurate perché queste
mancanze si manifesteranno come lacune che vi impediranno di trovare le soluzioni ade-
guate alle vostre necessità di sviluppo.
111
Adesso, dato che vedere le cose sullo schermo fa sempre piacere scriviamo un semplice
programmino come quello che vedete qui sotto.
112
Che riportiamo nel dettaglio nel riquadro successivo.
Option Explicit On
Public Class Form1
Dim Stringa As String = ""
Dim Matrice(9) As Integer
For j = 0 To 9
Stringa = Stringa & "Matrice(" & j & ") = " & Matrice(j) & vbLf
Next j
End
End Sub
End Class
In questo modo vedremo comparire sullo schermo il contenuto di ogni singolo elemento
dell’Array.
113
Un Array bidimensionale invece si presenta così:
Matrice(0,0) Matrice(1,0) Matrice(2,0) Matrice(3,0)

Penso che ci siamo capiti vero? In questo caso ci siamo fermati a 4 colonne ma gli elementi
possono essere anche molti di più, come ad esempio nel caso delle tabelline sono 10.
I numeri degli indici possono anche essere invertiti basta che teniate presente quello che
volete realizzare ad esempio:
Dim Matrice(9, 5) As Integer
Oppure:
Se giurate di aver capito il meccanismo possono essere la stessa cosa (come dimensione)
purché rispettate il parametro che occupa la prima e la seconda posizione durante lo svi-
luppo del codice, ovvero non scambiate le cose nello stesso programma altrimenti i dati si
mischiano e non corrispondono a quello che vi immaginate o come alternativa si materia-
lizzerà sullo schermo un messaggio d’errore come quello precedente.
Un Array può avere fino a 32 dimensioni ma io dopo la terza, che mi sembra

già tanto, mi perdo…
Quindi dovete ricordare esattamente cosa per voi rappresenta il primo, il secondo e il terzo
indice, ad esempio se l’array ne ha tre, e rispettarne la disposizione altrimenti accederete
a dei dati che non sono quelli che vi immaginate.
Il codice nel riquadro successivo contiene un loop per generare la tabella delle tabelline con
i valori calcolati al volo:
Option Explicit On
Imports System.Math
Public Class Form1
Dim Stringa As String = ""

114
Dim k As Integer = 0
For k = 0 To 9
For j = 0 To 9
Matrice(j, k) = (k + 1) * (j + 1)
Stringa = Stringa & "Matrice(" & j & "," & k & ") = " & Matrice(j, k) & " - "
Next j
Next k
End Sub
End Class
Il risultato sullo schermo è un po’ confuso però la matrice contiene il valore corrispondente
alle tabelline. Ricordate che il computer inizia a contare da zero mentre voi da 1.
Gli Strumenti a disposizione del programmatore
115
I controlli
In questo capitolo presenteremo una panoramica dei Controlli che il programmatore di-
spone per rendere il suo programma più potente e accattivante che mai. Esistono una va-
langa di Controlli dalle caratteristiche più disparate che fanno cose mirabolanti però ovvia-
mente noi presenteremo solo quelli di utilizzo comune, che sono già tanti a dire la verità, e
che vi permetteranno di cavarvela egregiamente in qualunque situazione.
Create un nuovo progetto come abbiamo già visto nei capitoli precedenti e assegnategli il
nome di ProgettoIniziale ad esempio. La figura sottostante mostra la situazione iniziale.
Dal menu VISUALIZZA scegliete Casella degli strumenti oppure eseguite dalla tastiera
la combinazione CTRL+ALT+X
116
Gli strumenti sono raggruppati in categorie. Fate click per iniziare sulla voce Tutti i Win-
dows Form.
Per lavorare meglio, vi consiglio di spostare la casella degli strumenti e di dimensionarne la

larghezza in modo da riuscire a vedere tutte e 4 le principali finestre di progettazione.
Ancoratela ad esempio nella parte sinistra della finestra. Come abbiamo già detto per motivi
di miglior riproduzione la risoluzione grafica utilizzata in questo libro è ridotta a 1024x768.
Sicuramente sullo schermo del vostro computer ci sarà più spazio per lavorare. (Risoluzione
consigliata 1280x1024 o maggiore).
117
Il pulsante di comando o Button
Dalla casella degli strumenti cercate il controllo Button (i controlli dovrebbero presentarsi
in ordine alfabetico quindi non sarà difficile rintracciarli)
Per inserire un controllo in quello che sarà il vostro form scegliete uno di questi metodi.
Fate doppio click con il tasto SX del mouse sul controllo che si trova sulla casella degli
strumenti. Il controllo comparirà un punto casuale del vostro form, quindi dovrete spostarlo
con il metodo trascina e rilascia dove credete faccia più bella figura all’interno della finestra.
La seconda possibilità è quella di fare click con il tasto SX del mouse sul controllo che si
trova nella casella degli strumenti, e portare il puntatore del mouse sopra il form come si
vede nella figura sottostante.
A questo punto, potete disegnare il controllo sul form semplicemente facendo click con il
tasto SX del mouse nel punto dove desiderate posizionare il controllo, e tenendo premuto
generate un’area rettangolare. Quindi rilasciate il tasto SX del mouse. Al momento del rila-
scio comparirà il vostro controllo. La figura successiva mostra la fase di creazione del pul-
sante nel form.
118
Dopo aver rilasciato il tasto SX del mouse appare il pulsante
Adesso proviamo a passare in rassegna le caratteristiche fondamentali di questo oggetto

che milioni di volte avrete visto in una qualsiasi finestra di Windows.
Ovviamente è possibile spostare il pulsante di comando in un qualsiasi punto del form sem-
plicemente trascinandolo (drag & drop)
Attraverso la proprietà Text è possibile impostare il testo che dovrà comparire sul pulsante,
ad esempio Salva, Stampa o cose di questo genere qui.
119
Con la proprietà TextAlign è possibile impostare l’allineamento che il testo descrittivo sopra
il pulsante dovrà avere, ad esempio in basso, in alto a destra ecc. ecc.
La proprietà Size regola la grandezza del pulsante sullo schermo, ma essendo in ambiente
grafico potete anche impostarla semplicemente attraverso un semplice ridimensionamento
utilizzando il mouse.
La proprietà FlatStyle serve per cambiare l’aspetto che il pulsante avrà quando l’utente
sposta il mouse su di esso e farà click.
La Proprietà Cursor serve invece a modificare l’aspetto del puntatore del mouse quando
questo passerà sul pulsante. Normalmente è impostata su Default.
La proprietà BackColor permette di impostare il colore del pulsante.
La proprietà Enabled serve per abilitare o disabilitare il pulsante.
La Proprietà Visibile invece può renderlo Visibile o invisibile agli occhi dell’utente a seconda
dei casi e delle necessità
Ovviamente in questa panoramica ci limiteremo ad utilizzare quelle proprietà di più comune
utilizzo, tralasciando invece quelle che raramente in un programma hanno qualche forma
di applicazione.
Adesso ci occuperemo della proprietà Image che permette di inserire un’immagine o
un’icona sul pulsante per rendere graficamente accattivante il nostro lavoro, anche perché
nell’ambito della programmazione anche l’occhio vuole la sua parte. Qualcosa di visibil-
mente brutto ricorda all’utente qualcosa di poco pratico, un programma non piacevole da
utilizzare. Ovviamente il primo scopo del programmatore è quello di mettere in grado
l’utente finale di utilizzare il suo programma con estrema facilità, come si dice in gergo il
programma deve essere intuitivo da utilizzare.
Vi garantisco che le immagini in quest’ambito fanno la parte del leone al pari e anche di più
della descrizione che può apparire o meno su un pulsante. Un esempio lampante è una
barra degli strumenti che mostra tutta una serie di icone, che piano piano chiunque ha
imparato ad utilizzare anche senza avvalersi della descrizione. In parole povere se vedo un
120
dischetto mi viene l’idea che quel comando effettui un salvataggio del lavoro che sto fa-
cendo. Prima di partire con le operazioni dobbiamo però procurarci i ferri del mestiere,
ovvero le immagini o le icone che ci serviranno per i nostri abbellimenti grafici.
Nel nostro computer ce ne sono migliaia nascoste e per trovarle procedente così:
Riducete ad icona l’ambiente di sviluppo come mostra la figura sottostante
Fate doppio click sull’icona Questo PC o Computer, a seconda del sistema operativo Win-
dows, che dovrebbe trovarsi sul vostro Desktop. È probabile che compaia una finestra simile
a questa.
Fate doppio click sul Disco locale C: e dalla casella di ricerca in alto a destra digitate dalla
tastiera *.ico
121
Attendete che la ricerca sia finita e vedrete migliaia di icone materializzarsi nella finestra di
ricerca. Le icone servono appunto per abbellire i nostri programmi. A questo punto Copiate
(mi raccomando e non Spostate) le icone in una vostra cartella in modo che siano sempre
disponibili, per non procedere tutte le volte che ne serve una alla ricerca come abbiamo
appena fatto. Questa cartella piena di icone mettetela dove si trova più facilmente ad esem-
pio io l’ho piazzata dentro la cartella Documenti.
Adesso tornate nell’ambiente di sviluppo, e dopo avere per sicurezza fatto click sul vostro
pulsante da abbellire, (ve lo dico perché quando in una finestra ci sono diversi oggetti se
non controllate quale di questi oggetti è quello selezionato, correte il rischio di modificare
le proprietà di un altro oggetto invece che quello desiderato) fate click sulla proprietà
Image.
Dalla finestra che appare fate click sull’opzione Risorsa Locale si vede nella figura succes-
siva e quindi fate click sul pulsante Importa.
122
Cercate la cartella che contiene le icone, ma ricordate che in basso nella finestra di dialogo
che vi permette di scegliere i file dovete impostare il filtro su Tutti i File, altrimenti non
sarete in grado di visualizzare le icone. Sceglietene una a caso o quella che piace di più con
un doppio click del mouse, oppure ricercatela con lo strumento di ricerca.
Completate le operazioni con il pulsante OK al passaggio successivo.

123
La situazione finale potrebbe essere quella della figura qui sopra. Ricordate che con le pro-
prietà TextAlign e ImageAlign del vostro pulsante è possibile posizionare il testo e l’icona
nella posizione più conveniente per la vostra sensibilità artistica.
Ed adesso, per completare la nostra panoramica vedremo la Proprietà più importante
dell’intero lotto ovvero la proprietà Name che di solito si trova in cima alla lista delle pro-
prietà.
Nessuno vi vieta di lasciare il valore di questa proprietà invariato, ad esempio nel nostro
caso è Button1. Ma quando si programma e dobbiamo richiamare le funzioni di un oggetto
o di un controllo in quanti si ricorderanno come si chiama questo controllo?
Vi dico subito che io sono fra quelli che non si ricorderanno sicuramente il nome, specie se
ci sono 20 pulsanti, 30 caselle di testo 15 caselle di opzione e così via.
Certo, un programma composto da un pulsante e da un textbox non ha bisogno di tanta
memoria da parte vostra, ma quanti programmi esistono in giro con queste caratteristiche?
Quindi per evitare di perdere la strada per tornare a casa, la prima cosa che vi consiglio di
fare è quella di dare un nome descrittivo ad ogni controllo o oggetto che inserite nel vostro
programma, in modo da ricordarsi chiaramente come si chiama.
Per la verità esiste anche una notazione ad esempio alcuni chiamerebbero in nostro pulsante
b_Prova e a dire la verità non fanno male. La prima parte prima del trattino basso (under-
score) serve per ricordare al programmatore che si tratta di un pulsante (button) mente la
seconda è il nome vero e proprio.
Ma nessuno vi vieta di chiamarlo PulsanteProva che di sicuro non lascia adito a dubbi.
Quindi modificate il valore della proprietà in uno di questi modi a piacere.
124
Adesso fate doppio click sul pulsante per accedere all’aera del codice…
e facciamo fare qualcosa a questo pulsante. Per una visione migliore (ma è solo una mia
opinione) ho chiuso la casella degli strumenti e spostato le altre finestre. Se il vostro
schermo è sufficientemente ampio, non ci sono questi problemi. Il codice da digitare è
questo:
PulsanteProva.Enabled = False
MsgBox("Grazie per aver fatto click su questo pulsante", MsgBoxStyle.Exclamation,"Grazie")
End
125
Ricordate che gli apici o la parola REM precedono un commento da parte del programma-
tore e sono completamente ininfluenti ai fini del funzionamento del programma.
Avviate il progetto con il pulsante Avvia sulla barra degli strumenti in alto.
Cliccate sul pulsante OK per terminare il programma. Trovando l’istruzione End il pro-
gramma viene terminato.
126
Il TextBox
Un controllo veramente importante che si trova praticamente in tutti i programmi è la ca-
sella di testo o TextBox, attraverso il quale è possibile inserire dalla tastiera dei dati che poi
il programma dovrà elaborare. Identificate il controllo in questione nella casella degli stru-
menti e inseritelo nel form.
Come nel caso precedente è conveniente cambiare il nome del controllo per facilitarne il
l’identificazione nel marasma che potrebbe venirsi a creare quando in un form si trovano
decine di controlli. Abituatevi a dare dei nomi descrittivi ai controlli. Di solito i programma-
tori professionisti chiamano i controlli di testo txt seguiti da un trattino basso (underscore)
e da una descrizione ad esempio txt_cognome. In questo modo sicuramente ricorderemo
che quella casella di testo serve per acquisire un cognome che l’utente inserirà nella casella
stessa.
La casella di testo dispone di una valanga di proprietà che troverete in parte elencate nella
tabella qui sotto con una breve descrizione dei valori che possono assumere. Tenete pre-
sente che attualmente ci troviamo ancora nella fase dove prenderemo confidenza con le
127
caratteristiche fondamentali dell’ambiente di sviluppo, e quindi non staremo ad elencare
tutte le possibilità di cui un controllo può deliziarci, ma cercheremo di mettere in evidenza
quelle fondamentali per poi approfondire più avanti nei prossimi capitoli.
Proprietà Descrizione
BackColor Imposta il colore dello sfondo della casella
Font Serve per scegliere il tipo di carattere utilizzato per il testo della
casella.
MaxLength Indica il massimo numero di caratteri che è possibile immettere nella
casella.
Multiline Trasforma la casella di testo in modo che l’utente possa inserire del testo
su più righe.
PasswordChar Proprietà che si utilizza per creare un campo dove ad esempio va inserita
una password. Quello che digitiamo viene mascherato in modo che l’utente
non veda quello che viene digitato.
ReadOnly Serve per impedire la modifica testo contenuto nella casella.
Text Rappresenta il contenuto del testo nella casella
TextAlign Serve per allineare il testo all’interno della casella di testo.
Queste proprietà possono essere cambiate indifferentemente dalla finestra delle proprietà
oppure dal codice. Ad esempio, se il colore dello sfondo della cella deve cambiare quando
facciamo click al suo interno, ovvero quando il controllo diviene attivo, e deve tornare come
prima quando invece faccio click su un altro controllo, devo farlo da codice, mentre se il
colore non deve mai cambiare durante l’arco dell’esecuzione del programma allora posso
cambiarlo anche dalla finestra delle proprietà.
Proviamo a creare un piccolo programma con un Textbox per capirne meglio il funziona-
mento.
Quando avvio un programma con un unico form, salvo che il programmatore non
abbia specificato diversamente, vengono eseguite per prime le istruzioni che si tro-
vano nell’evento Load.
È inoltre molto importante per il programmatore scegliere l’evento giusto in base a cosa
vuole realizzare, ad esempio se quando facciamo click in un TextBox questo deve cambiare
il colore del suo sfondo dovete utilizzare l’evento GotFocus.
Dalla scheda di progettazione fate doppio click sul controllo Casella di testo (TextBox) per
entrare nel lato codice.
128
Quando entrate nel lato codice per la prima volta attraverso il click su un determinato
Controllo, non so perché ma Visual Basic si sente in obbligo di creare il codice di uno spe-
cifico evento, che vi garantisco non è mai quello giusto o per lo meno quello che vi serve in
un determinato momento.
Se fate click e portate il cursore all’interno del codice dell’evento in alto la lista si posiziona
automaticamente sull’evento in questione. Quindi prestate particolare attenzione a cosa
indica la lista, per evitare di scrivere codice in una posizione sbagliata del programma con
la conseguenza che non funzionerà nulla.
Dalla lista selezionate l’evento GotFocus. Scorrete la lista se necessario.

129
Apparirà in un punto del programma il codice dell’evento generato automaticamente da

Visual Basic ammesso che non esista già.
Non importa in che punto del programma questo codice compare, l’importante è che non
venga modificato in maniera arbitraria per evitare malfunzionamenti del programma stesso.
Digitate il codice corrispondente, che riguarda appunto il cambio di colore di sfondo dell’og-
getto quando fate click al suo interno per scrivere qualcosa.
txt_cognome.BackColor = Color.LightYellow
130
Adesso per pura curiosità avviate il progetto con il pulsante Avvia in alto sulla barra degli
strumenti.
Non appena farete click all’interno della casella di testo il colore del suo sfondo cambierà
con quello selezionato nel codice.
Adesso interrompete l’esecuzione del programma (Runtime) e vediamo cosa è necessario

fare per far tornare lo sfondo del colore originario quando il controllo perde l’azione, ovvero
quando faccio click da un’altra parte del Form o su un altro controllo presente nel Form.
In questo caso abbiamo bisogno dell’evento LostFocus ovvero tradotto in italiano perde
l’azione.
Dopo aver terminato l’esecuzione del programma, altrimenti non sarete in grado di effet-
tuare nessuna modifica, fate click all’interno di un qualsiasi pezzo di codice che riguardi
l’oggetto txt_cognome (per il computer così si chiama la casella di testo che abbiamo inse-
rito nel Form anche perché il nome glielo abbiamo assegnato noi).
Oltre a fare click all’interno del codice che riguarda un controllo o un oggetto è possibile
selezionarlo anche dalla lista che vedete nella figura sottostante, che vi elenca tutti gli
131
controlli che avete inserito nel Form. Infatti, potete vedere il Form1, il PulsanteProva e la
casella di testo txt_cognome.
Quindi controllate sempre su quale oggetto state operando.
Aprite la lista e questa volta selezionate l’evento LostFocus.
Viene automaticamente generato come nel caso precedente il codice relativo all’evento.
Digitate il codice corrispondente.
132
Eseguite il programma e verificatene il funzionamento.
Impostazioni iniziali
Se avete delle impostazioni dei vari oggetti che il programma deve eseguire all’inizio, ov-
vero se ad esempio l’immissione del testo nella casella deve essere limitata a 50 caratteri,
oppure nella casella non si può scrivere nulla se prima non ho premuto un determinato
pulsante o cose di questo genere qui, dovete scrivere il codice corrispondente nell’evento
Load del Form che viene eseguito per primo quando si avvia il programma (salvo diverse
impostazioni).
Quelle che vediamo in questo esempio sono alcune delle possibili applicazioni pratiche della
casella di testo che potete utilizzare a vostro piacimento a seconda delle situazioni.
Il codice è il seguente. Quelle dopo l’apostrofo come ben sapete ci sono solo note che ho
inserito come breve spiegazione e possono essere omesse.
txt_cognome.MaxLength = 50 'massima lunghezza 50 caratteri

txt_cognome.CharacterCasing = CharacterCasing.Upper ' scrive tutto in maiuscolo
txt_cognome.Text = "Inserisci qui il tuo cognome" ' Scritta iniziale dentro la casella
txt_cognome.ForeColor = Color.Red ' Colore del testo
133
Inoltre, per fare in modo che appena avviato il programma, senza fare nessuna operazione
particolare, la casella di testo riceva l’azione (ovvero venga selezionata per prima) è neces-
sario generare dalla casella degli eventi l’evento Shown come nella figura seguente.
Ignorate i numeri di linea e anche in quale punto del programma compaiono le

routine dei vari eventi. Se lo desiderate, per rendere il programma più leggibile,
ma con molta attenzione possono essere spostate in seguito con un semplice taglia
e incolla.
E quindi aggiungere il codice:
txt_cognome.Focus()
avviate il programma e verificate il funzionamento.
Quindi alla fine il codice aggiunto fino ad ora sarà:

134
Public Class Form1
Private Sub PulsanteProva_Click(sender As Object, e As EventArgs) Handles

PulsanteProva.Click
' appare un messaggio

MsgBox("Grazie per aver fatto click su questo pulsante",
MsgBoxStyle.Exclamation, "Grazie")
End
End Sub
txt_cognome.MaxLength = 50 'massima lunghezza 50 caratteri

txt_cognome.CharacterCasing = CharacterCasing.Upper ' scrive tutto in maiuscolo
txt_cognome.Text = "Inserisci qui il tuo cognome" ' Scritta iniziale dentro la casella
txt_cognome.ForeColor = Color.Red ' Colore del testo
End Sub
Private Sub Form1_Shown(sender As Object, e As EventArgs) Handles Me.Shown
txt_cognome.Focus()
End Sub
Private Sub Txt_cognome_GotFocus(sender As Object, e As EventArgs) Handles

txt_cognome.GotFocus
End Sub
Private Sub txt_cognome_LostFocus(sender As Object, e As EventArgs) Handles

txt_cognome.LostFocus
txt_cognome.BackColor = Color.White
End Sub
Attenzione: non tutte le proprietà di un controllo presenti nella finestra delle pro-
prietà possono essere cambiate in fase di Run Time (ovvero in fase di esecuzione
del programma). Le proprietà definite come Read Only sono modificabili solo dalla
finestra delle proprietà di un oggetto in fase di progettazione.
Campo password
Per mascherare l’immissione del testo in una casella è sufficiente scrivere questa linea di
programma:
txt_cognome.PasswordChar = "*"
135
Qualsiasi cosa digitata viene sostituita dal simbolo *. Altri comandi interessanti sono:
Impedisce all’utente di scrivere in quella casella di testo.
txt_cognome.ReadOnly = True
Disattiva la casella di testo rendendola diciamo “evanescente”.
txt_cognome.Enabled = False
La Label o etichetta
L’etichetta è utile per inserire delle descrizioni o dei titoli che l’utente del programma non
può modificare. Dalla scheda di progettazione del Form1 cercate nella casella degli stru-
menti il controllo Label e inseritelo nel Form.
Si tratta di un oggetto semplice ma importante che ci permette di aggiungere descrizioni ai

comandi. Prima di modificare un valore di proprietà assicuratevi che l’etichetta sia selezio-
nata altrimenti compariranno nella lista le proprietà di un altro oggetto. È abbastanza facile
sbagliare…
Nella proprietà text è possibile inserire il testo che deve comparire sull’etichetta.
136
Se l’etichetta resta immutata durante tutto l’arco di esecuzione del programma vi consiglio
di lasciare il nome che il computer assegna automaticamente ovvero label1. Ma se durante
la fase di Runtime, ad esempio, il testo deve cambiare, allora vi consiglio di dargli un nome
specifico in modo da riconoscerla fra le tante componenti del programma. I programmatori
professionisti hanno il maledetto vizio di dare un nome a tutto…
Proprietà Descrizione
AutoSize Serve per adattare le dimensioni dell’etichetta al suo contenuto.
BackColor Imposta il colore dello sfondo dell’etichetta
Font Serve per scegliere il tipo di carattere utilizzato per il testo.
Text Il testo che comparirà sull’etichetta
TextAlign Allinea il testo all’interno dell’etichetta.
Visible Serve per far scomparire il controllo in fase di Run Time. È possibile far
apparire o scomparire in qualsiasi momento l’etichetta.
Esempio:
per fare sparire l’etichetta lbl_cognome.Visible = False
per farla riapparire lbl_cognome.Visible = True
per cambiare colore al testo dell’etichetta lbl_cognome.ForeColor = Color.Red
Per scrivere qualcosa dentro l’etichetta lbl_cognome.text = “Aiuto !!!!”
Il CheckBox o casella di controllo

Si tratta di un controllo frequentemente utilizzato in qualsiasi progetto. In sostanza è un
quadratino dove apporre un segno di spunta per attivare o disattivare qualche funzione o
qualche diavoleria. Una volta che l’avete trovato nella casella degli strumenti inseritelo nel
Form, e se volete cambiategli il nome dalla proprietà Name. Se nel Form non esistono altri
controlli di quel tipo non vi potete sbagliare, ma se ne fossero presenti altri 10?
137
Supponiamo che abbia bisogno di un controllo che attivi o disattivi, ad esempio, il pulsante
Prova che ho inserito all’inizio del capitolo. Lo stesso può valere per qualsiasi altro tipo di
controllo. Innanzitutto, cambio il testo con la Proprietà Text.
Nella routine Load del Form aggiungo la seguente istruzione supponendo che inizialmente
il quadratino sia spuntato.
CheckBox1.Checked = True
138
Poi come mostra la figura successiva selezionate l’oggetto CheckBox1 dalla lista di sinistra
e l’evento CheckStateChanged dalla lista di destra. Fra le dichiarazioni Private Sub e End
Sub digitate questo codice.
If CheckBox1.Checked = True Then
PulsanteProva.Enabled = True
Else
End If
Si lo so, esistono altri cento modi più eleganti di fare la stessa cosa ma lascio a voi
scoprirli quando sarete Programmatori…
Adesso avviate il programma e divertitevi ad abilitare e disabilitare il pulsante.

139
Il RadioButton o Pulsante di Opzione

Un altro comando molto utilizzato in qualunque programma è il RadioButton. Si distingue
da quello precedente dal fatto che in presenza di più RadioButton ne posso selezionare solo
uno, perché una scelta esclude le altre, mentre per quanto riguarda il CheckBox, nel caso
della presenza di più elementi, posso selezionare uno o più oggetti CheckBox a piacimento.
In effetti è difficile trovare un solo RadioButton in un form in quanto una volta selezionato,
qualora ne fosse presente uno solo, non sarebbe possibile deselezionarlo se non da codice.
Cercate questo controllo nella casella dagli strumenti e inseritene un paio nel Form dal lato
della Progettazione.
Se avviate il programma vedrete che la selezione dell’uno esclude l’altro.

140
Adesso non staremo a cambiare il nome dei controlli perché visto l’esiguo numero non ci
dovrebbero essere problemi di sorta. Supponiamo che desideriamo nascondere alla vista
dell’utente e poi far ricomparire il pulsante Prova. Procediamo come segue.
- Fate doppio click sul RadioButton1 per passare al lato codice.

- Viene generato l’evento CheckedChanged ma ignoratelo perché per il momento non fa al
caso nostro.
- Cercate nella lista degli eventi l’evento Click e digitate il codice:
PulsanteProva.Visible = False
- Cercate lo stesso evento del RadioButton2 e digitate il codice:
PulsanteProva.Visible = True
Avviate il programma e guardate quello che accade selezionando alternativamente l’uno o

l’altro RadioButton.
GroupBox
È una simpatica cornice che serve per raggruppare alcuni comandi in un riquadro con tanto
di titolo, ma soprattutto può essere utile quando in un Form si trovano due o più gruppi di
RadioButton che devono essere mantenuti separati.
Come mostra la figura successiva, passando al lato Progettazione dalla casella degli stru-
menti prendete un GroupBox e piazzatelo in un punto del Form. Se reputate vi sia poco
spazio a disposizione potete ridimensionare opportunamente il Form per ingrandirlo.
Per spostarlo portate il puntatore del mouse in alto a sinistra del GroupBox dove si trova
l’icona di una freccia quadrupla e trascinatela in un posto a scelta.
Si tratta di semplici operazioni di uso comune come il Drag & drop (trascina e rilascia)
oppure la classica operazione di ridimensionamento di una finestra.
Se invece desiderate delle misure precise dovete impostarle nella Proprietà Size.
141
Trascinate al suo interno i due RadioButton.
Adesso supponiamo che attraverso la selezione di uno o l’altro RadioButton sia possibile
cambiare il colore del testo del pulsante.
In questa parte del libro ci alleneremo a prendere confidenza, attraverso semplici

esempi, con molti dei controlli che poi ritroveremo nei vari progetti presentati, in
modo da sviluppare quella pratica necessaria per affrontare poi la programmazione
delle vostre soluzioni.
Prima di modificare le proprietà di un oggetto dalla lista delle proprietà sinceratevi

di aver selezionato l’oggetto giusto nella scheda di Progettazione, altrimenti potre-
ste modificare le proprietà di altri oggetti. Purtroppo, questo controllo deve essere
maniacale.
Quindi, ad esempio, selezionate la cornice GroupBox e verificate se sulla testata della fine-
stra delle proprietà compare il suo nome. Poi potete cambiare il valore della proprietà Text
per fare comparire sulla cornice, ad esempio, la dicitura “Colore testo”.
142
Adesso fate click sulla scheda del codice del Form e modificate il codice dell’esempio pre-
cedente con questo:
PulsanteProva.ForeColor = Color.Blue
PulsanteProva.ForeColor = Color.Red
Ovviamente ciascuna riga all’interno dell’evento click dei rispettivi RadioButton, come mo-
stra la figura sottostante.
Avviate e provate il funzionamento del programma.
DateTimePicker
Si stratta di un controllo molto interessante perché vi permette di selezionare una data
comodamente da una lista senza necessità di digitarla dalla tastiera, impedendo un errore
143
di formato da parte dell’operatore. Prima di addentrarci nell’esempio chiudiamo il nostro
progetto e partiamo daccapo con uno nuovo. Dal menu File in alto a sinistra scegliete la
voce Chiudi Soluzione.
Fate click sulla voce Crea un nuovo progetto.
Scegliete dalla finestra App Windows Forms e quindi fate click sul pulsante AVANTI in
basso a destra.
144
Date un nome al nuovo progetto e fate click sul pulsante Crea in basso a destra nella
finestra.
Cercate sulla casella degli strumenti il controllo DateTimePicker e inseritelo nel Form.
In teoria il controllo funziona già così com’è con pochi ritocchi. Ci limitiamo a dare le infor-
mazioni sulle proprietà fondamentali senza dilungarci su come si cambia il colore di sfondo
del calendario tanto queste impostazioni le trovate anche da soli.
Dalla lista delle proprietà selezionate impostate il valore Format a Short in modo da vi-
sualizzare sulla lista solo la data così come siamo abituati a vederla. Comunque nessuno vi
vieta, se l’indicazione vi interessa, di tenere il valore a long per visualizzare anche il giorno
della settimana.
145
Adesso inseriamo anche un TextBox che ci servirà come riprova per capire quello che resti-
tuisce il programma quando selezioniamo una data. Dalla proprietà Name affibbiategli il
nome t_DataFattura per riconoscerlo durante la fase di scrittura del codice.
Fate doppio click sul DateTimePicker per generare l’evento ValueChanged e digitiamo il
codice che vedete nella figura successiva.
Ovviamente si tratta di un esempio per vedere come si recupera una data dall’oggetto
DateTimePicker per poi riutilizzarla sotto forma di variabile all’interno del flusso del pro-
gramma.
146
Option Explicit On
Public Class Form1
Dim DataFattura As Date
DateTimePicker1.MaxDate = "31/12/2060"
DateTimePicker1.MinDate = "01/01/2000"
End Sub
Private Sub DateTimePicker1_ValueChanged(sender As Object, e As EventArgs) Handles

DateTimePicker1.ValueChanged
DataFattura = DateTimePicker1.Value.Date
t_DataFattura.Text = DataFattura
End Sub
End Class
La variabile DataFattura viene dichiarata in quella posizione in modo che in qualunque punto
del programma (in questo caso il programma è rappresentato da questo unico Form) sia
possibile accedere al suo valore.
Le proprietà MaxDate e MinDate dell’oggetto DateTimePicker servono per limitare il campo
di utilizzo, sempre ammesso che non vogliate creare un programma che si avvale di date
stratosferiche. Ovviamente è possibile anche passare direttamente il valore della data al
TextBox in questo modo:
t_DataFattura.Text = DateTimePicker1.Value.Date
147
DateTimePicker1.Value.Date Restituisce la data selezionata
DateTimePicker1.Value.Day Restituisce il giorno
DateTimePicker1.Value.DayOfWeek Numero seriale del giorno della settimana ad esempio mer-
coledì=3
DateTimePicker1.Value.DayOfYear Numero dei giorni passati dall’inizio dell’anno della
data selezionata
DateTimePicker1.Value.Month Restituisce il mese selezionato
DateTimePicker1.Value.Year Restituisce l’anno selezionato
NumericUpDown
Anche questo controllo ha un ampio utilizzo e sicuramente vi sarete imbattuti molto spesso
in qualcosa del genere. Vediamone le caratteristiche salienti.
Create un nuovo progetto come per il controllo precedente in modo da non confondervi con
il codice generato per altri controlli. Se non vi ricordate come si fa riguardatevi l’esempio
precedente.
Inserite nel Form una casella di testo e un controllo NumericUpDown.
Quindi per accedere al codice e generare l’evento ValueChanged fate doppio click sul con-
trollo NumericUpDown.
148
Option Explicit On
Public Class Form1
Dim Numero As Double
Private Sub Form1_Load(sender As Object, e As EventArgs) Handles Me.Load
' Tutte le impostazioni sottostanti sono opzionali
NumericUpDown1.DecimalPlaces = 2 'Imposta il numero dei decimali

NumericUpDown1.Value = 1 'Imposta eventualmente un valore iniziale a piacere
NumericUpDown1.Increment = 5 ' Imposta un valore per l'incremento
NumericUpDown1.Cursor = Cursors.Hand 'imposta la forma del cursore durante la selezione
NumericUpDown1.ReadOnly = True ' per impedire l'immissione manuale di valori
End Sub
Private Sub NumericUpDown1_ValueChanged(sender As Object, e As EventArgs) Handles

NumericUpDown1.ValueChanged
TextBox1.Text = NumericUpDown1.Value
Numero = NumericUpDown1.Value
End Sub
ComboBox o Casella Combinata

Create un nuovo progetto d’ora in avanti per ogni nuovo controllo, perché alcuni di questi
presentano una quantità di codice non indifferente ed alle prime armi è meglio concentrarsi
sulle cose fondamentali. D’altra parte si tratta di un libro che “Parte da Zero”. Se fosse stato
dedicato a programmatori esperti il linguaggio utilizzato sarebbe stato sicuramente meno
amichevole...
In questo controllo le cose si complicano un po’ e per saperne di più vi consiglio di leggere
il capitolo che tratta dei database in quanto il ComboBox è un controllo ampiamente utiliz-
zato proprio in quell’argomento.
Si tratta di qualcosa che somiglia a un campo di testo con una freccetta sulla sua destra
che lascia intendere che ci si nasconda una lista.
Il ComboBox come prima caratteristica presenta tre stili diversi e ve li elencherò insieme al
codice per attivare questa modalità.
Stile semplice non mostra la freccetta

della lista a discesa e per selezio-
ComboBox1.DropDownStyle = ComboBoxStyle.Simple nare visualizzare la lista dovete
farlo attraverso i tasti freccia-su e
freccia-giù della tastiera
Mostra una lista dove è possibile sce-
ComboBox1.DropDownStyle = ComboBoxStyle.DropDownList
gliere fra le voci presenti.
Funzione piena del controllo. È possi-
bile oltre alla funzione di lista im-
ComboBox1.DropDownStyle = ComboBoxStyle.DropDown
mettere manualmente altri valori non
presenti in lista.
Inserite sia un ComboBox che un TextBox per recuperare i valori e sincerarci del corretto
funzionamento. Fate doppio click sul ComboBox per generare l’evento SelectedIndexChan-
ged.
149
Il codice dell’esercizio è visibile nella figura sottostante. Le note del programmatore sono
in verde.
Si tratta ovviamente di un esempio. Maggiori informazioni sull’utilizzo del controllo potere

trovarle nella parte del libro che tratta dei database.
Option Explicit On
Public Class Form1
Dim TestoCombo As String
Private Sub Form1_Load(sender As Object, e As EventArgs) Handles Me.Load

150
ComboBox1.Sorted = True 'Ordina i valori della lista
'scegli fra gli stili
'ComboBox1.DropDownStyle = ComboBoxStyle.DropDownList
'ComboBox1.DropDownStyle = ComboBoxStyle.Simple
ComboBox1.DropDownStyle = ComboBoxStyle.DropDown
'Aggiungi elementi alla lista
ComboBox1.Items.Add("PROPRIO")
ComboBox1.Items.Add("NOSTRO")
ComboBox1.Items.Add("PACCO POSTALE")
ComboBox1.Items.Add("FERROVIA")
ComboBox1.Items.Add("VETTORE")
'selezione iniziale di un elemento

ComboBox1.SelectedIndex = 0
End Sub
Private Sub ComboBox1_SelectedIndexChanged(sender As Object, e As EventArgs) Handles

ComboBox1.SelectedIndexChanged
TextBox1.Text = ComboBox1.Text
TestoCombo = ComboBox1.Text
End Sub
End Class
ListBox
Si tratta sempre di una lista ma con caratteristiche un po’ diverse da quelle del caso prece-
dente. Identificate il ListBox sulla casella degli strumenti e inseritelo tanto per cambiare
insieme al solito TextBox che ci servirà solo per verificarne il funzionamento.
Fate doppio click sul ListBox per generare l’evento SelectedIndexChanged e quindi inserite
il codice che vedete nella figura successiva.
151
Per recuperare il testo di uno degli elementi della lista dovete utilizzare la riga di codice che
vedete qui sotto:
Testo = ListBox1.Items(ListBox1.SelectedIndex)
In pratica, il valore dell’indice dell’elemento selezionato nella lista (in realtà si tratta di un
numero che la lista assegna ai suoi elementi)
(ListBox1.SelectedIndex)
va a specificare quale degli elementi della lista deve richiamare.
ListBox1.Items(ListBox1.SelectedIndex)
Option Explicit On
Public Class Form1
Dim Testo As String
ListBox1.Items.Add("Milano")
ListBox1.Items.Add("Torino")
ListBox1.Items.Add("Bologna")
ListBox1.Items.Add("Genova")
ListBox1.Items.Add("Venezia")
ListBox1.Items.Add("Firenze")
ListBox1.Items.Add("Roma")
152
ListBox1.Items.Add("Napoli")
ListBox1.Items.Add("Palermo")
'seleziona il primo elemento della lista

ListBox1.SelectedIndex = 0
End Sub
Private Sub ListBox1_SelectedIndexChanged(sender As Object, e As EventArgs) Handles

ListBox1.SelectedIndexChanged
'qui per recuperare il testo è più complesso

TextBox1.Text = ListBox1.SelectedIndex
'per inserire il testo in una string
Testo = ListBox1.Items(ListBox1.SelectedIndex)
End Sub
End Class
Le finestre di dialogo
153
Come dice il nome stesso, sono finestre che “dialogano” con l’operatore ovvero possono
avvisare oppure possono aprire o salvare dei file, scegliere colori e tipi di carattere o cose
di questo genere qui. Alzi la mano chi non ha mai avuto a che fare, durante l’utilizzo di un
computer. con qualcosa del genere. In questo capitolo cercheremo di affrontarle una alla
volta, anche se la trattazione ovviamente si limiterà all’utilizzo più frequente di queste fi-
nestre e non certo all’esposizione di tutte le caratteristiche che vi garantisco non sono po-
che.
Message Box, Le finestre di Messaggio

Per prima cosa affrontiamo le finestre di messaggio o messagebox che normalmente ven-
gono utilizzate per segnalare il temine di una procedura, un messaggio di errore o la richie-
sta di intervento da parte dell’operatore.
Create un nuovo progetto e inserite nel Form un Pulsante (Button) e una Casella di testo
(TextBox) come ad esempio nella figura successiva.
Fate doppio click sul pulsante (Button) per generare l’evento Click nel codice.
154
La figura precedente mostra la posizione del codice di questo esercizio.
Public Class Form1
Dim Risposta As Integer
Button1.Text = "Premi Qui"
End Sub
Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
Dim TitoloFinestra As String = "Help"

Dim TestoMessaggio As String = "Ciao Come va?"
Risposta = MessageBox.Show(TestoMessaggio, TitoloFinestra,
MessageBoxButtons.OKCancel, MessageBoxIcon.Information)
If Risposta = 1 Then
TextBox1.Text = "Hai premuto OK"
End If
If Risposta = DialogResult.Cancel Then
TextBox1.Text = "hai premuto Cancel"
End If
End Sub
End Class
L’apertura di una finestra ha una sintassi ben precisa anche se ci sono innumerevoli varianti
che affronteremo nei capitoli successivi. Anche se sembra scritta su due righe in realtà
potete trascriverla anche su una sola.
MessageBox.Show(TitoloMessaggio, TitoloFinestra,
MessageBoxButtons.OKCancel, MessageBoxIcon.Exclamation)
MessageBox.Show Questa parte di codice comanda l’apertura della finestra, ovviamente da sola
non funziona e aspetta la specifica di altri parametri da parte vostra.
Questa variabile l’ho messa io in realtà è il testo del messaggio della
finestra. Potevate anche scrivere direttamente il testo fra virgolette in-
TitoloMessaggio
vece che utilizzare una variabile ma se il testo della finestra cambia
durante le varie fasi del programma è meglio assegnarlo ad una variabile.
Vale quanto detto per la variabile precedente. Sapete cos’è il titolo della
TitoloFinestra finestra vero? Altrimenti vi rimando al Volume “Il Computer Partendo da Zero
Vol.1”
Vuole sapere quali pulsanti devono apparire sulla finestra di
MessageBoxButtons.OKCancel
messaggio. La lista è più avanti in questo paragrafo
Vuole sapere quale icona deve fare apparire accanto al testo
MessageBoxIcon.Exclamation
del messaggio.
155
Alcuni di questi parametri sono facoltativi ad esempio è possibile visualizzare una finestra
di messaggio anche senza l’icona. (Che brutto)
Infine, la riga
If Risposta = DialogResult.OK Then
Seve per capire quale tasto da parte dell’operatore è stato premuto in modo da elaborare
una risposta degna. La tabella qui sotto mostra la lista dei pulsanti che è possibile fare
apparire nella finestra di messaggio.
MessageBoxButtons.OK Fa apparire il solo pulsante OK

MessageBoxButtons.OKCancel OK e Cancel.
MessageBoxButtons.AbortRetryIgnore Interrompi, Riprova o Ignora
MessageBoxButtons.RetryCancel Riprova e Cancel.
MessageBoxButtons.YesNo Si o No
MessageBoxButtons.YesNoCancel Si, No e Cancel.
Anche se non è importante perché è possibile scoprire quale pulsante è stato premuto in
un altro modo, alla pressione di un tasto la variabile Risposta assume questi valori.
OK 1
Cancel 2
Abort 3
Retry 4
Ignore 5
Yes 6
No 7
Quindi è possibile scrivere questo codice con gli stesso risultato.
If Risposta = DialogResult.OK Then If Risposta = 1 Then
Per quanto riguarda il parametro che gestisce l’icona che accompagna il messaggio nella
finestra, quelli principali sono elencati qui sotto. Fate una serie di prove e vedrete che vi
divertirete non poco.
MessageBoxIcon.Error Errore
MessageBoxIcon.Exclamation Esclamativo
MessageBoxIcon.Information Informazione
MessageBoxIcon.Question Domanda
MessageBoxIcon.Stop Stop
MessageBoxIcon.Warning Avviso
156
InputBox
Questa finestra visualizza sullo schermo una richiesta di immissione dati, attende che
l’utente inserisca il testo e prema dalla tastiera il tasto invio o faccia click sul pulsante OK
nella parte destra della finestra, quindi restituisce una stringa con il contenuto della casella
di testo. È utilizzata per acquisire dati, anche se poi nella realtà l’immissione dei dati può
avvenire con altri metodi più sofisticati.
La sintassi competa del comando è:
InputBox(Stringa1, Stringa2, Stringa3, Int32, Int32)
Stringa1 Obbligatoria. Questa è la frase che verrà visualizzata sulla finestra di dialogo.
La massima lunghezza di questa frase è circa 1024 caratteri. Se la frase è
lunga è possibile disporla su più righe attraverso il comando VbLf. (vedi
esempio di codice)
Stringa2 Espressione facoltativa. Rappresenta il Titolo della finestra. Se si omette
sulla barra del titolo verrà visualizzata il nome dell’applicazione.
Stringa3 Espressione facoltativa. Rappresenta un valore predefinito che è possibile far
comparire sulla casella di testo. Se l’utente non inserisce nulla viene consi-
derato come valore predefinito.
Int32 Facoltativo. Rappresenta un numero intero a 32 bit che specifica in twip
(qualcosa che somiglia al pixel) la distanza dal bordo sinistro dello schermo.
Se si omette questo argomento la finestra sarà centrata nello schermo
Int32 Facoltativo. Rappresenta un numero intero a 32 bit che specifica in twip la
distanza dal bordo superiore dello schermo. Se si omette questo argomento
la finestra sarà centrata nello schermo.
L’espressione restituisce una stringa di caratteri che rappresenta il testo che è stato im-
messo dall’utente. Esempio di codice:
Dim Messaggio, Titolo, Predefinito As String

Dim PosizioneX As Integer
Dim PosizioneY As Integer
Dim Risultato As String
Messaggio = "Ciao ! Come ti chiami?"

Titolo = "Richiesta nome"
Predefinito = "Pippo"
PosizioneX = 500
PosizioneY = 500
Risultato = InputBox(Messaggio, Titolo, Predefinito, PosizioneX, PosizioneY)
MsgBox("Ti chiami " & Risultato, vbOKOnly + vbExclamation, "Bravo")
Creo tre variabili tipo String che serviranno per contenere il messaggio che comparirà sulla
finestra, il titolo della finestra e il valore predefinito che, in mancanza di inserimento
dell’utente verrà preso come valore inserito.
Dim Messaggio, Titolo, Predefinito As String

157
Creo due variabili Integer che servono per memorizzare la posizione sullo schermo dove
dovrà comparire la finestra InputBox.
Dim PosizioneX As Integer
Dim PosizioneY As Integer
Assegno i valori alle tre variabili stringa.

Messaggio = "Ciao ! Come ti chiami?"
Titolo = "Richiesta nome"
Predefinito = "Pippo"
Definisco la posizione sullo schermo

PosizioneX = 500
PosizioneY = 500
Faccio apparire la finestra InputBox sullo schermo ed inserisco nella variabile Risultato
quello che l’utente ha digitato dalla tastiera. Se l’utente non digita nulla e si limita a premere
Invio dalla tastiera o a fare click sul pulsante OK sulla finestra, il valore predefinito che
verrà inserito nella variabile Risultato è quello specificato dalla variabile Predefinito.
Risultato = InputBox(Messaggio, Titolo, Predefinito, PosizioneX, PosizioneY)
Fa comparire una finestra di messaggio, vista nel capitolo precedente, che mostra sullo
schermo il contenuto della variabile Risultato, ovvero quello che l’utente ha digitato dalla
tastiera.
Ricordate che alcuni parametri sono facoltativi, quindi possono essere omessi, come nella
seguente riga di codice dove non sono specificati. In questo caso la finestra verrà centrata
nello schermo e la casella di testo comparirà all’utente senza nessun valore predefinito.
Risultato = InputBox(Messaggio, Titolo)
Nel caso di valori omessi, ai quali ne seguono altri non omessi, digitate le virgole che sepa-
rano i parametri come ad esempio nella riga successiva.
Risultato = InputBox(Messaggio, Titolo,, PosizioneX, PosizioneY)
Se sostituite l’ultima parte del codice con quello che esegue, finché l’utente non avrà inserito
un nome valido, la finestra di richiesta si ripresenterà imperterrita sullo schermo.
Etichetta:
Risultato = InputBox(Messaggio, Titolo,, PosizioneX, PosizioneY)
If Len(Risultato) = 0 Then
MsgBox("Non hai inserito il nome" & Risultato, vbOKOnly + vbExclamation, "Bravo")
GoTo Etichetta
End If
Per disporre messaggio di richiesta su più righe.
Messaggio = "Ciao ! Come ti chiami?" & vbLf & "Per favore digita il nome nella casella
sottostante"
158
OpenFileDialog
Questa finestra corrisponde alla finestra Apri nel menu File di qualsiasi programma di que-
sto mondo, quindi molto popolare rispetto a tante altre finestre che tratteremo in questo
capitolo. Vedremo subito l’applicazione pratica di questo Oggetto senza dilungarci in inutili
questioni teoriche.
OpenFileDialog & PictureBox

In questo esercizio vedremo insieme come si fa ad aprire un’immagine che si trova in una
cartella del nostro computer e visualizzarla utilizzando un controllo tipo PictureBox, che non
è stato trattato nella sezione dei controlli proprio per rendere l’esempio più realistico e
vedere all’opera due controlli in un colpo solo.
Create un nuovo progetto e inserite nel Form un controllo Button ed un controllo PictureBox
dalla Casella degli strumenti.
Inserite adesso un controllo tipo OpenFileDialog che troverete sempre nella Casella degli
strumenti e noterete che questo non viene inserito nel Form, ma piazzato in basso in un’area
tutta sua. Si tratta di un oggetto che non è visibile all’operatore e per questo viene posizio-
nato in un’area separata in basso nella finestra.
Quindi fate doppio click sul pulsante che avete inserito nella finestra per generare l’evento
Click del pulsante stesso, e inserite il codice nelle varie aree del programma come mostra
la figura successiva.
159
Per maggiore chiarezza il codice viene riportato anche nella tabella successiva.
Option Explicit On
Public Class Form1
Dim percorsoImmagine As String
PictureBox1.SizeMode = PictureBoxSizeMode.StretchImage
Button1.Text = "Apri"
End Sub
OpenFileDialog1.Title = "Apri Immagine"

OpenFileDialog1.InitialDirectory = "C:\Users\Giuseppe\Pictures\"
OpenFileDialog1.Filter = "Immagini (*.jpg)|*.jpg|Bitmap (*.bmp)|*.bmp|Tutti i File
(*.*)|*.*"
OpenFileDialog1.FilterIndex = 1
If OpenFileDialog1.ShowDialog = DialogResult.OK Then
percorsoImmagine = OpenFileDialog1.FileName
PictureBox1.Image = Image.FromFile(percorsoImmagine)
End If
End Sub
End Class
160
Descriviamo brevemente le operazioni principali per poi andare sul complicato.
Con questa riga viene dichiarata una variabile che conterrà sotto forma di stringa di caratteri
la posizione nel vostro computer dove si trova l’immagine e il nome dell’immagine stessa.
Con questa riga dico che il controllo PictureBox deve adattare alla grandezza del controllo
stesso l’immagine che gli verrà assegnata.
Inserisco un titolo alla finestra ad esempio “Apri Immagine”
Assegno alla finestra di dialogo una cartella iniziale dove dovrà aprirsi, quindi sul vostro
computer dovete sostituire il nome dell’utente
OpenFileDialog1.InitialDirectory = "C:\Users\Giuseppe\Pictures\"
Attivo il filtro per tipologia dei file. Le varie tipologie vanno separate da una barretta verti-
cale che si trova alla sinistra del tasto “1” in alto a sinistra nella tastiera.
OpenFileDialog1.Filter = "Immagini (*.jpg)|*.jpg|Tutti i File (*.*)|*.*"
Altri esempi:
In questo caso verranno visualizzati a richiesta i file tipo jpg, bmp oppure tutti i file contenuti
nella cartella.
OpenFileDialog1.Filter = "Immagini (*.jpg)|*.jpg|Bitmap (*.bmp)|*.bmp|Tutti i File (*.*)|*.*"
Posiziona il filtro sul primo tipo di File della lista (jpg)
Quindi se viene premuto il pulsante Apri o OK in basso nella finestra di dialogo dopo che è
stata selezionata l’immagine
Assegno al controllo PictureBox il percorso del file con tanto di nome proveniente dalla
selezione fatta nella finestra di dialogo.
percorsoImmagine = OpenFileDialog1.FileName
PictureBox1.Image = Image.FromFile(percorsoImmagine)
Fate una prova di funzionamento ma mi raccomando cambiate il nome dell’utente come

consigliato prima altrimenti non funzionerà. Avviate il programma per fare una prova
Per fate in modo che questo programma funzioni su qualsiasi tipo di computer (Windows
ovviamente) dovete sostituire il codice di esempio con quello che vedete nella figura suc-
cessiva.
161
Le differenze sostanziali sono:

con queste due righe recupero il nome dell’utente che sta lavorando su quel computer e lo
metto nella stringa NomeUtente. Questo giochino separa il nome dell’utente da quello del
computer in quanto quando invoco la proprietà My.User.Name viene restituito sia il nome
dell’utente che quello del computer. A noi basta quello dell’utente per il momento.
Dim Informazione() As String = Split(My.User.Name, "\")

Dim NomeUtente As String = Informazione(1)
Poi cambio la riga che assegna la cartella inziale alla finestra di dialogo in questo modo
passo il nome utente.
OpenFileDialog1.InitialDirectory = "C:\Users\" & NomeUtente & "\Pictures\"
Avviate il programma e verificatene il funzionamento.
Adesso faremo altre considerazioni sull’utilizzo del PictureBox. Questa riga di programma
che vedete qui sotto è solo dimostrativa e può essere anche non digitata nel codice, nel
senso che se desiderate assegnare direttamente l’immagine al controllo PictureBox senza
utilizzare la finestra di dialogo OpenFileDialog, potete eseguire l’assegnazione direttamente
così:
Dim percorsoImmagine As String = "C:\Users\Giuseppe\Pictures\girasoli.jpg"

PictureBox1.Image = image.FromFile(percorsoImmagine)
Oppure

PictureBox1.Image = image.FromFile("C:\Users\Giuseppe\Pictures\girasoli.jpg")
162
SaveFileDialog e File di Testo
In quest’esempio vediamo come realizzare un semplice programma che ci permette di scri-
vere file di testo come quelli del blocco note di Windows, di salvarli o modificarli utilizzando
le finestre di Dialogo Apri e Salva. Dato che la quantità di codice scritto è maggiore di quella
degli esempi precedenti, non può essere visualizzata in una solo schermata e quindi la
riporteremo dentro un riquadro.
Innanzitutto, create un nuovo progetto e inserite in un Form due pulsanti e una casella di
testo. Prima di ridimensionare la casella di testo per renderla simile alla figura qui di seguito
dovete modificare la sua proprietà Multiline ed impostarla su True, in modo che quella ca-
sella diventi un riquadro di testo dove è possibile scrivere anche su più di una riga. Prima
di modificare una proprietà di un qualsiasi oggetto, per favore fate un click sull’oggetto
stesso per essere sicuri che sia selezionato, onde evitare di modificare la proprietà di qual-
che altro oggetto.
Inserite quindi anche un controllo OpenFileDialog e un SaveFileDialog.
Fate doppio click sul pulsante Button1 che avete inserito nel Form per generare il codice
corrispondente all’evento Click per poi ripetere l’operazione anche con l’altro pulsante.
Il listato competo del codice è riportato qui di seguito:
Option Explicit On
Imports System.IO
Public Class Form1

163
Dim NomeFile As String
Button2.Text = "Salva"
Button2.Enabled = False
End Sub
OpenFileDialog1.FileName = ""
OpenFileDialog1.Title = "Apri File di Testo"
OpenFileDialog1.InitialDirectory = "C:\Users\" & NomeUtente & "\Documents\"
OpenFileDialog1.Filter = "File di Testo (*.txt)|*.txt|Tutti i File (*.*)|*.*"
NomeFile = OpenFileDialog1.FileName
Dim OggettoReader As StreamReader = New StreamReader(NomeFile)

TextBox1.Text = OggettoReader.ReadToEnd
OggettoReader.Close()
OggettoReader = Nothing
End If
End Sub
SaveFileDialog1.FileName = NomeFile
SaveFileDialog1.Title = "Salva file di text"
SaveFileDialog1.InitialDirectory = "C:\Users\" & NomeUtente & "\Documents\"
SaveFileDialog1.Filter = "File di Testo (*.txt)|*.txt|Tutti i File (*.*)|*.*"
SaveFileDialog1.FilterIndex = 1
If SaveFileDialog1.ShowDialog = DialogResult.OK Then
NomeFile = SaveFileDialog1.FileName
Dim OggettoWriter As StreamWriter = New StreamWriter(NomeFile, False)
OggettoWriter.Write(TextBox1.Text)
OggettoWriter.Close()
OggettoWriter = Nothing
End If
End Sub
Private Sub TextBox1_TextChanged(sender As Object, e As EventArgs) Handles

TextBox1.TextChanged
Button2.Enabled = True
If TextBox1.TextLength = 0 Then
164
End If
End Sub
End Class
Proviamo ad analizzarlo riga per riga (ora le cose si complicano un po’) saltando ovviamente
le righe di codice che aggiunge in automatico Visual Basic per generare le routine e lo Spazio
dei nomi.
Rendo esplicite le dichiarazioni delle variabili per evitare errori.
Option Explicit On
Devo importare una libreria che contiene oggetti utili alla lettura ed alla scrittura di un file
dato che non sono presenti in Visual Basic.
Imports System.IO
Tecnica già vista nell’esempio precedente per recuperare il nome dell’utente del computer

Dichiaro una variabile che conterrà il nome del File.
Assegno il testo ai due pulsanti
Button2.Text = "Salva"
Disattivo il pulsante Salva.
Faccio in modo che inizialmente nella finestra Apri File non ci sia nessun nome nel riquadro
del nome del file da aprire in basso nella stessa finestra.
In questo modo dò un titolo alla finestra per evitare di confonderla con Salva File.
Mi posiziono inizialmente nella cartella Documenti del computer.
Faccio in modo che sulla lista compariranno solo le cartelle e i file del tipo txt, ovvero dei
comuni File di testo.
Mi posiziono quando si aprirà la lista per la scelta del tipo di file sul primo tipo, ovvero file
di testo.
165
Faccio comparire sullo schermo la finestra Apri e verifico che la risposta dell’utente sia
positiva.
Inserisco nella variabile nome file recuperato dalla selezione che l’operatore ha fatto nella
lista
Definisco un oggetto tipo StreamReader che serve per leggere in un file di testo.
Metto il testo dentro la casella di testo.
Chiudo l’oggetto
Lo faccio sparire dalla memoria.
La parte che riguarda il salvataggio del file viene gestita così.

Inserisci il nome del file nella casella di testo che si trova in basso nella finestra Salva con
Nome, in modo che eventualmente sovrascriva il file già esistente senza creare un altro.
SaveFileDialog1.FileName = NomeFile
Assegno il titolo alla finestra per evitare di sbagliare fra Apri e Salva.
SaveFileDialog1.Title = "Salva file di text"
Imposto la destinazione nella cartella Documenti.
SaveFileDialog1.InitialDirectory = "C:\Users\" & NomeUtente & "\Documents\"
Faccio in modo che nella lista compariranno solo i file di testo.
SaveFileDialog1.Filter = "File di Testo (*.txt)|*.txt|Tutti i File (*.*)|*.*"

SaveFileDialog1.FilterIndex = 1
Se l’utente salva correttamente
If SaveFileDialog1.ShowDialog = DialogResult.OK Then
Prendo il nome del file e lo salvo nella variabile
NomeFile = SaveFileDialog1.FileName
Definisco un oggetto StreamWriter che mi permetterà di scrivere un File di testo
Dim OggettoWriter As StreamWriter = New StreamWriter(NomeFile, False)

166
Scrivo nel file il contenuto della casella di testo.
OggettoWriter.Write(TextBox1.Text)
Chiudo l’oggetto e l’annullo.
OggettoWriter.Close()
OggettoWriter = Nothing
Inoltre, inserisco nell’evento Text_Changed della casella di testo questo codice che serve
per abilitare o disabilitare il pulsante Salva nel caso in cui il testo non venga modificato.
If TextBox1.TextLength = 0 Then
End If
il codice completo di questo ed altri esercizi è scaricabile previa registrazione all’indirizzo

www.edizionifutura.com oppure richiedendolo per posta elettronica all’indirizzo:
libri@edizionifutura.com
167
FontDialog
La finestra di dialogo Font è decisamente meno complicata nella gestione del codice rispetto
a quelle precedenti.
Come nel caso precedente, create un nuovo progetto e in un form inserite una casella di
testo e un pulsante. Inoltre, inserite un controllo tipo FontDialog che utilizzeremo per cam-
biare le caratteristiche del testo che digiteremo nella casella di testo.
Quando trasciniamo un controllo che rappresenta una finestra di dialogo in un form questo
si posiziona nella parte bassa della finestra in un’area separata.
Il codice del progetto è tutto qui, quindi prendiamo la cosa per buona. È possibile aggiun-
gere il codice all’esercizio precedente tenendo presente però che un file di testo non può
contenere la formattazione del testo, e quindi la diversificazione del Font vale solo sul vostro
schermo.
168
ColorDialog
Questo controllo vi permette di scegliere un colore per poi farne i più svariati utilizzi, come
ad esempio, cambiare il colore del testo contenuto in una casella di testo, oppure cambiare
il colore di testo di un pulsante.
A volte è necessario permette all’utilizzatore del programma di personalizzare l’ambiente di
lavoro, e questo controllo vi permette appunto di modificare i colori del testo presente su
altri controlli, oppure cambiare i colori di una finestra di Windows. (oggetto Form)
Come nel caso precedente, create un nuovo progetto e inserite una TextBox, un Button e
un ColorDialog in un Form, come si vede nella figura successiva.
Il codice è abbastanza semplice come nel caso precedente.

169
PrintDialog
Qui le cose invece si complicano e non poco. La finestra di Dialogo Print o PrintDialog in
realtà non esegue la stampa vera e propria ma serve semplicemente per scegliere la stam-
pante sulla quale stampare. Nell’esempio che troverete insieme al codice allegato a questo
libro, che come abbiamo già detto è scaricabile sul sito della casa editrice previa registra-
zione, ho reso la stampa più realistica attraverso l’utilizzo di tre componenti:
• PrintDialog che serve solo per permettere la scelta della stampante,

• PrintDocument serve per stampare il testo,
• PrintDocumentPreview serve per visualizzare l’anteprima di stampa, prima che il
testo venga realmente stampato
aggiungendo anche la finestra di dialogo OpenFileDialog che abbiamo già visto nei capitoli
precedenti per aprire un file di testo.
In pratica vedremo come sia possibile stampare un file di testo (.txt) attraverso Visual
Basic. Altri esempi di stampa sono esposti nei capitoli che trattano dei database.
Una volta che avete aggiunto al form una casella di testo in versione MultiLine e due pul-
santi, possiamo concentrarci sul codice dell’esercizio.
Option Explicit On
Imports System.IO
Imports System.Drawing.Printing
Public Class Form1

170


Dim NumeroRighe As Integer
Dim LettoreFile As StreamReader
Button2.Text = "Stampa"
PrintDialog1.AllowPrintToFile = True
PrintDialog1.ShowNetwork = False
End Sub
LettoreFile = New StreamReader(NomeFile)
If PrintDialog1.ShowDialog = DialogResult.OK Then

PrintPreviewDialog1.Document = PrintDocument1
PrintPreviewDialog1.Width = Me.Width
PrintPreviewDialog1.Height = Me.Height
PrintPreviewDialog1.ShowDialog()
End If
LettoreFile.Close()
LettoreFile = Nothing
End Sub
Dim LettoreFile As StreamReader = New StreamReader(NomeFile)

TextBox1.Text = LettoreFile.ReadToEnd
LettoreFile.Close()
End If
End Sub
171
Private Sub PrintDocument1_PrintPage(sender As Object, e As PrintPageEventArgs) Handles
PrintDocument1.PrintPage
Dim Font1 As New Font("Verdana", 8, FontStyle.Bold)

Dim RigheperPagina As Single = 0
Dim PosizioneVerticale As Single = 0
Dim ConteggioRiga As Integer = 1
Dim MargineSinistro As Single = e.MarginBounds.Left
Dim Marginesuperiore As Single = 100
Dim StringaRiga As String
Dim j As Integer
RigheperPagina = Int(e.MarginBounds.Height / Font1.GetHeight(e.Graphics))
PosizioneVerticale = PosizioneVerticale + 20
For j = 1 To RigheperPagina
If (LettoreFile.EndOfStream = True) Then Exit Sub
StringaRiga = LettoreFile.ReadLine
'calcola la posizione verticale nella pagina

PosizioneVerticale = Marginesuperiore + (ConteggioRiga *
Font.GetHeight(e.Graphics))
'Stampa Riga
e.Graphics.DrawString(StringaRiga, Font1, Brushes.Black, MargineSinistro,
PosizioneVerticale)
ConteggioRiga = ConteggioRiga + 1
Next j
If ConteggioRiga >= RigheperPagina Then
ConteggioRiga = 0
e.HasMorePages = True
End If
End Sub
End Class
Innanzitutto, importo le due librerie necessarie all’esercizio.
Imports System.IO
Recupera il nome dell’utente del computer e lo inserisce nella stringa NomeUtente. Questa
operazione l’abbiamo già vista in diversi altri esercizi.

Definisco le seguenti variabili:

172
Dim NumeroRighe As Integer
Dim LettoreFile As StreamReader
Nell’evento Form_Load inserisco questo codice che fa comparire sui relativi pulsanti Button
il testo Apri e Stampa.
Button2.Text = "Stampa"
Disattiva per il momento il pulsante di stampa.
I comandi seguenti servono per permettere o meno la “stampa su File” dalla finestra di
dialogo PrintDialog e per accedere alle stampanti in rete. Sono solo alcune opzioni disponibili
sulla finestra PrintDialog utilizzate come esempio di assegnazione, possono tranquillamente
essere ignorate.
PrintDialog1.AllowPrintToFile = True
PrintDialog1.ShowNetwork = False
Il codice inserito nell’evento Click del pulsante Button1 serve per aprire un file di testo ed
inserire il contenuto nella casella di testo. Abbiamo visto questo tipo di applicazione
nell’esempio della finestra OpenFileDialog.
Dim LettoreFile As StreamReader = New StreamReader(NomeFile)

TextBox1.Text = LettoreFile.ReadToEnd
LettoreFile.Close()
End If
Il codice sotto l’evento Click del Button2 serve invece per aprire la finestra di dialogo
Stampa e in caso di risposta affermativa da parte dell’utente alla stampa del file che com-
parirà sullo schermo, fa comparire l’anteprima di stampa prima di effettuare la stampa vera
e propria.
LettoreFile = New StreamReader(NomeFile)

173
End If
LettoreFile.Close()
Assegna all’anteprima di stampa di dati che si trovano nell’oggetto PrintDocument1.
Imposta l’anteprima di stampa alla grandezza dello schermo o meglio dell’applicazione.
Fa apparire l’anteprima sullo schermo.
L’ultima parte del codice serve per gestire la stampa vera e propria. Innanzitutto, decido il
font (tipo di carattere) di stampa.
Creo una variabile che per memorizzare quante righe ci saranno per pagina.
Dim RigheperPagina As Single = 0
Questa variabile memorizza la posizione verticale nella pagina della riga che andrò a stam-
pare. Capiremo meglio il suo utilizzo più avanti nell’esercizio.

Questi invece sono i margini della pagina, recupero il margine sinistro dalle impostazioni
predefinite.
Dim MargineSinistro As Single = e.MarginBounds.Left
Quello superiore lo stabilisco io ma potrei anche fare la stessa operazione che ho fatto per
il margine sinistro, ovvero recuperarlo da quello predefinito che a dire la verità è un po’
abbondante.
Definisco la variabile che serve per memorizzare ogni riga del file mentre viene letto.
Dim StringaRiga As String

Dim j As Integer
Calcolo orientativamente quante righe possono stare in una pagina a seconda del font uti-
lizzato.
Imposto un passo per le righe di stampa
174
Ripeto le istruzioni che si trovano fra le parole chiave For e Next finché la variabile j incre-
mentandosi di 1 arriva a uguagliare la variabile RigheperPagina.
Controllo che il lettore di flusso del file non sia arrivato alla fine del file stesso.
If (LettoreFile.EndOfStream = True) Then Exit Sub
Leggo una riga dal file.
StringaRiga = LettoreFile.ReadLine
Calcola la posizione verticale nella pagina dove devo stampare la riga che ho letto.
PosizioneVerticale = Marginesuperiore + (ConteggioRiga * Font.GetHeight(e.Graphics))
Stampa la riga letta nel file. L’istruzione è abbastanza chiara su quali parametri vanno
passati alla stampante, ovvero i dati che devo stampare, il font da utilizzare, il colore del
testo, il margine sinistro e la posizione verticale dove il testo si deve trovare nella pagina
che verrà stampata.
e.Graphics.DrawString(StringaRiga, Font1, Brushes.Black, MargineSinistro, PosizioneVerticale)
incremento la posizione verticale nella pagina e conteggio della riga
Incremento il valore della variabile j e ricomincio dalle istruzioni che si trovano sotto l’istru-
zione For fino a quando j non è uguale al Numero di righe per pagina.
Next j
Controllo che il numero delle righe che sto stampando non ecceda quello del numero di
righe che entrano nella pagina.
Se si verifica questa condizione resetto il contatore di riga e …
ConteggioRiga = 0
aggiungo una nuova pagina. Tutte le volte che viene aggiunta una nuova pagina viene
creato un evento PrintPage per l’oggetto PrintDocument quindi tutto il codice quell’evento
viene rieseguito nuovamente fino ad esaurimento righe di stampa.
End If
Fino a quando non si esauriscono le righe da stampare. Dato che i vari parametri sono
realmente tanti, e quindi per creare stampe complesse la strada è veramente lunga, se
desiderate visionare altre applicazioni per la stampa consultate anche il capitolo dei data-
base.
Operazioni sui Form e sui Menu
175
Qualsiasi progetto di questo mondo è costituito sicuramente di diverse finestre che insieme
formano l’applicazione, ad esempio una finestra dove inserisco i nuovi clienti, quella dove
verifico le vendite e così dicendo.
Esistono però diverse tipologie di finestre a seconda delle nostre necessità. Gli esempi con
cui abbiamo avuto a che fare fino ad adesso sono sostanzialmente progetti costituiti da
un’unica finestra, mentre in questo capitolo affronteremo un progetto strutturato.
Form MDI
Create un nuovo progetto facendo Click sul menu File e selezionando la voce Nuovo-Pro-
getto oppure attraverso la combinazione da tastiera CTRL+MAIUSC+N. come mostra la
figura successiva scegliete la voce App Windows Forms e fate click sul pulsante Avanti
in basso a destra nella finestra.
Assegnate un nome al progetto dalla finestra successiva e salvate.

Questo tipo di finestra chiamata Form MDI in realtà è un contenitore che gestirà le altre
finestre del progetto, mostrando il menu principale, le barre degli strumenti, la barra di
stato e un’area dove tutte le finestre verranno visualizzate e, se ci pensate bene, quasi tutti
i programmi Windows hanno alla fine della fiera, queste caratteristiche.
Iniziamo sistemando l’area di lavoro come mostra la figura successiva visualizzando sullo
schermo la finestra Esplora Soluzioni (che si attiva anche dalla tastiera attraverso il co-
mando CTRL+ALT+L) e la finestra delle Proprietà (tasto F4).
Adesso dal menu Progetto in alto nella finestra scegliete la voce Aggiungi Windows
Form come mostra la figura successiva.
176
Fate click sulla voce Windows Form, selezionate Form padre MDI e assegnategli un
nome. Di solito lo chiamo Principale ma potete dare sfogo alla vostra fantasia.
177
Quindi fate click sul pulsante Aggiungi in basso a destra nella finestra e vedrete comparire
sullo schermo qualcosa di molto simile alla figura sottostante.
Nella finestra Esplora soluzioni vediamo elencato in ordine alfabetico i form e altri oggetti
presenti nel progetto.
Il Form padre MDI viene fornito con una serie di elementi già pronti che onestamente,
abituato a fare tutto in modo manuale, non gradisco granché.
Il menu principale presenta le caratteristiche classiche di un programma standard ma vi
garantisco che la maggior parte di quelle voci non serve a nulla, oppure le potete persona-
lizzare in altro modo.
Inoltre, dovete procedere in modo particolarmente accorto perché gli elementi che vengono
inclusi automaticamente nel Form MDI come ad esempio i menu o le barre degli strumenti
generano automaticamente un sacco di codice che potrebbe portarvi fuori dal seminato con
il rischio di perdere la strada per tornare a casa.
Una delle prime cosa da fare una volta presa coscienza che la situazione è particolarmente
ingarbugliata è quella di dire al progetto quale finestra deve apparire per prima quando lo
avvierete. Se non impostate questo parametro, il progetto partirà chissà da dove e nessuno
potrà dire con certezza quello che apparirà sullo schermo.
Fate click sul menu Progetto in alto nella finestra e selezionate la voce Proprietà seguita
di solito dal nome del vostro progetto, che in questo caso abbiamo chiamato FormMDI,
per restare in argomento.
178
Selezionate dalla lista Form di Avvio il form Principale come form che comparirà per
primo sullo schermo quando l’applicazione si avvierà.
Assegnate se desiderate un’icona distintiva per all’applicazione.

179
Per il momento non smanettate in altre impostazioni di questa finestra, anche se
sembrano dotate di descrizioni amichevoli, il loro cambiamento arbitrario potrebbe
portare dei funzionamenti non graditi.
Chiedete la Finestra delle proprietà come indicato nella figura sottostante.
Fate click sul FormMDI (Principale) per essere sicuri che le proprietà che vedete nella figura
successiva si riferiscano al Form e non a chissà quale altro oggetto presente nella finestra.
A volte basta una semplice distrazione per non trovare nella lista la proprietà che cerchiamo.
Modificate la proprietà WindowsState e impostatela a Maximized in modo che la finestra
Principale al momento dell’avvio dell’applicazione occupi tutto lo schermo a disposizione.
Avviate il progetto per vedere se fino a qui abbiamo eseguito le operazioni in modo corretto.
Una volta verificato che tutto procede secondo i piani, tornate in modalità di progettazione
ed eliminate la Barra degli strumenti, perché nessun programmatore utilizzerà mai la barra
come la vedete adesso. Per eliminarla basta selezionarla con un click del tasto SX del mouse
e premere CANC o DEL dalla tastiera. Il risultato sarà simile alla figura successiva.
180
Adesso passate dal lato codice facendo doppio click all’interno del FormMDI ed eliminate
tutto il codice, fino a che non resta solo quello che vedete nella figura successiva. Ponete
particolare attenzione a questa operazione, altrimenti rischiate che il progetto mostri qual-
che malfunzionamento che poi diventa complicato da gestire.
In pratica resta solo quello che vedete di seguito.

181
Imports System.Windows.Forms
Public Class Principale
Private Sub Principale_Load(sender As Object, e As EventArgs) Handles MyBase.Load
End Sub
End Class
Il Menu Principale
Quando iniziamo un progetto è molto difficile che nelle fasi iniziali il programmatore conosca
con certezza tutte le voci che compariranno sul menu principale, che sicuramente non sa-
ranno comunque quelle proposte dal Visual Studio. Per questo il menu è ampiamente per-
sonalizzabile anche in maniera relativamente veloce attraverso semplici passi.
Anche se può sembrare una cosa ovvia, il menu in fase di progettazione non si comporta
come nella fase di esecuzione del programma, quindi prestate attenzione perché qui un
click o due click del mouse realizzano operazioni diverse.
Fate click sul menu File per aprire la lista.
Come in fase di esecuzione del programma, anche in questo caso viene visualizzato il menu
a tendina classico di Windows, con il quale fin dai primi anni, quindi praticamente al tempo
di Re Pipino, tutti ma proprio tutti abbiamo avuto a che fare durante l’utilizzo di un qualun-
que programma.
Per eliminare una voce non gradita selezionatela con un click del tasto DX del mouse e dalla
lista scegliete la voce Elimina come mostra la figura successiva.
Eliminate per prova qualche voce (non tutte per favore) prima di passare all’esempio suc-
cessivo.
182
Per aggiungere un nuovo elemento (non importa la posizione iniziale in quanto le voci sono
facilmente spostabili) fate click in fondo alla lista in corrispondenza del testo [Digitare qui]
e dalla tastiera digitate il testo corrispondente all’azione da eseguire.
Digitate ad esempio la voce Impostazioni che si riferirà alle impostazioni e personalizza-

zioni del programma che potrà effettuare l’utente, ad esempio, cambiare il colore del testo
o cose di questo genere qui, quindi premete il tasto Invio dalla tastiera per confermare il
testo.
183
Per spostare la voce del menu in un’altra posizione basta trascinarla con il tasto SX del
mouse e rilasciarla (drag & drop) nel posto che reputate più comodo.
Per modificare il testo della voce fate click sulla voce stessa, attendete qualche istante e
ripete il click in modo che il testo venga evidenziato, quindi digitate il nuovo testo e premete
Invio dalla tastiera per confermare la nuova immissione.
184
Separatore
Il separatore come dice il nome, è un elemento grafico che appare come una linea che
separa le voci del menu in modo da presentarle per argomenti o utilità. L’immagine suc-
cessiva è un esempio.
Per spostare un separatore in un’altra posizione si opera un trascinamento con il tasto SX

del mouse, mentre per inserirne uno nuovo fate click con il tasto DX del mouse in un punto
del menu dove ritenete necessario l’inserimento del separatore, e dalla voce Inserisci sce-
gliete Separator.
Per eliminare un separatore invece basta fare click con il tasto SX del mouse per selezionarlo
e dalla tastiera premete il tasto CANC o DEL.
185
Personalizzare un menu
Andando avanti nella personalizzazione del nostro menu principale, vediamo adesso altre
operazioni di carattere estetico/funzionale che ci permetteranno di padroneggiare le impor-
tanti funzionalità del menu a tendina (controllo MenuStrip).
Per eliminare un intero blocco di menu, ad esempio come nella figura sottostante, fate click
con il tasto DX del mouse in corrispondenza della voce di menu e dalla lista scegliete la
voce Elimina.
Eliminate altri menu lasciando solo il menu file e il menu (?) come si vede nella figura
sottostante.
Per aggiungere altri menu a tendina nella riga in alto accanto al menu File, ad esempio,
fate click sulla Barra dei menu (MenuStrip) come nella figura successiva e digitate nel ri-
quadro (digitare qui) il testo del menu ad esempio Tabelle. Quando avrete metabolizzato
186
tutte queste operazioni potete iniziare a sviluppare la vostra applicazioni Windows utiliz-
zando le voci più consone a descrivere le varie funzioni del programma. L’esempio che
facciamo adesso ricalca quello che è il programma Gestioni da me sviluppato.
La situazione finale è simile a quella della finestra sottostante.
Per spostare un menu in orizzontale in un’altra posizione lungo la Barra dei menu basta
trascinarlo come abbiamo già visto per le voci di menu e per i separatori, la tecnica è la
stessa.
187
Combinazioni di tasti da tastiera.
Ogni voce di menu, per mantenere la compatibilità con tutti quei modi di lavorare che esi-
stono fin dalla notte dei tempi dell’informatica, è attivabile anche attraverso la tastiera,
anziché con il mouse come viene fatto di solito.
Le combinazioni di tasti da tastiera vengono attivate dal tasto ALT che si trova in basso a
sinistra nella tastiera accanto alla barra di spazio. Per fare in modo che un menu venga
attivato con la tastiera basta aggiungere un simbolo & (e commerciale) alla parola che
rappresenta il menu ad esempio &Tabelle.
In questo modo quel menu si attiverà anche dalla tastiera eseguendo la combinazione
ALT+T ovvero la lettera accanto alla quale abbiamo posizionato il simbolo &.
Sul menu la lettera T apparirà sottolineata. (Tabelle)
Il risultato finale è visibile nella figura qui sotto.
È possibile anche attivare un menu con una lettera diversa da quella iniziale, ad esempio
nessuno vi vieta di posizionare il simbolo & accanto alla lettera a come a esempio T&abelle.
In questo caso il menu verrà attivato dalla tastiera con la combinazione ALT+A.
Se c’è più di un menu che inizia con la stessa lettera ovviamente siete costretti a
sceglierne un’altra con la tecnica che abbiamo appena visto, ricordando che tutti i
menu allineati in alto devono essere attivati necessariamente con lettere diverse
altrimenti possono verificarsi dei malfunzionamenti.
È possibile inoltre assegnare anche una scorciatoia da tastiera per ogni voce di un menu,
ad esempio come si vede nella figura successiva. Per attivare direttamente una voce per
188
l’utente sarà necessario agire in questo modo. Se ad esempio voglio dal menu Tabelle atti-
vare la voce Clienti premete e tenete premuto il tasto ALT dalla tastiera mente con l’altra
mano battete rispettivamente la lettera T rilasciando (ma sempre tenendo premuto il tasto
ALT) battete ancora la lettera C.
Attenzione. In fase di Run Time (esecuzione del programma) se non premo il tasto
ALT dalla tastiera non riesco a vedere le sottolineature delle lettere, contrariamente
ad altre versioni di Visual Basic che rendevano visibili le lettere sottolineate dei
menu sempre.
Inoltre, è possibile modificare il testo delle voci principali o della lista del menu semplice-
mente cliccando sull’elemento, ad esempio la voce Tabelle in alto nella finestra, e dalla
proprietà Text eseguire le varie modifiche del caso.
189
Scorciatoie da tastiera
Per assegnare una scorciatoia da tastiera, caratteristica presente in qualunque programma
o applicazione professionale che si rispetti, è necessario fare click per selezionare la voce
in questione ad esempio Agenti e dalla finestra delle proprietà scovate la proprietà
ShortCutKeys. Fate click sulla freccia che gestiste la lista.
Attraverso gli appositi comandi impostate ad esempio la scorciatoia CTRL+A selezionandola

dall’apposita lista indicata nella figura sottostante, quindi fate click nuovamente sulla freccia
che apre la lista per confermarne la scelta. Non fate click su Reimposta altrimenti azzerate
la scelta (sempre ammesso che non lo vogliate volutamente fare).
Verificate che la scorciatoia da tastiera scelta sia visibile accanto al menu.
190
ToolTip
Un’altra interessante caratteristica è quella di poter fare apparire un’etichetta descrittiva su
un comando al momento del passaggio del mouse sullo stesso comando, cosa molto utile
specialmente per l’operatore alle prime armi.
Dalla casella degli strumenti identificate e trascinate nel form l’oggetto ToolTip qualora que-
sti non fosse già presente nel Form (controllate in basso nella finestra). Questo controllo
aggiunge a tanti altri controlli la capacità di mostrare delle etichette al passaggio del mouse
aggiungendo la proprietà ToolTipText.
Ad esempio, quando il puntatore viene passato sulla voce Agenti, questa mostrerà una
descrizione aggiuntiva.
Sinceratevi di aver selezionato con un click la voce Agenti sul menu Tabelle e andate nella
finestra delle Proprietà alla voce ToolTipText come si vede nella figura successiva.
191
Nello spazio accanto a quella proprietà è possibile digitare il testo che dovrà comparire
all’utente quando porta il mouse sulla voce senza fare click.
Questa operazione è realizzabile anche da codice inserendo nella routine dell’evento Load
del Form il codice che vedete qui sotto.
AgentiToolStripMenuItem.ToolTipText = "Se clicchi qui visualizzi gli Agenti"
È possibile anche cambiare le voci che compaiono sul menu ad esempio la voce “Tabelle”
anche attraverso il codice con l’istruzione:
TabelleToolStripMenuItem.Text = "&Strumenti"
In questo caso il menu Tabelle diverrà il menu Strumenti.
Attenzione. Assegnate voci univoche ai menu in modo da non fare confusione

quando poi ci sarà da assegnargli delle funzioni vere e proprie.
Attiva e disattiva un menu

Per disattivare o riattivare una voce di menu basta digitare il codice che vedete qui sotto.
Dato che si tratta di un’operazione abbastanza frequente nei programmi di un certo spes-
sore meglio conoscerla bene.
192
Disattiva il menu Agenti
AgentiToolStripMenuItem.Enabled = False
Attiva il menu Agenti.
AgentiToolStripMenuItem.Enabled = True
Assegnare un’icona ad un menu

Un menu che si rispetti può presentare anche degli abbellimenti grafici per aiutare l’utente
nelle scelte, per dare un colpo d’occhio un po’ diverso dal solito e creare un ambiente più
gradevole. Innanzitutto, come già raccomandato nella parte inziale del libro, ogni program-
matore ha una cartella nel suo computer piena di icone che utilizzerà per abbellire i suoi
programmi. Nel materiale di esempio di questo libro, che potete richiedere all’indirizzo email
libri@edizionifutura.com ho incluso un po’ di questo materiale per facilitarvi l’apprendimento
della materia.
Attenzione al fatto che alcune icone, specialmente se trovate su Internet, possono essere
soggette a diritto d’autore, quindi verificatene la provenienza se le utilizzerete in un pro-
gramma che dovete distribuire, meglio ancora se utilizzate quelle proposte da Microsoft così
non correte nessun rischio.
Per assegnare un’icona ad una voce di un menu fate click sulla voce stessa per selezionarla
e dalla finestra delle proprietà cercate la proprietà Image. Fate click dove indicato in figura
al punto 3.
Dalla finestra successiva scegliete, qualora non lo fosse già, la voce Risorsa locale e quindi
fate click sul pulsante Importa.
193
Cercate la cartella depositaria delle vostre icone e sceglietene una degna di rappresentare
la voce del menu in questione. Selezionatela con un doppio click del mouse.
194
A questo punto tornando alla finestra precedente confermate la scelta con il pulsante OK
in basso a destra.
Richiamare un Form da un Form MDI.

In questo paragrafo vediamo come si fa dal menu principale ad aprire un altro oggetto Form
(o finestra chiamatela come vi pare). Dal menu Progetto inseriamo un nuovo oggetto Form
nella nostra applicazione, dato che per il momento, com’è visibile dalla Finestra Esplora
Soluzioni, è presente un solo Form ovvero quello Principale, che nel nostro caso è il Form
padre (Form MDI) ovvero il form che farà da contenitore per gli altri.
Dalla finestra successiva scegliete un oggetto Windows Form e, come si vede nella figura
successiva nella parte inferiore della finestra, potete assegnargli un nome ad esempio
“Agenti” dato che ci apprestiamo a progettare la finestra dove verranno gestiti gli Agenti di
commercio che lavorano per la ditta del vostro cliente.
Fate click in basso a destra nella finestra per aggiungere questo form al progetto in atto.
195
Nella finestra Esplora Soluzioni verrà visualizzato l’oggetto aggiunto. Non toccate per il
momento nessun elemento presente nella lista che non sia identificabile come un Windows
Form per evitare di creare problemi all’applicazione.
Tornate attraverso la scheda posta sotto la barra degli strumenti dell’ambiente di sviluppo
alla progettazione del form Principale, e quindi fate doppio click sul menu Agenti come si
vede nella figura successiva.
196
In questo modo verrà generato l’evento click del menu, ovvero cosa dovrà fare il computer
quando qualcuno va a cliccare sulla voce Agenti dal menu Tabelle.
Il codice per aprire la finestra è il seguente.
Creo l’oggetto FormAgenti che in realtà sarà la finestra Agenti e creo una nuova istanza
dell’oggetto, quindi dico che questo FormAgenti deve essere figlio di Principale (Me si rife-
risce al form dove sto inserendo il codice in questo caso Principale). La parentesi graffa si
realizza dalla tastiera con la combinazione ALT+123 (aperta) e ALT+125(chiusa)
Dim FormAgenti As New Agenti With {.MdiParent = Me}

FormAgenti.Show()
Lo faccio apparire sullo schermo
FormAgenti.Show()
Provate adesso ad eseguire il programma avviandolo dall’apposito comando sulla barra de-
gli strumenti dell’ambiente di sviluppo e verificatene il funzionamento.
197
ToolStrip o Barra degli Strumenti

Un altro controllo veramente comune di ogni applicazione è la Barra degli strumenti o Tool-
Strip o ToolBar dipende da che versione di Visual Studio vi trovate fra le mani. In questo
libro è stato volutamente utilizzato un codice che funziona anche con le versioni precedenti
di Visual Basic, ovviamente non quelle del secolo scorso ma perlomeno quelle abbastanza
recenti. La Barra degli strumenti rappresenta una scorciatoia alle funzioni più comuni di
un’applicazione, ovvero i comandi più gettonati che di solito si trovano a giro dispersi fra i
vari menu.
Cercatela fra i controlli e trascinatela nel Form Principale.
Tutti i controlli che vediamo in questo capitolo in realtà hanno centinaia di funzioni e appli-
cazioni varie che per motivi di spazio non possiamo farvi vedere in questo libro. Quando
avrete una certa dimestichezza con le operazioni esposte in questi capitoli, disporrete di
198
una buona base per poi avventurarvi da soli alla ricerca di altre funzioni e, soprattutto,
sarete in grado di capire il funzionamento del codice scritto da altri, che magari troverete
in Internet e che utilizzerete per i vostri progetti.
La caratteristica principale della ToolStrip è la proprietà Items, che rappresenta i vari oggetti
che si trovano sulla barra come pulsanti, caselle combinate ed altro.
Secondo me è un componente che va aggiunto al progetto quando questi è quasi terminato

o per lo meno definito nel suo insieme, in modo da non fare troppi cambiamenti e realizzare
velocemente un Barra degli strumenti elegante e funzionale.
Partiamo con un esempio semplice aggiungendo un pulsante sulla Barra degli strumenti.
199
Fate click sul pulsante Aggiungi in modo da aggiungere sulla Barra degli strumenti un
elemento Button (dalla lista in alto a sinistra è possibile scegliere diverse tipologie di con-
trolli ma per il momento ci accontentiamo di questa) e:
1) Verificate che sia selezionato l’elemento in questione dalla lista di sinistra altrimenti
nella lista di destra compariranno le proprietà di un alto controllo.
2) Scorrete la lista di destra e identificate la proprietà Name.
3) Cambiatela assegnando un nome descrittivo al controllo.
Identificate scorrendo la lista di destra la proprietà DisplayStyle, per decidere se questo

pulsante deve presentare del testo, un’immagine o tutti e due e quant’altro si trova nella
lista.
200
Supponiamo di scegliere la voce ImageAndText così da visualizzare sul pulsante entrambe
le cose. Fate click in alto sul pulsante che mette in ordine alfabetico tutte le proprietà così
le identifichiamo meglio.
Andate alla proprietà Text e assegnategli il valore “Agenti” ovvero il testo che comparirà
sul pulsante.
Adesso con la proprietà TextAlign decidete come deve essere allineato il testo all’interno
del pulsante, diciamo centralmente a destra ad esempio.
Dalla proprietà Image assegnate come abbiamo visto nel capitolo precedente un’icona al
pulsante in modo che sia graficamente rappresentativo del comando che esegue.
201
Fate click sul pulsante OK in basso a destra nella finestra per confermare le impostazioni.
Adesso dovreste trovarvi sulla scheda Principale in fase di progettazione fate doppio click
sul pulsante Agenti in modo da generare l’evento Click del controllo.
202
Inserite il codice che vedete qui sotto all’interno della routine dell’evento click del controllo
PulsanteAgenti.
In teoria dovremmo ripetere tutto il codice che si trova poco sopra ovvero:

FormAgenti.Show()
Che serviva appunto ad aprire la finestra FormAgenti ma siccome siamo furbi scriviamo:
AgentiToolStripMenuItem.PerformClick()
Ovvero esegui tutto quello che si trova nella routine AgentiToolStripMenuItem_Click come
se avessi fatto click (PerformClick).
Verificate il funzionamento e vedrete che fare click dal menu oppure dal pulsante posto
sulla Barra degli strumenti il risultato sarà lo stesso.
StatusStrip o Barra di stato (StatusBar)

Un altro simpatico controllo, molto utilizzato nei programmi di un certo spessore, è la Barra
di stato, ovverosia una zona che si trova nella parte bassa della finestra e che di solito dà
indicazioni su qualcosa che sta accadendo.
Identificate il controllo StatusStrip sulla Casella degli strumenti e trascinatelo nel Form Prin-
cipale. Il controllo verrà ancorato alla parte bassa della finestra.
203
Come nel caso della ToolStrip la caratteristica principale del controllo è la proprietà Items
ovvero la lista dei componenti che appariranno sulla barra di stato. Per accedere alla colle-
zione di elementi fate click dove indicato nella figura sottostante.
Seguite le istruzioni della figura successiva, ovvero:

204
1) Selezionate dalla lista l’oggetto ProgressBar,
2) Aggiungetelo alla Barra con il pulsante Aggiungi,
3) Ordinate le proprietà in ordine alfabetico,
4) Selezionate la proprietà Name,
5) Cambiate il valore della proprietà Name, io l’ho chiamato BarradiProgresso ma po-
tete affibbiargli il nome che vi pare. Ricordate che questi nomi poi vanno tenuti
presente durante il flusso del programma quindi non affibbiategli nomi improbabili
che poi non siete in grado di ricordare.
Eseguite le stesse operazioni viste nel caso precedente, selezionando stavolta dalla lista
l’oggetto StatusLabel che servirà per fare comparire descrizioni accattivanti in basso sulla
barra.
205
Timer
Dato che una Barra di progresso viene di norma utilizzata quando un programma esegue
una serie di operazioni che richiedono un certo tempo di elaborazione, risulterebbe quindi
inutile utilizzarla in un progetto come il nostro, (allo stato attuale delle cose) inseriamo un
nuovo controllo per animare la Barra di progresso che in realtà viene utilizzato in altri scopi.
Si tratta del controllo Timer.
Questo controllo se attivato esegue una procedura ad intervalli di tempo costanti fino a che
non viene disattivato dal programmatore.
Inseriremo nel Form principale il controllo Timer dalla Casella degli strumenti che verrà
automaticamente posizionato in basso nella finestra, in quanto controlli che non hanno una
consistenza fisica sul Form.
Il codice completo dell’esercizio è il seguente:
Public Class Principale
Private Sub Principale_Load(sender As Object, e As EventArgs) Handles MyBase.Load
AgentiToolStripMenuItem.ToolTipText = "Se clicchi qui visualizzi gli Agenti"

AgentiToolStripMenuItem.Enabled = True
StatusStripLabel.Text = "Ciao. Tutto bene?"

'scegli uno stile per la barra di progresso
'BarradiProgresso.Style = ProgressBarStyle.Blocks
BarradiProgresso.Style = ProgressBarStyle.Continuous
'BarradiProgresso.Style = ProgressBarStyle.Marquee
Timer1.Interval = 1000 ' corrisponde a 1 secondo.

206
Timer1.Enabled = True ' attivo il timer
Me.WindowState = FormWindowState.Maximized
End Sub
Private Sub AgentiToolStripMenuItem_Click(sender As Object, e As EventArgs)

Handles AgentiToolStripMenuItem.Click

FormAgenti.Show()
End Sub
Private Sub PulsanteAgenti_Click(sender As Object, e As EventArgs)

Handles PulsanteAgenti.Click
AgentiToolStripMenuItem.PerformClick()
End Sub
Private Sub EsciToolStripMenuItem_Click(sender As Object, e As EventArgs)

Handles EsciToolStripMenuItem.Click
'termina il programma
End
End Sub
Private Sub Timer1_Tick(sender As Object, e As EventArgs) Handles Timer1.Tick
BarradiProgresso.Value = BarradiProgresso.Value + 10
If BarradiProgresso.Value = 100 Then
Timer1.Enabled = False 'disattivo il timer

StatusStripLabel.Text = "Ho finito! Tutto secondo i piani"
End If
End Sub
End Class
Le parti in verde sono le note del programmatore. Abituatevi a descrivere le operazioni con
impressioni personali particolareggiate in modo che risulti chiaro il funzionamento di qual-
cosa che inventate. Quando riprenderete in mano un progetto, perderete molto meno
tempo a capire cosa diavolo facesse una procedura.
Il codice ovviamente è scaricabile dal sito, vanno però date un minimo di spiegazioni.
L’esempio serve solo per spiegare il funzionamento di certi controlli come ad esempio la
Barra di Progresso che solitamente è utilizzata, come abbiamo già detto, quando si verifica
un’elaborazione particolarmente lunga da parte del computer e l’operatore ha la necessità
di capire se il programma funziona o è bloccato. Quindi non è il nostro caso al momento.
Quando avvio il programma e viene caricato il Form imposto il Timer a un secondo (speci-
ficando i millesimi). Ogni volta che trascorre questo tempo il Timer eseguirà il codice che
trova nell’evento Timer1_Tick.
Timer1.Interval = 1000 ' corrisponde a 1 secondo.

207
Il Timer inoltre va abilitato per avviare il conteggio altrimenti non accadrà nulla di interes-
sante.
Timer1.Enabled = True ' attivo il timer
Allargo la finestra principale del programma alla grandezza dello schermo.
Me.WindowState = FormWindowState.Maximized
Nell’evento Tick del Timer che è limitato dalle istruzioni che vedete qui sotto e che verranno
eseguite ogni secondo dal computer.
Private Sub Timer1_Tick(sender As Object, e As EventArgs) Handles Timer1.Tick
End Sub
va scritto questo codice che serve solo per animare la Barra di progresso.
BarradiProgresso.Value = BarradiProgresso.Value + 10
If BarradiProgresso.Value = 100 Then

Timer1.Enabled = False 'disattivo il timer
StatusStripLabel.Text = "Ho finito! Tutto secondo i piani"
End If
In pratica si arresta quando la proprietà Value della Barra di progresso arriva al valore 100.
208
Trascina e Rilascia
Drag & Drop, come è conosciuto nel mondo della programmazione, rappresenta una delle
operazioni più popolari disponibili fin dagli albori dell’informatica in un qualsiasi sistema a
finestre. Alzi la mano chi non ha mai trascinato un oggetto in un’altra posizione sul desktop,
ad esempio. L’operazione si può estendere anche in altri ambiti oltre a quello più famoso
dello spostamento di file o cartelle. Nell’esempio che trovate nel codice allegato al libro sono
presenti due listbox con una lista di voci, e attraverso l’operazione di trascinamento verrà
mostrato come realizzare il trasferimento di una voce nell’altra listbox e viceversa.
Il codice completo del progetto lo trovate nel box sottostante.
Option Explicit On
Public Class Form1

ListBox1.Items.Add("PINCO PALLINO")
ListBox1.Items.Add("PAOLINO PAPERINO")
ListBox1.Items.Add("BABBO NATALE")
ListBox1.Items.Add("GASTONE PAPERONE")
ListBox1.Items.Add("MARIO ROSSI")
ListBox1.Items.Add("NONNA PAPERA")
ListBox1.Items.Add("VARIE ED EVENTUALI")
End Sub
Private Sub ListBox1_MouseDown(sender As Object, e As MouseEventArgs)

Handles ListBox1.MouseDown
If ListBox1.Items.Count = 0 Then Exit Sub
ListBox1.AllowDrop = False
ListBox2.AllowDrop = True
'attiva il drag drop utilizzando l'evento MouseDown
'ma è possibile utilizzare anche altri eventi
ListBox1.DoDragDrop(ListBox1.SelectedItem.ToString,
DragDropEffects.Copy Or DragDropEffects.Move)
End Sub
Private Sub ListBox2_DragDrop(sender As Object, e As DragEventArgs)

Handles ListBox2.DragDrop
'Aggiunge il dato che e stato trascinato dalla list 1 alla lista 2

ListBox2.Items.Add(e.Data.GetData(DataFormats.Text).ToString)
'riumove il dato trascinato dalla list 1
ListBox1.Items.Remove(ListBox1.SelectedItem)
End Sub
Private Sub ListBox2_DragEnter(sender As Object, e As DragEventArgs)

Handles ListBox2.DragEnter
If e.Data.GetDataPresent(DataFormats.Text) Then
e.Effect = DragDropEffects.Copy
Else
e.Effect = DragDropEffects.None
End If
End Sub
209

Else
End If
End Sub

End Sub
Private Sub ListBox1_DragDrop(sender As Object, e As DragEventArgs)

Handles ListBox1.DragDrop
End Sub
End Class
Andiamo adesso ad analizzare il codice. Innanzitutto, la prima parte popola il primo listbox
con una serie di voci pseudocasuali, giusto per fare un esempio.
Il primo evento da tenere in considerazione, se vogliamo realizzare il trascinamento di una
voce presente nella lista, è l’evento MouseDown. Questo evento viene attivato quando si
preme il tasto SX del mouse all’interno di un controllo.

End Sub
La prima riga serve per evitare che qualcuno trascini qualcosa anche quando la lista è vuota.
L’operazione genererebbe un’eccezione che blocca il programma.
Quando si vuole realizzare un trascinamento e quindi un rilascio è necessario che il controllo

che riceve il rilascio sia abilitato a questa operazione. Se viene attivata una lista va disatti-
vata l’altra altrimenti, se per sbaglio viene rilasciato il dato nella stessa lista dove è stato
prelevato, verrà creato un duplicato.
210
DoDragDrop inizia un’operazione di trascinamento della selezione. Come primo parametro

va specificata la sorgente dei dati, in questo caso la ListBox1, come secondo, uno dei valori
DragDropEffect che specifica gli effetti consentiti dall’operazione di trascinamento della se-
lezione, ad esempio la copia (Copy), lo spostamento (Move) o il collegamento (link).
Questo è quanto presente nell’evento MouseDown della Listbox1.

L’evento successivo che andiamo ad analizzare e DragEnter della ListBox2. Questo evento
si attiva quando un oggetto viene trascinato entro i limiti di un controllo che funziona da
destinazione del rilascio.

Else
End If
End Sub
Verifica che i dati che vengono trascinati sulla lista siano una stringa di caratteri. Se questo
è vero abilità la copia, altrimenti non viene eseguita nessuna azione.
Else
End If
L’evento DragDrop, della ListBox2, viene attivato quando la selezione fatta nella ListBox1
viene rilasciata nella ListBox2.
Aggiunge il dato che è stato trascinato dalla ListBox1 alla ListBox2.
Quindi rimuove il dato prelevato dalla ListBox1.
Il resto del codice è speculare, ovvero si applica l’operazione inversa quando si trascina un
dato dalla ListBox2 alla ListBox1.
In sostanza, quando si esegue un Drag & Drop si attivano nell’ordine i seguenti eventi:
MouseDown o un altro evento compatibile con un’operazione di inizio del trascinamento
nella ListBox1, DragEnter nella ListBox2 e DragDrop sempre nella ListBox2. Il progetto si
trova nel codice di esempio allegato al libro.
211
Eventi comuni.
Un evento è un messaggio inviato da un’oggetto per segnalare che è avvenuta una qualche
azione. L’azione può essere generata dall’interazione dell’utente come ad esempio fare click
un controllo, oppure può essere generata anche da altre logiche di un programma, ad
esempio viene modificato il valore di una proprietà.
La lista che trovate in queste pagine riassume gli eventi principali che può chiamare un
controllo generico. Non tutti i controlli dispongono degli stessi eventi. Questo dipende dalla
natura del controllo, ad esempio un TextBox avere in comune eventi con controlli diversi
da lui, ad esempio un Button, ma dispone anche di eventi completamente diversi, propri di
quel controllo.
Evento Descrizione
Si attiva quando il valore della proprietà BackColor, che gestisce il colore
BackColorChanged
di sfondo del controllo, cambia.
BorderStyleChanged Si verifica quando cambia il valore della proprietà BorderStyle.
Viene attivato quando il valore della proprietà CausesValidation cambia.
CausesValidationChanged Se questa proprietà è impostata su False gli eventi Validating e Validated
non vengono attivati né gestiti.
Si verifica quando lo stato attivo o i tasti di scelta rapida dell'interfaccia
ChangeUICues
utente vengono modificati.
Questo evento si verifica quando l’utente seleziona il controllo con un
Click
click del tasto SX del mouse.
Si verifica in seguito al cambiamento del valore della proprietà Con-
ContextMenuChanged
textMenu.
ContextMenuStripChanged Si attiva quando il valore della proprietà ContextMenuStrip cambia.
CursorChanged Si verifica quando il valore della proprietà Cursor cambia.
Si verifica quando il componente viene eliminato da una chiamata al
Disposed
metodo Dispose().
Si attiva quando il valore della proprietà Dock cambia. La proprietà Dock
DockChanged serve per definire la modalità di ridimensionamento automatico di un
controllo in base al ridimensionamento di un controllo padre.
Viene attivato l’evento in seguito al doppio click del tasto SX del mouse
DoubleClick
sul controllo.
Quando viene completata un'operazione di trascinamento e rilascio si
DragDrop
attiva questo evento.
Se un oggetto viene trascinato nei limiti del controllo viene generato
DragEnter
questo evento.
Si verifica quando un oggetto viene trascinato fuori dai limiti del con-
DragLeave
trollo.
Quando un oggetto viene trascinato sui limiti del controllo viene attivato
DragOver
questo evento.
EnabledChanged Si attiva quando viene modificato il valore della proprietà Enabled.
Enter Si attiva quando si entra nell'area del controllo.
Si verifica quando il valore della proprietà Font cambia. La proprietà font
FontChanged
gestisce il tipo di carattere.
Si verifica quando il valore della proprietà ForeColor cambia. ForeColor
ForeColorChanged
rappresenta il colore del carattere.
GiveFeedback Si verifica durante un'operazione di trascinamento.
GotFocus Si verifica quando il controllo riceve lo stato attivo.
212
Evento Descrizione
Si verifica quando si preme un tasto dalla tastiera mentre il controllo ha
KeyDown
lo stato attivo.
Si verifica quando si preme un tasto carattere, la barra spaziatrice o il
KeyPress
tasto backspace mentre il controllo ha lo stato attivo.
Si verifica quando si rilascia un tasto mentre il controllo ha lo stato at-
KeyUp
tivo.
Si verifica quando è necessario riposizionare i controlli figlio di un con-
Layout
trollo.
Leave Si verifica quando lo stato attivo per l'input esce dall'area del controllo.
Si verifica quando viene modificato il valore della proprietà Location.
LocationChanged Questa proprietà ottiene o imposta le coordinate dell’angolo superiore
sinistro del controllo in relazione al suo contenitore.
LostFocus Si verifica quando il controllo perde lo stato attivo.
Si verifica quando cambia il valore della proprietà Modified. Questa pro-
ModifiedChanged prietà ottiene o imposta un valore (true o false) che indica che il conte-
nuto del controllo è stato modificato.
MouseClick Si verifica quando si fa click con il mouse sul controllo.
MouseDoubleClick Si verifica quando si fa doppio click con il mouse sul controllo.
Si attiva quando il puntatore del mouse si trova sul controllo mentre
MouseDown
viene premuto un pulsante del mouse.
MouseEnter Si verifica quando il puntatore del mouse entra nell'area del controllo.
MouseHover Quando il puntatore del mouse si sofferma sul controllo.
MouseLeave Si verifica quando il puntatore del mouse esce dall'area del controllo.
MouseMove Si attiva quando il puntatore del mouse viene spostato sul controllo.
Si verifica quando il puntatore del mouse si trova sul controllo mentre
MouseUp
viene rilasciato un pulsante del mouse.
Si verifica quando si sposta la rotellina del mouse mentre il controllo ha
MouseWheel
lo stato attivo.
Move Si verifica quando il controllo viene spostato.
ParentChanged Si verifica quando il valore della proprietà Parent cambia.
Si verifica prima dell'evento KeyDown quando viene premuto un tasto
PreviewKeyDown
mentre il controllo ha lo stato attivo.
ReadOnlyChanged Si verifica quando cambia il valore della proprietà ReadOnly.
Resize Si verifica quando il controllo viene ridimensionato.
SizeChanged Si verifica quando il valore della proprietà Size cambia.
StyleChanged Si verifica quando lo stile del controllo viene modificato.
SystemColorsChanged Si verifica quando i colori di sistema vengono modificati.
TabIndexChanged Si verifica quando il valore della proprietà TabIndex cambia.
Si verifica quando il valore della proprietà TabStop cambia. Questa pro-
TabStopChanged prietà ottiene o imposta un valore (true o false) che indica se l’utente
può assegnare lo stato attivo al controllo con il tasto TAB,
Validated Si verifica al termine della convalida del controllo.
Validating Si verifica durante la convalida del controllo.
Si verifica quando il valore della proprietà Visible cambia. La proprietà
VisibleChanged
determina se il controllo è visibile all’utente oppure no.
I Database
213
I Database
Un database è una struttura dinamica dove è possibile inserire dei dati, anche senza nessun
ordine prestabilito, per poterli recuperare in successivamente in tutti i modi possibili e im-
maginabili. Questo tipo di struttura, per garantire una simile flessibilità nel recupero dei
dati, in realtà è deve essere rigida, ovvero è necessario definire con precisione ogni ele-
mento che la compone. In pratica bisogna creare una base per i vostri dati. Al giorno d’oggi
questa tipologia di programmi rappresenta il 70% di tutti i programmi in circolazione. Alla
fine della fiera un computer serve proprio per memorizzarci dentro dei dati, altrimenti a che
serve?
All’interno di un database si trovano alcuni oggetti dei quali è necessario comprenderne il
funzionamento per poter sfruttare un database in tutte le sue potenzialità. Se dovete svi-
luppare un programma per un singolo utilizzatore Microsoft Access risulta la scelta migliore,
ma se avete altre necessità come ad esempio un numero maggiore di 3 utilizzatori contem-
poranei, allora la scelta ricade su un database ad alte prestazioni come MySQL. Studiatevi
però questo capitolo perché se siete a “digiuno” di database è da qui che dovete partire.
Le tabelle.
La tabella è l’elemento chiave di qualsiasi database. Senza tabelle il database non esiste
perché non può contenere nulla. Per fare un paragone una tabella può essere paragonata
ad un foglio di calcolo, come ad esempio Microsoft Excel, dove però la struttura del foglio
va inventata di sana pianta, ovvero devo in dettaglio dire al database come si deve chiamare
la tabella per poter essere identificata nel mucchio, come si devono chiamare le colonne di
questa tabella, che in realtà si chiamano campi e non colonne, e quali tipi di dati devono
contenere.
Le righe che in questo caso vengono chiamate record, non hanno bisogno di nessuna defi-
nizione da parte nostra in quanto si tratta di una struttura dinamica che aggiunge la riga
solo se ce n’è realmente bisogno, ad esempio, se in libreria ho mille libri nella tabella ci
saranno sicuramente mille righe o record. Quindi le righe aumenteranno o diminuiranno
all’aumentare o al diminuire dei dati immessi e dunque non si presenta come una struttura
statica come nel caso del foglio di calcolo. Dato che si tratta di argomento alquanto ostico
affronteremo poco per volta la questione. Una lista dei libri o un elenco telefonico ad esem-
pio possono stare all’interno di una tabella del database.
Query
Le query sono uno strumento per il recupero dei dati da un database. In pratica la query è
una domanda che noi facciamo database stesso per avere una risposta. Se ad esempio
abbiamo una lista di libri posso chiedere che questa venga ordinata in ordine alfabetico
piuttosto che per Autore ecc. Il risultato di una query ha l’aspetto di una tabella.
Maschera.
La maschera è uno strumento che rende più gradevole il lavoro di immissione dei dati in un
database. Fondamentali per lavorare con comodità ad esempio all’immissione dei dati. Le
maschere nel nostro caso verranno create con Visual Basic e si chiamano Form.
Report.
Il report ha invece il compito di rendere più gradevole l’aspetto dei dati sulla stampa o sullo
schermo. Anche in questo caso ignoreremo questa caratteristica di Access per utilizzare
invece Visual Basic. Quindi in questo capitolo verranno esposte le funzionalità di Access che
hanno un utilizzo pratico con Visual Basic mentre verranno volutamente ignorate quelle
caratteristiche di Access tipiche del suo ambiente di lavoro che non hanno nessuna affinità
con Visual Basic.
214
Microsoft ACCESS
Le tabelle
Vediamo adesso come il database è in grado di memorizzare i nostri dati. La componente
più importante di questa struttura sono le tabelle, che memorizzano i dati immessi permet-
tendoci in un secondo momento di recuperarli a nostra discrezione.
Queste tabelle come struttura somigliano molto a un foglio di calcolo di Excel, soltanto che
le “colonne” si chiamano Campi e le “righe” si chiamano Record.
Si tratta inoltre di una struttura dinamica dove non esiste un numero fisso di righe (record)
ma la tabella si “allunga” in virtù della quantità di dati che vengono inseriti.
Inoltre, le colonne (campi) devono essere preparate in fase di progettazione, quindi il pro-
grammatore deve sapere con certezza quali tipologie di dati le colonne devono contenere.
È anche vero che questa struttura può essere modificata in tempi successivi, e adattata ad
eventuali nuove esigenze con ampie possibilità di modifica da parte del programmatore,
che per buona norma, è bene che abbia le idee chiare fin dalle prime fasi della progetta-
zione. Se volessi realizzare un archivio di clienti o di contatti personali devo innanzi tutto
pensare a quali informazioni devo memorizzare.
Cognome e Nome
Indirizzo
CAP
Città
Email
Con Excel, tanto per fare un esempio che sicuramente vi richiama qualcosa alla memoria,
risolvere questo problema è abbastanza semplice e non penso abbia bisogno di troppi chia-
rimenti. Parlo di Microsoft Excel perché è che programma che si avvicina di più a quello che
dobbiamo realizzare, ovviamente in un modo completamente diverso, e che essendo estre-
mamente diffuso presumo che abbiate avuto prima o poi il piacere di imbattervi in esso.
Quello che vedete nella figura sottostante potrebbe essere un buon punto di partenza.
Gli stessi dati per quanto riguarda un database vanno gestiti in un modo completamente
diverso. Intendiamoci, nessuno vi vieterebbe di realizzare questa cosa attraverso appunto
Excel però con l’andare del tempo vi rendereste conto che esistono alcune limitazioni.
Microsoft ACCESS
215
Ad esempio, la facilità con la quale erroneamente un eventuale utente potrebbe cancellare
o modificare i dati, oppure la difficoltà di gestire molte migliaia di questi personaggi o come
l’impossibilità da parte dell’operatore non eserto di estrapolare dati e statistiche.
Per questo il programmatore deve sapere progettare programmi ad hoc che non necessi-
tano da parte dell’operatore particolari conoscenze o abilità.
Inoltre, esistono altre limitazioni che vedremo in questo capitolo andando avanti con l’espo-
sizione degli argomenti. È per questo che alcuni problemi gestionali non è possibile risolverli
con Excel ma abbiamo necessità di qualcosa di diverso come Microsoft Access ad esempio,
tanto per citare qualcosa che magari avrete avuto sottomano tante volte ma non sapevate
come utilizzare.
Quindi per progettare una tabella si deve innanzitutto sapere quali tipologie di dati deve
accogliere e creare la struttura. Dobbiamo quindi specificare per ogni campo (colonna)
quale tipologia di dati deve ospitare, come ad esempio nella tabella sottostante:
Nome del campo Tipologia di dati

Cognome e Nome TESTO
Indirizzo TESTO
CAP TESTO
Città TESTO
Email TESTO
Nel nostro esempio sono tutti campi di testo anche quelli che contengono dei numeri come
ad esempio il CAP o anche eventualmente il numero di telefono. Vengono definiti come
campo di testo perché in quel campo lì, sembra strano, ma non avrete la necessità di ef-
fettuare operazioni matematiche e quindi, anche i numeri saranno definiti come Testo pro-
prio perché il computer non li deve trattare come numeri ma semplicemente come testo.
Dunque, tutti i campi non coinvolti in operazioni matematiche devono essere definiti come
campi di testo.
Dato che in questo capitolo tratteremo i database in generale vediamo alcune convenzioni
che ci permetteranno di utilizzare qualsiasi tipo di database senza legarci a nessun in par-
ticolare anche se per gli esempi viene utilizzato Microsoft Access.
In generale i nomi dei campi vanno digitati in minuscolo (anche se per alcuni database non
è vero abituatevi alle convenzioni per evitare di imbattervi in qualche malfunzionamento
dovuto semplicemente a una regolina non rispettata) non separati da spazi, ma eventual-
mente, per simulare lo spazio e rendere maggiormente leggibile un nome, è possibile uti-
lizzare la linea bassa detta underscore come mostra l’esempio della tabella successiva.
È meglio inoltre non utilizzare lettere accentate anche se Access le tollera.

cognome_nome TESTO
indirizzo TESTO
cap TESTO
citta TESTO
email TESTO
Adesso veniamo ad un’altra caratteristica di un campo, ovvero la lunghezza dei dati che
deve contenere. Per gestire correttamente una tabella i campi devono avere una lunghezza
specificata ovvero il programmatore deve pensare in anticipo, anche se poi può effettuare
le opportune modifiche in seguito, quale numero massimo di caratteri deve contenere quel
216
campo (colonna), in modo da poter risparmiare spazio prezioso quando i record (righe)
saranno molte migliaia. In parole povere mai sprecare lo spazio disponibile proprio perché
non sappiamo quanti un domani saranno i dati contenuti.
Per fare un esempio di lunghezza la nostra struttura potrebbe diventare:

cognome_nome TESTO (60)
indirizzo TESTO (50)
cap TESTO (5)
citta TESTO (40)
email TESTO (100)
Ad esempio, è inutile assegnare più spazio al campo CAP in quanto in Italia non esistono al
momento CAP che superano le 5 cifre. Se invece devo progettare una tabella che contiene
anche contatti esteri, allora dovrò in questo caso pensare a questa eventualità allungando
il campo se ho necessità di maggiore spazio.
È possibile completare la progettazione della tabella attraverso l’aggiunta di altre informa-
zioni ad esempio il numero di telefono (anche questo sarà un campo di testo in quanto non
andremo mai a fare operazioni matematiche sul numero di telefono di qualcuno) data di
nascita (in questo caso esiste un tipo specifico di campo) e tutto quello che vi può passare
dalla mente. Come già detto è possibile aggiungere campi in un momento successivo a
quello della progettazione di una tabella.
Passiamo all’azione
Quello che vedete nella figura sottostante è la schermata iniziale di Microsoft Access. Per
iniziare creiamo un database vuoto facendo click nel riquadro Database desktop vuoto.
Inserite il nome del database che desiderate realizzare. Questo diverrà un file che è possi-
bile rintracciare nella cartella Documenti. Fate click sul pulsante Crea.
Microsoft ACCESS
217
La situazione inziale è simile a quella della figura sottostante. Essendo vuoto il database vi
chiede di creare almeno una tabella.
Per migliorare la visualizzazione degli oggetti è stata volutamente scelta una risoluzione
grafica dello schermo più bassa del normale, in modo che i vari comandi compaiano ben
visibili. Quindi è probabile che la disposizione e l’aspetto dei comandi sulla barra multifun-
zione non corrisponda esattamente a quella riportata nel libro, restando comunque di facile
individuazione.
Iniziamo dalla realizzazione della prima tabella, tendendo presente che l’esercizio è volto a
realizzare l’esempio di una biblioteca con funzione di prestito di libri che sia da spunto anche
per altri utilizzi. Questa prima tabella conterrà i dati dei libri presenti nella biblioteca.
Fate click con il tasto DX del mouse sulla Tabella1 che si vede nella parte sinistra dello
schermo e scegliete la voce Visualizzazione struttura.
218
Date un nome descrittivo alla tabella che vi apprestate a creare e salvate facendo click sul
pulsante OK nella finestra.
Adesso sullo schermo viene proposta la visualizzazione della struttura che ci permetterà di
creare la base per i nostri dati. Come si vede nella figura successiva, iniziamo a creare quelli
che si chiamano Campi, ovvero quegli spazi dove andranno a inserirsi i dati. Come abbiamo
visto nel capitolo precedente ogni campo deve essere progettato correttamente a seconda
dei dati che deve contenere.
Quando viene aperta la schermata Access crea un campo automatico chiamato ID che serve
per identificare in modo univoco ogni libro che inseriremo nel database. Non tutte le tabelle
hanno bisogno di un campo ID ma è sempre meglio crearlo perché se un domani volessimo
utilizzare un ambiente di programmazione come Visual Basic (guarda caso) per interfacciare
il nostro database, risulterà più facile identificare un determinato dato. Questo campo non
ha bisogno di impostazioni da parte vostra.
Microsoft ACCESS
219
Adesso veniamo alla creazione dei campi che ospiteranno i dati iniziano dal campo ISBN. Si
tratta di un codice di 13 cifre che si trova sul retro di un libro e che identifica univocamente
un qualunque libro pubblicato. Qualche anno fa il codice ISBN non esisteva perciò non tutti
i libri, soprattutto quelli molto vecchi, lo riportano. Nella figura sottostante sono riportate
le impostazioni di questo campo.
Dopo aver digitato in nome del campo, nel nostro caso ISBN è necessario specificare dalla
lista che si trova alla sua destra che tipologia di dati deve contenere e, anche se il codice in
realtà è un codice numerico come abbiamo già visto nel capitolo introduttivo dove parla-
vamo delle caratteristiche di un campo, dovete impostare la sua tipologia a Testo breve.
Questo perché nessuno, benché si tratti di numeri, andrà mai a fare calcoli matematici su
un codice ISBN.
220
Nella parte bassa della finestra limitiamo la dimensione del campo a 13 caratteri in
quanto una dimensione maggiore sarebbe spazio sprecato.
Specificate il valore Sì accanto a Consenti lunghezza zero, ovvero, dato che non tutti i
libri dispongono di un codice ISBN è anche possibile lasciare questo campo vuoto cioè senza
nessun dato.
La caratteristica Indicizzato invece va posizionata sul valore Sì (duplicati non am-
messi). Questa impostazione impedisce l’inserimento di due libri distinti con lo stesso co-
dice ISBN. Se in fase di immissione dei dati dovesse verificarsi questa eventualità il com-
puter vi segnalerebbe con un messaggio questo tipo di problema.
L’indice è qualcosa che permette ricerche più veloci quando si consultano dei dati. I campi
indicizzati risulteranno più rapidi nel dare le risposte.
Passiamo adesso al titolo del libro.
Come nel caso precedente scegliamo la stessa tipologia di dati (testo breve) e lasciamo la
dimensione del campo a 255 caratteri. Ovviamente se ritenete che la Dimensione del
campo del titolo del libro risulti eccessiva, siete autorizzati a diminuirla a seconda della
vostra sensibilità artistica.
Ponete la caratteristica Consenti lunghezza zero sul valore No in quanto il libro deve
necessariamente avere un titolo, quindi il campo non può essere lasciato vuoto.
Questa volta Indicizzato può essere impostato sul valore Sì (Duplicati ammessi), in quanto
è possibile l’esistenza di due libri che hanno lo stesso titolo.
Quando dovete impostare i valori di alcune proprietà dei campi, ricordate di fare click sulla
piccola freccia che va verso il basso. Molte delle caratteristiche che vedete nella schermata
nascondono una lista predefinita di valori, dove dovete scegliere quello che risulta più adatto
al vostro utilizzo, mentre per altri campi come ad esempio Dimensione campo i valori
vanno digitati dalla tastiera.
Microsoft ACCESS
221
Un libro quasi sicuramente sarà collegato ad un Autore, quindi dobbiamo riportare nella
tabella anche qualcosa che identifichi l’autore. Invece che il nome dell’autore viene riportato
un campo che conterrà un codice che identifica l’autore cosi tutti i libri di quell’autore sa-
ranno marcati con quel codice senza possibilità di errore. Questo ovviamente vale quando
un libro ha un solo autore, ma quando questi sono più di uno è necessario creare una
struttura diversa che vedremo più avanti. Per il momento ci limitiamo alle soluzioni di base
in modo da assimilare le tecniche prima di inoltrarci verso argomenti più complessi.
Impostate il campo IDAUTORE a Numerico e indicizzatelo con duplicati ammessi in quanto
un autore potrebbe aver scritto più di un libro, e quindi il codice dell’autore potrebbe com-
parire più volte nella tabella in record diversi.
Ricordate che l’assegnazione di un indice ad un campo velocizza le ricerche dei dati in quel
campo non di poco. Se determinati valori sono unici allora conviene impostare questa ca-
ratteristica a Duplicati non ammessi, se invece si possono ripetere allora conviene asse-
gnare il valore Duplicati ammessi.
Se viene fatto un tentativo di immissione degli stessi dati in un campo dove i duplicati non
sono ammessi allora il database impedisce l’immissione di tali dati.
Il prossimo campo contiene il numero di pagine del libro. Questo campo viene impostato
come Numerico in quanto il numero delle pagine di un libro è con buona approssimazione
qualcosa che somiglia a un numero. Posizionate il parametro Dimensione campo a Intero,
ovvero potranno essere contenuti solo valori numerici interi che vanno da -32.768 a
+32.767 se vi può bastare…
Quando si progetta un database e quindi una tabella, è buona norma decidere, anche se
poi è tranquillamente possibile cambiare in seguito, quali tipi di dati verranno inseriti in un
campo in modo da creare una struttura che non spreca spazio inutile e che risulterà più
snella e veloce. In parole povere è inutile utilizzare un tipo di campo con precisione doppia
quando non verranno mai inseriti valori interi più grandi di qualche migliaio.
222
Lo stesso discorso vale per il campo Anno_Edizione.
Il prossimo campo, il campo Annotazioni, è utilizzato per permettere all’operatore di inserire

impressioni personali o sinossi del libro in questione in modo da arricchire i dettagli dell’og-
getto. Posizionate il tipo di dati a Testo lungo, come si nota nella figura successiva, che vi
permetterà di inserire in quel campo descrizioni particolarmente esaustive.
A questo punto la tabella Libri può considerarsi terminata anche se lascio alla vostra imma-
ginazione o a qualche necessità specifica l’inserimento di altri eventuali campi che ospite-
ranno altri dati di interesse.
Microsoft ACCESS
223
Salvate la struttura della tabella facendo click sull’apposito comando che si trova in alto a
sinistra sulla Barra di accesso rapido oppure eseguite la combinazione da tastiera
MAIUSC+F12 come suggerito dall’etichetta che appare quando posizionate il mouse sul
comando.
Uscite dalla struttura della tabella facendo click sull’apposito comando a destra nella scheda.
224
Adesso fate click sulla scheda Crea in alto nella finestra e selezionate il comando Struttura
tabella come si vede nella figura sottostante.
Ripartiamo con l’avventura stavolta con la creazione della tabella Autori. Assegnate al primo
campo il nome IDAUTORE che sarà quel codice che legherà un autore ai suoi libri, asse-
gnando come tipologia di dati la Numerazione automatica. Questo campo viene gestito
automaticamente dal database quindi non avrà bisogno di nessun intervento futuro da parte
vostra.
Come mostra la figura successiva, fate click con il tasto DX del mouse nello spazio del nome
del campo, oppure all’inizio della riga dove si trova il quadratino grigio, e dalla lista selezio-
nate la voce Chiave Primaria.
La Chiave primaria di una tabella è un campo dove i valori non si ripetono mai ovvero non
esistono due record etichettati con la stessa chiave, in modo che ogni record sia identificato
univocamente senza possibilità di errore. Ogni tabella come abbiamo già detto dovrebbe
avere un campo definito come chiave primaria, questo per non generare eventuali doppioni
in fase di programmazione che potrebbero portare a degli errori di aggiornamento o di
modifica di un record (o riga chiamatelo come volete).
Microsoft ACCESS
225
A questo punto inserite un altro campo etichettato come Nome_Cognome dove, indovina
un po’, verrà inserito dall’operatore il nome ed il cognome dell’autore di uno o più libri.
Presumo che un campo di tipo Testo breve dovrebbe ampiamente coprire le vostre neces-
sità. Limitatene la lunghezza a piacere, ad esempio 100 caratteri potrebbero essere suffi-
cienti (ammesso che non abbia 10 nomi) e indicizzate il campo in modo che possa contenere
omonimi (come se non fosse mai successo…)
Aggiungiamo l’immancabile campo Note per sbizzarrirci con tutte le descrizioni che il nostro
autore merita.
226
Adesso chiudiamo la tabella con l’apposito comando in alto a destra.
Tutte queste operazioni ci servono per iniziare ad ambientarci in questo nuovo spazio di
lavoro e per assimilare le operazioni più frequenti che si verificano in fase di progettazione
del database, perciò verranno riproposte più volte per evitare di dare qualcosa per scontato.
Fate click sul pulsante Sì per salvare la struttura della tabella.
Adesso come mostra la figura successiva, date un nome alla tabella che state per salvare
ad esempio Autori, e fate click sul pulsante OK nella finestra di dialogo per confermare
l’operazione.
Microsoft ACCESS
227
A questo punto nel database ci saranno due tabelle (ovviamente vuote).
Tipi di campo
Vediamo brevemente cosa è possibile memorizzare nel database. La scelta della tipologia
di un campo è molto importante in quanto è necessario specificare con precisione quale tipo
di dati deve contenere altrimenti, sbagliando tipologia, è possibile che tutta la struttura non
funzioni affatto. Inoltre, ogni tipologia dispone di caratteristiche da non trascurare, come
ad esempio la dimensione e altre caratteristiche tipiche di uno specifico campo. Facciamo
un breve riepilogo delle tipologie di campi presenti in Access e del loro utilizzo standard.
Testo breve: il testo breve è un campo che può contenere qualsiasi carattere, numerico o
alfabetico fino ad un massimo di 255 caratteri, quindi come direbbero i programmatori una
stringa di 255 caratteri lunghezza massima, ideale quindi per memorizzare nomi, cognomi
indirizzi ecc. ottimizzatelo per la lunghezza massima che ritenete utile quindi per contenere
un CAP utilizzate solo 5 caratteri non 255.
Testo Lungo: stesse caratteristiche del caso precedente con la sola differenza che la lun-
ghezza è limitata dalla fantasia. Questo tipo di campo sostanzialmente serve quando è
necessario aggiungere delle note o appunti di una certa lunghezza, anche parecchie pagine,
a margine dei dati principali.
Numerico: questo tipo di campo, come dice il nome, può contenere numeri, che è possibile
che vengano coinvolti in operazioni matematiche, quindi non definite come numerico un
228
campo dove dentro ci va memorizzato un CAP, ma esclusivamente quei dati che quasi si-
curamente da utilizzare in operazioni matematiche, come prezzo di un articolo, la quantità
o cose di questo genere qua.
Data/ora: in un campo di questo tipo solitamente vengono inserite una data, un’ora o
entrambe le cose, dipende dal formato che vogliamo scegliere.
Valuta: è una tipologia adatta a un utilizzo commerciale/contabile.
Numerazione Automatica: serve per creare campi che verranno relazionati con altre ta-
belle in quanto la numerazione automatica viene gestita dal computer. La chiave primaria
di una tabella spesso ha questa caratteristica.
Si/no: campo che può memorizzare solo due stati, Si/no oppure Vero/falso. Ottimo per
l’utilizzo con caselle di controllo o pulsanti di opzione. (date un’occhiata al capitolo dei con-
trolli).
Oggetto OLE: un oggetto OLE è qualcosa che proviene da altri programmi come ad esem-
pio un documento di Word o Excel.
Collegamento Ipertestuale: può contenere indirizzi Internet che avviano una volta che
avete fatto click su di essi il programma per navigare. Utili per memorizzare gli indirizzi
Internet di aziende ecc.
Allegato: un campo speciale che può allegare foto o altri documenti. È possibile memoriz-
zare anche più di un file in un unico record fino ad un massimo di 2 GB di dati, ovvero la
grandezza massima di un file di Access. Le dimensioni di un singolo file non possono essere
maggiori di 256 Megabyte.
Calcolato: un campo che è il risultato di un’espressione matematica o qualcosa di simile

che coinvolge altri campi. Si apre il generatore di espressioni che si aspetta da voi delle
istruzioni in merito a quello che deve fare. Per il momento lasciamo perdere.
Le relazioni
Prima di andare oltre diamo un rapido sguardo a un’altra caratteristica di un database,
ovvero le relazioni fra tabelle. Fate click sulla scheda Strumenti database in alto nella
finestra e scegliete il pulsante Relazioni sulla barra multifunzione.
Microsoft ACCESS
229
Le relazioni sono collegamenti fra tabelle che hanno un utilizzo virtuale, nel senso che se-
condo me non servono quasi a nulla se non che visualizzano gli intrecci fra tabelle, rendendo
meglio l’idea di come è strutturato il database ed aiutando magari a studiare eventuali
miglioramenti.
Dato che le relazioni sono sostanzialmente uno schema fate click su ciascuna delle tabelle
coinvolte e quindi fate click sul pulsante Aggiungi in basso nella finestra. Ogni volta che
aggiungete una tabella questa viene visualizzata nello schema sottostante.
Quando avete aggiunto tutte le tabelle coinvolte nell’operazione fate click sul pulsante
Chiudi in basso nella finestra.
230
La finestra si toglierà dalle scatole e avrete davanti a voi le tabelle con i relativi campi ben
in vista.
Adesso vediamo come si crea fisicamente una relazione fra le tabelle. Per fare questo en-
trambe le tabelle devono avere dei campi che possono essere correlati, ovvero uguali, una
Microsoft ACCESS
231
tabella primaria nel nostro caso la tabella Autori e una tabella secondaria, ovvero la tabella
libri.
La tabella “Autori” è definita “Primaria” solo perché ad ogni autore possono corrispondere
un numero qualsiasi di libri nella tabella “Libri”.
Portate come mostra la figura sottostante il puntatore del mouse a sovrapporsi al campo
IDAUTORE nella tabella Autori.
Fate click con il tasto SX del mouse e tenendo premuto effettuare il trascinamento del
campo fino a sovrapporsi con il suo omonimo nella tabella Libri.
Rilasciate il tasto SX del mouse e state certi che sullo schermo si presenterà questa finestra.
Ovviamente il prossimo passaggio ha bisogno di diverse spiegazioni per chiarificare la si-
tuazione.
In pratica esistono diverse tipologie di relazioni che ovviamente dipendono fortemente da

che tipo di utilizzo verrà fatto. La relazione più comune e quella Uno a molti ovvero che
ad un record nella tabella Autori possono corrispondere molti libri nella tabella Libri.
Il segno di spunta nella casella “Applica integrità referenziale” sta a significare che sarà
impossibile inserire un libro da parte dell’utente nella tabella Libri che non abbia una precisa
232
corrispondenza con un Autore nella tabella “Autori”. Quindi se inserisco un libro senza un
Autore viene violata l’integrità referenziale è questo provocherà un blocco nella procedura.
L’integrità referenziale si porta dietro anche un’altra caratteristica che è quella dell’aggior-
namento o dell’eliminazione dei record a catena nella tabella correlata. In pratica se elimino
un Autore dal database questo automaticamente eliminerà anche tutti i sui libri.
L’aggiornamento a catena invece dipende da come è strutturato il database, ma in pratica
se cambia l’IDAUTORE (che nel nostro caso non si può fare perché abbiamo detto che è un
codice generato automaticamente dal computer e non dall’utente) allora nella tabella cor-
relata, per quanti possono essere i libri il campo IDAUTORE, verrà aggiornata con il nuovo
valore automaticamente senza l’intervento di un programma ad Hoc.
Capite che queste situazioni si applicano a casi ben precisi che sicuramente potranno anche
verificarsi, ma certo si tratta di casi abbastanza rari.
Mettete un segno di spunta, giusto per gradire, nella sola casella di opzione Applica inte-
grità referenziale e fate click sul pulsante Crea a destra nella finestra. È probabile che il
risultato sia quello che vedete nella figura qui sotto.
Personalmente penso che le relazioni non servano a nulla, però non potete negare che il
colpo d’occhio è veramente accattivante. A parte tutto quando il Database, o Db per gli
amici, diventa complesso questa vista un aiutino a non perdersi nelle tabelle, bene o male
che sia, lo dà.
L’indicazione accanto alla relazione mostra che un record nella tabella Autori può corri-
sponde a nessuno, uno o molti record nella tabella Libri. Perciò, cari miei, a inserire i dati
quando il database è vuoto, dobbiamo necessariamente iniziare dalla tabella Autori e non
dalla tabella libri perché un libro non può corrispondere a nessun autore.
Se desiderate modificare una relazione portate il puntatore del mouse a sovrapporsi con
essa e quindi fate click con il tasto DX quindi dal menu scegliete Modifica relazione.
Microsoft ACCESS
233
Quando avete terminato gli aggiustamenti e le modifiche del caso fate click con il tasto SX
del mouse sul pulsante Chiudi in alto sulla barra multifunzione.
Qualora vi chiedesse di salvare il Layout fate click sul pulsante Si nella finestra oppure se
avete deciso che volete ricominciare tutto daccapo fate click sul pulsante No.
A questo punto si ritorna alla situazione iniziale.

234
Inserire i dati nelle tabelle.
Per inserire di dati in una tabella è possibile procedere per via diretta oppure attraverso
una Maschera ma non parleremo di questo tipo di oggetti tipici di Access perché lo faremo
attraverso Visual Basic. Attraverso una maschera l’inserimento può essere ampiamente
personalizzato e quindi risulta facilitato rispetto all’immissione diretta. Nel nostro caso ini-
zieremo per via diretta quindi fate doppio click con il tasto SX del mouse sulla tabella Autori
per iniziare l’avventura.
Fate click nello spazio sotto il campo Nome_Cognome come si vede nella figura sottostante.
Il computer entrerà in modalità di inserimento dei dati evidenziando con un contorno mar-
cato dove andrà a posizionarsi quello che digitate dalla tastiera.
Inserite il primo dei nostri autori. Come nel caso di un foglio di calcolo allargate pure le
colonne per adattarle alle vostre necessità.
Microsoft ACCESS
235
Inserite i vari personaggi come ad esempio nella figura sottostante. Come avrete notato
tutte le volte che inserite un nuovo autore il campo IDAUTORE viene incrementato di una
unità. Ogni autore perciò corrisponderà ad un codice e sarà quel codice che verrà riportato
nelle tabelle eventualmente collegate, ad esempio la tabella libri, per identificare chi è l’au-
tore del libro e non il suo nome e cognome o altre generalità.
Le operazioni comuni su ogni record, così si chiamano le righe di una tabella, sono accessibili
facendo click con il tasto DX del mouse in corrispondenza dell’autore interessato ad even-
tuali operazioni, quindi non ci dilungheremo nella descrizione dato che si tratta di operazioni
intuitive come ad esempio l’eliminazione di un autore.
Tenete presente che quando eliminate un autore il suo codice associato non verrà mai più
ripetuto in quella tabella.
Nel nostro esempio abbiamo utilizzato una tabella particolarmente scarna che presenta solo
il nome dell’autore ed eventualmente delle note (non obbligatorie) a margine. Di solito le
tabelle sono molto più prodighe di informazioni ma come punto di partenza può andare
bene. Nei prossimi capitoli cercheremo di migliorarne la struttura.
236
Adesso chiudete la tabella degli Autori facendo click con il tasto SX del mouse in corrispon-
denza del comando che si vede nella figura successiva.
Modificare se necessario la struttura di una tabella.

Adesso vediamo insieme alcune operazioni importanti per la modifica della struttura di una
tabella e del database in generale, in modo da capire come si opera quando si verifica la
necessità di ampliare lo spazio dedicato alle informazioni. Inseriamo innanzi tutto una nuova
tabella che chiameremo Case_Editrici. Avete mai visto un libro senza una casa editrice? Può
darsi ma è un’eventualità piuttosto semplice da prendere in considerazione, come ad esem-
pio un libro di un autore anonimo. Basta aggiunge nella tabella Autori un record che invece
di un nome riporta la voce “Anonimo”.
In questo modo qualsiasi libro di autore anonimo può essere facilmente catalogato sempli-
cemente associandolo alla voce “Anonimo”.
Partiamo adesso alla creazione della nuova tabella facendo click sul pulsante Tabella alla
scheda Crea.
Microsoft ACCESS
237
Prima di iniziare passiamo alla visualizzazione della struttura della tabella facendo click sul
pulsante Visualizza a sinistra nello schermo e quindi dal menu scegliamo la voce Visua-
lizzazione Struttura.
Date un nome descrittivo alla tabella come ad esempio quello della figura sottostante, te-
nendo presente che il nome poteva essere scritto anche tutto attaccato senza spazi, oppure
staccato cosa quest’ultima non consigliata per mantenere la compatibilità con altri database
nel caso, prima o poi, di una migrazione o di uno scambio dati. Quindi come consigliato per
mantenere la leggibilità utilizzate invece dello spazio il trattino basso _ (underscore).
Nella figura successiva si può osservare la situazione finale della nuova tabella Case_Edi-
trici. Ovviamente potete aggiungere qualsiasi campo riteniate di qualche utilità. Ricordate
238
che il primo IDCASAEDITRICE deve essere definito Chiave primaria della tabella come ab-
biamo già visto in precedenza per le altre tabelle, se il computer automaticamente non gli
assegnasse questa definizione.
Riepilogo delle caratteristiche dei campi, ricordando che possono avere caratteristiche an-
che diverse a seconda delle necessità contingenti.
Nome Campo Tipo Dati Dimensione Indicizzato

IDCASAEDITRICE Numerazione Automatica Si duplicati non ammessi
Ragione_Sociale Testo Breve 120 Si duplicati ammessi
Partita_IVA Testo Breve 11 Si duplicati non ammessi
Codice_Fiscale Testo Breve 16 Si duplicati non ammessi
Indirizzo Testo Breve 50 No
CAP Testo Breve 5 No
Citta Testo Breve 30 No
Telefono Testo Breve 16 No
email Testo Breve 120 No
Dopo la creazione e la definizione dei campi fate click sul comando per chiudere la tabella.
Dal riquadro di tutti gli oggetti di Access fate click con il tasto DX del mouse sulla tabella
libri in quanto vista l’aggiunta della tabella Case_Editrici necessita di qualche piccola modi-
fica. Dal menu scegliete la voce Visualizzazione Struttura.
Microsoft ACCESS
239
Per collegare la tabella Case_Editrici alla tabella libri, dato che ogni libro appartiene ad una
casa editrice, è necessario aggiungere un campo che ci permetterà di effettuare questa
operazione. Fate click con il tasto destro del mouse ad esempio sul campo ISBN e dal menu
scegliete la voce Inserisci righe.
Verrà creato lo spazio per inserire il nuovo campo IDCASAEDITRICE (i nomi dei campi sono
solo consigliati, avete la facoltà di chiamarli come volete, tenendo presente le regole che i
nomi dei campi devono avere) che sarà di tipo Numerico (intero lungo, tutti i campi che
correlano della tabella di solito sono definiti come tali) e deve essere indicizzato (per velo-
cizzare le ricerche) con possibilità di ammettere duplicati, ogni casa editrice può pubblicare
un numero qualsiasi di libri. Nella figura successiva vedete le varie impostazioni qui de-
scritte.
La posizione nella tabella del campo è indicativa è non è soggetta a regole, quindi era
possibile inserirlo anche in fondo alla lista dei campi.
240
Chiudiamo la tabella libri dopo le modifiche e ovviamente rispondete Sì alla richiesta di

salvataggio della struttura della tabella.
Dalla scheda Strumenti database fate click sul pulsante Relazioni per collegare le tabelle
libri e case editrici.
Microsoft ACCESS
241
Dal riquadro degli oggetti di Access fate click con il tasto SX del mouse sulla tabella
Case_Editrici e tenendolo premuto trascinate virtualmente la tabella nell’area delle rela-
zioni, come ad esempio mostra la figura successiva.
Rilasciate il tasto SX del mouse e la tabella comparirà nel layout delle relazioni. A questo
punto ripetete l’operazione di trascinamento con il campo IDCASAEDITRICE dalla tabella
Case_Editrici alla tabella libri.
242
Confermate l’applicazione dell’integrità referenziale e confermate la relazione con il tasto
Crea nella parte destra della finestra.
La situazione finale sarà quella della figura successiva.
Mettiamo un po’ d’ordine al layout delle relazioni.

Nel nostro caso data la presenza di sole tre tabelle non esistono problemi di ordine, ma
quando la situazione si complica e le tabelle diventano tante è anche probabile che gli
intrecci diventino complicati e a questo punto chi ci capisce più nulla in uno schema confuso?
Per questo è possibile con facilità spostare le tabelle attraverso il metodo del trascinamento
con il mouse nella posizione più gradita in modo da rendere la vista dell’insieme più chiara
ed efficace.
Per eseguire questa operazione basta portare il puntatore del mouse sulla testata della
tabella dove è riportato il suon nome e con il tasto SX del mouse effettuare un trascina-
mento nella posizione più gradita. La figura successiva mostra il risultato finale dell’opera-
zione di trascinamento.
Microsoft ACCESS
243
Chiudete il Layout delle relazioni con l’apposito comando e confermate il salvataggio delle
impostazioni.
Adesso inseriamo nella relativa tabella i dati, anche parziali di almeno una casa editrice,
perché visto l’impostazione dell’integrità referenziale ogni libro deve necessariamente ap-
partenere ad un autore (anche anonimo) e fare parte di una casa editrice. Quindi non è
possibile inserire un libro se almeno una casa editrice non è presente nella tabella.
Fate doppio click con il tasto SX del mouse sulla tabella Case_Editrici nel riquadro degli
oggetti di Access e inserite i dati relativi quindi salvate e uscite dalla tabella ritornando alla
schermata iniziale di Access.
244
Le Query o Viste.
Una query va interpretata come una domanda, che viene fatta al database, e dalla quale
mi aspetto una risposta (se ovviamente ho impostato correttamente la domanda, altrimenti
picche). La risposta è una tabella, diciamo virtuale, perché non si tratta di una tabella vera
e propria in quanto fisicamente non esiste nel database. È la risposta a quanto avete chiesto
incrociando i dati già esistenti nelle tabelle presenti. La query si può memorizzare per essere
richiamata tutte le volte che desideriamo.
Partiamo con un esempio abbastanza semplice per poi gradualmente andare più sul com-
plesso: supponiamo che voglia sapere quali sono i libri di un determinato autore. Questo è
l’esempio più semplice per un oggetto di questo tipo ma serve per mostrare le potenzialità
di questo strumento.
Dalla scheda Crea fate click sul pulsante Struttura Query.
Aggiungete al layout della query la tabella autori e la tabella libri e poi fate click sul pulsante
Chiudi in basso a destra nella finestra. Per selezionare più una tabella dalla lista tenete
premuto dalla tastiera il tasto CTRL e mantenetelo premuto mentre fate click sulle varie
voci da selezionare.
Sistemate le tabelle dove desiderate con la solita tecnica. Qualora non dovessero mostrare
tutti i campi ridimensionate opportunamente la tabella fino a una situazione come quella
che viene mostrata nella figura successiva.
Microsoft ACCESS
245
La zona inferiore della finestra non aspetta altro che gli diciate quali sono i campi che de-
vono essere visualizzati in quella che deve essere la risposta alla vostra domanda.
Per aggiungere un campo alla zona sottostante è sufficiente fare doppio click con il tasto
SX del mouse in corrispondenza del campo da aggiungere. Come mostra la figura succes-
siva verrà visualizzato nel layout o struttura della query. Quindi se nella prima colonna
vogliamo il nome dell’autore fate doppio click nel campo corrispondente.
Per rimuovere un campo inserito nel layout per errore o non gradito fate click nel punto
indicato nella figura sottostante e quando viene selezionato dalla tastiera premete il tasto
CANC.
246
Aggiungete tutti i campi che ritenete necessari dalle rispettive tabelle.
Fate click sul pulsante Esegui alla scheda Progettazione per vedere il risultato.
Direi che non è male come prima query. Come si vede nella figura successiva, il risultato è
perfettamente identico ad una tabella, solo che i dati provengono da due tabelle differenti
Microsoft ACCESS
247
e che non occupano nessuno spazio aggiuntivo in memoria perché si tratta solo di una vista,
come fosse una fotografia istantanea dei dati in quel momento.
Ritorniamo con l’apposito comando alla struttura della query per effettuare eventuali gradite
variazioni.
Come mostra la figura successiva, se desiderate uno specifico ordinamento dei record, ad
esempio vogliamo ordinare per codice ISBN in ordine crescente, è sufficiente in corrispon-
denza del campo interessato dall’ordinamento selezionare dalla lista la voce Crescente.
Come allenamento potete richiedere i dati dell’esercizio di questo libro all’indirizzo di posta
elettronica libri@edizionifutura.com dove troverete il database già pronto in modo da non
essere costretti a inserire tutti i titoli dei libri e gli eventuali dati presenti nelle tabelle.
248
Aggiungiamo al layout anche l’anno di edizione del libro, in modo da visualizzare informa-
zioni più complete, facendo doppio click del tasto SX del mouse sul campo corrispondente.
Supponiamo inoltre di desiderare solo i titoli pubblicati dal 2009 in poi. È sufficiente digitare
nello spazio Criteri all’altezza del campo in questione il testo >=2009 e il gioco è fatto.
Eseguite la query con l’apposito comando Esegui alla scheda Progettazione e godetevi il
risultato sullo schermo. Se tutti i campi non sono visibili nella query ottimizzate la larghezza
delle colonne dalle loro testate o ridimensionate il riquadro degli oggetti di Access.
Microsoft ACCESS
249
Ricordate che nel vostro computer sicuramente la visualizzazione sarà più dettagliata in
quanto, per chiarezza, nel libro è stata utilizzata una risoluzione più bassa altrimenti alcuni
dettagli non sarebbero stati visibili nelle figure.
In generale gli operatori di confronto sono:
= Uguale a:
> Maggiore di:
>= Maggiore o Uguale a:
< Minore di:
<= Minore o Uguale a:
<> Diverso da:
Adesso salvate la query di modo poterla recuperare in un secondo tempo facendo click sul
pulsante Salva in alto a sinistra sulla Barra di accesso rapido e quando appare la finestra
di dialogo assegnate un nome descrittivo alla query (utilizzate la fantasia) e completate le
operazioni facendo click con il tasto SX del mouse sul pulsante OK nella finestra.
La query appena salvata verrà elencata nel riquadro degli oggetti di Access nella parte
sinistra della finestra. È possibile creare un numero qualsiasi di query a seconda delle vostre
necessità per poi essere richiamate in un secondo tempo.
250
Chiudete la query e torniamo alla schermata iniziale di Access.
Query di raggruppamento.
Non faremo una trattazione completa dell’argomento query perché non basterebbe un libro,
però volevo mostrarvi altri tipi di query. Con queste funzionalità è possibile fare pratica-
mente tutto, da semplici domande come abbiamo visto nel capitolo precedente a modifiche
delle tabelle, a query di eliminazione ecc.
Microsoft ACCESS
251
Questo tipo di query raggruppa i dati fornendo se richiesto dei totali. Supponiamo ad esem-
pio di voler sapere quanti titoli appartengono ad un determinato autore. Dalla scheda Crea
in alto nella finestra fate click sul pulsante Struttura query
Aggiungete al layout le tabelle Autori e Libri, dato che la tabella Case_Editrici non contiene
dati utili per questo tipo di interrogazione, facendo click su ciascuna tabella che viene mo-
strata nella lista e quindi sul pulsante Aggiungi, dopo di che fate click sul pulsante Chiudi
in basso nella finestra.
Date una sistemata al layout in modo che abbia un aspetto estetico gradevole, in quando
difficilmente al momento dell’inserimento di una tabella questa occuperà il posto “giusto”.
La figura sottostante potrebbe essere un esempio. Ridimensionate le tabelle in modo che
tutti i campi siano visibili.
Scegliete il campo Nome_Cognome dalla tabella Autori in modo che sia visibile le generalità
dell’autore del libro, il campo Titolo dalla tabella libri ed il campo pagine che ci servirà solo
252
per vezzo in quanto, se la cosa può risultare utile, ci dirà il totale delle pagine scritte dall’au-
tore in tutti i suoi libri. A questo passaggio la situazione sarà quella della figura sottostante.
Se ci fermiamo a questo punto però la query non sarà di nessuna utilità, o per lo meno non
ci darà il risultato che ci aspettiamo. Entrano quindi in gioco le funzioni di raggruppamento
o aggregazione dei record.
Fate click con il tasto DX del mouse sul nome del campo in basso nella finestra (va bene un
campo qualsiasi) e dalla lista scegliete la voce totali, oppure dalla barra multifunzione fate
click son il tasto SX del mouse sul pulsante totali nella parte destra in alto della finestra.
Microsoft ACCESS
253
Il pulsante totali è facilmente riconoscibile dal simbolo Sigma (maiuscolo). In entrambe i
casi verrà aggiunto uno spazio etichettato come Formula in basso ad ogni campo. Inizial-
mente troverete riportato “raggruppamento” nel senso che verranno raggruppati tutti i re-
cord perfettamente uguali fra loro.
Nel nostro caso per quanto riguarda il campo Nome_Cognome della tabella Autori verrà
eseguito un raggruppamento mentre la stessa cosa non va bene per gli altri campi coinvolti
nella query, o per lo meno il risultato non avrebbe nessun tipo di interpretazione utile da
parte dell’utente. Dato che questo è un argomento non semplice vi consiglio di effettuare
sempre una serie di prove e di osservare i vari risultati fino a trovare quello gradito perché
non sempre le query funzionano al primo colpo.
Per quanto riguarda il campo Titolo (del libro) invece di raggruppamento come inizialmente
proposto scegliete dalla lista “Conteggio” vale a dire verranno contati i titoli e raggruppati
per Autore.
Infine per il campo Pagine della tabella libri scegliete la voce Somma, quindi per ogni record
raggruppato per autore verrà calcolata la somma delle pagine, tenendo presente che queste
operazioni possono essere eseguite sono in un campo di tipo numerico.
254
A questo punto fate click sul pulsante Visualizza foglio dati in alto a sinistra nella finestra,
oppure sul pulsante Esegui.
Il risultato finale molto probabilmente e simile alla figura sottostante. Per semplicità in
questo caso ogni autore ha pochi titoli ma in un caso reale verrà mostrato il conteggio di
titoli corrispondente all’autore.
Per ritornare alla struttura della query qualora fosse necessaria qualche modifica fate click
sullo stesso pulsante in alto a sinistra.
Salvate la query, se intendete utilizzarla in un secondo momento, facendo click sul comando
di chiusura mostrato nella figura successiva in alto a destra nella finestra e quindi assegnate
un nome descrittivo in modo da poterla identificare facilmente nella lista degli oggetti di
Access che si trova nel lato sinistra della finestra.
Microsoft ACCESS
255
Altri esempi
Supponiamo adesso di voler scoprire quanti titoli per anno vengono pubblicati per autore
(si potrebbe fare anche per casa editrice ma attualmente nel database c’è né una sola) in
questo caso la struttura della query assumerebbe la forma visibile nella figura sottostante.
Maggiore è la quantità di dati presenti nel database e più spazio si apre alla fantasia.
Access e il linguaggio SQL

Le query come abbiamo detto sono oggetti che creano “al volo” un risultato simile a una
tabella incrociando dati che sono disposti su una o più tabelle ed eseguendo anche alcune
operazioni come somme, aggregazioni e tante altre cose che per motivi di spazio non pos-
siamo elencare in questo capitolo.
Dietro questi oggetti in realtà si trova un “linguaggio” chiamato SQL, acronimo di Structured
Query Language, che altro non è che una serie di istruzioni più o meno standard per fare
domande al database, e quindi ricevere una risposta sotto forma di tabella oppure, per dare
dei comandi di eliminazione, modifica o di inserimento dei dati. Questo linguaggio è comune
256
alla quasi totalità dei database professionali e Access sotto questo punto di vista non rap-
presenta un’eccezione. Quello che abbiamo visto fino ad adesso a livello di query in realtà
è un comodo strumento per evitare di scrivere il linguaggio SQL vero e proprio che agisce
in secondo piano, vale a dire che dietro ad ogni query c’è una serie di comandi SQL strut-
turati e che la composizione delle query proposta da Access in realtà è un traduttore di
questa strana lingua.
Anche in questo caso daremo solo un’infarinatura di questo strumento molto versatile ma
estremamente complesso. Per vedere cosa c’è “dietro” una query fate click sul pulsante
Visualizza (nella parte bassa dove si trova la freccia che va verso il basso) in alto a sinistra
e scegliete la voce Visualizzazione SQL. Il risultato è apprezzabile nella figura sottostante.
In pratica avrei dovuto scrivere tutto quel codice per giungere al risultato dell’esercizio
precedente. Nell’utilizzo con Visual Basic questo strumento è fondamentale.
Perfezioniamo il database.
Adesso supponiamo di dovere gestire i prestiti dei libri in carico alla biblioteca. Il database
o Db così com’è non sarebbe adatto a questo scopo in quando manca di alcune strutture,
vale a dire un paio di tabelle, una per memorizzare i dati dell’utente che ha chiesto il prestito
e una per memorizzare i prestiti veri e propri. Vediamo insieme come si procede.
Fate click sul pulsante Struttura tabella che si trova alla scheda Crea. Quando devo ini-
ziare con la creazione di una nuova tabella preferisco questo comando.
Create una struttura con le caratteristiche che vedete nella figura successiva. Se non ricor-
date alcuni passaggi a proposito dei campi o delle tabelle consultate la parte di questo
manuale che tratta dell’argomento.
Le lunghezze dei campi, dato che si tratta per la grande maggioranza di campi di testo,
possono essere gestite a piacere ragionando sul loro utilizzo senza troppo spreco di spazio,
ad esempio è inutile utilizzare un campo lungo 255 caratteri per memorizzare la provincia.
Anche i campi si prestano ad ampie interpretazioni ovvero avete la facoltà di aggiungere
eventuali dati che ritenete utili che magari sono assenti nello schema qui proposto.
Microsoft ACCESS
257
Inoltre indicizzate come abbiamo visto nel capitolo della creazione delle tabelle i campi che
ritenete oggetto di future ricerche, tenendo presente che questa operazione è fattibile anche
in un secondo tempo.
Salvate la tabella e assegnategli il nome Utenti.

Adesso passiamo alla creazione della tabella Prestiti. La struttura consigliata potete osser-
varla nella figura successiva.
In questo caso buona parte dei campi sono ti tipo data/ora in quanto necessita l’inserimento
delle date di inizio, termine e reso del libro chiesto in prestito. La tabella è così strutturata
in quanto un utente può chiedere in prestito più di un libro. Ad ogni record corrisponde un
258
prestito. Inoltre è possibile apportare delle modifiche includendo tutte quelle informazioni
che ritenete utili al fine della corretta gestione di un prestito.
Salvate anche questa tabella e assegnategli il nome Prestiti. Se non vi ricordate qualcosa
consultate la parte del libro che parla della creazione delle tabelle.
Passiamo adesso al tocco finale, ovvero alla creazione delle relazioni fra tabelle.
Fate click sul pulsante Relazioni che si trova alla scheda Strumenti database.
Fate click sul pulsante Aggiungi tabella per aggiungere le tabelle coinvolte nelle relazioni
nel nostro caso Utenti e Prestiti, qualora non siano già presenti nel layout.
Selezionate le tabelle una alla volta e fate click sul pulsante Aggiungi in basso nella fine-
stra. Per aggiungere più di una tabella contemporaneamente alla selezione fate click su
ciascuna tabella tenendo premuto dalla tastiera il tasto CTRL.
Microsoft ACCESS
259
Create le relazioni tra tabelle come abbiamo già visto nel capitolo specifico. Il risultato finale
potrebbe essere quello della figura successiva. Ricordate che per motivi funzionali è possi-
bile collegare in relazione solo campi che supportano lo stesso tipo di dati. Se collegati due
campi di tipo diverso molto probabilmente si verificherà un errore che vi impedirà l’inseri-
mento dei dati.
Una disposizione esteticamente curata, dato che siete voi che dovete disporre le tabelle nel
layout delle relazioni, può aiutare molto a trovare errori o a farvi venire qualche idea per
migliorare la struttura…
Al termine fate click sul pulsante Chiudi per terminare le operazioni.
Quello che abbiamo visto fin qua serve come base per comprendere meglio come si ma-
neggia un database anche se molto semplice come Access, prima di avventurarci verso
situazioni più complesse. Quindi considerate quello che avete visto fino a qui un percorso
obbligato per avere le basi per potere proseguire l’avventura con l’utilizzo del database
attraverso Visual Basic. Sono inoltre nel prossimo capitolo esposte operazioni che possono
essere utili per acquisire dati dall’esterno di Access e argomenti non utilizzati di frequente
che il programmatore non può non conoscere…
260
Importare dati dall’esterno
Un buon database che si rispetti deve avere la possibilità di accedere a dati che si trovano
in altri file ed eventualmente importarli, ovvero inserirli nella propria struttura. Access di-
spone di un menu Dati esterni particolarmente nutrito di comandi con il quale interagire
con l’esterno e soprattutto con gli altri prodotti della suite Office quali Excel e Word.
Iniziamo ad importare i dati da un file di Excel. Fate click sulla scheda Dati esterni e dalla
lista dei comandi fate click sul pulsante Nuova origine dati. Dato che la Microsoft in questo
ultimo periodo ha preso il vizio di aggiornare continuamente i propri prodotti è probabile le
immagini presenti in questa sezione non siano esattamente rispondenti con quello che com-
pare sul vostro schermo. I concetti restano gli stessi, fortunatamente.
Utilizziamo la prima opzione che ci viene offerta ovvero quella di importare i dati in una
nuova tabella nel nostro Database attuale. Per avviare la procedura fate click sul pulsante
Sfoglia…
Microsoft ACCESS
261
Identificate il file di Excel dal quale volete importare i dati. In quest’esempio lo faremo dal
file Pivot utilizzato come esercizio, che potete richiedere all’indirizzo di posta elettronica
libri@edizionifutura.com Una volta identificato fate doppio click sull’icona del file. La finestra
si chiude e si torna a quella precedente.
Se il nome del file che avete selezionato compare nel riquadro fate click sul pulsante Ok in
basso nella finestra per continuare con la procedura altrimenti selezionate nuovamente il
file con il pulsante Sfoglia.
262
Un file di Excel può contenere diversi fogli come in questo caso. Selezionate quale dei fogli
deve essere la sorgente dei dati, nel nostro esempio il foglio1. In ogni caso al momento
della selezione una buona anteprima vi permette di valutare la tipologia dei dati in gioco o
per lo meno di cosa si tratta. Scelta la sorgente fate click sul pulsante Avanti.
Non in tutti i casi questa selezione è opportuna ma è abbastanza facile valutarla.

Microsoft ACCESS
263
Il prossimo passaggio invece riveste una certa importanza. Access vi permette di specificare
una per una la tipologia delle colonne di Excel per trasformarla in un campo con una tipo-
logia di dati corretta. Molto utile per evitare successive correzioni che potrebbero portare a
perdita di dati.
Fate click su ciascuna delle colonne, la prima viene selezionata automaticamente all’aper-
tura della finestra, e controllate nel riquadro sovrastante se la colonna selezionata ha i
requisiti giusti per il tipo di dati contenuto. Nel nostro caso il campo tipo Testo breve va
benissimo in quanto si tratta di nomi di città.
La colonna mese invece ha bisogno di una piccola variante. Come si vede nella figura suc-
cessiva la tipologia proposta per il campo è Precisione doppia. Dato che il mese è un numero
intero e non potrà mai assumere valori diversi da un numero intero è meglio dalla lista
scegliere questa tipologia per non sprecare spazio nel database.
Selezionate la lista Tipo dati e al posto di Precisione doppia impostate il campo a Intero.
Lo stesso discorso vale per il campo successivo.
Se invece il contenuto del campo non è utile alle vostre necessità potete anche scegliere
apponendo un segno di spunta nell’apposita casella di non importare il campo selezionato.
Ricordate sempre di selezionate con un click del tasto SX del mouse la colonna della quale
dovete specificare le informazioni altrimenti rischiate di sbagliare a importare i dati.
Fate attenzione ad esempio alla colonna “Giorno della settimana” che il computer imposta
a data/ora e che invece si tratta di un comune campo di testo breve.
Quando avete impostato le informazioni per tutti le colonne del foglio di Excel fate click sul
pulsante Avanti come si vede nella figura successiva.
264
Anche se in questo tipo di dati la chiave primaria non è necessaria utilizziamo lo stesso la
prima opzione e fate click sul pulsante Avanti.
Microsoft ACCESS
265
L’ultimo passaggio vi chiede di assegnare un nome alla tabella. Se vi va bene quello propo-
sto fate click sul pulsante Fine altrimenti assegnate un nome prima di completare la pro-
cedura.
Al prossimo passaggio non salvate nulla e fate click sul pulsante Chiudi in basso a destra.
266
Importare dati da altri database di Access
Come potevamo facilmente immaginare è possibile trasferire dati da un database di Access
ad un altro in maniera molto semplice in quanto si tratta di un dialogo fra amici, ovvero
due file che hanno la stessa struttura.
L’utilizzo principale di questa funzionalità è soprattutto l’importazione dei dati da un data-
base di Access in versione precedente all’attuale a quella più recente nel nostro caso la
versione 2019. È possibile inoltre importare dati e anche altri oggetti del database quali
query, maschere, report ecc. oppure semplicemente collegare le tabelle, ovvero non im-
portare i dati ma creare semplicemente un collegamento ad un altro database per consul-
tare o aggiornare i dati quando ad esempio si accede agli stessi dati da più postazioni.
(Client-Server). In questo modo tutte le postazioni lavorano sullo stesso file e i dati possono
essere aggiornati e consultati in tempo reale.
Partiamo con il primo esempio ovvero importare i dati da un database di Access. Fate click
sulla scheda Dati esterni e scegliete la pulsante Nuova origine dati nel riquadro Importa
e collega.
Fate click sul pulsante Sfoglia per selezionare il file da dove importare i dati.
Per questo esercizio utilizzeremo il database Northwind che si può trovare come esempio
nella pagina inziale di Access. Quello che vedete nella figura successiva è ingrandito rispetto
alle dimensioni reali del vostro schermo quindi se non trovate il collegamento a Northwind
scorrete la finestra verso il basso con le apposite barre di scorrimento che si trovano nella
parte destra della finestra o fate click sul collegamento Alti Modelli, dipende dalla versione
di Access che avete. Seguite la procedura guidata per generare il database dato che non è
Microsoft ACCESS
267
pronto per l’utilizzo. Questa procedura ovviamente viene eseguita una sola volta per gene-
rare il database di esempio dopo di che dovete accedere direttamente al file senza eseguire
questi passaggi.
Una volta terminata la procedura verrà creato nella cartella Documenti del vostro computer
il file Northwind che contiene tante tabelle e altri oggetti interessanti che possono esservi
utili quando avrete una certa abilità nell’utilizzo di Access per estrapolare idee e soluzioni
da utilizzare per i vostri futuri progetti.
Tornando al nostro esempio dopo la generazione del database Northwind eseguite tutti i
passaggi dall’inizio di questo capitolo e vi troverete nella situazione della figura successiva.
Selezionate con un doppio click del tasto SX del mouse il database di esempio.
268
Il nome del database verrà riportato nella finestra del passaggio precedente. Esaminiamo
il primo caso selezionando l’opzione corrispondente, ovvero importa tabelle, query o
quant’altro si trova nel database. Fate click su OK in basso nella finestra per andare al
passaggio successivo.
Selezionate una o più tabelle da importare e fate click sul pulsante OK nella parte destra
della finestra ricordando che per effettuare selezioni multiple è necessario tenere premuto
il tasto CTRL dalla tastiera.
Inoltre, è possibile scegliere attraverso il sistema a schede dalla finestra altri tipi di oggetti
contenuti nel database come Query, Maschere, Report, Macro e Moduli.
Microsoft ACCESS
269
In questo esempio scegliamo la tabella Clienti. Fate doppio click sulla tabella appena inclusa
nel vostro Db per visualizzarne i dati.
Collegare le tabelle
Al passaggio di pagina precedente scegliete l’opzione Collega all’origine dati creando
una tabella collegata, in questo modo in dati non saranno trasportati nel vostro database
ma saranno semplicemente collegati.
Con questa tecnica è possibile creare un file centralizzato su un computer al quale è possi-
bile accedere anche da postazioni remote in modo da aggiornare i dati anche da più posta-
zioni con l’enorme vantaggio che tutti possono disporre immediatamente di dati aggiornati.
Fate click sul pulsante OK per andare al passaggio successivo.
Scegliete una o più tabelle da collegare e quindi fate click sul pulsante OK nella parte destra
della finestra.
270
Nella lista delle tabelle troverete stavolta la tabella con una piccola freccia che sta ad indi-
care il fatto che la tabella è collegata quindi esterna al vostro database.
Importare dati da un file di testo.

Non sempre due strutture di dati sono compatibili, ad esempio possono esserci dei database
i cui dati non sono convertibili direttamente nel formato Access, ad esempio il database
MySQL, ma ne esistono tantissimi, non è direttamente importabile da Access.
Un punto buon d’incontro fra sconosciuti potrebbe essere il File di testo oppure un File XML
entrambi adatti al dialogo fra strutture con compatibili.
Per importare dei dati di questo tipo fate click sulla scheda Dati esterni e selezionate il
pulsante Nuova origine dati dal riquadro Importa e collega.
Microsoft ACCESS
271
In questo esempio abbiamo prima esportato (consultate il capitolo corrispondente) dal da-
tabase Northwind la tabella Clienti in formato file di testo (per intendersi è un normale tipo
di file che si può facilmente leggere con Word o WordPad) e poi l’abbiamo recuperata nel
nostro database Biblioteca.
Selezionate attraverso il pulsante Sfoglia il file che contiene i dati da importare, selezionate
quindi l’opzione Importa dati di origine in una nuova tabella nel database corrente e quindi
fate click sul pulsante OK in basso per procedere al passaggio successivo.
Al passaggio successivo dovete scegliere se i dati sono separati fra loro da caratteri come
virgole, tabulazioni o cose di questo genere qui oppure sono del tipo a Larghezza fissa
ovvero sono allineati in colonne con spazi come caratteri di riempimento.
Nella parte sottostante della finestra compare un’anteprima che vi può facilitare questa
scelta tenendo presente che è necessario andare al passaggio successivo e controllare nuo-
vamente l’anteprima per poter cantare vittoria, ovvero se i dati si presentano leggibili e ben
separati.
272
Ne nostro caso si vede chiaramente che l’opzione da preferire è la prima quindi fate click
sul pulsante Avanti per procedere con l’operazione.
Infatti i campi sono ben separati e i dati si leggono molto bene. Qualora questa fortunata
coincidenza non dovesse verificarsi al primo colpo provate a selezionare altri delimitatori di
campo come ad esempio la tabulazione o altri caratteri e fate click sul pulsante Avanti.
Microsoft ACCESS
273
La situazione della figura successiva è già stata trattata nel capitolo che parla di come
importare i dati dal Excel. In sostanza si tratta di scegliere per ogni campo la giusta tipologia
per migliorare l’interpretazione dei dati. Quindi stabilite per ogni campo la giusta tipologia
(testo, numerico, ecc.) prima di fate click sul pulsante Avanti in basso a destra nella fine-
stra.
Al passaggio successivo fate ancora riferimento al capitolo che tratta l’importazione dei dati
da un foglio di Excel. Al termine fate click sempre sul pulsante Avanti.
Terminate infine la procedura assegnando un nome descrittivo alla tabella dove andranno
a collocarsi i dati così importati.
Esportare i dati
Esportare i dati è un’operazione importante quanto l’importazione che abbiamo analizzato
nel capitolo precedente, in quanto attraverso tale procedura è possibile scambiare i dati con
altri programmi che normalmente non hanno nulla a che fare con Access. I comandi neces-
sari si trovano nel riquadro Esporta alla scheda Dati esterni.
Esportare dati in un file di Excel

Fate click sul pulsante Excel che si trova nel riquadro Esporta alla scheda Dati Esterni
dopo aver selezionato nel riquadro di sinistra la tabella che desiderate esportare.
274
Il computer vi propone un nome per il file che verrà generato alla fine dell’esportazione dei
dati ovviamente nel formato Excel. Qualora il nome non fosse di vostro gradimento (Clienti
nel nostro caso) sostituite solo quello lasciando come si può vedere nella figura successiva
tutto il resto cosi come viene proposto.
In alternativa se desiderate salvare il file in un’altra cartella o in altra posizione del computer
fate click sul pulsante Sfoglia nella parte destra della finestra. Normalmente viene proposta
la cartella documenti per il salvataggio dei vostri documenti da qualsiasi programma di
Office e quindi date sempre un’occhiata al contenuto di tale cartella prima di dichiarare
scomparso un qualsiasi file.
A questo punto non vi resta che fare click sul pulsante OK in basso a destra nella finestra.
Ignorate per il momento l’eventuale passaggio successivo che si dovesse presentare dopo
aver fatto click sul pulsante OK della figura successiva in quanto è utile solo in caso di
esportazioni ripetitive o periodiche dei dati.
Microsoft ACCESS
275
Esportare dati in un file di Access
Per esportare i dati in un altro file di Access, dopo aver selezionato la tabella in questione,
fate click sul pulsante Access nel riquadro Esporta.
Al passaggio successivo fate click sul pulsante Sfoglia nella parte destra della finestra per
specificare in quale database di Access va inviata la tabella selezionata in precedenza.
Selezionate il file nel nostro caso utilizzeremo il database di esempio “Prova” e fate click sul
pulsante Salva in basso a destra nella finestra.
276
Ritornando al passaggio precedente che qui omettiamo fate click sul pulsante OK in basso
nella finestra per confermate l’operazione.
Adesso non ci resta che decidere se esportare solo la struttura della tabella oppure anche i
dati. Se questa tabella non esiste nel database di destinazione è necessario selezionare la
prima opzione che corrisponde alla situazione più comune. Inoltre è possibile scegliere un
nome di destinazione diverso rispetto alla tabella di origine semplicemente digitandolo nello
spazio al posto di quello che propone il computer. Fate click sul pulsante OK per portare a
termine l’operazione. Come al solito ignorate il passaggio successivo facendo click sul pul-
sante Chiudi in basso a destra nella finestra che compare sullo schermo.
Microsoft ACCESS
277
Se fate click con il tasto DX del mouse su una tabella e scegliete il menu Esporta potete
accedere a tutte le funzioni che avete visto fino ad adesso ed a tanto altro.
In questi capitoli abbiamo parlato di Microsoft Access in quanto per alcune applicazioni può
risultare un ottimo partner di Visual Studio per le sue caratteristiche molto apprezzate come
database.
Per applicazioni di una certa importanza, o se non disponete di Microsoft Access sul vostro
computer, potete optare per l’utilizzo di MySQL che è un prodotto gratuito nella versione
Community e offre prestazioni molto elevate che possono coprire tutte le esigenze nel
mondo dei database professionali.
278
ACCESS & Visual Basic
In questo capitolo affronteremo il problema di interfacciare Access con Visual Basic per
accedere ai dati. Si tratta di un argomento particolarmente vasto ed esistono ed inoltre
diverse tecniche per arrivare allo scopo. Inoltre sarebbe necessario un libro intero per
esporre le tecniche principali e quindi in questo capitolo mostreremo e commenteremo solo
le componenti essenziali delle procedure rimandando il codice completo al materiale extra
incluso nel libro e scaricabile dal sito.
Accedere al database Access

La prima cosa da fare per raggiungere i dati è collegarsi al database e per fare questo è
necessario quello che in gergo viene chiamata Stringa di Connessione. Ogni tipologia di
Database ha una sua “Stringa di Connessione” e la cosa migliore per verificare la possibilità
di accesso è quella di utilizzare l’utilità inclusa in Visual Studio. Fate click sul menu Stru-
menti in alto nella finestra e scegliete la voce Connetti a Database.
Dovrebbe apparire sullo schermo una finestra simile a quella che vedete nella figura suc-
cessiva. È probabile che a seconda dell’origine dati selezionata la finestra può essere anche
diversa.
Adesso è necessario fare alcune considerazioni prima di addentrarci oltre, nei meandri di
questa utilità.
279
Per quanto riguarda il database Access nei vari anni sono stati fatti alcuni cambiamenti, ad
esempio esistono due tipologie di database Access, quelli mdb e quelli accdb. Dato che un
database in linea di massima deve sempre essere accessibile anche se è datato, ammesso
che non sia stato volontariamente aggiornato, esistono strumenti diversi per connettersi a
queste diverse tipologie di database.
Se avete fra le mani un database mdb (era in voga prima del 2007) per accedere e ricavare
la stringa di connessione seguite questi semplici passi:
database mdb
fate click sul pulsante Modifica per cambiare l’origine dei dati.
Dalla finestra successiva sulla lista dovrebbe comparire la voce File di database Microsoft
Access e quindi fate click sul pulsante OK in basso nella finestra.
Compare ancora un’altra finestra. Fate click sul pulsante Sfoglia per cercare il vostro da-
tabase in formato mdb nei meandri del vostro computer.
280
Il mio si trova nella Cartella Documenti e quindi selezionatelo e fate click sul pulsante Apri
in basso a destra nella finestra.
Come vedete dopo la selezione il nome ed il percorso completo del database compaiano
nella casella di testo del nome del File. Qualora il database fosse protetto da una password
d’accesso dovete inserirla nell’apposito spazio e quindi, prima di procedere oltre, fate click
sul pulsante Test Connessione per verificare che tutto sia configurato nel migliore di modi.
281
Se il risultato è come quello che vedete nella figura sottostante allora siete sulla buona
strada altrimenti è possibile che il database sia danneggiato o che avete sbagliato qualche
parametro nella connessione come ad esempio la password d’accesso.
Se l’esito è positivo alla finestra successiva fate click sul pulsante OK. La vostra connessione
sarà aggiunta all’elenco delle connessioni disponibili nella finestra Esplora Server.
282
Diamo quindi una sbirciatina dentro il database per vedere se i dati sono realmente rag-
giungibili oppure si tratta di un bluff. Fate click accanto al nume della connessione per
visualizzare i dettagli.
I dati si trovano nelle tabelle quindi fate click per visualizzare la lista.
Fate click su una tabella con il tasto DX del mouse e dalla lista scegliete Recupera Dati.
Adesso che vi siete sincerati che il database non è vuoto chiudete la finestra dei dati.
283
Adesso per ricavare la stringa di connessione fate click con il tasto DX del mouse sulla
nostra connessione e dalla lista scegliete proprietà. La stringa è visibile accanto all’omonima
proprietà.
In caso di utilizzo come vedremo nei prossimi capitoli dovete selezionarla, copiarla e incol-
larla dove serve. Qui sotto vediamo alcuni esempi dato che la stringa di connessione è un
argomento molto “caldo” nell’ambito database.
Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\Users\Giuseppe\Documents\archivio.MDB
Nel caso di un database protetto con password:
Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\Users\Giuseppe\Documents\archivio.MDB;
User ID=Admin;Password=PincoPallino;
la stringa è scritta su due righe per motivi di spazio ma in realtà e tutta su una riga.
Se il database è protetto tramite sicurezza a livello utente Access crea per i database tipo
mdb un file con lo stesso nome del database ma con estensione mdw, che contiene le
informazioni sul gruppo di lavoro qualora ci fossero altri utenti oltre all’amministratore. Si
tratta di un argomento particolarmente lungo che non possiamo esporre in questo libro,
che è facilmente verificabile per la presenza dell’omonimo file mdw.
In questo caso la stringa di connessione diventa:
Provider=Microsoft.Jet.OLEDB.4.0;Data Source= C:\Users\Giuseppe\Documents\archivio.MDB;

Jet OLEDB:System Database= C:\Users\Giuseppe\Documents\archivio.mdw;
User ID=*****;Password=*****;
284
ovviamente sostituendo agli asterischi il nome dell’utente e la sua password.
Quindi scollegatevi facendo click sul database con il tasto DX del mouse e dalla lista sce-
gliete Chiudi Connessione.
Database accdb
Adesso proveremo la connessione ad un database più moderno di Access quello con formato
accdb. Supponiamo che il database si trovi dentro una determinata Cartella come si vede
nella figura sottostante. (nel nostro caso la cartella documenti.)
Fate click son il tasto DX del mouse sulla barra degli indirizzi e dalla lista scegliete la voce
Copia indirizzo come testo.
Questo vi serve per evitare imbarazzanti situazioni quando vi chiede dove si trova il nome
del file dato che la finestra in questo secondo caso è leggermente finestra.
Dall’ambiente di sviluppo fate click sul menu Strumenti in alto nella finestra e dalla lista
scegliete la voce Connetti a database come avete fatto nel caso precedente.
285
Scegliete dalla lista sottostante, dopo avere verificato che nella lista Origine dati sia stato
selezionato il Provider di Dati.NET framework per OLE DB, il provider Microsoft Office
12 Access Database Engine OLD DB Provider nel caso che il vostro database sia stato
creato con Access 2007-2013 mentre scegliete la versione 16 se il vostro database è stato
creato con Access 2016.
Attenzione: questi due Provider di dati come altri della lista che vedete nella figura
precedente difficilmente saranno installati sul vostro computer. Per procurarveli do-
vete provvedere a scaricarli da Internet ed installarli sul vostro computer. La pro-
cedura non la riportiamo per motivi di spazio ma comunque equivale all’installa-
zione di qualsiasi programma. Si trovano sul sito della Microsoft ma andate su un
motore di ricerca come ad esempio Google e digitate Microsoft Office 2016 Run-
time Library nel caso di Access 2016 (attualmente anche per la versione 2019 va
bene) oppure Microsoft Office 2013 Runtime Library nel caso di Access 2007-
2013. Se disponibili scaricateli in lingua italiana e soprattutto sinceratevi di scari-
carli dal sito della Microsoft e non da altre parti.
Dopo l’installazione riavviate il computer e rientrate nell’ambiente di sviluppo quindi ripetete

la procedura. I provider di dati questa volta dovrebbero essere ben visibili nella lista.
Adesso incollate il percorso del database che avevate copiato nel primo passaggio in quanto
stavolta il pulsante Sfoglia non c’è nella finestra e dovete scrivere il percorso per intero
(sfido chiunque a ricordarlo) tenendo presente che il minimo errore vanifica la connessione
ai dati con sommo disappunto da parte del programmatore. Come si vede nella figura suc-
cessiva oltre al percorso va anche aggiunto il nome del database accdb.
286
Anche in questo caso qualora il database fosse protetto da password è necessario specifi-
carla assieme al nome utente (che di solito nel caso di access è admin) per potervi accedere
quindi fate il test della connessione prima di procedere oltre.
Se tutto fila liscio ed il test sulla connessione è positivo confermate facendo click sul pul-
sante OK in basso nella finestra.
Come nel caso precedente fate click con il tasto DX del mouse nella finestra di sinistra sulla
connessione appena creata e dalla lista scegliete la voce Proprietà.
La stringa è ricavabile dalla proprietà Stringa di Connessione.
Nel caso di questo tipo di database la stringa si presenta in modo diverso:
Provider=Microsoft.ACE.OLEDB.12.0;Data Source=C:\Users\Giuseppe\Documents\biblioteca.accdb
287
Stesso discorso per un database protetto.

Provider=Microsoft.ACE.OLEDB.12.0;Data Source=C:\Users\Giuseppe\Documents\biblioteca.accdb;
User ID=Admin;Password=PincoPallino;
Accesso ai dati da Visual Basic.

Perché è impossibile mostrare tutte le possibilità che offre questo strumento ho creato un
esempio che troverete nel materiale incluso nel libro da scaricare dal sito della casa editrice
che si chiama Access1 che riepiloga tutto quello che vedremo in questo capitolo e che per
motivi di spazio è impossibile mostrare nel libro quindi ne riassumeremo i tratti salienti.
Innanzitutto, avete bisogno di un oggetto OleDbConnection quindi è necessario richiamare
le librerie nello spazio dei nomi:
Imports System.Data
Imports System.Data.OleDb
che contengono tutti gli oggetti dei quali abbiamo bisogno. Va detto che il progetto non è
composto di un solo Form quindi è abbastanza articolato e mostra tutto quello che vi serve
per inserire nuovi dati, modificare i dati ed eliminare dati da un database di Access.
Il Form denominato Principale serve solo per aprire il database e fare da contenitore (MDI-
Form) agli altri Form del progetto.
StringaConnessione = "Provider=Microsoft.ACE.OLEDB.12.0;Data Source=" & NomeFile & ";User

ID=admin"
Definisco un oggetto che rappresenta la mia connessione
Dim Connessione As OleDbConnection
Assegno all’oggetto una nuova connessione tipo OleDbConnection
Connessione = New OleDbConnection(StringaConnessione)
Quindi apro la connessione
Connessione.Open()
Quando voglio chiudere una connessione scrivo semplicemente:
Connessione.Close()
E fin qui tutto fila liscio. Nel codice completo dell’esercizio ovviamente la questione è molto
più complicata ad esempio vi è un controllo che verifica che la connessione sia Ok resti-
tuendo un messaggio d’errore qualora la connessione non vada a buon fine:
Try
Connessione.Open()
Catch Eccezione As System.Exception
Cursor = Cursors.Default
MsgBox(Eccezione.Message)
Exit Try
End Try
Questa trappola per errori, per maggiori informazioni consultate il capitolo della gestione
degli errori in Visual Basic, esegue tutte le istruzioni che si trovano fra Try e Catch e nel
caso di insuccesso esegue le istruzioni che si trovano fra Catch e End Try.
288
È importante saper gestire gli errori per evitare che, quando il progetto sarà completo e
funzionerà sul computer di qualche cliente, si interrompa facendo esternare frasi che non
sempre rappresentano un apprezzamento per il vostro lavoro.
Adattatore dei dati (OleDbDataAdapter)

Collegarsi al database non basta certo per poter vederne il contenuto ma è necessario un
ulteriore componente chiamato OleDbDataAdapter, ovvero un adattatore di dati che per-
mette di leggere, modificare ed eliminare i dati all’interno del database.
DataSet
Questo tipo di oggetto rappresenta un insieme di dati recuperati con l’oggetto OleDbDa-
taAdapter e contiene anche i nomi dei campi e i tipi di dati.
OleDbCommand
Viene invece utilizzato per eseguire istruzioni SQL (vedi il capitolo che tratta gli aspetti del
linguaggio SQL) per eseguire istruzioni sul database e possono comprendere comandi per
inserire, eliminare o aggiornare i dati presenti.
La versione semplificata è:
dichiaro gli oggetti:
Dim Adattatore As OleDbDataAdapter

Dim DataSet As DataSet
Dim OggettoCommand As OleDbCommand
apro la connessione
Connessione.Open()
voglio la lista tutti i libri che si trovano nella tabella Libri
Dim stringaSQL As String = "SELECT * FROM Libri ORDER BY ISBN "
Creo l’adattatore
Adattatore.SelectCommand = New OleDbCommand(stringaSQL, Connessione)

Adattatore.SelectCommand.CommandType = CommandType.Text
al posto delle due righe precedenti è possibile utilizzare anche queste per avere lo stesso
risultato.
Adattatore.SelectCommand = New OleDbCommand()

Adattatore.SelectCommand.Connection = Connessione
Adattatore.SelectCommand.CommandText = stringaSQL
Adattatore.SelectCommand.CommandType = CommandType.Text
Quindi lo riempio con i dati
Adattatore.SelectCommand.ExecuteNonQuery()
Adattatore.Fill(SetDati, "Libri")
Inserisco i dati nel controllo DataGridView
DataGridView1.DataSource = SetDati.Tables("Libri")
Chiudo la connessione
289
Connessione.Close()
Questo a grandi linee è la descrizione del codice presente nel form Libri del progetto.
Ovviamente è necessario introdurre brevemente un controllo molto importante
DataGridView
Si tratta del componente principe per visualizzare sullo schermo quello che è l’equivalente
di una tabella di dati. Presenta tantissime caratteristiche e nel nostro progetto ne sono
messe in evidenza diverse. Dato che si tratta di un controllo completamente personalizza-
bile, e quindi funziona già quando gli viene assegnato un set di dati ma ovviamente li vi-
sualizza come vuole lui, sono necessari dei ritocchi per evitare che ciò che è visualizzato sia
a tutti gli effetti difficilmente leggibile.
La DataGridView si trova sulla Casella degli strumenti sotto la voce Dati. Una volta inserita
in un form ha un aspetto insignificante come si vede nella figura sottostante, ma quando la
vedrete all’opera allora vi ricrederete.
Dico alla griglia che quando seleziono una riga questa va selezionata tutta e non solo un
delle celle.
DataGridView1.SelectionMode = DataGridViewSelectionMode.FullRowSelect
Per evitare di scrivere mille volte DataGridView1 utilizzo la parola chiave With omettendo
il nome dell’oggetto in questione mettendo però un punto prima di richiamare le proprietà
dell’oggetto.
With DataGridView1
Definisco il carattere del font per le celle.

290
.DefaultCellStyle.Font = New Font("Verdana", 7)
Definisco il carattere del testo della testa delle colonne.
.ColumnHeadersDefaultCellStyle.Font = New Font("Verdana", 7)
Dichiaro che la griglia e di sola lettura quindi l’utente non può modificare i dati che com-
paiono sulla griglia.
.ReadOnly = True
Permetto all’utente di ridimensionare manualmente le righe
.AllowUserToResizeRows = False
Non permetto all’utente di inserire altre righe.
.AllowUserToAddRows = False
Imposta l’altezza di una riga in pixel.
.RowTemplate.Height = 18
Imposta la larghezza in pixel della colonna che contiene le intestazioni delle righe.
.RowHeadersWidth = 15
Imposta lo stile predefinito applicato alle celle, in questo caso il colore di sfondo e giallo
chiaro,
.RowsDefaultCellStyle.BackColor = Color.LightYellow
Le righe dispari delle celle invece avranno uno sfondo bianco per migliorare la leggibilità
della griglia.
.AlternatingRowsDefaultCellStyle.BackColor = Color.White
Il codice che segue invece serve a impostare le colonne della griglia per migliorare la leg-
gibilità dei dati. Assegno alla prima colonna della griglia il campo ID della tabella libri ma
non lo rendo visibile nella griglia. Mi serve solo per recuperare l’ID univoco del libro per
poterci apportare modifiche o altre operazioni.
.Columns("ID").Visible = False
Alla colonna successiva assegno il campo ISBN. La testa della colonna deve descrivere
quello che compare in quella colonna in questo caso proprio ISBN
.Columns("ISBN").HeaderText = "ISBN"
I dati nella colonna devono essere allineati a destra in orizzontale e al centro in verticale.
.Columns("ISBN").DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleLeft
La larghezza della colonna in pixel
.Columns("ISBN").Width = 130
291
Determina il formato del numero, nel caso di contenuto numerico della cella. In questo caso
il codice corrisponde ad un numero che presenta il separatore delle migliaia e due cifre
decimali.
.Columns("Prezzo_Listino").DefaultCellStyle.Format = "##,##.00"
Quelle che abbiamo appena visto sono le caratteristiche principali di una griglia e alcune
personalizzazioni che è possibile applicarle. In realtà le proprietà sono veramente tante e il
loro utilizzo dipende anche dall’impiego finale che la griglia deve avere.
La personalizzazione della griglia viene eseguita in una routine separata per non fare troppa
confusione con il resto codice che invece manipola i dati.
Eliminare un record
Il codice che vedete nel riquadro seguente serve a eliminare un record in una tabella, nel
nostro caso per eliminare un libro nell’omonima tabella.
Dim ID As Long
Try
ID = DataGridView1.Item(0, DataGridView1.CurrentCell.RowIndex).Value
Exit Sub
End Try
Dim Risposta As String = MsgBox("Eliminare il libro Selezionato ?", vbYesNo +

vbExclamation, "Elimina Libro")
If Risposta = vbNo Then
Exit Sub
End If
'Eliminazione libro Selezionato

Dim ComandoCancellazione As String = "DELETE FROM Libri WHERE ID = " & Str(ID) & " "
Dim OggettoComando As OleDbCommand = New OleDbCommand(ComandoCancellazione, Connessione)
Connessione.Open()
Try
OggettoComando.ExecuteNonQuery()
Catch ex As OleDbException
Connessione.Close()
MsgBox(ex.Message)
Exit Sub
End Try
Connessione.Close()
Leggi_Dati()
MsgBox("Libro eliminato con successo", vbOKOnly + vbExclamation, "Eliminazione OK")
Vediamo un po’ che cosa fa questo benedetto codice:

Intanto recupero il valore univoco che rappresenta il libro dalla Griglia. Questo valore non
deve apparire all’utente infatti se vi ricordate nel paragrafo precedente avevamo nascosto
la colonna ID nella griglia. L’utente infatti non farà mai nessuna operazione su questo
campo.
Dim ID As Long
292
ID = DataGridView1.Item(0, DataGridView1.CurrentCell.RowIndex).Value
Creo un comando SQL (per maggiori informazioni fate riferimento al capitolo che tratta
questo linguaggio)
Dim ComandoCancellazione As String = "DELETE FROM Libri WHERE ID = " & Str(ID)
Creo un oggetto comando assegnandogli il comando di cancellazione di cui sopra e le infor-

mazioni di connessione.
Dim OggettoComando As OleDbCommand = New OleDbCommand(ComandoCancellazione, Connessione)
Apro la connessione con il database.
Connessione.Open()
Dico all’oggetto comando di eseguire il comando di testo assegnato in precedenza.
OggettoComando.ExecuteNonQuery()
Chiudo la connessione e il record è cancellato.
Connessione.Close()
Consultate sempre il codice nel materiale allegato al libro per maggiori informazioni.
ComboBox
Nella parte del libro dedicata ai controlli abbiamo fatto conoscenza con questo utile stru-
mento per elencare in una lista a discesa una serie di valori. Una cosa ben diversa è invece
riempire la lista di valori acquisendoli da una tabella di un database.
Nel nostro caso il combo si chiama C_Autori e viene riempito dai valori presenti nella tabella
Autori del database. Il codice in linea di massima e quello che vi vede nel riquadro.
Dim Adattatore As New OleDbDataAdapter

Dim DataSetAutori As New DataSet("Autori")
Dim stringaSQL As String = "SELECT IDAUTORE, Nome_Cognome FROM Autori ORDER BY Nome_Cognome"

Adattatore.Fill(DataSetAutori, "Autori")
C_Autori.DataSource = DataSetAutori.Tables("Autori")
C_Autori.ValueMember = "IDAUTORE"
C_Autori.DisplayMember = "Nome_Cognome"
Dichiaro un adattatore di dati (ovviamente prima devo aprire una connessione)
Dim Adattatore As New OleDbDataAdapter
Dichiaro un oggetto DataSet
Dim DataSetAutori As New DataSet("Autori")
Attraverso una stringa SQL non prendo tutti i dati nella tabella Autori ma limito la scelta ai
campi IDAUTORE e Nome_Cognome
Dim stringaSQL As String = "SELECT IDAUTORE, Nome_Cognome FROM Autori ORDER BY Nome_Cognome"
Passo il comando all’adattatore dei dati

293
Riempio l’adattatore con i dati
Adattatore.Fill(DataSetAutori, "Autori")
Assegno il ComboBox alla tabella Autori
C_Autori.DataSource = DataSetAutori.Tables("Autori")
Associo il campo IDAUTORE alla proprietà ValueMember che mi servirà per identificare uni-
vocamente l’autore ma non deve comparire nella lista combinata.
C_Autori.ValueMember = "IDAUTORE"
Assegno come campo da visualizzare nella lista a discesa il campo “Nome_Cognome”
C_Autori.DisplayMember = "Nome_Cognome"
In pratica degli autori vengono visualizzati solo i nomi ed i cognomi ma in realtà per iden-
tificarli univocamente utilizzo l’IDAUTORE che pur non comparendo nella lista viene tenuto
in considerazione dal ComboBox. (Come se fosse una Griglia di dati con due sole colonne
di cui la prima la nascosta.)
Aggiungere un record.
Per aggiungere dei dati ad una tabella esistono diverse tecniche. In questo esempio viene
utilizzato un OleDbCommandBuilder che provvedere a creare in modo automatico un co-
mando SQL da passare al database per aggiungere nuovi record o eseguire altre operazioni.
Il codice di esempio per questa operazione è visibile nel riquadro successivo.
Connessione.Open()
'Creazione di Adattatore dei Dati
Dim stringaSQL As String = " SELECT * FROM Libri "
Dim Adattatore As New OleDbDataAdapter(stringaSQL, Connessione)

Dim SQLComBuilder As New OleDbCommandBuilder(Adattatore)
Dim DataSet1 As New DataSet("Libri")

Adattatore.Fill(DataSet1, "Libri")
Connessione.Close()
Dim Tabella As DataTable = DataSet1.Tables("Libri")

Dim Righe As DataRowCollection
Dim NuovaRiga As DataRow
Righe = Tabella.Rows
NuovaRiga = Tabella.NewRow
Dim Titolo As String = Trim(t_Titolo.Text)

Dim ISBN As String = Trim(t_ISBN.Text)
Dim Prezzolistino As Double = Val(t_Prezzo.Text)
Dim Pagine As Integer = Val(t_Pagine.Text)
Dim AnnoEdizione As Integer = Val(t_AnnoEdizione.Text)
Dim Annotazioni As String = Trim(t_Note.Text)
Dim Autore As String = C_Autori.SelectedValue

294
Dim CasaEditrice As String = C_CaseEditrici.SelectedValue
NuovaRiga("IDCASAEDITRICE") = CasaEditrice
NuovaRiga("IDAUTORE") = Autore
NuovaRiga("ISBN") = ISBN
NuovaRiga("Titolo") = Titolo
NuovaRiga("Prezzo_Listino") = Prezzolistino
NuovaRiga("Pagine") = Pagine
NuovaRiga("Anno_Edizione") = AnnoEdizione
Righe.Add(NuovaRiga)
Connessione.Open()
Adattatore.Update(DataSet1, "Libri")
DataSet1.AcceptChanges()
'Chiudo la connessione al Database

Connessione.Close()
Tanto per cambiare apro la connessione
Connessione.Open()
Dichiaro una stringa SQL che serve per recuperare i dati nella tabella del database
Dim stringaSQL As String = " SELECT * FROM Libri "
Associo l’adattatore dei dati
Dim Adattatore As New OleDbDataAdapter(stringaSQL, Connessione)
Creo un oggetto OleDbCommandBuilder e lo associo all’adattatore
Dim SQLComBuilder As New OleDbCommandBuilder(Adattatore)
Creo nella memoria del computer un DataSet con la tabella libri
Riempio l’adattatore con i dati
Chiudo la connessione
Connessione.Close()
Creo un oggetto tabella. Dato che non sono più collegato al database l’aggiornamento dei
dati avviene prima nella memoria del computer e poi passato al database al termine della
procedura di aggiornamento. In questo modo è possibile accedere in più utenti al database
rendendo la struttura più veloce senza tenere aperte le connessioni per tutta la durata del
funzionamento del programma.
Dim Tabella As DataTable = DataSet1.Tables("Libri")
Creo un oggetto Righe per la tabella che corrisponde alla collezione di righe della tabella.

295
Creo l’oggetto NuovaRiga ovvero il record che dovrò aggiungere al database.
Associo all’oggetto righe, le righe della tabella.
Associo all’oggetto NuovaRiga una nuova riga della tabella.
Assegno delle variabili ai campi che si trovano sul form. Recupero i dati dai TextBox e li
inserisco nelle variabili

Dim Annotazioni As String = Trim(t_Note.Text)
Recupero dai ComboBox, come abbiamo visto nell’esempio precedente, il valore dell’iden-
tificato corrispondente e non quello che viene mostrato nella lista.
Dim Autore As String = C_Autori.SelectedValue

Dim CasaEditrice As String = C_CaseEditrici.SelectedValue
Aggiungo questi dati alla nuova riga. Lo posso fare in diversi modi come si vede dal codice
nel box leggermente diverso ma la sostanza resta quella.
NuovaRiga("IDCASAEDITRICE") = CasaEditrice
NuovaRiga("IDAUTORE") = Autore
NuovaRiga("ISBN") = ISBN
NuovaRiga("Titolo") = Titolo
NuovaRiga("Prezzo_Listino") = Prezzolistino
NuovaRiga("Pagine") = Pagine
NuovaRiga("Anno_Edizione") = AnnoEdizione
Aggiungo la nuova riga alla collezione delle righe del set di dati.
Apro la connessione
Connessione.Open()
Aggiorno la tabella libri passando il set di dati all’adattatore
Adattatore.Update(DataSet1, "Libri")
Sperando che accetti i cambiamenti
E chiudo la connessione
Connessione.Close()
296
Modificare un Record
In questo specifico caso prima di apportare le eventuali modifiche è necessario leggere i
dati e presentarli a schermo. Il progetto dispone infatti di un form che si chiama LibriModi-
fica che permette di modificare dati relativi a un libro già inserito.
La prima parte quindi permette di recuperare i dati nella tabella libri nel database.
Dim StringaSQL1 As String = "SELECT * FROM Libri where ID = " & Str(MioLibro)
Dim Adattatore As New OleDbDataAdapter(StringaSQL1, Connessione)

Dim Tabella As DataTable
Tabella = DataSet1.Tables("Libri")
t_ISBN.Text = Tabella.Rows(0).Item("ISBN")
t_Titolo.Text = Tabella.Rows(0).Item("Titolo")
t_Prezzo.Text = Tabella.Rows(0).Item("Prezzo_Listino")
t_Pagine.Text = Tabella.Rows(0).Item("Pagine")
t_AnnoEdizione.Text = Tabella.Rows(0).Item("Anno_Edizione")
C_Autori.SelectedValue = Tabella.Rows(0).Item("IDAUTORE")
C_CaseEditrici.SelectedValue = Tabella.Rows(0).Item("IDCASAEDITRICE")
Connessione.Close()
Intanto devo creare una Stringa SQL che recuperi dal database solo ed esclusivamente il
libro specificato. La variabile MioLibro e stata definita Public, quindi disponibile in tutto il
progetto, e si trova nel modulo di codice denominato Modulo1 nella finestra Esplora Solu-
zioni.
Tenete presente che un valore numerico (del campo ID) in questo caso va passato come
Stringa (Str(MioLibro)) al comando SQL.
Quindi creo un adattatore di dati

297
Creo un set di dati
E quindi riempio l’adattatore.
Creo un oggetto tabella
Assegno i dati alla tabella.
Recupero i dati dall’unica riga che compone la tabella, quella di indice 0, e li metto nei vari
campi di testo. (TextBox)
dato che in precedenza ho già riempito i due ComboBox (Autori e Case Editrici) con i dati
delle rispettive tabelle con questi due comandi dico ai ComboBox che devono posizionarsi
sull’autore e la casa editrice del libro in questione.
Chiudo la connessione.
Connessione.Close()
Questo è quello che riguarda la lettura dei dati. Ovviamente vi invito a dare un’occhiata al
codice completo contenuto nell’esercizio visto che nel libro mettiamo in risalto le parti più
importanti.
Dim Adattatore1 As New OleDbDataAdapter("SELECT * FROM Libri WHERE ID = " & Str(MioLibro) &
" ", Connessione)
Dim Dataset1 As New DataSet("Libri")

Adattatore1.Fill(Dataset1, "Libri")
Dim CommBuild As New OleDbCommandBuilder(Adattatore1)
Dim Tabella As DataTable = Dataset1.Tables("Libri")
Dim Riga As DataRow = Tabella.Rows(0)

Riga.BeginEdit()
298
Riga("IDCASAEDITRICE") = C_CaseEditrici.SelectedValue
Riga("IDAUTORE") = C_Autori.SelectedValue
Riga("ISBN") = ISBN
Riga("Titolo") = Titolo
Riga("Prezzo_Listino") = Prezzolistino
Riga("Pagine") = Pagine
Riga("Anno_Edizione") = AnnoEdizione
Riga.EndEdit()
Adattatore1.Update(Dataset1, "Libri")
CommBuild.GetUpdateCommand()
Connessione.Close()
Adesso per modificare il record creo un adattatore utilizzando come prima una stringa che
seleziona esclusivamente il record in questione che devo modificare.
Dim Adattatore1 As New OleDbDataAdapter("SELECT * FROM Libri WHERE ID = " & Str(MioLibro) & "
", Connessione)
Creo un DataSet e riempio l’adattatore dei dati
Dim Dataset1 As New DataSet("Libri")

Adattatore1.Fill(Dataset1, "Libri")
Creo un oggetto OleDbCommandBuilder che provvederà a creare il comando SQL in maniera

automatica.
Dim CommBuild As New OleDbCommandBuilder(Adattatore1)
Creo l’oggetto tabella
Dim Tabella As DataTable = Dataset1.Tables("Libri")
Creo l’oggetto Riga assegnandogli i dati che si trovano nella riga 0 della tabella.
Prendo i dati che l’utente ha modificato, prima li metto in alcune stringhe ma posso asse-
gnarli anche direttamente

Do inizio alle modifiche
Riga.BeginEdit()
Inserisco i dati modificati nei rispettivi campi
Riga("IDCASAEDITRICE") = C_CaseEditrici.SelectedValue
Riga("IDAUTORE") = C_Autori.SelectedValue
Riga("ISBN") = ISBN
Riga("Titolo") = Titolo
299
Riga("Prezzo_Listino") = Prezzolistino
Riga("Pagine") = Pagine
Riga("Anno_Edizione") = AnnoEdizione
Termino le modifiche
Riga.EndEdit()
Riempio l’adattatore con i nuovi dati
Adattatore1.Update(Dataset1, "Libri")
Dico al CommandBuilder di eseguire il comando di Update (aggiornamento)
Chiudo la connessione ed il gioco è fatto.
Connessione.Close()
Stampare con Visual Basic.

Alcune considerazioni su questo argomento le abbiamo già fatte nel capitolo delle finestre
di dialogo (PrintDialog). In questo capitolo invece vediamo come è possibile stampare il
contenuto di una DataGridView in modo da riportare su carta un risultato visibile a schermo.
L’argomento stampa con Visual Basic ricopre un ruolo di primo piano in quanto difficilmente
esistono dei programmi che si “accontentano” di visionare a schermo un risultato senza poi
avere la possibilità di stamparlo. Si tratta anche di un argomento particolarmente vasto e
complesso che per la sua varietà di impieghi che se ne può fare non può essere riportato in
un libro. Lo scopo del libro è quello di fornirvi degli strumenti di base (ma anche qualcosina
di più) che spesso vengono trascurati lasciando l’aspirante programmatore in una situazione
critica riguardo quest’argomento.
Tutto il codice di questo esercizio lo trovate insieme al materiale da scaricare allegato al
libro in modo che possiate continuare con l’approfondimento dell’argomento stampa.
Le alternative alle tecniche che vediamo qui esistono ma sono troppo costose per l’utente
non professionale e comunque a conti fatti non meno complicate. Lo scopo del libro è anche
quello di portarvi ad avere una buona produttività nel minor tempo possibile senza affron-
tare argomenti assurdi di rara se non inesistente applicazione.
Innanzitutto, dovete importare le librerie
Imports System.Data
Imports System.Drawing
Dichiarate queste variabili nella classe.
Public Class Libri
Dim Riga As Integer = 0

Dim TotaleRighe As Integer
Nella routine Click del pulsante che servirà a fare partire la stampa va inserito questo codice.
Nel capitolo PrintDialog abbiamo già visto a cosa serve.
Private Sub p_Stampa_Click(sender As Object, e As EventArgs) Handles p_Stampa.Click

300
End If
End Sub
Mentre nella routine che serve per formare la pagina che andrà in stampa il codice è il
seguente. Alcune righe di codice sono particolarmente lunghe quindi vanno accapo.
Private Sub PrintDocument1_PrintPage(sender As Object, e As Printing.PrintPageEventArgs)

Handles PrintDocument1.PrintPage

Dim Font3 As New Font("Verdana", 8)
Dim RigheperPagina As Integer = 0

Dim MargineSinistro As Single = 40
Dim j As Integer
e.Graphics.DrawString("Lista dei Libri", Font1, Brushes.Red, MargineSinistro, 60)

e.Graphics.DrawString("ISBN", Font2, Brushes.Black, MargineSinistro, PosizioneVerticale)
e.Graphics.DrawString("Titolo", Font2, Brushes.Black, MargineSinistro + 125,
PosizioneVerticale)
e.Graphics.DrawLine(Pens.BlueViolet, MargineSinistro, PosizioneVerticale, 750,

PosizioneVerticale)
TotaleRighe = DataGridView1.RowCount
PosizioneVerticale = Marginesuperiore + 25
Dim FormatoStringa As New StringFormat

FormatoStringa.FormatFlags = StringFormatFlags.DirectionRightToLeft
If Riga = TotaleRighe Then Exit Sub
e.Graphics.DrawString(DataGridView1.Item(3, Riga).Value, Font3, Brushes.Black,

MargineSinistro, PosizioneVerticale)
e.Graphics.DrawString(DataGridView1.Item(4, Riga).Value, Font3, Brushes.Black,
MargineSinistro + 125, PosizioneVerticale)
Valore = Format(DataGridView1.Item(5, Riga).Value, "##.00")
e.Graphics.DrawString(Valore, Font3, Brushes.Black, MargineSinistro + 680,

PosizioneVerticale, FormatoStringa)
301
Riga = Riga + 1
Next j
ConteggioRiga = 0
End If
End Sub
Adesso diamo un’occhiata da vicino a quanto compare nel riquadro precedente:

queste tre istruzioni creano tre tipologie di carattere (font) diversi (anche se abbiamo uti-
lizzato “Verdana” è possibile utilizzare anche altri a vostra discrezione) di dimensione di-
versificate che serviranno nella stampa, ad esempio i titoli e cose di questo genere.

Dim Font3 As New Font("Verdana", 8)
Per le variabili utilizzate nomi che poi vi ricorderanno vagamente quello che rappresentano
altrimenti poi sarà difficile capire quello che fanno durante le varie fasi del programma.
Dim RigheperPagina As Integer = 0

Dim MargineSinistro As Single = 40
Dim j As Integer
Questa parte di codice stampa la testata di quello che sarà la pagina di stampa e sarà
ripetuta in ogni pagina successiva.
e.Graphics.DrawString("Lista dei Libri", Font1, Brushes.Red, MargineSinistro, 60)

e.Graphics.DrawString("ISBN", Font2, Brushes.Black, MargineSinistro, PosizioneVerticale)
e.Graphics.DrawString("Titolo", Font2, Brushes.Black, MargineSinistro + 125,
PosizioneVerticale)
ogni riga che verrà stampata va dichiarata con precisione attraverso il metodo
Graphics.DrawString che ha il seguente formato:
e.Graphics.DrawString(StringadaStampare, FontdelCarattere, ColoredelTesto,

MargineSinistro, PosizioneVerticale, FormatodiStampa)
Quindi si tratta di una riga piuttosto lunga che sicuramente si presenterà su più righe.
Il font di stampa va passato nel formato che abbiamo visto in precedenza, il margine sinistro
e la posizione verticale sono variabili tipo Single.
Mette un po’ di spazio verticale.
302
Disegna una riga per separare la testata della pagina dalla lista dei libri
e.Graphics.DrawLine(Pens.BlueViolet, MargineSinistro, PosizioneVerticale, 750,

PosizioneVerticale)
il formato del metodo Graphics.DrawLine è il seguente:
e.Graphics.DrawLine(ColoredellaRiga, MargineSinistro, PosizioneVerticale,

LunghezzaRiga, PosizioneVerticale)
Calcola orientativamente quante righe entrano in una pagina basandosi sul margine supe-
riore della pagina e sulla grandezza del font utilizzato per stampare i dati, nel nostro caso
Font3 che abbiamo definito all’inizio.
Controlla quante righe ci sono da stampare.
Mette ancora un pochino di spazio verticale.
PosizioneVerticale = Marginesuperiore + 25
Crea un formato per quei dati che devono essere stampati, come ad esempio un importo,
partendo con l’allineamento da destra verso sinistra e non viceversa con il testo. Questo
parametro verrà specificato al momento di stampare quel dato specifico.
Dim FormatoStringa As New StringFormat

FormatoStringa.FormatFlags = StringFormatFlags.DirectionRightToLeft
Inizia un ciclo For...Next per stampare ogni riga presente nella DataGridView tenendo pre-
sente però che c’è un limite per ogni pagina altrimenti….
Controlla se la variabile che dice a quale riga di stampa siamo arrivati non eccede il valore
del totale delle righe altrimenti ci sarà un errore di overflow, ovvero un valore va oltre il
limite ammissibile.
If Riga = TotaleRighe Then Exit Sub
Ognuno di questi comandi stampa un preciso dato della DataGridView, rispettivamente il

contenuto della colona 3, 4 e 5. Le altre colonne sono state ignorate, ad esempio non ha
nessun senso stampare la colonna 1 che contiene l’identificativo della casa editrice.
e.Graphics.DrawString(DataGridView1.Item(3, Riga).Value, Font3,

Brushes.Black, MargineSinistro, PosizioneVerticale)
e.Graphics.DrawString(DataGridView1.Item(4, Riga).Value, Font3,

Brushes.Black, MargineSinistro + 125, PosizioneVerticale)
Questo dato va stampato allineato a destra e non a sinistra come di solito perciò va for-
mattato in maniera diversa che i dati contenuti nelle altre colonne.
Valore = Format(DataGridView1.Item(5, Riga).Value, "##.00")

303
Stampa questo dato allineandolo a destra utilizzando la stringa FormatoStringa che ho de-
finito in precedenza.
e.Graphics.DrawString(Valore, Font3, Brushes.Black, MargineSinistro + 680,

PosizioneVerticale, FormatoStringa)
Avrete notato che ogni dato viene stampato incrementando il margine sinistro di un valore.
Questo valore va sperimentato in fase di anteprima di stampa per vedere se si adatta alle
vostre necessità.
Incremento la posizione verticale per la stampa della riga successiva. Questa operazione
può essere fatta anche in altri modi.
Incremento il conteggio delle righe della pagina corrente.
Incremento il conteggio delle righe totali. Questa variabile è stata definita nello spazio della
classe per evitare che ad ogni pagina successiva venga azzerata perdendo quindi il riferi-
mento. Ricordate che tutte le volte che viene generata una nuova pagina il computer esegue
di nuovo l’evento PrintDocument1_PrintPage, ricominciando la routine daccapo.
Riga = Riga + 1
Incremento il valore J per ripetere il ciclo per stampare la riga successiva.
Next j
Se il conteggio delle righe stampate per quella pagina è uguale o maggiore delle Righe per
pagina allora il codice deve generare una nuova pagina.
ConteggioRiga = 0
End If
Questa riga genera una nuova pagina.
Beh… la stampa è tutta qui, facile no?

Non troppo anche perché questo è solo l’antipasto rispetto ad un banchetto luculliano. Però
da qualche parte dovevamo partire.
304
MySQL
Si tratta di un database professionale ad alte prestazioni e gratuito nella versione Commu-
nity che comunque può coprire qualsiasi necessità si possa anche lontanamente immagi-
nare. Data la potenza del prodotto è destinato ad utilizzi professionali, piccole, medie e
grandi aziende e dunque siamo sostanzialmente in buone mani.
Siamo approdati a questa scelta in quanto altri database con caratteristiche confrontabili
con questo hanno prezzi non alla portata di chi sviluppa applicazioni ad un livello non pro-
fessionale, ovvero che ancora non ha fatto di questa “passione” un lavoro.
Installare MySQL
Per usufruire dei servigi di questo prodotto è necessario installarne una copia su vostro
computer dopo averlo scaricato da Internet all’indirizzo www.mysql.com
Prestate attenzione al fatto che gli indirizzi Internet, le grafiche e i collegamenti nelle pagine
che vediamo qui di seguito sono soggetti a continui aggiornamenti e quindi è improbabile
che fra cinque anni queste immagini rispecchino fedelmente le modifiche fatte nel frat-
tempo.
Se non riuscite a trovare MySQL cercatelo con un motore di ricerca. (Google ecc.)
Quando siete giunti all’indirizzo in questione fate click sul collegamento Prodotti e cercate
da qualche parte MySQL Community Edition dato che si tratta della versione gratuita.
Dalla figura successiva fate click sul collegamento che vi permette di scaricare il prodotto
sempre tenendo presente che queste pagine sono soggette a continui aggiornamenti quindi
non sono statiche e immutabili (d’altra parte Internet è fatto così).
Ovviamente alcune pagine sono in italiano ma è altamente probabile che molte altre siano
in inglese quindi non vi meravigliate se vi trovate davanti ad una pagina piena di testo
incomprensibile…ammesso che non conosciate la lingua.
MySQL
305
Dato che il prodotto supporta diversi sistemi operativi dovete cercare quello che opera in
ambito Windows. Individuate MySQL installer for Windows che contiene tutte le carat-
teristiche del prodotto per l’installazione in ambiente Windows.
306
Le versioni del motore del database variano continuamente ma non vi è nessuna necessità
di fare degli aggiornamenti continui. Personalmente utilizzo su un Server MySQL che ho
scaricato nel lontano 2006 e funziona perfettamente ancora oggi.
Mentre il database di Access è riconducibile ad un file tipo mdb o accdb la stessa

cosa non vale per MySQL. Non si tratta di un file ma di un server dove potete creare
tutti i database che desiderate.
La versione attuale del prodotto è la 8.0.19 quindi aspettatevi in futuro altre versioni…. Fate
click dove indicato in figura
Scorrete la pagina successiva fino in fondo e fate click sul collegamento che vedete nella
figura successiva. Qualora non fosse possibile fare altrimenti perché nel frattempo hanno
cambiato politica, registratevi e create un account, è gratis.
MySQL
307
Mettetevi comodi perché ci sono diversi passaggi da eseguire prima dell’installazione del
prodotto.
Al temine del download fate click su Apri cartella per aprire la cartella dove si trova il file
di installazione.
Il file di installazione ha un aspetto simile a quello della figura sottostante. Fate doppio click
per avviare l’installazione del prodotto.
Appena viene avviato il programma di installazione compare sullo schermo una finestra che
vi chiede se desiderate effettuare un aggiornamento del prodotto (upgrade). Confermate
pure la scelta.
308
Scegliete l’installazione tipica per
lo sviluppatore che contiene
tutte le funzionalità necessarie
per il vostro utilizzo. Fate click
sul pulsante Next in basso a de-
stra nella finestra.
La lista che compare vi ricorda

che sono mancanti alcuni com-
ponenti per l’installazione. Il pro-
gramma proverà comunque a
procurarseli automaticamente
altrimenti sarà necessario l’in-
stallazione manuale da parte vo-
stra anche se non tutte le com-
ponenti sono realmente necessa-
rie. Procedete facendo click sul
pulsante Next.
Siamo pronti per l’installazione.

Fate click sul pulsante Execute.
MySQL
309
Lasciate lavorare il computer du-
rante la fase di installazione. La
finestra indica a che punto siamo
dell’installazione del prodotto.
Fate click sul pulsante Next al

termine dell’installazione delle
componenti.
E a questo punto fate ancora

click sul pulsante Next e ancora
alla finestra successiva per av-
viare la configurazione del pro-
dotto. Il passaggio è stato inten-
zionalmente saltato in quanto
ovvio.
Adesso passiamo alla configura-
zione del prodotto. Fate click sul
pulsante Next.
310
Configurare MySQL
In questo capitolo invece vediamo
come configurare il prodotto in
modo che funzioni sul nostro com-
puter nel miglior modo possibile. I
passaggi sono tanti ma fortunata-
mente in questi passaggi non sono
presenti operazioni complicate da
eseguire anzi, a parte qualche fine-
stra dove è necessaria qualche
spiegazione il resto fila abbastanza
liscio. Fate click sul pulsante Next
in fondo alla finestra.
Selezionate se necessario le impo-

stazioni che vedete nella figura ac-
canto.
Lasciate pure le impostazioni racco-

mandate. Vi ricorda semplicemente
che il metodo di autenticazione è
diverso da quello della Versione 5
di MySQL.
Fate click sul pulsante Next.
MySQL
311
Inserite la password dell’ammini-
stratore, ovvero quel personaggio
che ha potere di vita e di morte su
tutta la struttura. Non dimentica-
tela. Noi per l’installazione ab-
biamo scelto VBdazero2019, voi
potete sceglierne una qualunque
basta che non ve la dimenticate.
Non configuriamo per il momento
altri utenti per l’accesso a MySQL
anche se a seconda della consi-
stenza dei programmi che andrete
a sviluppare potrebbe essere ne-
cessario crearne alcuni. Fate click
quindi sul pulsante Next.
Se le impostazioni corrispondo a
quello che vedete nella figura ac-
canto fate click sul pulsante Next.
Questa finestra riepiloga la situa-

zione prima dell’esecuzione di
questa parte della configurazione.
Fate click sul pulsante Execute.
Pensa lui a tutto.
312
Quando dopo qualche secondo
viene portata a termine questa
parte della configurazione, come
mostra la figura successiva fate
click sul pulsante Finish, ma in
realtà non è finita qui.
Anche per quanto riguarda questa

parte della configurazione basta
fare click sul pulsante Finish in
quanto vengono proposte modifi-
che che, salvo qualche caso spe-
cifico, non hanno bisogno di es-
sere apportate.
Al passaggio successivo fate click

sul pulsante Check, dopo avere
digitato la password di accesso
nel relativo riquadro, per verifi-
care che il servizio sia avviato e
funzionante quindi fate click sul
pulsante Next. Inutile dilungarsi
in spiegazioni che al momento
non hanno motivo di essere espo-
ste, quindi mi limiterò a darvi quel
minimo di informazioni che vi ser-
vono per lavorare. L’esperienza vi
porterà a ulteriori approfondi-
menti ed a una comprensione più
specifica dell’argomento in que-
stione.
MySQL
313
Fate ancora click sul pulsante
Execute per proseguire.
E quindi ancora una volta comple-

tiamo con il pulsante Finish per
terminare con le operazioni di in-
stallazione. Può darsi che qualche
passaggio sia stato saltato perché
necessita da parte vostra solo un
click di conferma.
A questo punto si apre la Shell del
server MySQL. Chiudete questa
finestra in quanto fortunatamente
non verrà utilizzata nel nostro
progetto. In teoria da qui si può
dare i comandi al Server di
MySQL affinché intraprenda le
operazioni più complicate, ma
guardatelo bene…
Nell’epoca dei Tools grafici è perfettamente inutile utilizzare la riga di comando, come con
il DOS dell’epoca di Re Pipino, solo perché fa figo. Inutile perdere mesi per memorizzare
comandi che neanche il più abile dei programmatori è in grado di ricordare (ammesso che
non sia iscritto al club dei Nerd) quando tutto può essere semplice e produttivo in pochi
passi. Riavviate quindi il vostro computer e quindi avviate Visual Studio.
314
Connetti al database
Adesso vediamo se tutto funziona (o almeno la connessione) al Server MySQL. Si parla di
Server in quanto è possibile creare un numero qualunque di database (catalogs) ed è inoltre
accessibile anche da altri computer della vostra rete (ad esempio un ufficio). Per motivi di
spazio, non possiamo esporre nel dettaglio il funzionamento di una rete di computer ma
cercheremo di dare alcuni rudimenti che possono essere utili al programmatore, nel caso
dovesse creare applicazioni che agiscono su un database che si trova su un altro computer,
ovvero in rete ad esempio in un’azienda. (Rete che non ha nulla a che vedere con Internet)
Dalla finestra principale di Visual Studio senza creare nessun nuovo progetto fate click sul
menu Strumenti e selezionate la voce Connetti a database.
Ogni tipologia di database, Microsoft Access, MySQL, Oracle, SQL Server ecc. ha
bisogno del proprio provider di dati per poter funzionare altrimenti sarà impossibile
collegarsi al Server o al database. Se dovesse comparire una finestra che vi chiede
un qualche aggiornamento eseguitelo pure.
Dalla finestra visibile nella figura successiva verificate l’esistenza nella lista di MySQL Da-
tabase e selezionatelo con un click. Se questa voce non dovesse comparire nella lista allora
annullate questa procedura e procuratevi dal sito MySQL il pacchetto MySQL Connector e
installatelo sul vostro computer. Ricordate di riavviare il computer al termine di qualsiasi
procedura di installazione. Fate click sul pulsante Continua.
MySQL
315
Compliate i parametri presenti nella finestra come mostra la figura sottostante. Il nome del
Server (127.0.0.1) significa che il database si trova sullo stesso computer che state utiliz-
zando al momento, root è l’utente amministratore del Server MySQL e la password è quella
che avete assegnato in fase di installazione qualche decina di passaggi fa. (Ve l’avevo detto
di non dimenticarla che poi sarebbe risultata utile.)
Fate click sulla casella di controllo Save my password in modo da non doverla digitare
agli accessi successivi e infine scegliete il database world, o altri presenti nella lista, che
verranno utilizzati per prova.
Quindi fate click sul pulsante Test connessione per verificare che la connessione sia cor-
retta. Se compare una finestra simile a quella della figura successiva, allora non avete nulla
da temere. Tutto è andato (per ora) nel migliore dei modi.
Fate click sul pulsante Ok in basso nella finestra, per salvare il collegamento nella lista
Esplora Server, che è molto utile per verificare che una qualsiasi connessione ad un qua-
lunque database funzioni correttamente. In questo modo, in teoria, riduciamo al minimo i
problemi di connessione quando andremo a sviluppare le nostre applicazioni che si connet-
teranno al database.
316
Quello che abbiamo selezionato è un database di esempio che si trova sul Server MySQL,
infatti, in fase di installazione, abbiamo confermato l’installazione di questi accessori. Nel
prossimo capitolo vediamo invece come si fa a sviluppare un database con MySQL partendo
da zero attraverso dei strumenti grafici sviluppati appositamente per questo tipo di impiego.
Il database.
Dopo aver installato MySQL, prima di proseguire, sono necessarie alcune considerazioni
teoriche. In questo capitolo affronteremo uno degli argomenti più importanti, se non il più
importante, del mondo dell’informatica. Il programmatore, qualunque linguaggio adotti, che
sia Visual Basic, C# o Java, solo per citare i più diffusi, non può assolutamente ignorare
quest’argomento. Il 70% dei programmi in circolazione si appoggia ad un database per
memorizzare i dati e da questo si può capire l’importanza di questo argomento.
Questa struttura chiamata appunto database è particolarmente complessa per la quantità
di argomenti, quindi cercheremo di rendere comprensibili le sue caratteristiche nel modo
più semplice possibile.
Se avete già una certa esperienza per quanto riguarda la teoria e la progettazione dei da-
tabase potete passare ai capitoli successivi, per andare oltre con la programmazione e af-
frontare il linguaggio SQL o altre caratteristiche, in quanto questa sezione del libro è espres-
samente dedicata a chi parte da zero o quasi.
Se siete quasi o completamente a digiuno, vi suggerisco di seguire questo capitolo in ma-
niera di assimilare quelle nozioni teoriche e pratiche che vi permetteranno di entrare in
questo mondo dalla porta principale.
Questo “articolo”, il database appunto, altro non è che una struttura che immagazzina i dati
che vengono inseriti, li memorizza ed eventualmente, a vostra richiesta, li elabora e li vi-
sualizza sullo schermo, e tutto questo indipendentemente dall’ordine in cui questi dati sono
stati immagazzinati nella struttura.
Per ottenere questo tipo di risultato, un database deve essere fortemente strutturato e
quindi necessita di una meticolosa progettazione come abbiamo già visto nel capitolo che
tratta di Microsoft Access.
Tabelle
Sono le sorgenti dei dati senza le quali un database non ha senso.
Query o View
Chiamatele come volete ma questa è una componente molto importante di un database.
Una Query è una domanda che l’operatore formula per avere delle risposte ed il risultato di
questa domanda è una tabella che riassume, o incrocia, i dati provenienti da una o più
tabelle in modo da dare una vista sui dati diversa da quella che normalmente una tabella
offre.
MySQL
317
Posso ad esempio riepilogare gli incassi di un singolo negozio appartenente ad una catena
in modo veloce proprio attraverso le Query. La singola tabella dove sono inseriti i dati
avrebbe difficoltà a fornirveli riepilogati in quel modo.
La query può essere memorizzata e richiamata facilmente dai meandri del database.
Utenti
Un database non è una porta aperta a tutti, per il semplice motivo che può contenere dati
sensibili di una certa importanza e quindi, come capite, esiste tutta una serie di strumenti
che limita o esclude l’accesso agli oggetti del database, come tabelle, query ecc. a deter-
minati personaggi chiamati utenti. L’utente che normalmente ha l’accesso a tutti i dati e
dispone di tutti i poteri si chiama amministratore, o admin, oppure root, a seconda del
database che stiamo utilizzando.
Questo signore può gestire anche quelli che vengono chiamati utenti ovvero chiunque altro
che possa collegarsi a un database che non sia l’amministratore.
L’amministratore decide i nomi degli utenti e quello che possono fare o vedere nel Db.
Progettare un database
Capite che per progettare una struttura come quella che vedremo è necessaria un po’ di
pratica per evitare che i dati vengano distribuiti in modo errato nelle varie tabelle, e soprat-
tutto che le tabelle abbiamo la giusta correlazione fra di loro altrimenti diverrebbe impossi-
bile recuperare i dati.
I passaggi della progettazione sono esposti nei capitoli successivi dove passo per passo
verranno mostrate le caratteristiche di un database e verrà spiegato come padroneggiare
quelle tecniche che vi permetteranno di realizzare un database in modo efficace.
Successivamente affronteremo attraverso il linguaggio SQL l’estrazione dei dati dal data-
base, la creazione di tabelle e tutti quei comandi che vi permetteranno di accoppiare il
vostro database con il linguaggio di programmazione Visual Basic. Quindi andiamo avanti
con la nostra avventura.
Utilizziamo uno strumento grafico per MySQL

Esistono un’infinità di questi strumenti dedicati a MySQL e ad altri database, ma quello da
me più apprezzato è MySQL Workbench in quanto integrato nell’ambiente. Inoltre è sem-
pre disponibile contrariamente a tanti altri che non sono gratuiti, anche se a volte possono
risultare più pratici ma periodicamente spariscono o cambiano politica creandovi un mare
di problemi.
L’unica raccomandazione è che ultimamente si tende a progettare programmi per sistemi
operativi a 64 bit (x64) e se il vostro sistema operativo è a 32 Bit (x32) è necessario
scaricare separatamente Workbench qualora non sia stato installato dalla procedura di in-
stallazione di MySQL dall’archivio delle versioni precedenti del sito internet di MySQL.
Va ricordato, che per motivi di didattica in questo libro vengono utilizzati i pro-
grammi più recenti al momento della pubblicazione, ma tutte le procedure che ve-
diamo sono valide anche per le versioni precedenti di MySQL ed anche precedenti
versioni di Visual Studio (2013, 2015, 2017). Magari cambia un po’ la grafica e
qualche menu ma i concetti basilari sono quelli.
Utilizzare Workbench
Se non fosse già stato installato con la procedura che abbiamo visto nel capitolo precedente,
installatelo sul vostro computer attraverso la procedura d’installazione, che permette una
volta avviata qualora il prodotto fosse già installato, l’aggiornamento dei vari programmi
318
che compongono il pacchetto. Avviatelo cercandolo nel menu di avvio e se tutto va bene la
prima schermata sarà come quella che vedete nella figura sottostante.
Innanzitutto, viene identificato il Server che si trova sul vostro computer.
Adesso è necessario creare una connessione al Server per creare le basi di dati vere e
proprie e tutti quegli oggetti, come le tabelle, che abbiamo visto nel capitolo introduttivo e
dove è stato spiegato a grandi linee il funzionamento di un database.
Inserite la password che avete utilizzato durante l’installazione del prodotto per accedere
al server come utente root ovvero come utente amministratore. Salvate la password con il
segno di spunta nella casella di controllo che vedete subito sotto il campo password in modo
che non ve la chieda ad ogni successivo accesso.
MySQL
319
A questo punto comparirà l’ambiente di lavoro in tutta la sua complessità.
Il vostro schermo sicuramente sarà impostato ad una risoluzione maggiore quindi

avrete più spazio e potrete apprezzare i dettagli. Non è possibile fare la stessa cosa
sul libro altrimenti certi dettagli risulterebbero troppo piccoli per essere distinti.
Creare e rimuovere database.

Fate click con il tasto SX del mouse sulla scheda Schemas. Quindi fate click con il tasto DX
del mouse in uno spazio vuoto del riquadro Schemas (ovvero database) e dalla lista fate
click sulla voce Create Schema.
320
Digitate il nome del database che volete creare e quindi fate click in basso sul pulsante
Apply.
Si apre una finestra piuttosto minacciosa, ma fate finta di nulla e fate click sul pulsante
Apply in basso nella finestra.
MySQL è un database SQL e in teoria bisognerebbe dialogare con lui attraverso

questo linguaggio esposto nel capitolo omonimo di questo libro. Dato che la cosa
risulterebbe troppo complicata per un “programmatore” alle prime armi, è neces-
sario avvalersi di uno strumento grafico per evitare mesi di estenuanti tentativi
prima che ne venga una buona…
MySQL
321
Alla finestra successiva fate click sul pulsante Finish per portare a temine la procedura.
Ed ecco che il vostro nuovo database è pronto per l’utilizzo (vi piacerebbe eh!!)
Nossignori, ancora il percorso è molto lungo ma comunque siete sulla buona strada.
Eliminare un database.
Fate click con il tasto destro del mouse puntando il nome del database in questione e dalla
lista scegliete la voce Drop Schema.
Puntate con una precisione maniacale perché distruggere il lavoro di anni è più
facile di quanto crediate, con questi maledetti strumenti grafici, e soprattutto non
eliminate per il momento altri database (Schemas) presenti nella lista.
Creare le tabelle
L’oggetto principe di un database sono appunto le tabelle che contengono i dati veri e propri.
Qui armatevi di pazienza perché la lezione è particolarmente lunga.
Sicuramente esistono altri database più “maneggevoli” ad esempio Microsoft Access ma
una volta che avete acquistato una certa confidenza vi garantisco che troverete solo pregi.
322
Come abbiamo già visto nel capitolo introduttivo ai database la tabella è il fulcro del sistema
proprio perché contiene i dati e quindi è importante saperla gestire nel migliore dei modi.
Anche se vi dovessero capitare fra le mani prodotti diversi da questo alla fine vedrete che
sono tutti molto simili con qualche piccola differenza.
Come prima tabella ci apprestiamo ad analizzare la tabella Agenti che può servire come
esempio di massima per le altre soprattutto per prendere la mano con lo strumento in
questione. Non mostreremo tutto il database completo per ovvi motivi di spazio.
Il database già pronto lo potete richiedere all’indirizzo di posta elettronica:
Fate doppio click in corrispondenza del database in questione come mostra la figura suc-
cessiva per accedere agli oggetti contenti nel database.
Fate click on il tasto destro del mouse in corrispondenza delle Tabelle (Tables) e dal menu
scegliete la voce Create Table.
MySQL
323
Come mostrato nella figura successiva per prima cosa digitate nell’apposito spazio il nome
della tabella in questione. È inutile che aggiunga che in un database non possono esserci
due oggetti tabella che si chiamano con lo stesso nome. (logico no!?).
Adesso concentriamoci sui campi e sulle loro caratteristiche. Per aggiungere un campo fate
doppio click in corrispondenza della prima riga vuota come mostra la figura sottostante e
digitate il nome del campo, nel nostro caso IDAGENTI, che può essere digitato indifferen-
temente maiuscolo o minuscolo.
Non utilizzare lettere accentate per i nomi dei campi ad esempio “città”
Non inserire spazi nei nomi dei campi, ad esempio UnitaMisura è possibile anche scriverlo
Unita_Misura ma non Unita Misura perché il computer genererebbe un errore.
Applicate le proprietà del campo :
PK = PRIMARY KEY o chiave primaria.
NN = NOT NULL ovvero non può essere lascito vuoto
AI = AUTO INCREMENT cioè che si incrementa da solo (come il campo ID di un database
Access.)
Altre caratteristiche per i campi che è possibile applicare in altri casi sono:
UNIQUE = il valore di quel campo non può ripetersi in altri record presenti nella tabella.
ZERO FILL = Viene riempito dal database automaticamente con degli zeri se nessuno ci
inserisce altri valori dentro.
BINARY = Campo che contiene valori Binari.
324
La figura sottostante mostra la situazione finale. Di fondamentale importanza utilizzare per
i campi le lunghezze che meglio si adattano alla situazione, ad esempio, per la provincia è
inutile utilizzare un campo VARCHAR lungo 30 se al massimo il campo sarà impegnato con
2 caratteri.
Un campo tipo Double può contenere qualsiasi tipo di numero mentre ad esempio un
campo tipo INT può contenere solo numeri interi. Un campo tipo DATE può contenere una
data. Altre caratteristiche verranno presentate un po’ per volta quando ci troveremo ad
affrontare l’argomento specifico. Nel Campo LONGTEXT è possibile scrivere un sacco di
cose. Portate a termine l’operazione facendo click sul pulsante Apply in basso a destra nella
finestra.
Come mostra la figura successiva, tutto il vostro lavoro per la creazione della tabella viene
convertito in linguaggio SQL, l’unico che il database è in grado di capire.
Quando sarete campioni di linguaggio SQL potete scrivere o modificare voi stessi le righe
presenti nella finestra.
Il fatto che venga generato il corrispondente linguaggio SQL è particolarmente ap-

prezzato dai programmatori, che possono copiarlo e incollarlo all’interno dei loro
programmi per creare database, tabelle o altri oggetti direttamente dal codice come
vedremo nei capitoli successivi, altrimenti ci sarebbe da scervellarsi troppo con il
rischio che un piccolo errore possa compromettere il funzionamento del codice.
Fate click sul pulsante Apply in basso a destra nella finestra SQL.
MySQL
325
Il messaggio è rassicurante. Fate click sul pulsante Finish.
In teoria dovreste proseguire l’avventura con altre tabelle ma se state lavorando ad un

vostro programma è probabile che scegliate nomi diversi per i campi in questione o che
abbiate la necessità di aggiungere altri campi.
Chiudete con l’apposito comando le schede che non vi servono più, dato che dopo l’opera-
zione restano aperte nella finestra, tenendo presente che resta aperta solo quella della
Query che permette di dare comandi diretti al database.
326
Modificare le tabelle
Per modificare una tabella selezionate con un click del tasto DX del mouse la tabella stessa,
come si vede nella figura sottostante (ricordando di essere maniacali nella precisione del
click onde evitare la selezione di altri oggetti che non c’entrano nulla) e dal menu scegliete
la voce Alter Table.
Adesso è possibile modificare la struttura della tabella aggiungendo ad esempio altri campi,
oppure modificare le caratteristiche degli stessi come ad esempio la lunghezza o tutte quelle
variazioni che è possibile fare anche in fase di creazione.
MySQL
327
Gli indici
Gli indici sono un’altra componente importante di una tabella. Di solito sono associati ai
campi e permettono di velocizzare una ricerca. Ad esempio, se sospettate che l’utente che
utilizzerà il programma farà delle ricerche sul campo della descrizione di un prodotto, per
velocizzare queste ricerche non c’è nulla di meglio che creare un indice ed associarlo a quel
campo. L’indice è fondamentale per velocizzare le ricerche specialmente se una tabella ha
molte migliaia di record (righe).
Ma passiamo alla pratica: fate click sulla voce Indexes nella parte bassa dello schermo.
A questo punto comparirà una situazione simile a quella della figura successiva.
Intanto la tabella possiede già un indice etichettato con PRIMARY che si trova nella prima
riga della lista di sinistra. Questo perché la PRIMARY KEY, ovvero la chiave primaria, è
già di per sé stessa un indice.
Quindi, come mostra la figura successiva, basta fate click nella riga sottostante PRIMARY e
digitare il nome che l’indice deve avere. Il nome può essere anche di fantasia ma per evitare
che poi la fantasia ci faccia perdere la strada per tornare a casa, è meglio seguire questa
notazione: IX_RAGIONESOCIALE se ad esempio voglio creare un indice associato al
campo RagioneSociale.
Nel nostro caso impostate la tipologia dell’indice a INDEX, come si vede nella colonna
accanto a quella del nome.
Per terza cosa mettete un segno di spunta accanto al nome del campo che vogliamo indi-
cizzare nel nostro caso il campo Descrizione.
Terminate le operazioni con il pulsante Apply in basso a destra nella finestra.
Nel riquadro Index Comment è possibile digitare anche una descrizione che può esservi
utile per ricordare in un secondo tempo cosa fa quell’indice.
328
Adesso compare la solita finestra che trasforma in linguaggio SQL le nostre modifiche e le
passa al database. Fate click sul pulsante Apply in basso a destra.
MySQL
329
Nella finestra successiva che qui non riportiamo fate click sul pulsante Finish. Quindi tor-
niamo alla situazione iniziale chiedendo la scheda della tabella Agenti.
Relazioni fra tabelle

Difficilmente un database contiene una sola tabella, anzi direi quasi mai. Il motivo è che i
dati sono spesso frammentati fra diverse tabelle e l’abilità del programmatore sta proprio
nella capacità di metterli insieme.
Un database composto da una sola tabella potrebbe essere tranquillamente un file di Excel,
che sicuramente è molto utile, ma non si presta a certe applicazioni gestionali. Supponiamo
di avere un certo numero di clienti e che per ognuno di questi clienti vogliamo memorizzare
le loro fatture.
Non posso inserire ogni singola fattura nella tabella che abbiamo visto prima perché sarebbe
impossibile da gestire, in quanto ad ogni riga dovrei ripetere il nome del cliente e probabil-
mente anche altri dati. Per risolvere il problema attraverso un database dobbiamo creare
necessariamente due tabelle: nella prima troviamo i clienti mentre nella seconda troviamo
le fatture corrispondenti ai clienti stessi.
Come è possibile collegare i clienti con le proprie fatture in modo che non ci siano errori di
interpretazione?
Lo schema sottostante vi dà un’idea di massima di come funziona il meccanismo:
In questo database si trovano due tabelle: Clienti e Fatture. Visto che è impossibile inserire
questi dati in una singola tabella sono stati inseriti in due tabelle separate.
Per fare in modo che il database non possa avere dubbi su quale cliente sia collegato alle
rispettive fatture viene creato un campo IDCLIENTE nella tabella clienti e un campo analogo
nella tabella Fatture. Il campo viene chiamato così per una convenzione che vedremo fra
poco ma nessuno vi vietava di utilizzare un altro nome di fantasia.
Nella tabella fatture viene creato lo stesso campo. In realtà questi campi non contengono i
dati del cliente ma un codice numerico univoco assegnato ad ogni cliente che viene ripetuto
nella tabella fatture in corrispondenza della fattura di quello specifico cliente.
330
Ogni cliente ha un codice che lo identifica univocamente, senza possibilità di errore, che
viene riportato nella tabella Fatture tutte le volte che viene inserita una fattura relativa a
quel cliente.
Il codice viene automaticamente assegnato dal database al momento dell’inserimento di un
cliente mentre nella tabella fatture ce lo deve inserire il programmatore in un modo che
vedremo successivamente.
In questo capitolo viene esposta solamente la parte teorica in modo che quando affronte-
remo la parte pratica sappiamo almeno di cosa stiamo parlando. Anche il modo di dichiarare
il campo IDCLIENTE e tutto il resto lo vedremo in fase di creazione della tabella nella parte
pratica del libro. Il passo successivo dello sviluppo del database in questione lo vediamo
nella figura qui sotto.
Ogni fattura e composta da diverse righe che ne specificano il contenuto, ad esempio se un

cliente acquista 10 articoli diversi la fattura avrà 10 righe con la descrizione di ciascun
articolo ed altre caratteristiche. Quindi ogni riga dovrà essere correlata con la propria fattura
nella tabella fatture (con la stessa tecnica che abbiamo adottato per la tabella clienti) at-
traverso il campo IDFATTURA.
Per completare la panoramica la figura sottostante aggiunge alcuni particolari.
MySQL
331
Ovviamente per il momento si tratta solo di teoria e quindi le tabelle vengono presentate
nella versione semplificata ma per completare il progetto c’è bisogno anche della tabella
magazzino, che contiene i dettagli degli articoli disponibili. La tabella DettaglioFatture è
correlata con quest’ultima per poter recuperare i dati degli articoli acquistati dal cliente.
I dati del cliente si trovano solo nella tabella clienti, eppure volendo è possibile conoscere
tutto ciò che il cliente ha acquistato, magari in un determinato lasso di tempo, grazie alla
flessibilità di questa struttura, che ad un primo acchito potrebbe apparire anche strana ma
che risulta molto efficace quando si tratta di recuperare i dati dalle tabelle.
Inserire i dati in una tabella.

Questa operazione non è troppo agevole attraverso Workbench (il programma che avete
utilizzato fino ad adesso), perché bisogna essere campioni di linguaggio SQL. Nel libro ho
inserito anche un capitolo che riepiloga le istruzioni principali del linguaggio SQL, che vi
consiglio di leggere per avere bene a mente tutto quello che è possibile fare con tale lin-
guaggio. Ovviamente nessun vi chiederà mai di ricordare a memoria tutti i comandi dispo-
nibili, però è giusto conoscerne almeno quegli aspetti che vi permetteranno di padroneg-
giare questo complicato strumento.
Immettere i dati in una tabella lo si può fare comodamente con un programma in Visual
Basic, che vedremo nella prossima sezione del libro, però vale la pena vedere come è pos-
sibile eseguire questa operazione attraverso il linguaggio SQL, dato che poi lo stesso mec-
canismo andrà replicato con Visual Basic.
Passiamo all’inserimento del primo Cliente. Dalla riga di comando digitate:
INSERT INTO Clienti (RagioneSociale, Indirizzo, Citta) Values ('Paolino Paperino', 'Via Roma
35','Firenze')
E quindi avviate il comando attraverso il pulsante con l’icona del fulmine come mostra la
figura sottostante.
Se in basso nell’area di Output non viene segnalato nessun errore il database ha inglobato
i vostri dati. La spiegazione dettagliata del comando verrà illustrata nel capitolo teorico del
linguaggio SQL.
Come mostra la figura successiva sono anche possibili immissioni multiple basta ricordare
che al termine di ogni riga si deve trovate il punto e virgola, come separatore di istruzioni.
Eseguite la Query o comando, come dir si voglia, con il solito pulsante con il fulmine sulla
barra degli strumenti.
Nell’area di Output al momento non viene visualizzato nessun errore come si può vedere
qui di seguito, quindi i vostri dati sono finiti nei meandri del database. Ricordate il punto e
virgola alla fine di ogni istruzione!!
332
Per ripulire lo schermo dalle istruzioni SQL che sono andate a buon fine basta chiudere la
scheda in alto, dove trovate scritto Query1 o qualcosa di simile, con l’apposito comando
Chiudi (la piccola X presente in qualsiasi scheda) come mostra la figura qui sotto.
Adesso vediamo se è vero che tutti quei nomi sono finiti dentro la tabella Clienti. Verifi-
chiamo con il comando SQL che vedete qui sotto:
select * from Clienti;
Quindi premete il solito pulsante col fulmine per eseguire il comando. Il risultato dell’ope-
razione sarà elencato subito sotto.
MySQL
333
Come vedete la colonna (campo) IDCLIENTE si incrementa da solo senza nessun aiuto da
parte dell’utente.
Adesso inseriamo qualche fattura nella tabella Fatture tanto per vedere come ci si deve
comportare se desiderate inserire i dati in questa tabella.
Se non vi ricordate e vi garantisco che accade spesso, i nomi dei campi della tabella Fatture
basta eseguire il comando:
describe fatture;
Inseriamo qualche dato in questa tabella.

334
Attenzione: stiamo maneggiando MySQL in modo completamente manuale.

L’utente finale lo farà attraverso il vostro programma in Visual Basic è sarà enor-
memente facilitato rispetto a quello che noi vediamo in queste pagine. Tenete pre-
sente che tutte queste operazioni servono a voi programmatori per gestire e pa-
droneggiare gli strumenti che vi permettono di programmare, non certo all’utente
finale per inserire i dati. Non sarete mai in grado di sviluppare un programma se
non conoscete queste tecniche.
Il comando da digitare è il seguente:
INSERT INTO Fatture (IDCLIENTE, Numero, Tipo, Data) VALUES (1, 1, 'F', '2020-09-27');
Tenete presente che:
• Come nel caso precedente prima devo invocare i nomi dei campi dove devo inserire
i dati e quindi dopo la parola chiave values devo digitare i valori da inserire nello
stesso preciso ordine in cui ho elencato i campi corrispondenti.
• Posso omettere il nome di un campo omettendo il valore da inserire in quel campo.
• Le date vanno inserire al contrario, ovvero prima l’anno, poi il mese e quindi il
giorno separati da un segno (-)
• I valori di testo vanno inseriti fra apici.
• I valori numerici vanno inseriti senza apici.
Se un comando è particolarmente lungo potete attivare il “testo a capo” con il pulsante che
vedete nella figura sottostante, in modo da vedete tutto il comando senza scorrere orizzon-
talmente la finestra.
Come potete vedere ho assegnato la fattura al cliente che corrisponde al numero 1 nella
tabella Clienti.
La domanda sorge spontanea: sono costretto a ricordare tutti i numeri corrispondenti ad
un certo Cliente a memoria per memorizzare una fattura in quella tabella?? Pura follia.
Ed in effetti è vero. Non è possibile ricordare a quale codice corrisponde un certo Cliente
sempre ammesso che non apra la tabella Clienti e guardi tutte le volte a quale codice cor-
risponde a quel Cliente. Non vi preoccupate perché il programma Visual Basic che andremo
a sviluppare serve proprio a questo, per assegnare in modo automatico il codice del Cliente,
visualizzando sullo schermo il nome del cliente e non il codice identificativo a lui assegnato.
Con il codice IDCLIENTE ci lavorerà il computer e non noi.
Come mostra la figura successiva sono possibili anche comandi multipli. Ricordate per non
sbagliare la sintassi del comando il Copia e Incolla potrebbe essere una buona idea. A quel
punto basta cambiare i valori e sfruttare il fatto che il comando è già scritto.
MySQL
335
Ricordate sempre il punto e virgola alla fine di ogni singola istruzione. Eseguite il comando
con il solito pulsante con l’icona del fulmine e guardate se la finestra di Output vi restituisce
qualche errore. Nella figura successiva sembra tutto ok.
Ricapitolando quanto visto in questo capitolo l’immissione dei dati in una tabella non è per
niente facile direttamente da Workbench ma è necessaria ai fini di acquisire con l’ambiente
database quella confidenza per programmare in modo efficace.
Ad esempio, Microsoft Access facilita non poco l’immissione dei dati nelle tabelle rispetto a
quanto abbiamo visto fino ad adesso, e rende l’ambiente di lavoro più simile a Microsoft
Excel. Ma attraverso la programmazione Visual Basic si può fare di più e meglio.
Ricordate però che se ignorate queste tecniche che abbiamo appena visto non sarete in
grado di programmare in Visual Basic.
Le Views
Questo oggetto serve creare una vista sui dati. Il risultato di una view è una tabella che
riepiloga i dati come noi desideriamo. È necessario però un po’ di pratica e la giusta sintassi
di comando altrimenti dal database non esce proprio nulla di buono, o peggio ancora qual-
cosa senza senso. Per creare una View fate click sull’apposito pulsante presente sulla barra
degli strumenti.
Compare sullo schermo la finestra principale per la costruzione di una View. Si tratta sempre
di questo benedetto linguaggio SQL.
Innanzitutto, una View deve avere un nome identificativo perché al pari una tabella verrà
memorizzata come oggetto all’interno del database pronta per essere richiamata in qual-
siasi momento. La tecnica delle View o Query è molto utilizzata in ambito Visual Basic quindi
tenetele presente perché sono particolarmente importanti.
336
Assegnate un nome alla View sostituendo quel ‘new_view’ con qualcosa di più specifico
come ad esempio query_Fatture. Il trattino basso migliora la leggibilità del nome perché è
altamente sconsigliato creare oggetti che hanno un nome che contiene spazi.
Quello che vedete qui sotto è un esempio di sintassi che nel nostro caso visualizza l’intero
contenuto della tabella libri.
Dovete modificare il nome della query dalla riga di comando come vediamo nella figura
successiva
Ovvero:
CREATE VIEW `query_Fatture` AS select * from Fatture;
Fate click sul pulsante Apply in basso a destra. Al passaggio successivo ancora click sul
pulsante Apply e poi ancora sul pulsante Finish. Non vi resta che fare click sul pulsante
Apply in basso a destra e chiudere la Query come mostra la figura successiva e se non
sono stati rivelati errori la prima parte termina qui.
MySQL
337
Adesso vediamo cosa accade quando andiamo ad eseguire una Query o View. Fate click
sulla piccola freccia che si trova alla sinistra degli oggetti Views nella finestra Schemas in
basso a sinistra nello schermo e fate click sulla query_Fatture con il tasto DX del mouse.
Dal menu contestuale scegliete la voce Select Rows come in figura sottostante. Il risultato
verrà visualizzato nella parte centrale dello schermo.
Adesso viene il bello. Se invece che il campo IDCLIENTE volessi vedere il nome del Cliente
vero è proprio come è possibile realizzare questa cosa?
Bisogna creare una query che mette in gioco non una ma due tabelle.
Collegare due tabelle

Per estrarre dati da due o più tabelle è necessario utilizzare un comando diverso da quello
che abbiamo visto finora. Per capire meglio quello che accade sullo schermo date un’oc-
chiata alla figura successiva. Al posto del campo IDCLIENTE che non è affatto descrittivo
adesso ho il campo che contiene la ragione sociale del cliente, decisamente più pratico per
chi desidera avere sott’occhio i dati in modo chiaro.
Nell’esempio non ho preso tutti i campi dalla tabella Fatture (nessuno mi vietava di farlo)
ma solo alcuni di maggior interesse, e per recuperare il nome del Cliente ho incrociato i dati
con la tabella Clienti. Questo incrocio è stato realizzato attraverso i campi IDCLIENTE pre-
sente in entrambe le tabelle.
In questo caso il comando SQL è diventato:
SELECT Fatture.IDFATTURA, Fatture.Numero, Fatture.Tipo, Clienti.RagioneSociale

FROM Fatture, clienti
WHERE fatture.IDCLIENTE = Clienti.IDCLIENTE
338
Ricordate che il comando va scritto tutto sulla stessa riga, io per aiutarmi con la memoria
separo le istruzioni principali del linguaggio SQL, mettendole su righe diverse in modo da
migliorarne la leggibilità.
Adesso passiamo dalla pratica alla teoria in quanto maggiori informazioni riguardo il lin-
guaggio SQL verranno date nel prossimo capitolo. Non trascuratele perché attraverso la
loro conoscenza, e la conoscenza di come si strutturano i database, è possibile affrontare
qualsiasi tipo di problema sorga durante la programmazione.
Se il numero di tabelle aumenta il comando SQL si complica non poco. Per districarsi in
questo marasma è possibile utilizzare anche Microsoft Access che ha uno strumento di crea-
zione Query molto potente, anche se il linguaggio va un po’ adattato perché presenta delle
differenze.
Altre utilità
Per pulire la lista delle risposte ai comandi Action Output fate click all’interno della lista
stessa con il tasto DX del mouse e scegliete la voce Clear.
Linguaggio SQL
339
Linguaggio SQL
Si tratta di un linguaggio strutturato che serve per estrapolare i dati da un database, ovve-
rosia interrogare ed avere delle risposte. SQL è l’acronimo di Structured Query Language
ed è nato appositamente per formulare delle domande dette Query. In sostanza l’operatore,
attraverso un preciso standard, può fare al database tutte le domande che vuole e ricevere
delle risposte, oppure eseguire delle operazioni come ad esempio creare una tabella o can-
cellare un gruppo di Record.
Anche se non si tratta di un vero linguaggio di programmazione è necessario conoscerne la
filosofia per due precise motivazioni:
1. In VisualBasic.net si interagisce con un database molto spesso attraverso il linguag-

gio SQL
2. Rappresenta uno standard nel gruppo di programmi che ricade nella categoria dei
database, ovvero tutti i database professionali definiti come SQL (MySQL, SQLSer-
ver, Oracle, Access) adottano questo linguaggio.
Ci sono tuttavia alcune differenze fra un tipo di database ed un altro a livello di istruzioni
SQL, ad esempio Microsoft Access ha un linguaggio leggermente diverso, ma con qualche
accorgimento dovremmo riuscire a superare con relativa facilità l’ostacolo.
In questo capitolo per motivi di spazio non tratterò approfonditamente tutti gli aspetti del
linguaggio SQL, che sono veramente tanti ed alcuni sono tipici di uno specifico database,
ma mi limiterò a mettere in evidenza e descrivere quei comandi che nella quasi totalità dei
casi sono quelli più utilizzati dai programmatori.
Nella prima parte di questo capitolo vedremo come si fa ad estrarre informazioni da un
database, quindi passeremo in rassegna quei comandi che servono a modificarne la strut-
tura attraverso le istruzioni SQL.
Utilizzeremo il database di esempio “World” che si trova in MySQL al momento dell’instal-
lazione se ovviamente non l’avete eliminato. Fate doppio click sul database per selezionarlo.
Fate click sull’icona della casetta per tornare alla schermata iniziale di MySQL Workbench.
340
Fate click sull’icona della piccola freccia che va verso destra e dal menu che compare sele-
zionate la voce Create ERR Model from Database.
Controllate di essere collegati all’istanza locale del Server (quello che funziona sul vostro
computer) e fate click sul pulsante Next in basso a destra.
Nel passaggio successivo, che non riportiamo, fate ancora click sul pulsante Next. Serve
solo per controllare che il collegamento sia andato a buon fine.
Adesso dovete selezionare, come mostra la figura successiva, il database da utilizzare per
visualizzarne il modello e quindi fare ancora click sul pulsante Next.
Linguaggio SQL
341
Anche il passaggio successivo è stato intenzionalmente soppresso. Basta comunque fare

click sul pulsante Next. Adesso se desiderate effettuare una scelta delle tabelle fate click
sul filtro, ma per il momento fate click direttamente sul pulsante Execute in basso a destra.
342
Alla schermata successiva fate invece click sul pulsante Cancel per completare l’opera-
zione. Reverse Engineer è un’utilità che permette di partire da un diagramma come quello
che vedete in figura successiva per creare un database. (Bello strumento da utilizzare
quando sarete più esperti).
La figura mostra le tre tabelle del database, Country ovvero Stato, City o Città e lingua
parlata.
Spostatele trascinandole per la testata della tabella per posizionale come credete.
Il diagramma mostra inoltre le relazioni fra tabelle, che servono solo per vedere quali campi
delle varie tabelle sono collegati fra loro, aiutandoci a trovare eventuale errori di progetta-
zione del database o altre soluzioni per il miglioramento dello stesso.
Queste tabelle contengono i dati su tutti gli stati del mondo, le città ad essi collegati e le
relative lingue. Le caratteristiche delle tabelle e dei campi sono state esposte nel capitolo
che spiega la progettazione di un database e quindi adesso ci limitiamo a vedere come è
possibile estrarre i dati da queste tabelle.
Per eseguire un comando SQL in diretta sfruttate la riga di comando SQL che trovate in
MySQL Workbench.
Il comando in alto a destra nella finestra fa comparire o scomparire la finestra di Output,
che serve per capire che effetto ha un comando sul database stesso e soprattutto se ci sono
errori nella digitazione di un comando.
È importante anche saper riconoscere gli errori perché quando utilizzeremo Visual Basic per
accedere ai dati basta un piccolo dettaglio per compromettere il funzionamento di un pro-
gramma.
Linguaggio SQL
343
Negli esempi illustrati in questo libro viene utilizzato il database World che trovate dentro
il server MySQL al momento dell’installazione come mostra la figura qui sopra.
Per accedere a questo database fate doppio click del tasto SX del mouse sul database stesso
nella lista di sinistra.
Allenatevi all’apprendimento del linguaggio SQL attraverso i comandi che vedrete nel capi-
tolo successivo, in modo da comprenderne la filosofia. Inoltre, potete utilizzare il capitolo
come riferimento rapido per i comandi principali del linguaggio, che poi troveremo in am-
biente di programmazione Visual Basic, quando dovremo realizzare il programma del caso
di studio.
SELECT
La prima istruzione del linguaggio SQL è la parola SELECT che serve per selezionare “qual-
cosa” che può essere specificato subito dopo. Questa parola è sempre utilizzata in coppia
con l’istruzione FROM che invece serve per specificare da quale tabella deve prendere que-
sto “qualcosa”. In pratica serve per indicare da quali campi devo estrapolare i dati.
Ad esempio, per visualizzare sullo schermo l’intero contenuto della tabella Country si deve
digitare il comando:
SELECT * FROM Country;
Le parole chiave del linguaggio SQL sono state volontariamente scritte in maiuscolo
per mettere in evidenza la struttura del linguaggio e per rendere più chiaro il co-
mando. È ovvio che potete scriverle indifferentemente in maiuscolo o in minuscolo.
Per lanciare il comando fate click sull’icona del fulmine.

344
Se invece sullo schermo vogliamo visualizzare solo il contenuto di alcuni campi dobbiamo
scrivere:
SELECT Code, Name FROM Country;
I nomi dei campi coinvolti nell’operazione vanno separati da una virgola.

Se desiderate ordinare la tabella risultante, ad esempio in ordine di Continente, allora devo
digitare il seguente comando:
SELECT * FROM Country ORDER BY Continent;
Oppure:
SELECT * FROM Country ORDER BY Continent ASC;
In alternativa se desiderate un ordine alfabetico contrario, quindi dalla Z alle A basta digi-
tare.
SELECT * FROM Country ORDER BY Continent DESC;

Linguaggio SQL
345
WHERE
Un’altra parola chiave fondamentale del linguaggio è WHERE che in pratica chiede in base
a quale criterio deve ‘filtrare’ il risultato, ad esempio, se desidero che sullo schermo com-
paiano solo i dati delle città del Nord America dovrò digitare:
SELECT * FROM country WHERE Continent = 'North America' ORDER BY Name;
Ovviamente ordinate per nome. Come potete notare se state effettuando il filtraggio in base
al contenuto di un campo che contiene testo devo mettere fra apici il testo di ricerca
AND
Questa parola chiave del linguaggio verifica che siano soddisfatte più condizioni contempo-
raneamente, ovvero ad esempio, che i record che verranno visualizzati come risultato de-
vono necessariamente rispettare la condizione di appartenenza sia al Nord America che alla
regione dei Caraibi. Tutti gli altri record saranno esclusi.
SELECT * FROM country WHERE Continent = 'North America' AND Region ='Caribbean' ORDER BY
Name;
OR
La clausola OR invece permette che una sola delle condizioni è sufficiente per selezionare i
record, in parole povere significa “Oppure”, “Anche” ad esempio, Nord America e anche
Europa, ed in questo caso verranno visualizzati sullo schermo tutti i record che rispettano
anche una sola di queste due condizioni.
SELECT * FROM country WHERE Continent = 'North America' OR Continent = 'Europe' ORDER BY
Name;
LIKE e NOT LIKE

Con Like è possibile filtrare i record in base a una domanda specifica come ad esempio
voglio tutti gli stati che iniziano con la lettera A.
SELECT * FROM Country WHERE Name LIKE 'A%' ORDER BY Name;
Se invece voglio escludere quelli con la lettera A:
SELECT * FROM Country WHERE Name NOT LIKE 'A%' ORDER BY Name;
Questo tipo di interrogazione è molto utilizzata nei programmi, ad esempio se desidero

avere la lista dei clienti che iniziano con A. Come si vede dal comando SQL è utilizzato il
carattere Jolly % dopo la lettera A per eseguire questo comando.
È possibile inoltre omettere la clausola ORDER BY (come anche in tutti gli altri comandi
SQL) se non desiderate elencare i record in un ordine specifico.
Operatori di Confronto
Maggiore
Se invece desidero una lista dove vengono elencati solo gli stati che hanno una popolazione
maggiore di quindici milioni di anime allora dovrò digitare dalla riga di comando:
SELECT * FROM country WHERE Population > 15000000 ORDER BY Name;
Come vedete dalla query quando si interpella un campo numerico non c’è bisogno degli
apici come nel caso di un campo di testo.
346
Minore
In questo caso la Query diventa:
SELECT * FROM country WHERE Population < 15000000 ORDER BY Name;
Ovviamente con le varianti sul tema come ad esempio:
Minore o uguale:
SELECT * FROM country WHERE Population <= 15000000 ORDER BY Name;
Maggiore o uguale:
SELECT * FROM country WHERE Population >= 15000000 ORDER BY Name;
Diverso da:
SELECT * FROM country WHERE Population <> 15000000 ORDER BY Name;
Se la ricerca deve limitarsi a una gamma di valori è possibile scrivere quello che vedete qui
sotto:
SELECT * FROM country WHERE Population BETWEEN 15000000 AND 30000000 ORDER BY Name;
Ovvero fra 15 e 30 milioni di persone. E come dire: fammi la lista degli stati che hanno fra
i 20 e i 30 milioni di persone ordinati per nome dello stato.
È anche possibile stratificare le clausole ad esempio tutti gli stati che si trovano in Europa
e che hanno fra 15 e 50 milioni di abitanti.
SELECT * FROM country WHERE Continent = 'Europe' AND Population BETWEEN 15000000 AND 50000000
ORDER BY Name;
Ho posizionato su due righe l’istruzione SQL per migliorarne la leggibilità ma in realtà va

scritta su una riga sola.
Se invece il risultato non deve essere compreso fra 15 e 50 milioni ma escluso:
SELECT * FROM Country WHERE Continent = 'Europe' AND Population NOT BETWEEN 15000000 AND
50000000 ORDER BY Name;
IS NULL
Un campo di un record dove al momento della creazione non sia stato inserito alcun dato è
per definizione dichiarato NULL ovvero non contiene un valore definito e non è un semplice
spazio vuoto.
Ad esempio, se volete come risultato solo gli stati che non hanno una data d’indipendenza
ben definita dovete digitare:
SELECT * FROM Country WHERE IndepYear IS NULL ORDER BY Name;
Questo ovviamente vale per l’esatto contrario:
SELECT * FROM Country WHERE IndepYear IS NOT NULL ORDER BY Name;
IN e NOT IN
Questo commando serve per selezionare soltanto una serie di valori che si trovano fra par-
tentesi, fra apici e separati da virgola. Ad esempio, il campo code della tabella Country
Linguaggio SQL
347
contiene il codice del paese. Se io voglio solamente i dati di alcuni paesi escludendone altri
dovete digitare il comando che vedete qui sotto:
SELECT * FROM Country WHERE Code IN ('CXR','BMU','VIR') ORDER BY Name;
Se invece voglio escludere solo qui paesi e prendere tutti gli altri:
SELECT * FROM Country WHERE Code NOT IN ('CXR','BMU','VIR') ORDER BY Name;
Colonne Calcolate
È possibile creare al “volo” risultati di operazioni matematiche che coinvolgono uno o più
campi del database.
Supponiamo che abbiate interesse solo per i campi selezionati nella Query qui sotto:
SELECT Code, Name, Continent, Population, SurfaceArea FROM Country ORDER BY Name;
e supponiamo che abbiate necessità di calcolare la densità della popolazione del paese,
possiamo scrivere:
SELECT Code, Name, Continent, Population, SurfaceArea, (Population / SurfaceArea)

FROM Country ORDER BY Name;
Tenete presente che ho diviso la query su più righe per migliorarne la leggibilità, quindi
dovete considerarla come se fosse scritta in modo lineare senza rimandi a capo.
Se invece la digitate così:
SELECT Code, Name, Continent, Population, SurfaceArea, (Population / SurfaceArea) AS Density

FROM Country ORDER BY Name;
Create come risultato un campo che ha il nome Density. Questo campo non esiste nel da-
tabase ma si genera al volo quando lo interrogate attraverso la query.
La tecnica di creare campi ‘temporanei’ è fondamentale quando più in là affronteremo la
parte dedicata alla programmazione in Visual Basic e soprattutto quando affronteremo l’ar-
gomento SubQuery.
Ovviamente questi sono esempi che abbiamo ricavato sfruttando il database integrato di
esempio che si trova su MySQL, quindi tenete presente che i nomi dei campi sono a vostra
discrezione quando create la struttura del database.
Operazioni matematiche
Se volessi a questo punto conoscere in quale stato la vita media è più elevata dovrei scri-
vere:
SELECT Code, Name, MAX(LifeExpectancy) AS VitaMassima FROM country;
Per quella minima:
SELECT Code, Name, MIN(LifeExpectancy) AS VitaMinima FROM country;
E per una media generale:
SELECT Code, Name, AVG(LifeExpectancy) AS Media FROM country;
Considerate inoltre che:

348
Per semplicità ho selezionato con l’istruzione SELECT solo alcuni campi della tabella Coun-
try ma come esercizio potete selezionarne anche altri tenendo presente che devono essere
separati da una virgola.
GROUP BY
Se desidero conoscere la somma popolazione e della superfice per continente ho bisogno
di raggruppare e sommare i dati per questo entra in gioco la parola chiave GROUP BY.
SELECT Continent, SUM(Population), SUM(SurfaceArea) FROM country GROUP BY Continent;
Se desidero anche la vita media devo digitare:
SELECT Continent, SUM(Population), SUM(SurfaceArea), AVG(LifeExpectancy)

FROM Country GROUP BY Continent;
Combinazione di dati su più tabelle.

Per aumentare la potenza di una struttura i dati vengono spesso disposti su più tabelle. Con
SQL è possibile recuperare tutte le informazioni che desideriamo in modo abbastanza sem-
plice. Supponiamo che di ogni stato voglia conoscere la capitale. Come avrete notato nella
tabella Country non è presente il nome della capitale di ciascun stato ma semplicemente
un campo (Capital) che riporta un codice. Questo codice fa riferimento ad un codice corri-
spondente ma in un’altra tabella (City). Quindi per poter mettere insieme questi dati devo
correlare queste tabelle altrimenti non avrò il nome della capitale dello stato.
Per eseguire questa operazione dovete digitare:
SELECT Country.Code, country.Name, city.Name

FROM Country, City
WHERE Country.Capital = City.ID;
ORDER BY Country.name;
Le due tabelle vengono collegate nella clausola WHERE attraverso i campi Capital della
tabella Country e ID della tabella City.
Quando i dati provengono da più tabelle è buona norma specificare da quale tabella pro-
vengono i campi corrispondenti specificando prima il nome della tabella e poi separando
con un punto il nome del campo.
Nella clausola FROM si trovano entrambe i nomi delle tabelle coinvolte nell’operazione sem-
pre separati da una virgola.
La stessa query è possibile scriverla anche così, anzi è probabile che la troviate scritta in
questa forma quando ad esempio utilizzate uno strumento visuale per creare automatica-
mente le query come ad esempio con Microsoft Access.
SELECT country.Code, country.Name, city.Name

FROM country INNER JOIN City ON Country.Capital = City.ID
ORDER BY Country.Name;
In questo caso la relazione fra le tabelle viene creata nella clausola FROM invece che in
nella clausola WHERE.
Anche se affrontiamo l’argomento nel modo più ampio possibile è molto probabile che vi
farete aiutare da uno strumento visuale per creare Query di una certa complessità, per
risparmiare tempo e fatica. Questo ovviamente non vuol dire che dovete trascurare la parte
teorica di questo argomento che vi permette poi di rintracciare eventuale errori con mag-
giore facilità, però è comprensibile avvalersi di certi strumenti perché, ad esempio, una
query che estrae i dati da tre o quattro tabelle non è proprio la cosa più semplice del mondo
da scrivere. Per maggiori dettagli consultate il capitolo che parla degli strumenti visuali per
creare le Query come ad esempio Microsoft Access.
Linguaggio SQL
349
Creare un Database
Dopo aver visto come è possibile recuperare i dati da un database attraverso il linguaggio
SQL vediamo come è possibile effettuare modifiche al database stesso o alla sua struttura
sempre attraverso questo linguaggio.
Quando si utilizza Visual Basic per operare su un database, in realtà come già detto, si
utilizza il linguaggio SQL e quindi non dovete trascurare le basi teoriche di questo linguag-
gio.
Il comando per la creazione di un database è:
Create schema libreria;
Dove “libreria” è il nome del database che desidero creare.

Per eliminare invece il database il comando è
Drop schema libreria;
Creare una Tabella

Per creare una tabella dalla riga di comando dobbiamo specificare in dettaglio da quali
campi questa tabella è composta, e ovviamente, anche da quali caratteristiche devono
avere questi campi. Per esempio, il database “libreria” ha una tabella chiamata “Autori” che
presenta queste caratteristiche:
Nella tabella vi sono tre campi chiamati rispettivamente IDAUTORE, Descrizione, Citta.
Vi consiglio comunque di utilizzare lo strumento visuale MySQL WorkBench che è di grande
aiuto alle prime armi, ed inoltre fa mostra a schermo la stringa SQL che viene utilizzata
quando si agisce con un comando visuale.
CREATE TABLE àutori` (ÌDAUTORE` INT(11) NOT NULL AUTO_INCREMENT,

`Descrizione` VARCHAR(60) NOT NULL,
`Citta` VARCHAR(40) DEFAULT NULL,
PRIMARY KEY (ÌDAUTORE`))
Per quanto riguarda le caratteristiche dei singoli campi fate riferimento al capitolo che tratta
della strutturazione di un database, dove vengono spiegate nel dettaglio le caratteristiche
salienti di un campo e di una tabella.
Modificare una tabella.

La parola chiave in questo caso è ALTER TABLE e il codice sottostante è un esempio nel
caso volessi aggiungere due campi che si chiamano rispettivamente DataNascita e Luogo-
Nascita alla tabella.
ALTER TABLE `libreria`.àutori`

ADD COLUMN `DataNascita` DATETIME NULL AFTER `Citta`,
ADD COLUMN `LuogoNascita` VARCHAR(45) NULL AFTER `DataNascita`;
Eliminare una tabella

Per eliminare una tabella in un database è sufficiente digitare:
drop table autori
Attenzione al fatto che i comandi SQL non chiedono mai conferma per quanto viene
ordinato e quindi prestate particolare attenzione ai dettagli…
Inoltre, questi sono dei semplici esempi che non possono coprire tutte le situazioni
possibili e immaginabili che si possono verificare durante il vostro lavoro.
350
Inserire i dati in una tabella
Utilizzate le parole chiave INSERT INTO per dichiarare in quali campi dovete inserire i dati,
e VALUES per i dati che desiderate memorizzare nei vari campi.
Attenzione al fatto che le stringhe vanno inserite fra apici mentre i numeri senza, le date
vanno inserite con il formato che vedete qui sotto. (col formato aaaa-mm-gg o come è più
probabile che vi capiterà yyyy-mm-dd)
INSERT INTO Autori (Descrizione, Citta, DataNascita , LuogoNascita)

VALUES ('Babbo Natale', 'Firenze', '2017-10-09', 'Milano')
Elencare i record
Nel caso desiderate visualizzare il contento di una tabella:
SELECT * FROM Autori
Oppure se desiderate solo alcuni campi:
SELECT Descrizione, DataNascita FROM Autori;
Modificare un record
Modificare i valori all’interno di un campo capita molto spesso in questo ambito.
Questo è un semplice esempio che mostra come sostituire il valore nel campo citta. Per
identificare univocamente un record lo si fa attraverso il campo IDAUTORE.
UPDATE àutori` SET `Citta`='Torino' WHERE ÌDAUTORE`='1';
Eliminare un record
Come nel caso precedente è necessario identificare univocamente il record da eliminare
attraverso il campo IDAUTORE.
DELETE FROM àutori` WHERE ÌDAUTORE`='1';
Per maggiori informazioni potete consultare la guida SQL di MySQL.

Utilizzare Visual Basic con MySQL
351
L’accoppiata Visual Basic e MySQL può essere veramente fenomenale a livello di produtti-
vità, ma sono necessarie diverse informazioni supplementari per evitare di “battere contro
un muro”, informazioni che molto spesso sono parziali e mal documentate.
Per iniziare la nostra avventura con MySQL verificate la connessione attraverso lo strumento
Connetti al database che abbiamo già avuto occasione di conoscere nel capitolo che parla
dell’installazione del Server di MySQL.
Una volta verificato il funzionamento della connessione create un nuovo progetto come fate
di solito e dal menu Progetto scegliete la voce Proprietà.
Scegliete la voce Riferimenti dal menu di sinistra e quindi fate click sul pulsante Aggiungi.
Per aggiungere un riferimento che vi consentirà di accedere alla libreria di oggetti necessari
per connettersi e gestire i dati in un Server MySQL, fate click sul menu Assembly in alto a
sinistra e quindi selezionate la voce Estensioni.
Scorrete la lista e cercate l’estensione MySql.Data, come si vede nella figura successiva.
Selezionatela e quindi fate click sul pulsante OK per includere nel vostro progetto questa
estensione. Non aggiungete altre librerie se non vi è la necessità di includerle nel progetto.
352
Qualora, non si sa per quale losco motivo, l’estensione non comparisse nella lista allora fate
click sul pulsante Sfoglia e cercatelo nella cartella:
C:\Program Files (x86)\MySQL\Connector NET 8.0\Assemblies\v4.5.2\MySql.Data.dll

353
Quindi selezionate il file corrispondente e fate click sul pulsante Aggiungi.
Se il file in questione non fosse facilmente rintracciabile (ogni tanto si divertono a cambiare
posizione) eseguite una ricerca nel disco C: digitando il nome: MySql.Data.dll
Una volta aggiunto il riferimento chiudete la scheda delle Proprietà del progetto con l’appo-
sito comando come mostra la figura sottostante.
Ed a questo punto possiamo cominciare con la nostra avventura. Tenete presente che la
versione di Connector.NET può variare a seconda della versione di Visual Studio che state
utilizzando. Per maggiori informazioni consultate il sito internet di MySQL.
354
Accedere ai dati con Visual Basic.
Prima di effettuare il collegamento ad un Server di MySQL è necessario conoscere su quale
computer (in realtà si dice: su quale macchina) si trova il nostro Server. Dato che siamo
programmatori in linea di massima il server è localizzato sullo stesso computer dove state
sviluppando. Se così non fosse, ed il Server di MySQL si trovasse da qualche parte sulla
vostra rete locale, è sufficiente conoscere l’indirizzo IP della macchina che lo ospita.
L’indirizzo IP della vostra macchina è genericamente identificato con 127.0.0.1 (solitamente
è quello che viene utilizzato nel nostro caso) oppure può essere scoperto digitando il co-
mando ipconfig sul prompt dei comandi di Windows che si trova sul Menu di Avvio alla voce
Sistema Windows, o in alternativa facendo click con il tasto DX del mouse sul Menu di Avvio
e scegliendo la voce Windows PowerShell.
Questo numero poi sarà utile per effettuare il collegamento al Server.
Quando il Server si trova nella stessa macchina di sviluppo di solito si utilizza come indirizzo
IP 127.0.0.1
Come seconda operazione è necessario permettere all’utente amministratore di accedere al
Server MySQL non solo dall’utilità WorkBench ma anche da altre posizioni, come ad esempio
una altra macchina in rete o un altro programma. Come mostra la figura sottostante dalla
schermata principale fate click sulla scheda Administration, e quindi selezionate Users and
Privileges. Dalla lista degli utenti scegliete la voce root, che equivale all’amministratore,
quindi inserite il simbolo di percentuale (%) nel campo che limita l’accesso da altre posi-
zioni. Quindi fate click sul pulsante Apply in basso a destra nella finestra.
Se non viene fatta questa impostazione è probabile che il Server, tutte le volte che provate
ad accedere ai dati attraverso Visual Basic, generi un errore.
Non cambiate arbitrariamente altre impostazioni che vedete nella figura, ammesso che non
siate degli esperti, altrimenti è possibile che si verifichino comportamenti non graditi da
parte del Server.
355
Accedere ai dati.
Collegarsi ai dati di un database con Visual Basic è un argomento piuttosto vasto perché
ogni tipo di database ha un modo tutto suo di operare e quindi, le istruzioni possono variare
caso per caso. Esistono però degli elementi comuni che andremo ad analizzare.
Intanto nello spazio dei nomi dovete richiamare la libreria necessaria ad operare:
Imports MySql.Data.MySqlClient
Connessione a un Database MySQL

La prima cosa da fare è creare una connessione con il Server MySQL quindi avete bisogno
di una stringa di connessione che ha quest’aspetto qui:
"Data Source=127.0.0.1;DataBase=Prova;User ID=root;Password=VBdazero2019"
questa stringa va passata ad un oggetto Connection per poter funzionare
Data source indica il computer dove si trova il Server (nel nostro caso è locale), altrimenti
va specificato l’indirizzo IP della macchina sulla quale è installato, ad esempio 192.168.1.8.
Se il server di MySQL è installato sulla stessa macchina che utilizzate per programmare con
Visual Basic il parametro è 127.0.0.1
Database indica a quale database volete accedere.
User ID è il nome dell’utente nel nostro caso l’amministratore (root).
Password quella che avete utilizzato per l’utente in questione.
Passando subito alla pratica ed evitare sterili considerazioni squisitamente tecniche per col-
legarmi dichiaro cinque stringhe dove dentro ci inserisco i singoli parametri che utilizzerò
nella stringa di connessione
Dim StringaConnessione As String

Dim ServerName As String = "127.0.0.1"
Dim Password1 As String = "VBdazero2019"
Dim DataBaseName As String = "world"
Dim Utente As String = "root"
Assegno i valori alla stringa di connessione. Per migliorarne la leggibilità preferisco disporre
i vari parametri su righe diverse invece di scrivere tutto su una riga.
StringaConnessione = "server=" & ServerName & ";" &

"user id=" & Utente & ";" &
"password=" & Password1 & ";" &
"database=" & DataBaseName
Dichiaro un oggetto connessione e gli affibbio la stringa di connessione:
Dim OggettoConnessione As New MySqlConnection(StringaConnessione)
Oppure:
Dim OggettoConnessione As New MySqlConnection

OggettoConnessione.ConnectionString = StringaConnessione
Queste due dichiarazioni si equivalgono. Utilizzatene solo una delle due altrimenti Visual
Basic restituirà un errore.
356
Apro la connessione attraverso l’oggetto connessione.
OggettoConnessione.Open()
Questa ovviamente è la versione “base” per connettersi ai dati.

Quando si tratta di connessioni non sempre tutto va a buon fine al primo colpo, quindi è
conveniente inserire il codice che vedete qui sotto in modo che, se si verifica qualche pro-
blema all’atto della connessione sullo schermo, comparirà il motivo.
Try
Exit Sub
End Try
La figura sottostante mostra com’è disposto il codice della connessione.
Adesso inserite nel form un controllo tipo DataGridView per visualizzare sullo schermo il
contenuto, ad esempio, della tabella City del database World.
Questo database è inserito come esempio nel pacchetto di installazione di MySQL. Se avete
dei dubbi consultate il capitolo di installazione del database MySQL sul vostro computer.
Dalla Casella degli strumenti individuate e posizionate sul vostro Form un controllo tipo
DataGridView come mostra la figura successiva.
357
Se volete ridimensionate adeguatamente sia il form che il DataGridView.
Per visualizzare i dati nella DataGridView utilizzate il codice qui di seguito al posto di quello
precedente.
Option Explicit On
Public Class Form1

358
Me.Show()

Dim OggettoConnessione As New MySqlConnection(StringaConnessione)
Try
Exit Sub
End Try
'Creo Adattatore Dati

Dim Adattatore As New MySqlDataAdapter
'Creo Set di Dati

Dim SetDati As New DataSet("City")
'Creo la Stringa
Dim stringaSQL As String = "SELECT * FROM City ORDER BY Name "
Try
Adattatore.SelectCommand = New MySqlCommand(stringaSQL, OggettoConnessione)
Adattatore.Fill(SetDati, "City")
DataGridView1.DataSource = SetDati.Tables("City")

Exit Sub
End Try
OggettoConnessione.Close()
End Sub
End Class
Dopo che abbiamo descritto l’oggetto connessione è necessario introdurre altri due oggetti
che permettono l’accesso ai dati, il DataAdapter e il DataSet.
Il primo serve per adattare i dati mentre il secondo serve per creare dei set di dati vero e
proprio attraverso un’istruzione SQL.
Creo adattatore dei dati.
Creo il set di dati da passare alla DataGridView.
Dim SetDati As New DataSet("City")
Creo una stringa per selezionare determinati dati dalla tabella.

359
Dim stringaSQL As String = "SELECT * FROM City ORDER BY Name "
Associo l’adattatore dei dati con la stringa connessione e l’oggetto Connessione:
Adattatore.SelectCommand = New MySqlCommand(stringaSQL, OggettoConnessione)
Assegno il set di dati appena creati e gli assegno un nome
Adattatore.Fill(SetDati, "City")
Assegno il set di dati alla griglia in modo che visualizzi i dati.
DataGridView1.DataSource = SetDati.Tables("City")
Inserire nuovi record.

Una delle possibili tecniche per l’inserimento di nuovi record in una tabella è l’utilizzo dell’og-
getto CommandBuilder che provvede a creare un comando SQL per poi passarlo all’adatta-
tore dei dati per avere il risultato richiesto. Per inserire una nuova Città è necessario asso-
ciarla ad un paese e la prima parte del codice serve per riempire il ComboBox che mostra
all’utente la lista dei paesi, quindi ne recupera i nomi dalla tabella Country e li visualizza
sulla lista del ComboBox. L’utente vedrà l’elenco del nome del paese ma non il codice a lui
associato che invece è utile al computer per collegare una città ad un paese.
Private Sub Paese()
Dim OggettoAdattatore As New MySqlDataAdapter

Dim OggettoDataset As New DataSet("Country")
Dim stringaSQL As String = "SELECT Code, Name FROM Country ORDER BY Name"
Try
OggettoAdattatore.SelectCommand = New MySqlCommand(stringaSQL, OggettoConnessione)

OggettoAdattatore.Fill(OggettoDataset, "Country")
ComboBox1.DataSource = OggettoDataset.Tables("Country")
ComboBox1.ValueMember = "Code"
ComboBox1.DisplayMember = "Name"

Exit Sub
End Try
End Sub
Creo un nuovo adattatore per i dati:
Imposto un nuovo dataset e lo chiamo Country
Dim OggettoDataset As New DataSet("Country")
Creo una stringa SQL per che crea la lista dei paesi ordinati per nome.
360
Associo l’adattatore dei dati alla stringa SQL e all’oggetto connessione.
OggettoAdattatore.SelectCommand = New MySqlCommand(stringaSQL, OggettoConnessione)
Riempio l’adattatore con i dati.
OggettoAdattatore.Fill(OggettoDataset, "Country")
Associo la sorgente dei dati del ComboBox con il DataSet creato in precedenza.
ComboBox1.DataSource = OggettoDataset.Tables("Country")
Associo il campo Codice alla proprietà ValueMembrer che verrà utilizzata per associare il
codice al nome del paese.
La proprietà DisplayMember, ovvero ciò che deve essere visualizzato sulla lista viene asso-
ciato al campo Name. In pratica quando l’utente effettua una scelta seleziona il nome di un
paese ma in realtà e come se avesse scelto il suo codice.
Il codice che segue invece serve per inserire una nuova città nella tabella City del database
e si trova nel Form CittaNuova.vb che serve per salvare una nuova città dentro al database.
Private Sub Salva()
'apro la finestra dello stato connessione

StatoConnessione = New FrmStatoConnessione
StatoConnessione.Show("Connessione al Database!! Attendere prego")
Dim stringaSQL As String
Try ' Connessione con il Database

Catch Eccezione As MySqlException
End Try
'Creazione di Adattatore dei Dati
stringaSQL = "SELECT * FROM City"

Dim Adattatore1 As New MySqlDataAdapter(stringaSQL, OggettoConnessione)
Dim SQLComBuilder As New MySqlCommandBuilder(Adattatore1)
Dim DataSet1 As New DataSet("City")
Adattatore1.Fill(DataSet1, "City")
Dim Tabella As DataTable = DataSet1.Tables("City")

'Recupera il valore della Nazione nel combo box e inseriscilo nella variabile Country1
Dim Country1 As String = ComboBox1.SelectedValue
361
NuovaRiga("Name") = t_Citta.Text
NuovaRiga("CountryCode") = Country1
NuovaRiga("District") = t_Distretto.Text
NuovaRiga("Population") = t_Popolazione.Text
Try
End Try
Try
Adattatore1.Update(DataSet1, "City")

Exit Sub
End Try
'Chiudo la connessione al Database

'Chiudo la finestra dello stato della connessione

StatoConnessione.Close()
End Sub
Dichiaro una stringa SQL.
Dim stringaSQL As String

stringaSQL = "SELECT * FROM City"
Apro la connessione al database.
Associo L’adattatore dei dati alla Stringa SQL e alla connessione al database.
Dim Adattatore1 As New MySqlDataAdapter(stringaSQL, OggettoConnessione)
Creo un oggetto CommandBuilder.
Dim SQLComBuilder As New MySqlCommandBuilder(Adattatore1)
Creo un DataSet e lo riempio con i dati dell’adattatore.
Dim DataSet1 As New DataSet("City")

Adattatore1.Fill(DataSet1, "City")
Chiudo la connessione una volta recuperato i dati.

362
Creo un oggetto che rappresenta la tabella.
Dim Tabella As DataTable = DataSet1.Tables("City")
Creo un oggetto che rappresenta la collezione delle righe (record) di una tabella.
Creo un oggetto che rappresenta una nuova riga della tabella.
Recupera il valore della Nazione nel ComboBox e inseriscilo nella variabile Country1.
Dim Country1 As String = ComboBox1.SelectedValue
All’oggetto Righe vengono assegnate le righe dell’oggetto Tabella.
Aggiungo una nuova riga alla tabella (record).
Inserisco i valori presenti nelle caselle di testo del Form ai campi del nuovo record.
NuovaRiga("Name") = t_Citta.Text
NuovaRiga("CountryCode") = Country1
NuovaRiga("District") = t_Distretto.Text
NuovaRiga("Population") = t_Popolazione.Text
Aggiungo il nuovo record all’oggetto che rappresenta la collezione dei record di una tabella.
Riapro la connessione:
Aggiorno il dataset:
Adattatore1.Update(DataSet1, "City")
Chiudo la connessione al database:
Modificare un record
La modifica di un record prevede che siano visibili sullo schermo i dati che andranno modi-
ficati, quindi è necessario prima recuperarli dal database e sottoporli all’attenzione dell’ope-
ratore che provvederà eventualmente ad effettuare delle modifiche. Questo codice si trova
nel Form CittaModifica.Vb
Private Sub Leggi_Citta()

363
Dim StringaSQL1 As String = "SELECT * FROM City where ID = " & Str(MiaCitta) & " "
Dim OggettoAdattatore As New MySqlDataAdapter(StringaSQL1, OggettoConnessione)

Dim OggettoDataset As New DataSet("City")
OggettoAdattatore.Fill(OggettoDataset, "City")
Dim OggettoTabella As DataTable
OggettoTabella = OggettoDataset.Tables("City")
t_Citta.Text = OggettoTabella.Rows(0).Item("Name")
t_Distretto.Text = OggettoTabella.Rows(0).Item("District")
t_Popolazione.Text = OggettoTabella.Rows(0).Item("Population")
ComboBox1.SelectedValue = OggettoTabella.Rows(0).Item("CountryCode")
End Sub
Private Sub Leggi_Paese()
'Leggi i paesi e mettili nel combo Box

Dim OggettoDataSet As New DataSet("Country")
Try
OggettoAdattatore.SelectCommand = New MySqlCommand(stringaSQL,

OggettoConnessione)
OggettoAdattatore.Fill(OggettoDataSet, "Country")
ComboBox1.DataSource = OggettoDataSet.Tables("Country")

Exit Sub
End Try
End Sub
Analizzeremo solo la prima parte in quanto la seconda l’abbiamo già incontrata nel caso
precedente dell’aggiunta di un nuovo record.
Crea una stringa SQL che seleziona esclusivamente il solo record da modificare:
Dim StringaSQL1 As String = "SELECT * FROM City where ID = " & Str(MiaCitta) & " "
Che può essere scritta anche così:
Dim StringaSQL1 As String = "SELECT * FROM City where ID = " & Str(MiaCitta)
Creo un nuovo oggetto MySqlDataAdapter e lo associo alla stringa SQL e all’oggetto con-
nessione.
Dim OggettoAdattatore As New MySqlDataAdapter(StringaSQL1, OggettoConnessione)

364
Creo un nuovo oggetto DataSet:
Riempio l’adattatore dei dati:
Creo un oggetto tabella e gli associo il dataset:
Dim OggettoTabella As DataTable

OggettoTabella = OggettoDataset.Tables("City")
Leggo i campi dell’oggetto tabella e li inserisco nei ComboBox che si trovano nel Form.
t_Citta.Text = OggettoTabella.Rows(0).Item("Name")
t_Distretto.Text = OggettoTabella.Rows(0).Item("District")
t_Popolazione.Text = OggettoTabella.Rows(0).Item("Population")
ComboBox1.SelectedValue = OggettoTabella.Rows(0).Item("CountryCode")
Chiudo la connessione al database:
Adesso i dati sono visibili sullo schermo. Il codice che segue serve per modificarli.
Private Sub Salva_Modifiche()
'*************************
' Salva Città Modificata
'*************************
' controlla se i campi obbligatori sono specificati
Cursor = Cursors.WaitCursor
StatoConnessione = New FrmStatoConnessione

'*********************
'Salvataggio Modifiche
'*********************
Dim OggettoAdattatore As New MySqlDataAdapter("SELECT * FROM City WHERE ID = " &

Str(MiaCitta) & " ", OggettoConnessione)
Dim CommBuild As New MySqlCommandBuilder(OggettoAdattatore)
Dim Tabella As DataTable = OggettoDataset.Tables("City")
Riga.BeginEdit()
Riga("Name") = t_Citta.Text
Riga("CountryCode") = ComboBox1.SelectedValue
Riga("District") = t_Distretto.Text
Riga("Population") = t_Popolazione.Text
365
Riga.EndEdit()
OggettoAdattatore.Update(OggettoDataset, "City")
Me.Close()
End Sub
Questa parte riguarda la connessione ai dati e il riempimento dell’adattatore con il solo

record che riguarda la città da modificare.
Dim OggettoAdattatore As New MySqlDataAdapter("SELECT * FROM City WHERE ID = " &

Str(MiaCitta) & " ", OggettoConnessione)

Creo un nuovo oggetto CommandBuilder e lo associo all’adattatore dei dati.
Dim CommBuild As New MySqlCommandBuilder(OggettoAdattatore)
Definisco un nuovo oggetto “tabella” e anche l’oggetto che rappresenta l’unica riga di quella
tabella.
Dim Tabella As DataTable = OggettoDataset.Tables("City")

Inizio con le modifiche.
Riga.BeginEdit()
Modifico i dati dei rispettivi campi.
Riga("Name") = t_Citta.Text
Riga("CountryCode") = ComboBox1.SelectedValue
Riga("District") = t_Distretto.Text
Riga("Population") = t_Popolazione.Text
Chiudo le modifiche.
Riga.EndEdit()
Chiamo il metodo update dell’adattatore dei dati.
OggettoAdattatore.Update(OggettoDataset, "City")
Ottiene il comando dal CommandBuilder.
366
Eliminare un record
Tenete presente che il codice completo dell’esercizio è scaricabile dal sito della casa editrice
e qui ne riportiamo solo le parti salienti. Questa parte di codice si trova nel Form chiamato
Citta.
Private Sub p_Elimina_Click(sender As Object, e As EventArgs) Handles p_Elimina.Click
Dim IDCittà As Long
Try
IDCittà = DataGridView1.Item(0, DataGridView1.CurrentCell.RowIndex).Value
Exit Sub
End Try
Dim Risposta As String = MsgBox("Eliminare la Città Selezionata ?", vbYesNo +

vbExclamation, "Elimina Città")
Exit Sub
End If
'Eliminazione Città Selezionata

Dim ComandoCancellazione As String = "DELETE FROM City WHERE ID = " & Str(IDCittà)
Dim Comando As MySqlCommand = New MySqlCommand(ComandoCancellazione, OggettoConnessione)
Try
Comando.ExecuteNonQuery()
Catch ex As MySqlException
MsgBox(ex.Message)
Exit Sub
End Try
MsgBox("Città eliminata con successo", vbOKOnly + vbExclamation, "Eliminazione OK")
End Sub
Per eliminare un record intanto recupero dall’elemento selezionato nella griglia l’identifica-
tivo univoco.
Dim IDCittà As Long

IDCittà = DataGridView1.Item(0, DataGridView1.CurrentCell.RowIndex).Value
Poi chiedo, non si sa mai, all’utente se è proprio sicuro di eliminare la città selezionata nella
griglia.
Dim Risposta As String = MsgBox("Eliminare la Città Selezionata ?",

vbYesNo + vbExclamation, "Elimina Città")
In caso di sposta affermativa…

Exit Sub
367
End If
Creo un comando SQL, qui si ritorna all’importanza di conoscere almeno in linea di massima
le istruzioni del linguaggio SQL.
Dim ComandoCancellazione As String = "DELETE FROM City WHERE ID = " & Str(IDCittà)
Quindi creo un oggetto MySqlCommand
Dim Comando As MySqlCommand = New MySqlCommand(ComandoCancellazione, OggettoConnessione)
Apro la connessione:
Eseguo il comando:
Chiudo la connessione:
Un bel messaggino finale.
MsgBox("Città eliminata con successo", vbOKOnly + vbExclamation, "Eliminazione OK")
Ricercare un dato
La DataGridView in genere visualizza sullo schermo dell’operatore una lista di dati. Quando
questi dati diventano troppi, non sono pratici da consultare perciò è necessario in alcuni
casi limitare il numero dei records presenti nella DataGridView.
Ad esempio se l’utente volesse visualizzare solo le città che iniziano con la lettera A, e non
tutte le altre, è necessario creare una Query che contempli questa possibilità. Questo tipo
di ricerca può estendersi a qualunque campo del database a seconda delle necessità
dell’utente attraverso apposite Query di selezione.
Nell’evento click del pulsante “Cerca” è stato inserito del codice che permette di fare un’in-
terrogazione come quella proposta prima ovvero ricercare le città in base al nome. Questa
parte di codice si trova nel Form Citta.vb.
Private Sub p_Cerca_Click(sender As Object, e As EventArgs) Handles p_Cerca.Click
Dim StringaSQL As String

Dim Sigla As String = t_Citta.Text & "%"
StringaSQL = "SELECT * FROM City WHERE Name LIKE '" & Sigla & "' ORDER BY Name "
Cerca_Citta(StringaSQL)
End Sub
Il funzionamento di massima è questo:

Creo una stringa dove inserirò il comando SQL:
Creo una stringa dove inserirò il contenuto del TextBox “Citta” seguito dal simbolo di per-
centuale:
368
Dim Sigla As String = t_Citta.Text & "%"
Nel linguaggio SQL questo permette di fare ricerche sulla parte iniziale di un nome ad esem-
pio se cerco tutte le città che iniziano con la lettera A devo scrivere A%.
Questo carattere Jolly mi permette di non specificare altro oltre a quanto fatto, ovvero basta
la lettera A.
Posso anche cercare le città che iniziano per AL e in questo caso scriverei AL% o anche
quelle che iniziano con ALE che diverrà ALE% e così via. E’ quindi possibile scrivere non
solo la prima lettera, ma anche parte della stringa di ricerca, ed in questo modo posso
restringere il campo delle ricerche.
Quindi memorizzo il comando nella stringa che utilizzerò per fare l’interrogazione.
StringaSQL = "SELECT * FROM City WHERE Name LIKE '" & Sigla & "' ORDER BY Name "
Attenzione perché a seconda della tipologia di dati che ricercate il comando può cambiare
non poco, ad esempio una stringa in un campo di testo del database oppure un campo
numerico o addirittura un campo che contiene una data.
Nel caso di una ricerca in un campo numerico il comando diventa:
StringaSQL = DELETE FROM Clienti WHERE IDCLIENTE = " & Str(IDCLIENTE)
La differenza sta nel fatto che un valore numerico lo devo passare come una stringa utiliz-
zando gli apici in maniera diversa altrimenti il comando non funzionerà mai.
Per quanto riguarda le date il formato è come nell’esempio qui sotto.
Per semplicità e per evitare di sbagliare prendo i valori delle date da due controlli DateTi-
mePicker e le inserisco in queste due stringhe. Per maggiori informazioni consultate il ca-
pitolo che tratta del controllo DateTimePicker.
Dim DataIniziale As Date = DataInizio.Value

Dim DataFinale As Date = DataFine.Value
Creo la stringa di interrogazione:
StringaSQL = " SELECT * FROM DocumentiTestata " &

WHERE (DocumentiTestata.Data BETWEEN '" & Format(DataIniziale, "yyyy/MM/dd") & "' " &
" AND '" & Format(DataFinale, "yyyy/MM/dd") & "') "
Da notare che la data va passata nel formato contrario a quella che siamo abituati solita-
mente. Quindi tenete presenti queste informazioni dato che sicuramente vi imbatterete in
un problema del genere.
Il codice sottostante serve per visualizzare sullo schermo il risultato di una ricerca da parte
dell’utente. Il codice completo si trova nel materiale allegato al libro.
Private Sub Cerca_Citta(ByVal StringaSQL As String)
Dim StatoConnessione = New FrmStatoConnessione

OggettoConnessione = New MySqlConnection(StringaConnessione)
Try
369
Exit Sub
End Try
Try
SetDati = New DataSet("Citta")

Adattatore.SelectCommand = New MySqlCommand(StringaSQL, OggettoConnessione)
Adattatore.Fill(SetDati, "Citta")
DataGridView1.DataSource = SetDati
DataGridView1.DataMember = "Citta"
Dim Tabella2 As DataTable = SetDati.Tables("Citta")

Dim Record2 As Long = Tabella2.Rows.Count()
Label2.Text = "Record in archivio: " & Format(Record2, FORMATO)

Exit Sub
End Try
Griglia1()
End Sub
Faccio apparire il cursore di attesa sullo schermo durante la ricerca:
Creo e faccio comparire sullo schermo la finestra che riguarda lo stato della connessione al
database:
Dim StatoConnessione = New FrmStatoConnessione

Creo l’oggetto connessione:
OggettoConnessione = New MySqlConnection(StringaConnessione)
Apro la connessione e metto una trappola per errori casomai si verificasse qualche pro-
blema. Consultate anche l’omonimo capitolo per maggiori informazioni:
Try
Exit Sub
End Try
Inserisco una seconda trappola per errori.
Try
370
Creo un nuovo set di dati.
SetDati = New DataSet("Citta")
Associo la stringa SQL e la connessione all’adattatore dei dati che provvederà a passarla al
database.
Adattatore.SelectCommand = New MySqlCommand(StringaSQL, OggettoConnessione)
Riempio l’adattatore con i dati.
Adattatore.Fill(SetDati, "Citta")
Chiudo al momento la connessione.
Associo i dati recuperati dall’adattatore al DataGridView.
DataGridView1.DataSource = SetDati
DataGridView1.DataMember = "Citta"
Creo la tabella “Citta” nella memoria del computer:
Dim Tabella2 As DataTable = SetDati.Tables("Citta")
Mi faccio dire dalla tabella da quanti record è composta:
Dim Record2 As Long = Tabella2.Rows.Count()

Label2.Text = "Record in archivio: " & Format(Record2, FORMATO)
Chiudo la trappola per errori:

Exit Sub
End Try
Chiudo la connessione:
Chiudo la finestra dello stato della connessione:
Vado alla routine che si chiama Griglia1() che serve a sistemare quello che verrà visualiz-
zato sul DataGridView
Griglia1()
Modifico il puntatore sullo schermo e lo rimetto come è di solito ovvero una freccetta.
371
Controllare l’immissione dei dati da parte dell’utente
Si tratta di un argomento particolarmente importante, in quanto molti dei problemi e degli
errori di Runtime dipendono in larga parte dal fatto che l’utente inserisce nei campi a sua
disposizione valori non ammessi attraverso la tastiera.
Ad esempio se da un TextBox inserisco dei caratteri invece che valori numerici come richie-
sto, è altamente probabile che si generi un errore, dovuto al fatto che quei caratteri non
sono riconosciuti come valori numerici dal programma in fase di elaborazione o di memo-
rizzazione nel database.
La prima cosa da fare è attraverso la proprietà MaxLength di un TextBox è limitare il numero
di caratteri che il campo può accettare in modo, specialmente nei campi di testo, da evitare
che il numero di caratteri superi la lunghezza del campo nel database, ad esempio:
t_Titolo.MaxLength = 255
il titolo del libro non può superare i 255 caratteri anche perché il TextBox ne impedirebbe
l’immissione. Un'altra limitazione può essere quella di permettere all’utente di digitare solo
in maiuscolo:
t_Titolo.CharacterCasing = CharacterCasing.Upper
o in minuscolo:
t_Titolo.CharacterCasing = CharacterCasing.Lower
queste istruzioni possono essere inserite ad esempio nell’evento Load del Form in modo da
applicare le limitazioni subito all’inizio come mostra la figura sottostante.
Inoltre supponiamo che sia necessario impedire a un utente di inserire in un campo valori
non numerici, ad esempio devo digitare il prezzo di un libro o cose di questo genere qui. In
questo caso è necessario avvalersi dell’evento KeyPress di un TextBox ed inserire il se-
guente codice.
Il riquadro sottostante mostra il codice in dettaglio

372
Dim Keyascii As Integer = Asc(e.KeyChar)
If Keyascii <> 13 And Keyascii <> 8 And (Keyascii < Asc("0") Or Keyascii > Asc("9"))
And Keyascii <> Asc(".") Then
e.Handled = True
Exit Sub
End If
Crea una variabile di tipo Integer che contiene il valore Ascii del tasto premuto.
ASCII è l’acronimo di American Standard Code for Information Interchange, ovvero un co-
dice standard adottato nel 1968, che assegna un valore numerico ad ogni simbolo che
compare sulla tastiera (anche quelli che non compaiono). Non ho riportato la tabella nel
libro anche perché è facilmente rintracciabile su Internet.
In pratica quando premo un tasto viene convertito in un valore numerico.
La variabile (e) rappresenta, come si vede nella dichiarazione dell’evento, l’argomento della
pressione del tasto dal quale si può ricavare di quale tasto si tratta e convertirlo in valore
Ascii con la funzione Asc.
Il valore 8 del codice Ascii rappresenta il tasto Backspace sulla tastiera, quello sopra il tasto
Invio che serve per cancellare un carattere verso sinistra.
If Keyascii <> 13 And Keyascii <> 8 And (Keyascii < Asc("0") Or Keyascii > Asc("9")) And
Keyascii <> Asc(".") Then
Mentre il valore 13 rappresenta il tasto Invio qualora dovesse iniziare qualche ricerca in
quel campo attraverso tale tasto. Se non avete necessita di utilizzare il tasto Invio per
qualcosa di particolare il codice diventa:
If Keyascii <> 8 And (Keyascii < Asc("0") Or Keyascii > Asc("9")) And Keyascii <> Asc(".")
Then
373
Questa parte dell’istruzione esclude qualsiasi tasto diverso da uno numerico infatti consi-
dera solamente i tasti da 0 a 9.
(Keyascii < Asc("0") Or Keyascii > Asc("9"))
Questa istruzione permette l’utilizzo del punto decimale se necessario.
Keyascii <> Asc(".")
ed infine:
e.Handled = True
annulla la pressione del tasto come se non fosse mai stato premuto se non ricade nelle
condizioni che abbiamo visto prima. Per ulteriori approfondimenti consultate il capito che
tratta del controllo MaskedTextBox.
IsNumeric
Questa funzione serve per controllare se un valore può essere valutato come un valore
numerico oppure no. Ad esempio una variabile tipo Stringa contiene qualcosa che può sem-
brare un numero. Per associarla ad una variabile di tipologia più appropriata, prima di ese-
guire l’assegnazione, è meglio verificare che effettivamente il computer la possa interpre-
tare come numero onde evitare un errore che blocchi l’esecuzione del programma.
Il codice sottostante è un esempio.
Dim Pippo As String = "152.74"

Dim A As Double
If IsNumeric(Pippo) = True Then

A = Val(Pippo)
End If
Convalidare un indirizzo di posta elettronica

Nell’esempio seguente viene utilizzato un controllo TextBox per convalidare un indirizzo di
posta elettronica immesso dall’utente, unitamente ad un controllo ErrorProvider. Questo
tipo di controllo fornisce un’interfaccia utente che indica se, ad un controllo presente su un
form, ad esempio un TextBox, è associato un errore.
Se l’indirizzo immesso non rispetta il formato standard che deve contenere sia il carattere
“@” che il carattere “.” viene visualizzata accanto al TextBox un’icona generata dal controllo
ErrorProvider. Se viene sovrapposto il puntatore del mouse all’icona questa visualizza anche
un messaggio d’errore.
Per quanto riguarda il TextBox vengono utilizzati i seguenti eventi generati dal controllo:
l’evento Validated si verifica al termine della convalida del controllo e l’evento Validating si
verifica durante la convalida del controllo.
Il codice dell’esempio, che fa parte del codice allegato al libro, è il seguente:
Option Explicit On
Public Class Form1
End Sub
Private Sub textBox1_Validating(ByVal sender As Object, ByVal e As

374
System.ComponentModel.CancelEventArgs) Handles TextBox1.Validating
Dim MessaggioErrore As String
If Not ValidEmailAddress(TextBox1.Text, MessaggioErrore) Then
'Cancella l'evento e seleziona il testo in modo che l'utente possa corregerlo.

e.Cancel = True
TextBox1.Select(0, TextBox1.Text.Length)
'Imposta il testo da visualizzare nel ErrorProvider.

ErrorProvider1.SetError(TextBox1, MessaggioErrore)
End If
End Sub
Private Sub textBox1_Validated(ByVal sender As Object, ByVal e As System.EventArgs)

Handles TextBox1.Validated
' Se va tutto ok cancella il testo del ErrorProvider.
ErrorProvider1.SetError(TextBox1, "")
End Sub
Private Function ValidEmailAddress(ByVal IndirizzoEmail As String,

ByRef MessaggioErrore As String) As Boolean
' Verifica che ci sia del testo nel controllo TextBox.
If TextBox1.Text.Length = 0 Then
MessaggioErrore = "L'indirizzo email è obbligatorio"
Return False
End If
' verifica che sia presente "@" e un punto "." in un indirizzo email, nell'ordine
corretto.
If IndirizzoEmail.IndexOf("@") > -1 Then
If (IndirizzoEmail.IndexOf(".",IndirizzoEmail.IndexOf("@")) >
IndirizzoEmail.IndexOf("@")) Then
MessaggioErrore = ""
Return True
End If
End If
MessaggioErrore = "L'indirizzo email deve avere un formato valido." +

ControlChars.Cr + "Ad esempio 'mario.rossi@esempio.it' "
Return False
End Function
MsgBox("Indirizzo email formalmente corretto!",

vbOKOnly + vbExclamation, "Messaggio")
End Sub
End Class
Quando si modifica lo stato attivo di un controllo TextBox usando la tastiera, gli eventi di
attivazione si verificano nell'ordine seguente: Enter, GotFocus, Leave, Validating, Validated,
LostFocus mentre quando lo si modifica attraverso il mouse o chiamando il metodo Focus
dal codice, gli eventi si verificano nell'ordine seguente: Enter, GotFocus, LostFocus, Leave,
Validating, Validated
375
Se la proprietà CausesValidation è impostata su False, gli eventi Validating e Validated
vengono eliminati dalla lista e non vengono eseguiti. Nell’evento Validating, che si verifica
durante la convalida del controllo, troviamo il codice del box sottostante.
Private Sub textBox1_Validating(ByVal sender As Object, ByVal e As

System.ComponentModel.CancelEventArgs) Handles TextBox1.Validating
Dim MessaggioErrore As String
If Not ValidEmailAddress(TextBox1.Text, MessaggioErrore) Then
'Cancella l'evento e seleziona il testo in modo che l'utente possa corregerlo.

e.Cancel = True
TextBox1.Select(0, TextBox1.Text.Length)
'Imposta il testo da visualizzare nel ErrorProvider.

ErrorProvider1.SetError(TextBox1, MessaggioErrore)
End If
End Sub
ValidEmailAddress è una funzione che controlla la validità formale dell’indirizzo di posta

elettronica immesso dall’utente. Questa funzione accetta in ingresso come valore (ByVal)
l’indirizzo email da controllare, come riferimento (ByRef) il messaggio d’errore, e restituisce
un Boolean, ovvero un valore True o False. Controlla inoltre se la lunghezza del testo inse-
rito è uguale a zero, ovvero non è stato inserito nessun valore nel TextBox, rispondendo
che l’indirizzo email è obbligatorio.
Il metodo IndexOf serve per verificare che all’interno di una stringa sia presente o meno
uno specifico carattere. Se il carattere non è presente, questo metodo restituisce il valore
(-1). Quindi viene cercato nella stringa sia il carattere @ che il punto. Se vi è un’incon-
gruenza la funzione restituisce False, altrimenti se tutto va bene True.
Private Function ValidEmailAddress(ByVal IndirizzoEmail As String,

ByRef MessaggioErrore As String) As Boolean
' Verifica che ci sia del testo nel controllo TextBox.
If TextBox1.Text.Length = 0 Then
MessaggioErrore = "L'indirizzo email è obbligatorio"
Return False
End If
' verifica che sia presente "@" e un punto "." in un indirizzo email, nell'ordine
corretto.
If IndirizzoEmail.IndexOf("@") > -1 Then
If (IndirizzoEmail.IndexOf(".",IndirizzoEmail.IndexOf("@")) >
IndirizzoEmail.IndexOf("@")) Then
MessaggioErrore = ""
Return True
End If
End If
MessaggioErrore = "L'indirizzo email deve avere un formato valido." +

ControlChars.Cr + "Ad esempio 'mario.rossi@esempio.it' "
Return False
End Function
Al termine della convalida viene eseguita il codice che si trova nell’evento Validated del
TextBox.
376
Private Sub textBox1_Validated(ByVal sender As Object, ByVal e As System.EventArgs)
Handles TextBox1.Validated
' Se va tutto ok cancella il testo del ErrorProvider.
ErrorProvider1.SetError(TextBox1, "")
End Sub
DBNULL
Quando leggete dei dati da una tabella di un database può accadere una cosa piuttosto
strana, ovvero che venga generato un errore mentre cercate di inserire il valore di un
campo, ad esempio in un TextBox, per visualizzarlo successivamente sullo schermo.
Per fare un esempio calzante prendiamo la routine che legge i dati dei libri nel progetto
Access1 che trovate nel codice d’esempio allegato al libro scaricabile dal sito della casa
editrice. Per la cronaca la routine è la seguente:
Private Sub Leggi_Libro()

Connessione.Close()
End Sub
Questa singola istruzione ad esempio legge il codice ISBN dalla tabella del database e lo
inserisce nel TextBox corrispondente.
T_ISBN.Text = Tabella.Rows(0).Item("ISBN")
Può accadere però che si verifichi un errore abbastanza inspiegabile dovuto all’esistenza di
una condizione chiamata NULL.
Quando si crea un nuovo record in un database, e non tutti i campi vengono riempiti con
dei valori, può accadere che qualcuno di essi resti nella condizione NULL che non corri-
sponde ad un campo vuoto, ma a un campo dove non c’è mai stato nulla dentro. Per esem-
pio se in un campo viene cancellato il contenuto questo non corrisponde a NULL ma sem-
plicemente non contiene informazioni.
Questa condizione può generare degli errori non gestiti. Per questo è necessario sostituire
la singola riga di istruzione vista prima con il codice seguente.
If IsDBNull(Tabella.Rows(0).Item("ISBN")) Then
t_ISBN.Text = ""
Else
377
End If
Moduli di codice
Questo componente non presenta nessun controllo, né Form o pulsanti dove fare click ma
semplicemente solo codice. Viene utilizzato soprattutto per inizializzare un programma o
applicazione, chiamatela come volete, definendo alcune procedure che sarebbe inutile in-
serire in un form perché non richiamano nessun controllo come TextBox o cose di questo
genere. Ad esempio posso dichiarare alcune variabili o costanti che poi saranno disponibili
in tutto il progetto oppure posso creare delle routine accessibili da qualunque punto del
codice nei Form, oppure creare del codice per scrivere un file di accessi al programma da
parte degli utenti.
Dichiarando le variabili Public queste restano disponibili in tutto il progetto quindi state
attenti a non utilizzare localmente nomi che contrastano con quelli utilizzati nel modulo.
Nello stesso modo se dichiaro la Routine Sub Main() pubblica questa sarà accessibile da
qualsiasi punto del progetto. Di solito si fa iniziare l’esecuzione di un programma da questa
routine, anche se le nuove versioni di Visual Basic, se non esplicitamente dichiarato, fanno
iniziare l’elaborazione da uno del Form inclusi nel progetto.
Si tratta di una procedura assolutamente opzionale alla quale siamo abituati noi “vecchi”
programmatori in quanto i progetti di anni e anni or sono, avevano questa caratteristica,
ovvero l’avvio dalla routine Sub Main(). Dico opzionale perché non c’è nulla di quello che
vedremo in questo capitolo che non si possa fare in altro modo con strumenti attuali.
Se fate doppio click sulla finestra Esplora Soluzioni in corrispondenza del Modulo1 potete
visionare il codice che contiene.
Per aggiungere un modulo di codice ai vostri progetti, vi ricordo che è possibile aggiungerne
un numero qualsiasi, fate click con il tasto destro del mouse sul nome del progetto nella
finestra Esplora Soluzioni e dalla lista scegliete la voce Aggiungi – Modulo come mostra
378
la figura successiva. Io di solito non cambio nome al modulo anche se è possibile farlo in
tutta tranquillità come per i Form.
Il codice della Sub Main() e il seguente:
Option Explicit On
Imports System.IO
Module Modulo1
'**********************************
' definisce le variabili Pubbliche
'**********************************
Public StringaConnessione As String
Public PercorsoProgramma As String
Public Const FORMATO As String = "##,##"
Public MiaCitta As Long
Public MioPaese As String
Public Sub Main()
'*****************************************************
'**** Inserite qui il codice di inizializzazione ****
'*****************************************************
Cursor.Current = Cursors.WaitCursor


379
PercorsoProgramma =
Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly.Location)
Cursor.Current = Cursors.Default
Dim Princ As New Principale

Princ.ShowDialog()
End Sub
End Module
Restituisce il percorso completo della posizione del programma, ovvero in quale cartella si
trova l’eseguibile del programma che state sviluppando. È utile conoscere questa variabile
se durante il corso dello sviluppo, in un’altra parte nel codice, è necessario sapere in quale
cartella del computer si trova il programma che state sviluppando o che avete reso esegui-
bile.
PercorsoProgramma =
Questo codice serve per creare la stringa di connessione a un Server MySQL. Ho spezzato
le varie componenti per renderle più leggibili.


Per avviare un progetto dalla Sub Main() è necessario fare click sul menu Progetto e quindi
accedere alle proprietà del progetto.
380
Togliete il segno di spunta o verificate che non ci sia alla voce Abilita Framework Appli-
cazione, dalla scheda Applicazione in alto a sinistra, e dalla lista Oggetto di Avvio sce-
gliete Sub Main() che non sarebbe visibile con la casella spuntata.
Se infatti l’opzione fosse spuntata sarebbero disponibili come oggetti d’avvio solo i form.
Ricordate al termine della Sub Main() ci vuole il codice che fa avviare il Form principale
altrimenti il programma si concluderà con l’esecuzione del solo codice e sullo schermo non
accadrà nulla.
Dim Princ As New Principale

Princ.ShowDialog()
381
ComboBox & DataGridView
Il progetto contenuto nella cartella ComboBox & DataGridView, che fa parte del materiale
allegato al libro, mostra come utilizzare questi due controlli per interrogare un database.
Queste soluzioni possono essere poi applicate in molteplici progetti. Nel nostro esempio
viene utilizzato un database chiamato ComuniItaliani, che contiene informazioni a proposito
di Comuni, Province e Regioni, come ad esempio la popolazione, il codice avviamento po-
stale e altre informazioni generali. Questi dati si trovano nel file “Dump”, e vanno ripristinati
nel server MySQL della vostra macchina. Se avete dei dubbi, consultate l’apposita sezione
di questo libro che tratta del Restore (ripristino) dei dati in un Server SQL. Gli stessi dati
vengono forniti anche in un database di Microsoft Access.
La figura successiva mostra come sono relazionate le varie tabelle del database. Si riferisce
a Microsoft Access ma è valida per qualsiasi tipo di database, il concetto è lo stesso.
All’interno del progetto troviamo diversi Form che sono utilizzati per visualizzare i dati in
svariati modi. Nel Form1 troviamo due ComboBox e una DataGridView. Dal primo Com-
boBox si può selezionare la regione, nel secondo verranno visualizzate le province di quella
specifica regione, mentre nella DataGridView verranno visualizzati i vari comuni apparte-
nenti a quella provincia con i relativi dati informativi. Questo tipo di utilizzo è molto ricor-
rente quando si tratta di visualizzare dati provenienti da più tabelle, che appartengono solo
ad una determinata categoria, escludendo gli altri. Inoltre viene calcolato il totale degli
abitanti per la provincia selezionata.
Il codice completo del Form1 si trova nel box successivo.
Option Explicit On
Public Class Form1

Dim Database As String = "Comuni Italiani"
Dim USERID As String = "root"
Dim Password As String = "VBdazero2019"
Dim StringaConnessione As String = "server=" & ServerName & ";" &
"user id=" & USERID & ";" &
"password=" & Password & ";" &
382
"database=" & Database
Me.MaximizeBox = False
Me.MinimizeBox = False
DataGridView1.Top = 60
DataGridView1.Left = 5
t_Totale.Enabled = False
Using Connessione As New MySqlConnection(StringaConnessione)
Connessione.Open()

Dim SetDati As New DataSet
Dim StringaSQL As String = " SELECT IDREGIONE, " &
" Regione FROM Regioni ORDER BY Regione"
Adattatore.SelectCommand = New MySqlCommand(StringaSQL, Connessione)

Adattatore.Fill(SetDati, "Regioni")
ComboBox1.DataSource = SetDati.Tables("Regioni")
ComboBox1.ValueMember = "IDREGIONE"
ComboBox1.DisplayMember = "Regione"
End Using
ComboBox1.SelectedIndex = -1
End Sub
Private Sub Form1_Resize(sender As Object, e As EventArgs) Handles Me.Resize
Me.StartPosition = StartPosition.CenterScreen
Me.Width = 560
DataGridView1.Width = Me.Width - 30
DataGridView1.Height = Me.Height - 100
If Me.Height < 300 Then Me.Height = 300
End Sub
Private Sub ComboBox1_DropDownClosed(sender As Object, e As EventArgs)

Handles ComboBox1.DropDownClosed
If ComboBox1.SelectedIndex = -1 Then Exit Sub

If ComboBox1.Items.Count = 0 Then Exit Sub
Dim Regione As String = ComboBox1.SelectedValue.ToString

383
Connessione.Open()

Dim SetDati As New DataSet("Province")
Dim StringaSQL As String = " SELECT * FROM Province " &
" WHERE IDREGIONE = '" & Regione & "' "

Adattatore.Fill(SetDati, "Province")
ComboBox2.DataSource = SetDati.Tables("Province")
ComboBox2.ValueMember = "IDPROVINCIA"
ComboBox2.DisplayMember = "Provincia"
End Using
End Sub


Dim Provincia As String = ComboBox2.SelectedValue.ToString
Connessione.Open()

Dim SetDati As New DataSet("Comuni")
Dim StringaSQL As String = " SELECT Istat, Comune, Prefisso, CAP, " &
" CodiceFiscale, Abitanti " &
" FROM Comuni " &
" WHERE IDPROVINCIA = '" & Provincia & "' "

Adattatore.Fill(SetDati, "Comuni")
DataGridView1.DataSource = SetDati.Tables("Comuni")
With DataGridView1
.DefaultCellStyle.Font = New Font("verdana", 7)

.ReadOnly = True
.AllowUserToResizeColumns = False
.Columns("Istat").Width = 60
.Columns("Comune").Width = 200
384
.Columns("Prefisso").Width = 50
.Columns("CAP").Width = 50
.Columns("CAP").DefaultCellStyle.Alignment =
DataGridViewContentAlignment.MiddleCenter
.Columns("CodiceFiscale").Width = 50
.Columns("CodiceFiscale").DefaultCellStyle.Alignment =
End With
With DataGridView1.Columns("Abitanti")
.Width = 80
.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight
.DefaultCellStyle.Format = "##,##"
End With
End Using
Calcola_Totali()
End Sub
Private Sub Calcola_Totali()
'Calcolo dei totali della popolazione
Connessione.Open()

Dim SetDati As New DataSet("Totale")
Dim stringaSQL As String = "SELECT Sum(Comuni.Abitanti) As SommaDiAbitanti " &

" FROM Comuni WHERE IDPROVINCIA = '" & Provincia & "' " &
" GROUP BY Comuni.IDPROVINCIA "
Adattatore.SelectCommand = New MySqlCommand(stringaSQL, Connessione)

Adattatore.Fill(SetDati, "Totale")
t_Totale.TextAlign = HorizontalAlignment.Right
t_Totale.Text = Format(SetDati.Tables("Totale").Rows(0).Item(0), "##,##")
End Using
End Sub
End Class
Ovviamente ometterò la spiegazione del codice già visto in altri progetti. Il codice che ve-
diamo nel box successivo serve per scegliere in che modo il ComboBox deve visualizzare i
dati presenti nella lista. DropDown specifica che l'elenco viene visualizzato facendo click
sulla freccia in giù e che la parte di testo è modificabile. L'utente può pertanto immettere
385
un nuovo valore e non è limitato alla selezione di un valore esistente nell'elenco. Il para-
metro DropDownList invece specifica che l'elenco viene visualizzato facendo click sulla frec-
cia in giù e che la parte di testo non è modificabile. L''utente non può immettere nessun
nuovo valore. Possono essere selezionati solo i valori già presenti nell'elenco. Infine Simple
significa che l'elenco è sempre visibile e che il testo è modificabile. L'utente può pertanto
immettere un nuovo valore e non è limitato alla selezione di un valore esistente nell'elenco.
Il codice che vediamo nel box successivo invece serve a popolare il ComboBox con i nomi
delle regioni. Viene effettuata una connessione al database e quindi viene creata una query
che ordina in ordine alfabetico i nomi delle regioni. La parola chiave Using serve per dichia-
rare delle risorse che verranno eliminate liberando la memoria quando il programma incon-
tra l’istruzione End Using.
Connessione.Open()

Dim SetDati As New DataSet
Dim StringaSQL As String = " SELECT IDREGIONE, " &
" Regione FROM Regioni ORDER BY Regione"

Adattatore.Fill(SetDati, "Regioni")
End Using
Viene assegnato il set di dati risultanti della query alla proprietà DataSource del ComboBox1
per collegare i dati.
Alla proprietà ValueMember viene associato il campo IDREGIONE
Alla proprietà DisplayMember viene associato il nome della regione
In questo modo l’utente seleziona il nome della regione dalla lista, ma in realtà il computer
utilizzerà il contenuto del ValueMembrer per fare i suoi conti.
L’ istruzione che vedete nel box successivo fa in modo che inizialmente nel ComboBox non
sia selezionata nessuna voce, quindi non apparirà nulla nella lista fino a quando l’utente
non farà click sulla freccia alla destra del ComboBox.
386
Quando viene selezionato dall’utente un elemento della lista, e quindi la lista viene chiusa,
viene generato l’evento DropDownClosed del ComboBox1. In questo momento vengono
prima verificate le seguenti condizioni:

Che sia selezionato un elemento della lista. Il valore -1 di SelectedIndex significa che nes-
suna voce della lista è selezionata.
Che nel ComboBox ci sia effettivamente una lista di valori. Questa istruzione significa di
interrompere l’elaborazione se nella lista non è presente nessun elemento.
Questi controlli servono per impedire che venga generata un’eccezione che interrompa l’ela-
borazione del programma.
Quindi viene creata una variabile che immagazzina il valore della scelta del ComboBox.
Tenete presente che SelectedValue si riferisce alla colonna del ComboBox che memorizza il
campo IDREGIONE
Dim Regione As String = ComboBox1.SelectedValue.ToString
Il nome vero e proprio della regione sarebbe disponibile con la seguente riga di comando.
Dim NomeRegione As String = ComboBox1.SelectedItem("Regione").ToString
Che nel nostro caso non serve, ma non si sa mai. A questo punto viene ricreata la connes-
sione e vengono selezionate tramite un comando SQL le province che fanno parte di quella
specifica regione selezionata nel ComboBox1.
Connessione.Open()

Dim SetDati As New DataSet("Province")
Dim StringaSQL As String = " SELECT * FROM Province " &
" WHERE IDREGIONE = '" & Regione & "' "

Adattatore.Fill(SetDati, "Province")
End Using
387
End Sub
Esattamente per quanto visto per il ComboBox1 si può dire la stessa cosa per il ComboBox2.
Il valore del campo IDPROVINCIA è nascosto all’utente che invece vedrà nella lista i nomi
delle province.
Adesso che abbiamo selezionato una regione e quindi il ComboBox2 si è popolato con i nomi
delle province di quella regione, possiamo dalla lista selezionare una provincia, per vedere
la DataGridView popolarsi con i nomi e i dati dei comuni di quella specifica provincia.
Quindi utilizzando l’evento DropDownClosed del ComboBox2 lanceremo la ricerca dei co-
muni collegati a quella provincia.


Connessione.Open()

Dim SetDati As New DataSet("Comuni")
Dim StringaSQL As String = "SELECT Istat, Comune, Prefisso, CAP, " &
" CodiceFiscale, Abitanti " &
" FROM Comuni " &
" WHERE IDPROVINCIA = '" & Provincia & "' "

Adattatore.Fill(SetDati, "Comuni")
Una volta creata la connessione e la query si associa la proprietà DataSource della Data-
GridView al dataset risultante, quindi seguono una serie di istruzioni che servono per dare
un formato alla DataGridView. L’istruzione With serve per non ripetere DataGridView1 in
ogni riga successiva. La maggior parte di queste istruzioni sono intuitive quindi non le ana-
lizzeremo.
DataGridView1.DataSource = SetDati.Tables("Comuni")
With DataGridView1
.DefaultCellStyle.Font = New Font("verdana", 7)

388
.ReadOnly = True
.AllowUserToResizeColumns = False
.Columns("Istat").Width = 60
.Columns("Comune").Width = 200
.Columns("Prefisso").Width = 50
.Columns("CAP").Width = 50
.Columns("CAP").DefaultCellStyle.Alignment =
.Columns("CodiceFiscale").Width = 50
.Columns("CodiceFiscale").DefaultCellStyle.Alignment =
End With
With DataGridView1.Columns("Abitanti")
.Width = 80
.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight
.DefaultCellStyle.Format = "##,##"
End With
End Using
Al termine viene richiamata la routine Calcola_Totali che restituisce la somma degli abitanti
della provincia sommando quelli dei singoli comuni.
Calcola_Totali()
End Sub
Nello specifico, la routine esegue una query che raggruppa tutti i comuni di una provincia
e somma i suoi abitanti. Per la creazione di queste query, e per recuperare il comando SQL
che ne segue, mi faccio aiutare dall’utilità della creazione delle query presente in Microsoft
Access. Per maggiori informazioni consultate il capitolo che tratta dell’argomento nella se-
zione del libro dedicata ad Access.
Private Sub Calcola_Totali()
'Calcolo dei totali della popolazione
Connessione.Open()

Dim SetDati As New DataSet("Totale")
389
Dim stringaSQL As String = "SELECT Sum(Comuni.Abitanti) As SommaDiAbitanti " &
" FROM Comuni WHERE IDPROVINCIA = '" & Provincia & "' " &
" GROUP BY Comuni.IDPROVINCIA "
Quindi recupero il totale degli abitanti e lo metto nel TextBox. In realtà il risultato della
query di raggruppamento è una tabella con un solo record, dove troverete il totale deside-
rato.
Adattatore.SelectCommand = New MySqlCommand(stringaSQL, Connessione)

Adattatore.Fill(SetDati, "Totale")
t_Totale.TextAlign = HorizontalAlignment.Right
End Using
End Sub
Infatti questa istruzione recupera il dato proprio dall’unico record della tabella e lo mette
nel TextBox.
La figura sottostante mostra programma in funzione.

390
Creazione di un database MySQL con Visual Basic.
Questo esercizio, a margine dell’utilizzo di MySQL, è stato appositamente creato nel caso
vi sia la necessità di creare o modificare una struttura direttamente da Visual Basic invece
che dall’utilità WorkBench. In questo modo è possibile creare o eliminare un database, delle
tabelle ed anche delle Query o modificarne la struttura. Non è possibile visionare tutte le
possibilità che vengono offerte da questo strumento perché sono veramente tante.
Il codice completo dell’esercizio lo trovate insieme all’altro materiale allegato al libro.
L’immagine sottostante mostra l’aspetto del progetto che è composto da quattro etichette,
quattro TextBox e due pulsanti uno che permette di creare il database con due tabelle di
prova (una volta compreso il meccanismo potete crearne anche molte di più) ed uno per
eliminare il database creato.
Quando avviate il programma i TextBox risultano già compilati, ma prima di avviare la

creazione del database è anche possibile modificare i parametri quali il nome del database,
il nome del server, l’utente e la password per adattarli al vostro caso.
Quando eseguite l’eliminazione di un database prestate particolare atten-

zione e sinceratevi che sia uno di quelli del quale non ve ne importa nulla.
Non digitate mai nel riquadro il nome di un database importante che contiene
dati sensibili altrimenti verrà cancellato seduta stante.
Per iniziare vengono dichiarate le seguenti variabili:
Option Explicit On
391
Public Class Form1
Dim Comando As MySqlCommand

Dim Connessione As New MySqlConnection
Dim Risultato As Boolean
Dim NomeDatabase As String

Dim NomeServer As String
Dim Utente As String
Dim Password As String
Che poi verranno utilizzate per la connessione, il comando da inviare al Server MySQL e le
credenziali dell’utente che normalmente è root.
Nella routine Form1_Load vengono adottate alcune limitazioni all’inserimento da parte
dell’utente e viene creata una gerarchia nel caso l’utente voglia utilizzare il tasto TAB (ta-
bulatore) dalla tastiera per passare da un TextBox ad un altro durante l’immissione dei dati.
Inoltre, vengono inizializzati i valori dei TextBox.
t_MYSQLServer.MaxLength = 30
t_MYSQLname.MaxLength = 20
t_MYSQLPass.MaxLength = 30
t_MYSQLUser.MaxLength = 20
t_MYSQLServer.TabIndex = 0
t_MYSQLname.TabIndex = 1
t_MYSQLPass.TabIndex = 2
t_MYSQLUser.TabIndex = 3
t_MYSQLServer.Text = "127.0.0.1"
t_MYSQLname.Text = "Prova001"
t_MYSQLPass.Text = "VBdazero2017"
t_MYSQLUser.Text = "root"
End Sub
Questa routine invece serve per generare il database.
NomeDatabase = Trim(t_MYSQLname.Text)
NomeServer = Trim(t_MYSQLServer.Text)
Utente = Trim(t_MYSQLUser.Text)
Password = Trim(t_MYSQLPass.Text)
CreaDb()
If Risultato = False Then

MsgBox("Problemi nella creazione del Database!",
MsgBoxStyle.OkOnly + vbExclamation, "Info Database")
Exit Sub
392
End If
CreaTabellaAgenti()

MsgBox("Problemi nella creazione della Tabella AGENTI!",
Exit Sub
End If
CreaTabellaAliquote()

MsgBox("Problemi nella creazione della Tabella ALIQUOTE IVA!",
Exit Sub
End If
'Inserire qui altri controlli per le eventuali altre tabelle....
'Se tutto è filato liscio....

MsgBox("Operazione Conclusa con successo! Database MySQL creato correttamente!",
End Sub
Private Function CreaDb() As Boolean
StringaConnessione = "server=" & NomeServer & ";" &

"persist security info=True;"
Connessione = New MySqlConnection(StringaConnessione)
Try ' Connessione SERVER MySQL

Connessione.Open()
Connessione.Close()
Risultato = False
Return Risultato
Exit Function
End Try
Dim Comando As New MySqlCommand("CREATE DATABASE " & NomeDatabase, Connessione)
Try
Connessione.Close()'Chiusura Connessione
Risultato = False
Return Risultato
393
Exit Function
End Try
Connessione.Close()
Risultato = True
Return Risultato
End Function
Analizziamo le parti fondamentali:

inserisce i dati che recupera dai TextBox nelle rispettive variabili.
NomeDatabase = Trim(t_MYSQLname.Text)
NomeServer = Trim(t_MYSQLServer.Text)
Utente = Trim(t_MYSQLUser.Text)
Password = Trim(t_MYSQLPass.Text)
Passa l’esecuzione del programma alla funzione CreaDb()
CreaDb()
Nel caso che la creazione del database si concluda con successo la funzione restituisce un
valore Boolean che può essere Vero o Falso che utilizzeremo appunto per verificare il buon
fine delle operazioni. La funzione verrà analizzata più avanti nella spiegazione.
Quando il programma, dopo avere elaborato la funzione CreaDb() ritorna qui controlla se
tutto è andato a buon fine. Se la funzione restituisce il valore False allora si è verificato un
problema da segnalare all’operatore attraverso un preciso messaggio, e il programma ri-
torna alla schermata iniziale.

MsgBox("Problemi nella creazione del Database!",
Exit Sub
End If
Se invece il valore è True allora prosegue con la creazione della prima tabella. Ogni tabella
viene creata attraverso una funzione come nel caso del database.
CreaTabellaAgenti()
E chiaramente esegue gli stessi controlli.

MsgBox("Problemi nella creazione della Tabella AGENTI!",
Exit Sub
End If
Questo codice va ripetuto per ogni successiva tabella o altri oggetti come le Query che
volete creare nel database in modo che in caso d’errore, il programma non si blocca, e
inoltre risponde con un messaggio che indica dove si è verificato l’errore.
394
La singola funzione, che crea il solo database, si presenta come nel riquadro successivo:


Connessione.Open()
Connessione.Close()
Risultato = False
Return Risultato
Exit Function
End Try
Try
Connessione.Close() 'Chiusura Connessione
Risultato = False
Return Risultato
Exit Function
End Try
Connessione.Close()
Risultato = True
Return Risultato
End Function
La dichiarazione ci fa capire che la funzione restituisce un valore tipo Boolean. Notate anche
che nessun parametro viene inviato alla funzione ().
Creo una stringa connessione per il Server MySQL senza specificare il nome di nessun da-
tabase.

Mi connetto:
Qualora ci fossero problemi sulla connessione:

395
Connessione.Open()
Connessione.Close()
Risultato = False
Return Risultato
Exit Function
End Try
La funzione restituisce il valore False e quindi esce e torna alla riga successiva da dove è
stata chiamata.
Se la connessione è avvenuta crea un comando da inviare al server MySQL specifico della
creazione di un database.
Provo ad eseguire il comando e in caso di problemi opera come nel caso fosse fallita la
connessione.
Try
Connessione.Close() 'Chiusura Connessione
Risultato = False
Return Risultato
Exit Function
End Try
Se invece ancora una volta tutto è filato liscio chiude la connessione e restituisce il valore
True.
Connessione.Close()
Risultato = True
Return Risultato
Per quanto riguarda la creazione delle tabelle il concetto è lo stesso eccetto la stringa di
comando.
Creare una tabella è possibile attraverso l’utilità WorkBench, in modo da poter recuperare
il comando SQL da passare al Server con un bel “copia e incolla”, altrimenti sarebbe impos-
sibile ricordarsi tutta la sintassi senza sbagliare una virgola…
Private Function CreaTabellaAliquote()
StringaSQL = "CREATE TABLE `" & NomeDatabase & "`.àliquoteiva` " &
"(ÌDALIQUOTA` int(10) NOT NULL, " &
" `Descrizione` varchar(50) CHARACTER SET utf8 DEFAULT NULL, " &
" `valore` double DEFAULT NULL, " &
" `Detraibile` varchar(1) CHARACTER SET utf8 DEFAULT NULL," &
" Ìndedicibilita` double DEFAULT NULL, " &
396
" `Stampa` varchar(5) CHARACTER SET utf8 DEFAULT NULL, " &
" PRIMARY KEY (ÌDALIQUOTA`)) ENGINE=InnoDB DEFAULT CHARSET=latin1 "
Comando = New MySqlCommand(StringaSQL, Connessione)

Try ' Connessione con il Database remoto
Connessione.Close()
Risultato = False
Return Risultato
Exit Function
End Try
StringaSQL = "ALTER TABLE `" & NomeDatabase & "`.àliquoteiva` ADD INDEX
ÌX_valore`(`valore`)"
Try

Connessione.Close()
Risultato = False
Return Risultato
Exit Function
End Try
Risultato = True
Return Risultato
End Function
Dopo aver creato la tabella la modifica con il comando:
StringaSQL = "ALTER TABLE `" & NomeDatabase & "`.àliquoteiva` ADD INDEX
ÌX_valore`(`valore`)"

Per creare un indice per il campo Valore. Se avete dubbi fate riferimento al capitolo che
tratta di MySQL.
397
Visualizzare gli oggetti di un database MySQL con Visual Basic.
Questo progetto è utile per connettersi ad un server MySQL situato all’interno di una rete
locale di computer, come ad esempio un ufficio o un’azienda oppure sulla macchina dove
state sviluppando, e analizzare la struttura del Server elencando i database presenti, le
tabelle e i campi.
Il progetto presenta tre controlli ListBox. Nella lista di sinistra, a connessione avvenuta,
vengono elencati i database presenti sul server. In quella centrale, dopo aver selezionato
un qualsiasi database della lista di sinistra, vengono visualizzate le tabelle, e infine nella
lista di destra, i campi presenti nella tabella selezionata. Quando è in azione il progetto ha
questo aspetto.
Si inizia importando queste due librerie che serviranno per accedere agli oggetti della rete
e di MySQL.
Imports System.Net
Quindi si dichiara le variabili che devono essere accessibili da ogni procedura presente
nell’oggetto form, identificato dalle dichiarazioni Public Class ed End Class.
Public Class Form1

Dim ServerName As String
Dim USERID As String
398
Dim IPAddr As String
Il codice che si trova nell’evento Load del form viene eseguito per primo all’avvio del pro-
gramma. Troviamo subito la chiamata (Rete()) ad una procedura, che si trova in fondo al
codice, che recupera il nome sulla rete e l’indirizzo IP del computer. Quindi il programma
eseguirà questa procedura, poi continuerà l’esecuzione fino all’ultima istruzione che ve-
diamo nel codice sottostante, e attenderà il verificarsi di qualche evento. Assegna inoltre la
password, ovviamente dovete modificarla con quella del vostro server MySQL, e il nome
dell’utente, che di solito e l’amministratore del server (root), e li fa apparire nei due rispet-
tivi TextBox. Per connettersi al server fate click sul pulsante Connetti presente nel form.
t_NomeRete.Enabled = False
Rete()
USERID = "root"
Password = "VBdazero2019"
t_Utente.Text = USERID
t_Password.Text = Password
End Sub
Nell’evento Click del pulsante si trova il codice che vedete nel box successivo.
Private Sub p_Connessione_Click(sender As Object, e As EventArgs)

Handles p_Connessione.Click
ListBox1.Items.Clear()
USERID = Trim(t_Utente.Text)
Password = Trim(t_Password.Text)
ServerName = Trim(t_IndirizzoIP.Text)

"password=" & Password
Try
Connessione.Open()
Exit Sub
End Try
Dim ListaDatabase As DataTable = Connessione.GetSchema("Databases")
For Each Riga As DataRow In ListaDatabase.Rows
ListBox1.Items.Add(Riga("Database_Name"))
399
Next
End Using
End Sub
Vengono per prima cosa svuotate le ListBox da un eventuale contenuto precedente, dopo
di che viene creata la stringa di connessione al server MySQL, e quindi effettuata la con-
nessione. L’istruzione Using in Visual Basic è in realtà un blocco di istruzioni con un com-
portamento del tutto analogo a Try… Catch ed End Try. Si compone in tre fasi: acquisizione,
controllo ed eliminazione di una risorsa. La prima parte acquisisce una variabile che fa
riferimento ad una risorsa di sistema e la inizializza. L’istruzione Using può acquisire una o
più risorse di sistema; tutto ciò che si trova fra Using è End Using rappresenta l’utilizzo e
l’accesso alla risorsa e l’esecuzione delle necessarie azioni, mentre End Using elimina le
risorse sotto il controllo del blocco Using.
Viene quindi utilizzato un blocco Try… Catch ed End Try per gestire un eventuale problema
che si verifichi durante la connessione al database come ad esempio un Time Out, ovvero
un periodo di attesa troppo lungo dovuto al fatto che probabilmente il Server MySQL non
viene trovato. Quindi viene creato un oggetto tabella e viene detto alla connessione di
restituire l’elenco dei database.
Quindi il contenuto della tabella viene passato alla ListaBox1.
Next
Quello che segue è il codice che si trova nell’evento SelectedIndexChanged del ListBox1.
Tutte le volte che viene fatto click su una voce presente in questa lista, viene eseguita una
query che elenca le tabelle del database selezionato, e il risultato viene elencato nel List-
Box2.
Private Sub ListBox1_SelectedIndexChanged(sender As Object, e As EventArgs)

Handles ListBox1.SelectedIndexChanged
Dim Database As String = ListBox1.Items(ListBox1.SelectedIndex)

Try
Connessione.Open()
400
Exit Sub
End Try
Dim databaseSchema As DataTable = Connessione.GetSchema("Tables")
For Each Riga As DataRow In databaseSchema.Rows

ListBox2.Items.Add(Riga("Table_Name"))
Next
End Using
End Sub
Con questa istruzione si acquisisce le tabelle dello specifico database dalla connessione.
Dim databaseSchema As DataTable = Connessione.GetSchema("Tables")
Quindi si popola la ListBox2 con i nomi della tabelle.
For Each Riga As DataRow In databaseSchema.Rows

ListBox2.Items.Add(Riga("Table_Name"))
Next
Il codice che troviamo nell’evento SelectedIndexChanged del ListBox2 è sostanzialmente

simile a quello che vediamo nell’evento analogo del ListBox1.


Dim Tabella As String = ListBox2.Items(ListBox2.SelectedIndex)

Try
Connessione.Open()
Exit Sub
End Try
Dim Comando As New MySqlCommand("SELECT * FROM " & Tabella, Connessione)

Dim Lettore As MySqlDataReader = Comando.ExecuteReader()
Dim schemaTable As DataTable = Lettore.GetSchemaTable()
401
For Each Riga As DataRow In schemaTable.Rows
ListBox3.Items.Add(Riga(0))
Next
End Using
End Sub
Per accedere alla lista dei campi di una tabella è necessario creare un comando che esegue
una query che restituisce il contenuto di una tabella. Quindi attraverso un MySqlDataReader
eseguo il comando creato nella riga precedente. A questo punto creo una tabella con i nomi
dei campi.
Dim Comando As New MySqlCommand("SELECT * FROM " & Tabella, Connessione)

La routine successiva serve per acquisire il nome del vostro computer sulla rete, e il suo
indirizzo IP, il secondo è necessario per effettuare la connessione al server MySQL. Ovvia-
mente, è possibile collegarsi anche a server locati su altre macchine semplicemente inse-
rendo un indirizzo IP valido nel TextBox presente sul Form.
Private Sub Rete()
Dim NomeSullaRete As String

Dim IndirizzoIP As String
Try
NomeSullaRete = Dns.GetHostName()
'oppure
'NomeSullaRete = My.Computer.Name
Catch Errore As Sockets.SocketException

MsgBox("Problemi sul Socket di Rete:" & Errore.Source & vbLf & Errore.Message,
MsgBoxStyle.OkOnly + vbExclamation, "Errore")
Catch Errore As Exception
MsgBox("Problemi sulla rete " & Errore.Source & vbLf & Errore.Message,
End Try
Try
IndirizzoIP = Dns.GetHostByName(NomeSullaRete).AddressList(0).ToString()

MsgBox("Problemi sul Socket di Rete:" & Errore.Source & vbLf & Errore.Message,
End Try
t_IndirizzoIP.Text = IndirizzoIP
t_NomeRete.Text = NomeSullaRete
End Sub

402
t_Password.Text = ""
End Sub
End Class
La parte di codice presente fra i due blocchi Try… End Try serve per intercettare le eccezioni
che si possono verificare quando si lancia un comando che interroga la rete tipo:
IndirizzoIP = Dns.GetHostByName(NomeSullaRete).AddressList(0).ToString()
403
Il Backup dei dati con MySQL.

Questa funzionalità assume un’importanza di primo piano nella gestione dei dati di un da-
tabase, soprattutto per quanto riguarda la sicurezza, intesa come rischio di perdita dei dati.
Un database ha di solito un’importanza strategica in un’azienda o in qualsiasi altra organiz-
zazione, perché ospita dati la cui perdita potrebbe rivelarsi disastrosa.
Quindi è necessario periodicamente provvedere ad effettuare una copia di sicurezza dei dati
stessi, e salvarla su un supporto che possa essere rimosso dalla macchina che funge da
server, perché in caso di qualsiasi calamità naturale, furti, incendi, guasti o quant’altro,
l’impossibilità di rientrare in possesso dei dati risulterebbe catastrofica per l’organizzazione.
Nel nostro caso è sufficiente fare una copia dei dati, ad esempio, in una memoria di massa
rimovibile tipo USB, in modo che nel caso di un’accidentale perdita di dati, guasto al com-
puter o quant’altro, sia possibile recuperare il contenuto del database.
Come prima cosa, per provvedere al backup del dati, utilizzate Workbench e connettetevi
al server facendo click sulla connessione.
Quindi fate click sul collegamento Data Export come nella figura sottostante.
Quindi procediamo alla selezione dei database dei quali vogliamo effettuare il backup dei
dati. Se fate click sul nome del database vedrete nella lista di destra l’elenco delle tabelle e
delle view presenti; nel caso si voglia effettuare dei backup parziali è anche possibile esclu-
derne una o più dall’operazione.
Se non vengono fatte selezioni da parte dell’utente, l’utilità di esportazione dei dati include
automaticamente tutti gli oggetti (Tabelle e View) nel backup, altrimenti è possibile sele-
zionare con gli appositi pulsanti (Select View e Select Tables) solo una delle due tipologie.
Per ritornare alla selezione completa degli oggetti è necessario togliere e poi rimettere il
segno di spunta accanto al rispettivo database nella lista di sinistra.
404
A questo punto è possibile scegliere fra due tipologie di backup. La prima, Export to Dump
Project Folder, crea una cartella (solitamente, se non viene specificato diversamente,
dentro la cartella Documenti del vostro computer) dove all’interno troverete tanti file quante
sono le tabelle contenute in ogni database, con i relativi dati e struttura. In realtà sono dei
semplici file di testo leggibili anche con il blocco note di Windows.
La seconda opzione, Export to Self-Contained File, crea un singolo file dove dentro si
trovano tutti i dati di tutti i database. Personalmente utilizzo questa impostazione, però
nessuno vi vieta di adottare la prima opzione.
Volendo è possibile cambiare anche il nome del file di backup. Vi consiglio di lasciare il nome
che viene dato in automatico dal programma in quanto contiene la data del backup che
potrebbe risultare utile quando, ad esempio, vengono fatte spesso operazioni di backup e
volete riconoscere al volo quale file corrisponde ad una data specifica. Spesso non si elimina
immediatamente i file dei backup precedenti, ma vengono conservati anche per alcuni
giorni, a secondo ovviamente del tipo di lavoro svolto. Per uno sviluppatore i database
vengono utilizzati quasi esclusivamente come supporto allo sviluppo e spesso contengono
dati fittizzi, quindi non è strettamente necessario effettuarne una copia tutti i giorni.
Un’ultima opzione e quella che riporta Include Create Schema che serve, in caso di ripristino
dei dati, per ricreare la struttura del database nel caso non fosse assente sul server. (caso
di dati completamente persi) o di installazione ex-novo di un server MySQL. Quindi vi con-
siglio di spuntare questa casella.
Per far partire la procedura fate click sul pulsante Start Export in basso a destra nella
finestra. Nel nostro caso, come utilizzatori di MySQL a livello di sviluppo di programmi, non
è necessario ricorrere spesso al backup del dati. Chi invece lo utilizza in ambito lavorativo,
per motivi di sicurezza, ne fa un utilizzo piuttosto frequente, almeno una volta al giorno.
Restore
Si definisce così l’operazione di ripristino dei dati nella loro posizione a seguito di un pro-
blema. Se a causa di una nuova installazione del server MySQL su una macchina di sviluppo,
405
oppure un ripristino dati a seguito di un eliminazione maldestra, o anche un ripristino com-
pleto a causa della reinstallazione del sistema operativo Windows, dovete riportare i dati
esattamente dov’erano, effettuate questi passaggi.
Fate click sul collegamento Data Import/Restore nella parte sinistra della finestra. Sele-
zionate l’opzione Import from a Self-Contained File (se utilizzate questo tipo di backup)
quindi cercate il file da dove desiderate ripristinare i dati con l’apposita finestra, finché il
suo nome non si vede nel rispettivo riquadro (punto3 della figura successiva). Quindi fate
partire la procedura con il pulsante Start Import in basso a destra nella finestra.
Migrazione dei dati.

La migrazione di dati è un’operazione che si effettua fra due server di MySQL posti su
macchine diverse, per acquisire da un server i dati presenti sull’altro, in pratica un trasfe-
rimento di dati. (Ovviamente si tratta di una copia e, a operazione conclusa, i dati saranno
presenti su entrambi i server) È molto utile anche per acquisire dati da fonti diverse da
MySQL come ad esempio un database di Access, Microsoft SQL Server, PostgreSQL, ecc. o
qualsiasi tipo di database ODBC.
Nel nostro esempio migreremo dei dati fra due Server MySQL che server si trovano su
macchine diverse nella stessa rete locale come ad esempio in un’azienda.
La migrazione dei dati può essere avviata indifferentemente da una macchina o dall’altra
coinvolte nell’operazione, purché non confondiate la sorgente dei dati (source) con il Target
(destinazione o bersaglio) altrimenti rischiate di compromettere i dati stessi. Fate quindi
una bel backup di entrambi i server prima di iniziare la migrazione dei dati.
Iniziamo avviando dal Menu di avvio di Windows l’utilità Workbench e dalla schermata ini-
ziale verificate innanzitutto che sia presente la connessione al server al quale desiderate
accedere. Per esempio nella figura successiva si può vedere che sono presenti due connes-
sioni, Local Instance MySQL80 e l’altra identificata come UFFICIO1. Questi ovviamente sono
406
nomi che possono essere assegnati dall’operatore in modo da riconoscere facilmente a quale
server venite connessi. Se la connessione al secondo server non è presente sulla schermata
allora dovete provvedere a crearla. Se invece è già presente andate al passaggio succes-
sivo. Per creare la connessione fate click dove mostra la figura sottostante.
Inserite un nome che possa identificare la connessione, nel mio caso è UFFICIO1, ma potete
effettuare la scelta del nome che ritenete più opportuno, quindi inserite l’indirizzo IP del
macchina dove risiede questo server. Se non siete a conoscenza di questo parametro an-
date sulla macchina che funge da server e digitate sul prompt dei comandi di Windows il
comando ipconfig. Per accedere al prompt andate sul Menu di avvio di Windows e cercate
la voce Sistema Windows. Quindi selezionate Prompt dei comandi.
407
Memorizzate la password di accesso al server, in modo da non doverla digitare ad ogni
nuova connessione, ed effettuate un test della connessione per verificare che tutto funzioni
come si deve prima di fare click sul tasto OK in basso a destra nella finestra.
Una volta creata la nuova connessione fate click sul pulsante che esegue la migrazione dei
dati come mostra la figura successiva.
Il prossimo passaggio è un sommario dei passaggi che verranno effettuati per portare a
termine la migrazione dei dati. Fa un riepilogo dei prerequisiti necessari per iniziare il tra-
sferimento. Fate click sul pulsante Start Migration in basso nella finestra.
408
Questo passaggio serve per determinare quale è il server che rappresenta la sorgente dei
dati, ovvero da dove prendiamo i dati per trasferirli altrove. Dovete selezionare innanzitutto
la tipologia del database di partenza, che nel nostro caso è MySQL. Dalla lista al punto 1 è
possibile scegliere anche altre tipologie di sorgente, come ad esempio un file di Microsoft
Access oppure altri database con connessione ODBC (Open DataBase Connectivity), che
rappresenta un’interfaccia standard per il collegamento a qualsiasi database che supporta
questo tipo di connessione.
Al punto 2 dovere selezionare la connessione per accedere al database sorgente dei dati.
Questa connessione va creata precedentemente, come abbiamo visto all’inizio della proce-
dura, dalla pagina inziale dell’utilità WorkBench e memorizzata nella lista delle connessioni
che appare sempre nella pagina inziale.
Qualora vi dovesse chiedere una password, memorizzatela con pulsante Store in Vault, e
quindi fate una test della connessione col pulsante in basso a sinistra.
Se tutto va bene procediamo facendo click sul pulsante Next in basso a destra.
La figura successiva è esattamente uguale a quella precedente, e dunque è necessaria una
certa attenzione per evitare di confondere la Sorgente (source) dei dati con la Destinazione
(target) perché potrebbe creare non pochi problemi.
Come mostra la figura successiva, dovete scegliere la Destinazione dei dati, nel nostro caso
l’istanza locale del server MySQL ovvero la macchina verso dove state eseguendo la migra-
zione. In pratica i dati verranno acquisiti dal Server etichettato come UFFICIO1 e verranno
trasferiti nella macchina dove state operando il trasferimento. Si può fare anche il contrario
senza nessun problema. Questa utilità è particolarmente versatile.
Anche stavolta eseguite il test della connessione per verificare che tutto sia a posto prima
di andare al passaggio successivo, facendo click sul pulsante NEXT in basso a destra nella
finestra.
409
Il prossimo passaggio, che non riportiamo, verifica le connessioni e recupera la lista dei
database sul server Sorgente, quindi se tutto va come dovrebbe andare fate click sul pul-
sante Next in basso a destra.
Selezionate i database che desiderate migrare. Trasferite solo i database che conoscete
molto bene, ignorando quelli del sistema. Nel nostra esempio sono stati selezionati i data-
base biblioteca e world. Quindi fate click sul pulsante Next in basso nella finestra.
Anche il passaggio successivo e semplicemente informativo e quindi verrà saltato. Fate click
ancora sul pulsante Next.
È possibile eseguire delle migrazioni anche parziali delle tabelle o altri oggetti come le View
presenti nei database selezionati. Se desiderate traferire solo alcune tabelle fate click sul
pulsante Show Selection e selezionate gli oggetti che vi interessano, prima di andare al
passaggio successivo con il solito pulsante Next.
410
Anche al prossimo passaggio, se tutto procedere senza intoppi, potete fare click sul pulsante
Next. Procedete ancora fino a quando sullo schermo non compare qualcosa del genere, che
vi rammenta che al momento non ci sono problemi di sorta. Quindi procedete ancora con
Next.
Se il database non è presente sul server di destinazione, lasciate le cose come stanno e
fate click sul pulsante Next.
411
Quindi ancora Next, e a questo punto sono stati generati i comandi che procederanno alla
migrazione dei dati. Fate ancora click sul pulsante Next.
Lasciate queste impostazioni così come le vedete e continuate come al solito con Next.
A questo punto ancora una finestra che non riportiamo mostra il risultato delle operazioni.
Fate click sul pulsante Finish.
Adesso dalla schermata principale di Workbench andate a controllare nella finestra Schemas
se i database sono tutti dove dovrebbero essere.
412
Gli errori in Visual Basic
Sostanzialmente gli errori possono essere di tre tipi:
• Errori di Sintassi
• Errori di concetto ovvero il programma a livello di sintassi è perfetto ma non dà il
risultato giusto perché, ad esempio, ho sbagliato ad assegnare due variabili con-
fondendole fra loro
• Errori di Runtime o Eccezioni da gestire
Per quanto riguarda il primo tipo di errori questi vengono prontamente segnalati in fase di
digitazione del codice e quindi non li tratteremo nello specifico. Visual Basic in generale dà
dei suggerimenti che invece di risolvere il problema spesso lo complicano ulteriormente,
soprattutto per il fatto che i messaggi di errore sono incomprensibili all’utente medio. Di-
ciamo che ha un modo tutto suo di esternare quelli che sono gli errori che trova sulla sua
strada.
Alcuni di questi errori derivano anche da librerie non incluse correttamente nel progetto con
il comando Imports e questo è capibile per il fatto che un codice copiato e incollato che in
un altro progetto funzionava benissimo, in un nuovo progetto viene sottolineato in rosso.
Quindi verificate innanzitutto questa possibilità. Ad esempio se non importate le librerie per
accedere ai dati di MySQL il progetto non funzionerà mai.
Noi però ci concentreremo sugli errori che possono comparire in Runtime ovvero in fase di
esecuzione di un programma e su come si gestiscono le eccezioni, anche se già qualcosa
abbiamo visto nel codice d’esempio incluso nel libro.
Come mostra la figura sottostante durante l’esecuzione di un programma può accadere che
si blocchi e mostri un messaggio dal contenuto incomprensibile.
413
A prima vista è abbastanza improbabile capire cos’è accaduto veramente e dove si trovi
l’errore, anche perché Visual Basic ha il vizio di scrivere messaggi come: “Riferimento a un
oggetto non impostato su un’istanza di oggetto”. Mi capite che è un messaggio perlomeno
strano perché non svela la vera natura dell’errore.
Nel nostro caso per fortuna la soluzione è abbastanza semplice in quanto si vede che il
nome del campo invocato nell’istruzione:
.Columns("IBN").HeaderText = "ISBN"
È sbagliato perché doveva essere:
.Columns("ISBN").HeaderText = "ISBN"
Quindi sospendete l’esecuzione del programma ed effettuate le dovute correzioni.

In quest’altro caso invece il messaggio d’errore è molto più chiaro con la variante che l’er-
rore si verifica in un punto ben diverso di dove si trova la sorgente dell’errore.
Come si vede è nell’istruzione SQL che è stata chiamata erroneamente la tabella Libi invece
che Libri. Però grazie al fatto che qui qualche suggerimento Visual Basic ce l’ha dato è
possibile risolvere felicemente anche questa incombenza.
In altri casi però, quando si opera sulle variabili, queste possono assumere dei valori non
corretti e quindi generano errori o risultati indesiderati. In questo caso è necessario andare
a caccia dell’errore riga per riga ed analizzare il codice.
Per fare questo può essere utile la finestra di Controllo immediato detta anche Finestra
di comando che appare sullo schermo con la combinazione da tastiera CTRL+ALT+A op-
pure dal menu Visualizza alla voce Altre finestre.
414
Supponiamo di avere fra le mani un programma che non ne vuole sapere di dare il risultato
giusto. Entrate nel codice e fate click in corrispondenza della riga dove volete che il pro-
gramma si fermi per visionare che valori assumono le singole variabili.
Verrà piazzato un punto rosso, che si rimuove semplicemente facendo click una seconda
volta nello stesso punto, dove il programma si arresterà momentaneamente per premet-
tervi di eseguire alcune operazioni di controllo.
Avviate il programma è l’elaborazione si interromperà nel punto desiderato.
A questo punto posso visionare il valore delle variabili in gioco i due modi: o porto il pun-
tatore del mouse in prossimità della variabile sulla stessa riga del punto d’interruzione,
oppure digito un punto interrogativo, seguito dal nome della variabile, direttamente nella
finestra di comando premendo il tasto Invio dalla tastiera.
415
Tenete presente però che la variabile Risultato non è ancora stata calcolata se il punto
d’interruzione è sulla stessa riga.
In questo modo possiamo fare le nostre valutazioni in merito al valore assunto dalle altre
variabili coinvolte nell’operazione. Per andare all’istruzione successiva e continuare con il
flusso del codice premete il tasto F11 dalla tastiera.
Oppure F5 per continuare il programma fino alla fine o al prossimo punto d’interruzione.
416
Trappole per errori
Ci sono però degli errori diversi da quelli che abbiamo visto finora e che possono generare
un’eccezione bloccare e quindi terminare il programma durante l’elaborazione. Non credo
che sia bello vedere sullo schermo un messaggio d’errore senza senso per l’utente che sta
lavorando a quel programma.
In questo caso è necessario creare una trappola per errori con la funzione Try, nella zona
dove si suppone che in fase di Runtime si possa generare un errore e quindi terminare in
modo non gradito un programma. È possibile così scegliere se visualizzare un messaggio
d’errore oppure riprendere l’esecuzione del programma da un altro punto.
L’utilizzo classico di questa funzionalità è ad esempio sulla connessione al database, dove
può venire impartito un comando di aggiornamento dei dati o cose di questo genere qui.
Provo a aprire la connessione al database
Try
Connessione.Open()
Se non si verificano errori tutto finisce qui e il programma continua l’esecuzione dall’istru-
zione successiva ad End Try
Altrimenti continua l’esecuzione senza fermarsi dalle istruzioni che trova dopo la parola
chiave Catch fino ad End Try e poi, se non trova un’istruzione adeguata che lo rimanda da
un’altra parte del programma, continua dopo l’istruzione End Try come nel caso precedente.
End Try
Nelle istruzioni di esempio viene creata una variabile Eccezione che conterrà l’errore che
viene generato dal sistema recuperato dalla libreria System.Exception.
L’istruzione che segue serve per visualizzare un messaggio sullo schermo che riporta il tipo
d’errore.
Exit Sub serve per uscire dalla ruotine se dopo End Try si trovano delle istruzioni che in
caso d’errore non devono essere eseguite. In questo specifico caso se la connessione fallisce
il programma non deve eseguire ulteriori istruzioni ma deve semplicemente uscire dalla
routine.
Nella circostanza seguente invece viene eseguito un comando su un database MySQL e in
questo caso l’eccezione non deriva da System.Exception a ma da MySqlException ovvero dalla
connessione MySQL.
Try
ObjAdp1.Update(ObjDataSet1, "DocumentiTestata")
ObjDataSet1.AcceptChanges()

ObjConn.Close()
Exit Sub
End Try
417
Informazioni sul sistema
Può essere utile, a volte, avere informazioni a proposito di alcune caratteristiche del com-
puter e, anche se Visual Basic dispone di strumenti molto più potenti di quelli che vediamo
in questo esempio, questo progetto può essere un buon punto di partenza per le informa-
zioni di base. Di solito i programmatori inseriscono queste istruzioni nel menu (?) che ab-
biamo visto nella parte del libro che tratta dei FormMDI e dei progetti con più finestre.
Il progetto presenta solo un ListBox come controllo dove verranno visualizzate le informa-
zioni, ma era possibile utilizzare anche altri controlli per visualizzare le informazioni sullo
schermo.
Il codice del programma è riportato nel riquadro sottostante.
Option Explicit On
Imports System.IO
Imports System.Net
Public Class Form1
Me.Text = "Informazioni di sistema"

Dim NomeComputer As String = My.Computer.Name
Dim SistemaOperativo As String = My.Computer.Info.OSFullName
418
Dim PercorsoProgramma As String =
Dim MemoriaFisicaDisponibile As Double = My.Computer.Info.AvailablePhysicalMemory

Dim MemoriaVirtualeDisponibile As Double = My.Computer.Info.AvailableVirtualMemory
Dim MemoriaFisicaTotale As Double = My.Computer.Info.TotalPhysicalMemory

Dim MemoriaVirtualeTotale As Double = My.Computer.Info.TotalVirtualMemory
Dim Schermo As String = My.Computer.Screen.WorkingArea.Size.ToString
Dim NomeSullaRete As String
Try
NomeSullaRete = Net.Dns.GetHostName()

MsgBox("Problemi sul Soket di Rete:" & Errore.Source & vbLf & Errore.Message,
End Try
Dim IndirizzoIP As String
Try
IndirizzoIP = Net.Dns.GetHostByName(NomeSullaRete).AddressList(0).ToString()

MsgBox("Problemi sul Soket di Rete:" & Errore.Source & vbLf & Errore.Message,
End Try
ListBox1.Items.Add("Nome Computer: " & NomeComputer)

ListBox1.Items.Add("Sistema Operativo: " & SistemaOperativo)
ListBox1.Items.Add("Nome Utente: " & NomeUtente)
ListBox1.Items.Add("Percorso Programma: " & PercorsoProgramma)
ListBox1.Items.Add("Memoria Fisica Disponibile: " &
Format(MemoriaFisicaDisponibile, "##,##") & " bytes")
ListBox1.Items.Add("Memoria Fisica Totale: " &
Format(MemoriaFisicaTotale, "##,##") & " bytes")
ListBox1.Items.Add("Memoria Virtuale Disponibile: " &
Format(MemoriaVirtualeDisponibile, "##,##") & " bytes")
ListBox1.Items.Add("Memoria Virtuale Totale: " &
Format(MemoriaVirtualeTotale, "##,##") & " bytes")
ListBox1.Items.Add("Attuale Risoluzione Schermo: " & Schermo)
ListBox1.Items.Add("Nome sulla Rete : " & NomeSullaRete)
ListBox1.Items.Add("Indirizzo IP: " & IndirizzoIP)
End Sub
End Class
Disegnare con Visual Basic.
419
Se disegnare è stato il vostro sogno fin da bambini, con Visual Basic vi potete sbizzarrire.
In questo capitolo vedremo insieme le fondamenta del disegno e, dato che si tratta di un
argomento particolarmente vasto, non è possibile esporre tutte le sfumature di questa ca-
ratteristica in poche pagine. Possiamo invece partire da un insieme di caratteristiche da
offrire come materiale di spunto per affrontare poi eventuali approfondimenti, nel caso che
abbiate necessità di sviluppare uno specifico programma o app che riguardi quest’argo-
mento.
Innanzitutto chi dispone di una versione precedente alla 2017 di Visual Basic.NET deve
importare nello spazio dei nomi questa libreria altrimenti il codice non funzionerà.
Imports System.Drawing
Con le versioni 2017 e 2019 non è necessario in quanto è già inclusa nei riferimenti.
Adesso vediamo quali sono gli strumenti che Visual Basic ci mette a disposizione.
Disegnare una Linea

Il primo elemento da dove partiremo per affrontare la panoramica delle caratteristiche del
disegno è la linea. Prima di tutto è necessario dichiarare un oggetto Graphics che rappre-
senta una classe di oggetti grafici specifici per il disegno.
Dim Disegno As Graphics = CreateGraphics()
Quindi dichiarare un oggetto Brushes che rappresenta un pennello ovvero lo spessore e il

colore con il quale verrà disegnata la linea sullo schermo.
Dim Penna = New Pen(Brushes.Black, 2)
In teoria la preparazione è terminata qui inserendo questa linea di codice (si tratta di un
esempio).
Disegno.DrawLine(Penna, 10, 400, 800, 400)
La linea sarà disegnata sul vostro schermo. La sintassi è la seguente:
DrawLine(Penna, Coordinata x di inizio, coordinata y di inizio,

coordinata x di fine, coordinata y di fine)
in pratica il computer vuole conoscere le coordinate del punto di partenza e del punto di
arrivo della linea che deve disegnare. In questo caso le coordinate sono statiche mentre,
se voglio variare durante l’esecuzione del programma i valori di inizio e fine, basta dichia-
rare quattro variabili integer e passarle come parametri alla funzione DrawLine.
Dim X1 As Integer = 10
Dim X2 As Integer = 800
Dim Y1 As Integer = 400
Dim Y2 As Integer = 400
Disegno.DrawLine(Penna, X1, Y1, X2, Y2)
Nel codice allegato al libro troverete questo ed altri esempi. Quello che segue è un pro-
gramma che disegna una griglia di linee e gli assi cartesiani.
420
Public Class Form1
Me.StartPosition = FormStartPosition.CenterScreen
End Sub

Dim Penna2 = New Pen(Brushes.LightGray, 1)
For x = 10 To 810 Step 5
Disegno.DrawLine(Penna2, x, 10, x, 810)
Next x
For y = 10 To 810 Step 5
Disegno.DrawLine(Penna2, 10, y, 810, y)
Next y
'Disegna gli assi
'Asse delle X
'asse delle y
End Sub
End Class
Questa parte di codice disegna delle linee parallele distanziate di 5 twip parallele all’asse
delle ordinate (Y)
For x = 10 To 810 Step 5
Disegno.DrawLine(Penna2, x, 10, x, 810)
Next x
Questa parte invece disegna delle linee parallele all’asse delle ascisse(X)
For y = 10 To 810 Step 5
Disegno.DrawLine(Penna2, 10, y, 810, y)
Next y
421
Disegnare un Rettangolo
Per disegnare un rettangolo su un oggetto Form di Visual Basic.NET esistono sostanzial-
mente due metodi. Il primo metodo disegna il rettangolo partendo da una coppia di coor-
dinate che rappresentano il punto di partenza, in pratica l’angolo in alto a sinistra del ret-
tangolo, e da due dimensioni, una larghezza e un’altezza.
DrawRectangle(Pennello, X, Y, Larghezza, Altezza)
Parametri:
Pennello: Oggetto Pen che determina il colore, la larghezza e lo stile del rettangolo.
X (Int32) Coordinata X dell'angolo superiore sinistro del rettangolo da disegnare.
Y (Int32) Coordinata Y dell'angolo superiore sinistro del rettangolo da disegnare.
Larghezza (Int32) Larghezza del rettangolo da disegnare.
Altezza (Int32) Altezza del rettangolo da disegnare.
Esempio di codice:

Disegno.DrawRectangle(Penna, 150, 150, 200, 50)
Il secondo metodo disegna il rettangolo partendo da una struttura Rectangle, in pratica

memorizza un insieme di quattro numeri interi che rappresentano la posizione e la dimen-
sione di un rettangolo. Questa struttura dispone di una valanga di proprietà che non elen-
cheremo in quanto, oltre allo spazio necessario per tale disamina, esula dallo scopo di que-
sto libro elencare tutta una serie infinita di caratteristiche che difficilmente utilizzerete an-
che in minima parte nei vostri programmi.
Se desiderate maggiori informazioni sull’argomento, dopo che avete raggiunto una certa
abilità con gli esempi esposti in questo libro, vi consiglio di utilizzare la documentazione
ufficiale, assolutamente inadatta a chi è alle prime armi, all’indirizzo https://docs.micro-
soft.com/it/dotnet/api/ e dalla lista infinita cercate lo spazio dei nomi, o libreria chiamatela
come volete, System.Drawing. Sono elencate tutte le Classi, le Strutture, metodi ecc. che
vi permetteranno di orientarvi in questa “giungla”. Ricordate, per precisione, di selezionare
in alto a sinistra il vostro .NET Framework (attualmente l’ultima versione è la 4.8), e quando
visualizzate gli esempi di codice impostare il linguaggio a Visual Basic, altrimenti troverete
solo esempi in Visual C#.
DrawRectangle(Pennello, Rettangolo)
Pennello: Oggetto Pen che determina il colore, la larghezza e lo stile del rettangolo.
Rettangolo: Struttura Rectangle che rappresenta il rettangolo da disegnare.

Dim Pennello As New Pen(Color.Black, 3)
Dim Rettangolo As New Rectangle(200, 200, 320, 150)
Disegno.DrawRectangle(Pennello, Rettangolo)
Oppure:

422
Dim Pennello = New Pen(Brushes.Black, 2)
Dim Rettangolo As New Rectangle(New Point(200, 200), New Size(320, 150))
Dichiaro la classe Graphics che fornisce i metodi per disegnare oggetti in un Form. Per
attivare l’oggetto devo chiamare il metodo CreateGraphics().
Definisco il pennello, ovvero il tratto con il quale deve essere disegnato il rettangolo, nel
nostro caso viene specificato il colore e lo spessore del tratto.
Definisco una struttura Rectangle con le sue caratteristiche principali, coordinate del punto
di partenza ovvero l’angolo in alto a sinistra, la larghezza e l’altezza.
Oppure posso dichiararla così:
Questi parametri possono essere passati in modo indiretto sostituendo i numeri statici con
delle variabili (Integer) che possono variare all’interno del programma. Ad esempio:
Dim Rettangolo As New Rectangle(X, Y, Larghezza, Altezza)
Al termine disegno il rettangolo sullo schermo.
Se desiderate riempire il rettangolo con un colore aggiungete questa linea di codice.
Disegno.FillRectangle(Brushes.Green, Rettangolo)
Sostanzialmente queste due righe sono uguali:

Dim Pennello = New Pen(Brushes.Black, 2)
Disegnare un Poligono.
Per quanto riguarda un poligono, una struttura che è caratterizzata da più angoli, quindi
più lati, è necessario definire una matrice di punti tipo Point. Ogni punto contiene la coor-
dinata del punto stesso sullo schermo e si dichiara semplicemente:
Dim Punto1 As New Point(150, 100)
Ogni coppia di punti consecutivi specifica un lato del poligono e, se l’ultimo punto e il primo
punto definiti nella matrice non coincidono, creano l’ultimo lato del poligono.
Per creare una matrice di punti definisco ogni punto e poi li associo alla matrice

423
Dim MatricediPunti As Point() = {Punto1, Punto2, Punto3, Punto4}
Quindi concludo disegnando il poligono:

Disegno.DrawPolygon(Pennello, MatricediPunti)
E magari lo riempio con un tocco di colore:

Disegno.FillPolygon(Brushes.LightBlue, MatricediPunti)
Il codice completo, che disegna un trapezio, è riportato qui di seguito:


Dim MatricediPunti As Point() = {Punto1, Punto2, Punto3, Punto4}
Per disegnare un pentagono invece il codice diventa:


Dim MatricediPunti As Point() = {Punto1, Punto2, Punto3, Punto4, Punto5, Punto6}
Disegno.FillPolygon(Brushes.LightBlue, MatricediPunti)
Ellisse
Questo oggetto viene generato a partire da un rettangolo e, nel caso di Visual Basic, l’ellisse
è inscritta nel rettangolo definito. Se le dimensioni dei quattro lati sono uguali, quindi il
rettangolo diventa un quadrato, l’ellisse diventa una circonferenza.
Iniziamo definendo l’oggetto Graphics ed il pennello:

Quindi il rettangolo, utilizziamo nell’esempio il metodo più semplice.
Dim x As Integer = 200 'Coordinate di partenza del rettangolo

Dim y As Integer = 200
Dim Larghezza As Integer = 200 'larghezza del rettangolo
Dim Altezza As Integer = 100 'altezza del rettangolo
424
Quindi disegno l’ellisse.
Disegno.DrawEllipse(Pennello, x, y, Larghezza, Altezza)

Dim x As Integer = 200 'Coordinate di partenza del rettangolo

Dim y As Integer = 200
Dim Larghezza As Integer = 320 'larghezza del rettangolo
Dim Altezza As Integer = 150 'altezza del rettangolo
Disegno.DrawRectangle(Pennello, x, y, Larghezza, Altezza)
Oppure sfruttando la struttura Rectangle:

Disegno.DrawEllipse(Pennello, Rettangolo)
Stringa
È possibile disegnare un testo in un Form in due modi diversi. Il primo metodo disegna la
stringa direttamente avvalendosi delle coordinate del punto di inizio della scrittura mentre
il secondo metodo in pratica inserisce il testo in un rettangolo, i cui contorni possono essere
visibili o meno. La sintassi dell’istruzione è la seguente:
DrawString(Stringa, Font, Pennello, X, Y, FormatoStringa)
Stringa rappresenta la Stringa di caratteri da disegnare sullo schermo

Font è l’oggetto Font che definisce il formato del testo, come la grandezza del carattere.
Brush è l’oggetto che imposta il colore del testo e la trama.
X è la coordinata x dell’angolo superiore sinistro del testo che verrà disegnato
Y è la coordinata y dell’angolo superiore sinistro del testo disegnato.
FormatoStringa serve per impostare le caratteristiche della formattazione come ad esem-
pio l’interlinea o l’allineamento.
Questo esempio lo trovate nel progetto DisegnaStringa nel codice allegato al libro.
'Grandezza del Carattere

Dim Font1 As New Font("Arial", 10, FontStyle.Bold)
' colore del pennello

Dim Penna = New SolidBrush(Color.Black)
Dim Stringa As String = Trim(TextBox1.Text)
Dim Formato As New StringFormat
Formato.FormatFlags = StringAlignment.Near
Disegno.DrawString(Stringa, Font1, Penna, 300, 300, Formato)
425
Formato.FormatFlags = StringAlignment.Center
Formato.FormatFlags = StringAlignment.Far
Dim Penna1 = New Pen(Brushes.Black, 1)

Disegno.DrawLine(Penna1, 300, 10, 300, 500)
Crea un oggetto Graphics necessario per disegnare gli oggetti

Crea un oggetto Font con le caratteristiche citate fra parentesi e SolidBrush.

Dim Penna = New SolidBrush(Color.Black)
Prende il testo che dovrà disegnare da un textbox.

Dim Stringa As String = Trim(TextBox1.Text)
Crea una oggetto che rappresenta il formato che dovrà avere il testo che verrà disegnato.
Il codice che segue disegna tre volte il testo con tre allineamenti diversi con una linea che
mette in evidenza la differenza fra i vari allineamenti.
Formato.FormatFlags = StringAlignment.Near
Formato.FormatFlags = StringAlignment.Far
Dim Penna1 = New Pen(Brushes.Black, 1)

Disegno.DrawLine(Penna1, 300, 10, 300, 500)
Nel secondo caso la stringa di testo viene disegnata all’interno di un rettangolo, quindi è
necessario dichiarare prima un rettangolo e posizionarlo sullo schermo, e poi inserire la
stringa col testo.
La sintassi dell’istruzione è la seguente:
DrawString(Stringa, Font, Pennello, Rettangolo, FormatoStringa)
I parametri della funzione sono:
Stringa: Rappresenta la stringa da disegnare.

Font: Oggetto Font che definisce la grandezza del carattere e altre caratteristiche tipiche.
Pennello: Oggetto Brush che definisce il colore del testo disegnato.
Rettangolo: Disegna il rettangolo sullo schermo.
FormatoStringa: Imposta il formato della stringa all’interno del rettangolo.
Per iniziare bisogna sempre creare l’oggetto Graphics.

Definisco l’oggetto Font e l’oggetto Brush.

Dim Font1 As New Font("Arial", 8)
426
Dim Pennello = New SolidBrush(Color.Black)
Definisco l’oggetto rettangolo.

Definisco il formato. Per maggiori informazioni consultate il codice dell’esempio allegato al

libro.
Imposta l’allineamento verticale

Formato.LineAlignment = StringAlignment.Center
Imposta l’allineamento orizzontale

Formato.Alignment = StringAlignment.Center
Imposta il testo da disegnare

Dim Testo As String = "TESTO DI PROVA"
Disegna il rettangolo. In questo caso il colore del contorno del rettangolo è bianco ma se
desiderate che il rettangolo non si veda impostatelo come il colore di sfondo del form.
Disegno.DrawRectangle(Pens.White, Rettangolo)
Disegna la stringa inserendola nel rettangolo:

Disegno.DrawString(Testo, Font1, Pennello, RectangleF.op_Implicit(Rettangolo), Formato)
Il codice completo dell’esempio:

Dim Pennello = New SolidBrush(Color.Black)
Formato.LineAlignment = StringAlignment.Center
Formato.Alignment = StringAlignment.Center
Dim Testo As String = "TESTO DI PROVA"
Disegno.DrawRectangle(Pens.White, Rettangolo)
Disegno.DrawString(Testo, Font1, Pennello, RectangleF.op_Implicit(Rettangolo), Formato)
Icona
Può essere disegnato in un Windows Form anche un oggetto Icona. Insieme al codice alle-
gato al libro troverete una cartella che contiene un nutrito numero di icone da inserire nei
vostri progetti. Qui a seguito vi riporto il codice completo dell’esercizio. La prima parte serve
semplicemente, attraverso l’utilizzo del controllo OpenFileDialog, a selezionare un’icona che
poi verrà disegnata sul Form. In sostanza apre una finestra che vi permetterà di scegliere
l’icona. Per fare in modo che questo programma funzioni su tutti i computer è necessario
includere le prime tre righe di codice che servono per comporre il percorso iniziale, ovvero
in questo caso la Cartella Documenti del vostro computer.
427
Dim DirectoryIniziale As String = "C:\Users\" & NomeUtente & "\Documents\"
Dim PercorsoImmagine As String

OpenFileDialog1.InitialDirectory = DirectoryIniziale
OpenFileDialog1.Filter = "Immagini (*.ico)|*.ico"
PercorsoImmagine = OpenFileDialog1.FileName
Else
Exit Sub
End If
Dim Icona As New Icon(PercorsoImmagine)

Disegno.DrawIcon(Icona, 200, 200)
Questa riga definisce un nuovo oggetto Icon.

Dim Icona As New Icon(PercorsoImmagine)
Questa è una vecchia conoscenza

E questa invece disegna fisicamente l’icona.

Disegno.DrawIcon(Icona, 200, 200)
Immagine
Qui si va decisamente sul complicato, non perché effettivamente lo sia, ma per la grandis-
sima quantità di informazioni e varianti sul tema che sono disponibili per questo tipo di
oggetto, per cui vi rimando al sito http://docs.microsoft.com/it-it/dotnet/api/ che rappre-
senta la documentazione ufficiale della Microsoft. Cercate la libreria System.Drawing e il
metodo DrawImage. Qui mi limito alla versione di base del codice:


OpenFileDialog1.Filter = "Immagini (*.jpg)|*.jpg|Bitmap (*.bmp)|*.bmp|Tutti i File
(*.*)|*.*"
PercorsoImmagine = OpenFileDialog1.FileName
428
Else
Exit Sub
End If

Dim Immagine As Image = Image.FromFile(PercorsoImmagine)
Disegno.DrawImage(Immagine, 100, 100)
La prima parte del codice l’abbiamo già vista anche nell’esempio precedente.

Dim Immagine As Image = Image.FromFile(PercorsoImmagine)
Disegna l’immagine partendo dal punto di coordinata 100,100

Disegno.DrawImage(Immagine, 100, 100)
Altri Controlli utili.
429
In questo capitolo mostreremo molti controlli di cui Visual Basic dispone e che possono
risultare utili per migliorare le prestazioni di un programma.
Questo capitolo può essere saltato a piè pari per poi essere ripreso in un
secondo tempo. Vi sono alcuni controlli che probabilmente avranno un uti-
lizzo sporadico nelle vostre applicazioni, mentre altri saranno utilizzati piut-
tosto di frequente. Vengono esposti con lo scopo di mostrarne il funziona-
mento in modo che possiate valutarne l’utilizzo nei vostri lavori, e avere su-
bito a disposizione istruzioni sul loro modo d’impiego.
Quindi potete continuare lo studio di Visual Basic da questo capitolo oppure dirigervi diret-
tamente ad altri capitoli come ad esempio i database o disegnare con Visual Basic.
MaskedTextBox
Si tratta di un controllo molto utile per gestire l’immissione dei dati da parte dell’utente.
Una parte importantissima di un programma è quella di impedire all’utente di inserire nei
vari campi dei valori che farebbero generare un errore di esecuzione, come ad esempio
date non valide, valori strampalati e formati non validi. Per aiutare l’immissione dei dati il
controllo fornisce una maschera che impedisce perlomeno un errore di formato.
La proprietà Mask permette di specificare la tipologia della maschera che ho riportato nella
tabella qui di seguito.
Esempio di codice:
MaskedTextBox1.Mask = "00/00/0000" 'Formato Data

MaskedTextBox1.Mask = "0000.00" 'Formato Numero con due decimali
MaskedTextBox1.Mask = "00,000.00" ' migliaia
MaskedTextBox1.Mask = "$0000.00" 'Formato Valuta
MaskedTextBox1.Mask = "AAAAAAAAAAAA" 'Solo lettere e numeri
MaskedTextBox1.Mask = "LLLLLLLLLLL" 'Solo lettere
Maschera Descrizione
Numerico, obbligatorio. Questo elemento accetterà qualsiasi singola cifra compresa
0
tra 0 e 9.
9 Numerico o Spazio, facoltativo.
Numerico o Spazio, facoltativo. Se questa posizione è vuota nella maschera, verrà
# considerato come uno spazio nella proprietà Text. Sono consentiti segni più (+) e
meno (-).
L Carattere alfabetico, obbligatorio. Limita l’inserimento alle lettere ASCII a-z e A-Z.
? Carattere alfabetico, facoltativo. Limita l'input alle lettere ASCII a-z e A-Z.
Carattere alfabetico, obbligatorio. Se la proprietà AsciiOnly è impostata su true, que-
&
sto elemento si comporta come l'elemento "L".
Carattere alfabetico, facoltativo. Qualsiasi carattere non di controllo. Se la proprietà
C
AsciiOnly è impostata su true, questo elemento si comporta come l'elemento "?".
Alfanumerico, obbligatorio. Se la proprietà AsciiOnly è impostata su true, gli unici
A caratteri che vengono accettati sono le lettere ASCII a-z e A-Z. Questo elemento Mask
si comporta come l'elemento "a".
Alfanumerico, facoltativo. Se la proprietà AsciiOnly è impostata su true, gli unici ca-
a ratteri che accetteranno sono le lettere ASCII a-z e A-Z. Questo elemento Mask si
comporta come l'elemento "A".
Segnaposto decimale. Il carattere di visualizzazione effettivo utilizzato sarà il simbolo
. decimale appropriato per il provider di formato, come determinato dalla proprietà For-
matProvider del controllo.
430
Segnaposto Migliaia. Il carattere di visualizzazione effettivo usato sarà il segnaposto
, delle migliaia appropriato per il provider di formato, come determinato dalla proprietà
FormatProvider del controllo.
Separatore ora. Il carattere di visualizzazione effettivo usato sarà il simbolo di ora
: appropriato per il provider di formato, come determinato dalla proprietà FormatProvi-
der del controllo.
Separatore data. Il carattere di visualizzazione effettivo usato sarà il simbolo di data
/ appropriato per il provider di formato, come determinato dalla proprietà FormatProvi-
der del controllo.
Simbolo di valuta. Il carattere effettivo visualizzato sarà il simbolo di valuta appro-
$ priato per il provider di formato, come determinato dalla proprietà FormatProvider del
controllo.
< Converte tutti i caratteri che seguono in lettere minuscole.
> Converte tutti i caratteri che seguono in maiuscolo.
| Disabilitare uno spostamento precedente verso l'alto o lo spostamento verso il basso.
Fuga. Esclude un carattere di maschera, trasformandolo in un valore letterale. "\\" è
\
la sequenza di escape per una barra rovesciata.
Valori letterali. Tutti gli elementi non maschera verranno visualizzati nel MaskedText-
Tutti gli al-
Box. I valori letterali occupano sempre una posizione statica nella maschera in fase di
tri caratteri
esecuzione e non possono essere spostati o eliminati dall'utente.
Il codice che segue si trova nell’esempio allegato al libro nel progetto MaskedTextBox.
Option Explicit On
Public Class Form1
Private Sub MaskedTextBox1_MaskInputRejected(sender As Object, e As

MaskInputRejectedEventArgs) Handles MaskedTextBox1.MaskInputRejected
If (MaskedTextBox1.MaskFull) Then
ToolTip1.ToolTipTitle = "Errore: Hai inserito troppi dati"

ToolTip1.Show("Non puoi inserire ulteriori dati. Elimina alcuni caratteri.",
MaskedTextBox1, 120, 0, 2000)
ElseIf (e.Position = MaskedTextBox1.Mask.Length) Then
ToolTip1.ToolTipTitle = "Inserimento rifiutato"

ToolTip1.Show("Non puoi inserire altri caratteri alla fine di un campo data.",
Else

ToolTip1.Show("Puoi inserire solo caratteri numerici (0-9) in un campo data.",
End If
End Sub
End Sub
431
Private Sub MaskedTextBox1_KeyDown(sender As Object, e As KeyEventArgs) Handles
MaskedTextBox1.KeyDown
ToolTip1.Hide(MaskedTextBox1)
End Sub
Private Sub MaskedTextBox1_KeyPress(sender As Object, e As KeyPressEventArgs) Handles

MaskedTextBox1.KeyPress
If Keyascii = 13 Then
If IsDate(MaskedTextBox1.Text) = True Then
ToolTip1.ToolTipTitle = "Inserimento OK"
ToolTip1.Show("Hai inserito i dati corretti !!", MaskedTextBox1, 120, 0,
2500)
MaskedTextBox2.Focus()
Exit Sub
Else
ToolTip1.ToolTipTitle = "Inserimento Errato"
ToolTip1.Show("Quella che hai inserito non è una data valida !!",
End If
End If
End If
End Sub
End Class
Passiamo adesso ad una breve descrizione del funzionamento. Nell’evento Form_Load si

inserisce la configurazione della maschera, nel nostro esempio l’utente può inserire solo
informazioni che rappresentano una data.
End Sub
Quando l’inserimento da parte dell’utente vìola le regole che abbiamo dato con la proprietà
Mask allora viene generato l’evento MaskInputRejected, ovvero viene rifiutato il dato inse-
rito.
Si può utilizzare la proprietà MaskFull per verificare se sono stati inseriti tutti i caratteri
necessari, mentre la proprietà Text ci permette di recuperare il contenuto del campo for-
mattato in base alla maschera e alla proprietà TextMaskFormat.
Il controllo ToolTip è stato inserito per creare sullo schermo i messaggi d’errore indirizzati
all’utente se commette qualche violazione del formato.
Private Sub MaskedTextBox1_MaskInputRejected(sender As Object, e As

MaskInputRejectedEventArgs) Handles MaskedTextBox1.MaskInputRejected
432
ToolTip1.Show("Non puoi inserire ulteriori dati.",
Else

End If
End Sub
Quando viene generato l’evento MaskInputRejected se la maschera è piena:

Allora compare questo errore:

E verrà visualizzato per 2 secondi (2000 millisecondi) alle coordinate (120, 0) twip a di-
stanza dal controllo MaskedTextBox1.
ToolTip1.Show("Non puoi inserire ulteriori dati. Elimina alcuni caratteri.",
Quando viene generato l’evento MaskInputRejected se la maschera non è piena allora:
Else

End If
Quando viene premuto un qualsiasi tasto dalla tastiera per nascondere l’etichetta di mes-
saggio che si genererebbe.
Private Sub MaskedTextBox1_KeyDown(sender As Object, e As KeyEventArgs) Handles

MaskedTextBox1.KeyDown
ToolTip1.Hide(MaskedTextBox1)
End Sub
Questa parte di codice invece permette di convalidare i dati con il tasto Invio dalla tastiera
e verificare che quella che è stata inserita rappresenti una data valida a livello di sintassi.
Manda il cursore al TextBox o al MaskedTextBox successivo per l’inserimento di altro tipo
di dati.
Private Sub MaskedTextBox1_KeyPress(sender As Object, e As KeyPressEventArgs) Handles

MaskedTextBox1.KeyPress

433
If Keyascii = 13 Then
If IsDate(MaskedTextBox1.Text) = True Then
ToolTip1.ToolTipTitle = "Inserimento OK"
ToolTip1.Show("Hai inserito i dati corretti !!", MaskedTextBox1, 120, 0,
2500)
MaskedTextBox2.Focus()
Exit Sub
Else
ToolTip1.ToolTipTitle = "Inserimento Errato"
ToolTip1.Show("Quella che hai inserito non è una data valida !!",
End If
End If
End If
End Sub
Come per il controllo TextBox, diversi tasti di scelta rapida comuni non funzionano con
MaskedTextBox. In particolare, CTRL+R (Testo allineato a destra Text) e CTRL+L (Testo
allineato a sinistra).
RichTextBox
Questo controllo è utile per manipolare file RTF (Rich Text File) ovvero non semplici file di
testo ma file che supportano la formattazione del carattere, del paragrafo ed altre caratte-
ristiche tipiche di un programma di videoscrittura, come ad esempio Word.
RichTextBox può creare, modificare o salvare file in Formato RTF e TXT.
Dispone di diverse proprietà che è possibile utilizzare per applicare la formattazione a qual-
siasi parte del testo all'interno del controllo. Per effettuare delle modifiche è necessario
innanzitutto selezionare il testo. Solo il testo selezionato può essere assegnato alla format-
tazione dei caratteri e dei paragrafi. Dopo che è stata apportata un'impostazione a una
sezione di testo selezionata, tutto il testo immesso dopo la selezione viene formattato con
le stesse impostazioni, fino a quando non viene apportata una modifica dell'impostazione o
viene selezionata una sezione diversa del documento del controllo.
La proprietà SelectionFont consente di rendere il testo in grassetto o in corsivo, e può anche
modificare le dimensioni e il carattere tipografico del testo. La proprietà SelectionColor con-
sente di modificare il colore del testo. Per creare elenchi puntati, è possibile usare la pro-
prietà SelectionBullet. È inoltre possibile modificare la formattazione dei paragrafi impo-
stando le proprietà SelectionIndent, SelectionRightIndent e SelectionHangingIndent.
Fornisce inoltre metodi implementano l'apertura e il salvataggio di file.
Il metodo LoadFile consente di caricare un file di testo RTF o ASCII esistente nel controllo.
Il metodo SaveFile permette di salvare un file in formato RTF o ASCII.
Il controllo RichTextBox fornisce anche le funzionalità per la ricerca di stringhe di testo
all’interno di un documento attraverso il metodo Find.
Il codice dell’esercizio si trova nel progetto RichTextBox nel codice allegato al libro.
Il progetto dispone di un’area RichTextBox e tre pulsanti che rispettivamente servono per
creare un nuovo documento, aprirne uno esistente e salvare il documento creato o modifi-
cato dall’utente.
Il progetto è una versione base dimostrativa, quindi sta a voi apportarne eventuali migliorie,
ad esempio, inserendo altri pulsanti di formattazione rispetto a quello presente nel progetto
che serve semplicemente per mettere il testo in grassetto, magari aggiungendo una toolbar
per sfruttare le molte caratteristiche del controllo in questione.
Il codice dell’esercizio è il seguente:
434
Public Class Form1

Dim PercorsoFile As String
Dim Controllo As Boolean
Controllo = False
p_Salva.Enabled = False
p_Apri.Enabled = True
End Sub
Private Sub Button1_Click(sender As Object, e As EventArgs) Handles p_Apri.Click
Dim OpenFileDialog1 As New OpenFileDialog
OpenFileDialog1.Title = "Apri File RTF"

OpenFileDialog1.Filter = "File RTF (*.rtf)|*.rtf"
If OpenFileDialog1.ShowDialog = DialogResult.Cancel Then Exit Sub
PercorsoFile = OpenFileDialog1.FileName
RichTextBox1.LoadFile(PercorsoFile)
Controllo = True
End Sub
Private Sub Button2_Click(sender As Object, e As EventArgs) Handles p_Grassetto.Click
If RichTextBox1.SelectionFont IsNot Nothing Then
Dim FontAttuale As Font = RichTextBox1.SelectionFont

Dim NuovoFont As FontStyle
If RichTextBox1.SelectionFont.Bold = True Then

NuovoFont = FontStyle.Regular
Else
NuovoFont = FontStyle.Bold
End If
RichTextBox1.SelectionFont = New Font(FontAttuale.FontFamily, FontAttuale.Size,

NuovoFont)
End If
End Sub
Private Sub Button3_Click(sender As Object, e As EventArgs) Handles p_Salva.Click

435
Dim Risposta As String = MsgBox("Sei sicuro di volere salvare il File?",
vbExclamation + vbOKCancel, "Salva File")
If Risposta = vbCancel Then Exit Sub
' Salva con nome

If Controllo = False Then
Dim SaveFileDialog1 As New SaveFileDialog
SaveFileDialog1.Title = "Salva File RTF"
SaveFileDialog1.InitialDirectory = DirectoryIniziale
SaveFileDialog1.Filter = "File RTF (*.rtf)|*.rtf"
If SaveFileDialog1.ShowDialog = DialogResult.Cancel Then Exit Sub
PercorsoFile = SaveFileDialog1.FileName
End If
Controllo = True
RichTextBox1.SaveFile(PercorsoFile)
MsgBox("Salvataggio effettuato con successo", vbOKOnly + vbExclamation,

"Salva File")
End Sub
Private Sub Button1_Click_1(sender As Object, e As EventArgs) Handles p_Nuovo.Click
Controllo = False
RichTextBox1.Clear()
End Sub
Private Sub RichTextBox1_TextChanged(sender As Object, e As EventArgs) Handles

RichTextBox1.TextChanged
p_Salva.Enabled = True
End Sub
End Class
Analisi del codice.

Questa parte è presente in molti progetti e fa in modo che il progetto possa funzionare su
tutti i computer e non solo sul vostro. Quando salvate o aprite un file è necessario per il
computer sapere esattamente dove si trova (percorso completo). Dato che questo varia in
quanto in ogni computer il parametro Nome Utente è diverso, è necessario fare in modo di
poter recuperare le informazioni del percorso corretto.

436
Questa variabile vale False se il file che state salvando non ha un nome, oppure True se il
file ha già un nome.

Se il documento non ha nome si deve aprire sullo schermo la finestra Salva con Nome per
permettere all’utente di assegnargliene uno, mentre se ha già un nome questa operazione
non è necessaria.
Crea un nuovo controllo OpenFileDialog che serve per aprire un file già esistente.
Dim OpenFileDialog1 As New OpenFileDialog
Imposta le caratteristiche inziali del controllo OpenFileDialog. Fa in modo che nella finestra
siano visibili i soli file RTF.
OpenFileDialog1.Title = "Apri File RTF"
OpenFileDialog1.Filter = "File RTF (*.rtf)|*.rtf"
Mostra la finestra all’operatore. Se questi annulla l’operazione il computer esce dalla routine
senza fare altro e attende nuovi comandi.
If OpenFileDialog1.ShowDialog = DialogResult.Cancel Then Exit Sub
Se invece viene selezionato, il file da aprire viene associato al metodo LoadFile e aperto
sullo schermo.
PercorsoFile = OpenFileDialog1.FileName
RichTextBox1.LoadFile(PercorsoFile)
La variabile viene messa a True per far capire che stiamo modificando il documento.
Controllo = True
Questa parte del codice invece mette in grassetto il testo selezionato.

Se il testo selezionato contiene più di un tipo di carattere la proprietà SelectionFont vale
Null. Da questa proprietà è possibile modificare il testo del controllo in grassetto, corsivo e
sottolineato e anche il tipo e la grandezza del carattere.
If RichTextBox1.SelectionFont IsNot Nothing Then


Else
End If
RichTextBox1.SelectionFont = New Font(FontAttuale.FontFamily, FontAttuale.Size, NuovoFont)
Legge il font in base al testo selezionato nel RichTextBox.

Dichiara uno stile del font (grassetto, Sottolineato, Corsivo)

Come su Word, o qualsiasi altro programma di videoscrittura, serve per trasformare in

grassetto il testo normale e viceversa.
Else
437
End If
Applica le modifiche al testo
RichTextBox1.SelectionFont = New Font(FontAttuale.FontFamily, FontAttuale.Size, NuovoFont)
Questa parte di codice salva un file distinguendo fra i file che già hanno un nome, quindi si
tratta di una modifica, e file che il nome non ce l’hanno ovvero creati ex novo, basandosi
sulla variabile che nel codice è chiamata Controllo. Se questa variabile vale False il file non
ha un nome, quindi viene aperta la finestra Salva con nome per permette all’operatore di
assegnargliene uno.
Dim Risposta As String = MsgBox("Sei sicuro di volere salvare il File?", vbExclamation +

vbOKCancel, "Salva File")
If Risposta = vbCancel Then Exit Sub
' Salva con nome

If Controllo = False Then
Dim SaveFileDialog1 As New SaveFileDialog
SaveFileDialog1.Title = "Salva File RTF"
SaveFileDialog1.InitialDirectory = DirectoryIniziale
SaveFileDialog1.Filter = "File RTF (*.rtf)|*.rtf"
If SaveFileDialog1.ShowDialog = DialogResult.Cancel Then Exit Sub
PercorsoFile = SaveFileDialog1.FileName
End If
Controllo = True
RichTextBox1.SaveFile(PercorsoFile)
MsgBox("Salvataggio effettuato con successo", vbOKOnly + vbExclamation, "Salva File")
FolderBrowserDialog
È un semplice controllo che vi permette selezionare una cartella e memorizzarne il percorso
in una variabile. Una versione ridotta del controllo OpenFileDialog dove era possibile sele-
zionare un file. Lo trovate fra gli esempi annessi al libro.

Dim PercorsoCartella As String = "C:\Users\" & NomeUtente & "\Documents\"
FolderBrowserDialog1.SelectedPath = PercorsoCartella
If FolderBrowserDialog1.ShowDialog = DialogResult.OK Then

TextBox1.Text = FolderBrowserDialog1.SelectedPath
End Sub
438
PageSetupDialog
La finestra di dialogo PageSetupDialog modifica le informazioni relative a PageSettings e
PrinterSettings per un determinato Document. Per maggiori informazioni consultate il capi-
tolo che tratta della stampa e della stampa avanzata con Visual Basic. L'utente può modifi-
care la stampa, i margini, orientamento, dimensioni e origine della carta e per visualizzare
i pulsanti guida e rete. La proprietà MinMargins definisce i margini minimi che un utente
può selezionare.
Poiché un PageSetupDialog necessita di impostazioni di pagina da visualizzare, è necessario
impostare la proprietà Document, PrinterSettings o PageSettings prima di chiamare
ShowDialog; in caso contrario, si verificherà un errore.
PageSetupDialog1.PageSettings = New Printing.PageSettings

PageSetupDialog1.PrinterSettings = New Printing.PrinterSettings
'Non mostrare le stampanti di rete

PageSetupDialog1.ShowNetwork = False
'Mostra la finestra di dialogo PageSetupDialog e memorizza le impostazioni.

Dim risposta As DialogResult = PageSetupDialog1.ShowDialog()
' Se la risposta è OK le impostazioni verranno utilizzate per stampare il documento.
If (risposta = DialogResult.OK) Then

Dim results() As Object = New Object() _
{PageSetupDialog1.PageSettings.Margins,
PageSetupDialog1.PageSettings.PaperSize,
PageSetupDialog1.PageSettings.Landscape,
PageSetupDialog1.PrinterSettings.PrinterName,
PageSetupDialog1.PrinterSettings.PrintRange}
ListBox1.Items.AddRange(results)
End If
Crea un nuovo set di impostazioni della pagina:

PageSetupDialog1.PageSettings = New Printing.PageSettings
Crea una nuovo set di impostazioni della stampante:

PageSetupDialog1.PrinterSettings = New Printing.PrinterSettings
Non mostrare le stampanti di rete:

PageSetupDialog1.ShowNetwork = False
Mostra la finestra di dialogo PageSetupDialog e memorizza le impostazioni.

Dim risposta As DialogResult = PageSetupDialog1.ShowDialog()
Se la risposta è OK le impostazioni verranno utilizzate per stampare il documento, e visua-

lizzate nel ListBox1.
If (risposta = DialogResult.OK) Then

Dim results() As Object = New Object() _
{PageSetupDialog1.PageSettings.Margins,
PageSetupDialog1.PageSettings.PaperSize,
PageSetupDialog1.PageSettings.Landscape,
PageSetupDialog1.PrinterSettings.PrinterName,
PageSetupDialog1.PrinterSettings.PrintRange}
ListBox1.Items.AddRange(results)
End If
439
ImageList
Questo controllo rappresenta una lista di immagini che possono essere sfruttate da altri
controlli, ad esempio una barra degli strumenti oppure un controllo TreeView. Quindi di-
ciamo che da solo ha scarsa utilità, ma può essere utile per incorporare risorse utilizzate da
altri controlli. Quindi prima di introdurre altri controlli che si avvalgono una lista di immagini
vediamo come funziona ImageList.
Dalla casella degli strumenti scegliete il controllo ImageList e trascinatelo dentro il form del
progetto. Il controllo si posizionerà automaticamente in basso nell’ambiente di sviluppo
fuori dal form.
Quindi selezionate il controllo ImageList con un click e accedete alla proprietà Images.
Sullo schermo compare l’editor della raccolta immagini. Adesso, acquisiamo dalla cartella
che contiene le icone che di solito utilizzate per i vostri progetti, tutte le icone che saranno
necessarie per lo sviluppo di questo progetto, tenendo presente che è possibile aggiungere
o modificare questa lista in qualsiasi momento.
440
Queste icone potranno essere utilizzate e condivise in qualsiasi altro controllo presente nel
form, e questo vi permette di velocizzare la progettazione. Il controllo ImageList incorpora
la risorsa, ad esempio un’icona, evitando di richiamare attraverso il codice il file originario,
che in caso di spostamento, genererebbe un’eccezione bloccando il programma.
Fate click sul pulsante Aggiungi in basso a sinistra nella finestra per creare la lista delle
immagini.
Accedete alla cartella dove si trovano le icone e aggiungete tutte quelle che ritenete neces-
sarie ripentendo più volte l’operazione. Assegnate nomi descrittivi ai vari elementi della lista
dalla proprietà Name, in modo da poterli agevolmente richiamare nel progetto. Non lasciate
i nomi originari sempre ammesso che non siano descrittivi.
Fate click sul pulsante OK in basso nella finestra per tornare al progetto.
Adesso aggiungiamo al form un controllo ToolStrip che rappresenta una Barra degli stru-
menti.
441
Selezionate il controllo ToolStrip e accedete alla proprietà Items che rappresenta tutti gli
oggetti incorporati nel controllo. Questi possono essere pulsanti (Button), etichette(Label),
caselle di testo (TextBox), Separatori, pulsanti a discesa (DropDownButton) e altro visibile
nella lista. Non descriveremo tutte le possibilità che questo controllo offre in quanto sono
veramente tante e lascio a voi l’onere di scoprine le applicazioni.
Sullo schermo compare l’editor della raccolta Items.
Per semplicità illustrerò le possibilità che offre il controllo Button, che rappresenta un pul-
sante collocato sulla barra degli strumenti.
Selezionate dalla casella combinata un elemento da aggiungere, in questo caso una con-
trollo Button, e fate click sul pulsante Aggiungi alla destra della casella. È possibile inserire
sulla ToolStrip uno qualsiasi dei controlli che vedete nella lista, tenendo presente che è
possibile spostarli, rinominarli, eliminarli e aggiungerli in qualsiasi momento. L’importante
442
è che a ogni controllo venga assegnato un nome descrittivo per evitare la continua apertura
della raccolta Items per verificare come si chiama un determinato controllo.
In questo caso, ad esempio, sono stati inseriti sulla barra cinque pulsanti. Ognuno di questi
oggetti ha diverse proprietà alle quali potete accedere anche dal codice oltre che dalla lista
che appare nella parte destra della finestra dell’editor della raccolta Items. Ad ogni pulsante
ho assegnato attraverso la proprietà Name un nome descrittivo. Completate le operazioni
facendo click sul pulsante OK in basso nella finestra.
Adesso che sono stati creati i pulsanti ed è stato assegnato a ciascuno un nome descrittivo,
vediamo come dal codice è possibile accedere ai controlli e assegnargli alcune proprietà.
443
Nella raccolta del codice allegato al libro troverete nel progetto ImageList il codice che
riporto parzialmente nel box qui di seguito:
P_Apri.Image = ImageList1.Images.Item("I_Apri")
P_Apri.DisplayStyle = ToolStripItemDisplayStyle.ImageAndText
P_Apri.Text = "Apri"
P_Apri.TextAlign = ContentAlignment.MiddleRight
P_Apri.ImageAlign = ContentAlignment.MiddleLeft
P_Apri.Enabled = True
P_Chiudi.Image = ImageList1.Images.Item("I_Chiudi")
P_Chiudi.DisplayStyle = ToolStripItemDisplayStyle.ImageAndText
P_Chiudi.Text = "Chiudi"
P_Chiudi.TextAlign = ContentAlignment.MiddleRight
P_Chiudi.ImageAlign = ContentAlignment.MiddleLeft
P_Chiudi.Enabled = True
P_Connetti.Image = ImageList1.Images.Item("I_Connetti")
P_Connetti.DisplayStyle = ToolStripItemDisplayStyle.ImageAndText
P_Connetti.Text = "Connetti"
P_Connetti.TextAlign = ContentAlignment.MiddleRight
P_Connetti.ImageAlign = ContentAlignment.MiddleLeft
P_Connetti.Enabled = True
P_Disconnetti.Image = ImageList1.Images.Item("I_Disconnetti")
P_Disconnetti.DisplayStyle = ToolStripItemDisplayStyle.ImageAndText
P_Disconnetti.Text = "Disconnetti"
P_Disconnetti.TextAlign = ContentAlignment.MiddleRight
P_Disconnetti.ImageAlign = ContentAlignment.MiddleLeft
P_Disconnetti.Enabled = True
P_Esci.Image = ImageList1.Images.Item("I_Esci")
P_Esci.DisplayStyle = ToolStripItemDisplayStyle.ImageAndText
P_Esci.Text = "Esci"
P_Esci.TextAlign = ContentAlignment.MiddleRight
P_Esci.ImageAlign = ContentAlignment.MiddleLeft
P_Esci.Enabled = True
Innanzitutto assegna al pulsante, l’ordine delle assegnazioni ai vari pulsanti non è rilevante,
l’icona più adatta all’identificazione visiva del comando.
P_Apri.Image = ImageList1.Images.Item("I_Apri")
Assegno al pulsante uno stile che prevede la visualizzazione sul pulsante stesso di un’icona
e di un testo descrittivo del comando
P_Apri.DisplayStyle = ToolStripItemDisplayStyle.ImageAndText
Imposto il testo da visualizzare sul comando

P_Apri.Text = "Apri"
Allineo il testo
P_Apri.TextAlign = ContentAlignment.MiddleRight
Allineo l’icona
P_Apri.ImageAlign = ContentAlignment.MiddleLeft
Attivo il pulsante. Questo comando è opzionale perché per default un pulsante è abilitato.
Però magari voglio che inizialmente sia disabilitato. In questo caso il parametro e False.
P_Apri.Enabled = True
444
Il resto del codice personalizza i vari pulsanti presenti. Per attivare il codice dell’evento click
di un pulsante è sufficiente fare doppio click sul pulsante stesso, dove verrà inserito il codice
che dovrà essere eseguito se l’utente farà click sul pulsante in questione.
Le immagini della ImageList sono accessibili anche da altri eventuali controlli presenti nel
form o aggiunti successivamente.
TreeView
Il TreeView è un controllo piuttosto complesso e molto utilizzato nelle applicazioni desktop.
È quel componente che viene chiamato Riquadro di spostamento che solitamente appare
nella parte sinistra di una finestra di Windows, dove è possibile selezionare le risorse come
cartelle o altre risorse anche di rete. Quindi, un componente di utilizzo abbastanza fre-
quente. Queste, ovviamente, non solo le sole applicazioni che il TreeView può supportare.
Nel nostro esempio verrà utilizzato come controllo per recuperare la struttura di un server
MySQL e visualizzarla sullo schermo.
Ogni Server MySQL può contenere più database, il database può contenere tabelle e ogni
tabella può avere dei record e dei campi. Questo controllo ci permette di visualizzare questo
tipo di struttura in un modo detto “ad albero”, raggruppando gli oggetti in vari livelli e
ordinandoli alfabeticamente. Nella figura sottostante si può vedere l’aspetto che ha il pro-
getto in funzione.
Prima di analizzare il codice del progetto, ci soffermeremo sulle operazioni di base di questo
controllo. Per apportare delle modifiche all’elenco che appare nel TreeView è necessario
innanzitutto invocare il metodo:
TreeView1.BeginUpdate()
445
Quindi operare l’aggiunta di una voce o un ramo dipendente da una voce o ulteriore livello
di ramificazione. Prima ovviamente le voci principali.
TreeView1.Nodes.Add("Lista 1")
Dove “Lista 1” è semplicemente la descrizione che compare come nodo di livello principale.
Per aggiungere un ramo a questa voce principale:
TreeView1.Nodes(0).Nodes.Add("Voce 1")
Anche in questo caso “Voce 1” è il nome che comparire sulla lista come ramo della voce
“Lista 1”. Quindi, se vogliamo aggiungere un’altra voce principale:
Per aggiungere un ramo a questa seconda lista:
Come si può notare, l’indice dell’oggetto Nodes, che rappresenta i nodi o rami, è 1, mentre
nel primo caso era 0. Quindi se volte aggiungere un sotto – sotto elemento è possibile farlo
cosi:
TreeView1.Nodes(0).Nodes(0).Nodes.Add("Ramo 1")
Con le ultime tre righe si realizza una situazione del genere:
Il codice completo dell’esempio:
TreeView1.EndUpdate()
TreeView1.ExpandAll()
Per fare in modo che siano apportate le modifiche è necessario concludere le stesse con il
metodo:
Mentre:
446
fa in modo che tutti i rami presenti nel controllo vengano espansi, altrimenti risulteranno
collassati, ovvero saranno visibili solo le voci principali.
Se modificate il codice come nel box successivo:
Avremo questo risultato.
Infine un codice di questo tipo
447
Avrà come risultato:
Un’altra caratteristica importante di questo controllo è che per realizzare una lista come
quella che vedete nella figura precedente, è possibile aggiungere rami e sotto-rami anche
in tempi successivi, ad esempio, se nella Lista 1 vi siete dimenticati un ramo, è possibile
aggiungerlo in qualsiasi momento ed in qualunque punto del codice, purché sia già stato
dichiarato il ramo principale, in questo caso Lista 1, altrimenti verrà generata un’eccezione
che bloccherà l’esecuzione del programma. Tutte le modifiche alla struttura andranno rea-
lizzate fra queste due righe di codice:
………………………………
Per concludere:
TreeView1.Sort()
Elenca i nodi in ordine alfabetico, cosa molto utile in quanto, solitamente al posto delle
descrizioni utilizzate in questo esempio, si trovano voci ben più descrittive.
Dopo aver introdotto le caratteristiche principali del controllo TreeView, veniamo adesso al
progetto identificato con TreeView1 che si trova nel materiale di esempio allegato al libro.
Il codice completo del progetto lo trovate nel box successivo.
448
Public Class Form1

Dim Connessione As MySqlConnection
p_Connetti.Enabled = True
p_NuovaConnessione.Enabled = False
USERID = "root"
ServerName = "127.0.0.1"
t_IndirizzoIP.Text = ServerName
TreeView1.Indent = 20 'Distanza del primo nodo dal margine SX

TreeView1.BackColor = Color.LightYellow
TreeView1.Scrollable = True 'Barre di scorrimento automatiche se necessario
End Sub
Private Sub p_Connetti_Click(sender As Object, e As EventArgs) Handles p_Connetti.Click
TreeView1.ImageList = ImageList1
TreeView1.ImageIndex = 0 ' Per un ramo non selezionato
TreeView1.SelectedImageIndex = 1 'Per una ramo selezionato
TreeView1.ShowLines = True 'Mostra le linee fra i nodi

TreeView1.HotTracking = True
p_Connetti.Enabled = False
p_NuovaConnessione.Enabled = True
Dim Database As String

Dim DataBaseCorrente As Integer
Dim TabellaCorrente As Integer
Dim Tabella As String

Dim Connessione As New MySqlConnection(StringaConnessione)
Try
Connessione.Open()
449
Exit Sub
End Try
Connessione.Close()
DataBaseCorrente = 0
TreeView1.Nodes.Add(Riga("Database_Name"))
Database = Riga("Database_Name")

Using Connessione1 As New MySqlConnection(StringaConnessione)
Connessione1.Open()
Dim DataBaseSchema As DataTable = Connessione1.GetSchema("Tables")
TabellaCorrente = 0
For Each Riga1 As DataRow In DataBaseSchema.Rows
Tabella = Riga1("Table_Name")
TreeView1.Nodes(DataBaseCorrente).Nodes.Add(Tabella)
Using Connessione2 = New MySqlConnection(StringaConnessione)
Connessione2.Open()
Dim Comando As New MySqlCommand("SELECT * FROM " & Tabella, Connessione2)

For Each Riga2 As DataRow In schemaTable.Rows
TreeView1.Nodes(DataBaseCorrente).Nodes(TabellaCorrente).Nodes.Add(Riga2(0))
Next
End Using
TabellaCorrente = TabellaCorrente + 1
Next
End Using
DataBaseCorrente = DataBaseCorrente + 1
450
Next
'TreeView1.ExpandAll() ' Espande i nodi

TreeView1.CollapseAll() 'Compatta i nodi
TreeView1.Sort() 'Elenca i nodi in ordine alfabetico
End Sub
Private Sub p_NuovaConnessione_Click(sender As Object, e As EventArgs)

Handles p_NuovaConnessione.Click
p_NuovaConnessione.Enabled = False
TreeView1.Nodes.Clear()
End Sub
Private Sub Form1_Resize(sender As Object, e As EventArgs) Handles Me.Resize
StartPosition = FormStartPosition.CenterScreen
End Sub
End Class
Vediamo adesso le parti salienti del progetto. Queste sono alcune proprietà della lista ad
albero.
TreeView1.Indent = 20 'Distanza del primo nodo dal margine SX

TreeView1.BackColor = Color.LightYellow 'Colore di Sfondo del controllo
TreeView1.Scrollable = True 'Barre di scorrimento automatiche se necessario
Dato che viene utilizzata una ImageList per assegnare delle icone ai rami della TreeView
viene specificato da quale controllo la TreeView deve acquisire le immagini. Si usa una
ImageList in quanto incorpora le immagini ed evita di doverle richiamare da un file che, nel
caso venisse spostato, genererebbe un’eccezione bloccando il programma, e nel caso mi-
gliore non farebbe apparire le icone sulla TreeView.
TreeView1.ImageList = ImageList1
Nella ImageList sono presenti due Immagini. Quella di indice (0) è l’icona di una cartella
chiusa, quella di indice (1) è l’icona di una cartella aperta.
Questa linea di programma associa l’immagine con indice (0) che si trova nella ImageList
alla TreeView quando un ramo non è selezionato (immagine di una cartella chiusa).
TreeView1.ImageIndex = 0
Questa invece associa l’Immagine di indice (1) che si trova nella ImageList alla TreeView
quando un ramo è selezionato (immagine di una cartella aperta)
TreeView1.SelectedImageIndex = 1
Ottiene o imposta un valore che indica se un'etichetta del nodo dell'albero assume l'aspetto
di un collegamento ipertestuale al passaggio del mouse su di essa.
451
TreeView1.HotTracking = True
Mostra le linee fra i nodi
TreeView1.ShowLines = True
Il progetto consiste in tre loop annidati che vanno ad analizzare ciascun database presente
nel server, quindi ricava l’elenco delle tabelle di un database, e per ogni tabella ricava
l’elenco dei campi. L’analisi di un server con diversi database piuttosto corposi richiede circa
10-15 secondi. Tenete presente che nella lista compariranno anche i database che fanno
parte del sistema del Server MySQL, e non solo quelli che avete creato voi personalmente.
In pratica il funzionamento di massima dei loop è il seguente. Viene creata una connessione
che richiede al server la lista dei database (Schemas) ospitati.
Questa lista viene memorizzata in un oggetto tabella.
Il primo loop, quello di livello maggiore di annidamento, ripete le operazioni annidate tante
volte quanti sono i database presenti nella lista.
Quindi crea i nodi di livello superiore inserendo il nome del database come livello principale
della struttura.
TreeView1.Nodes.Add(Riga("Database_Name"))
Il secondo loop invece crea una tabella dove, per ogni database vengono recuperati i nomi
della tabelle che contiene.
Quindi inizia un loop che si concluderà quando saranno analizzate le tabelle del database
corrente definito dal primo loop.
For Each Riga1 As DataRow In DataBaseSchema.Rows
Tabella = Riga1("Table_Name")
Verrà aggiunta al controllo TreeView come rami di una voce principale (DataBaseCorrente),
il nome della tabella in questione.
TreeView1.Nodes(DataBaseCorrente).Nodes.Add(Tabella)
Poi verranno recuperati i nomi dei campi appartenenti a quella specifica tabella attraverso
una query.
Dim Comando As New MySqlCommand("SELECT * FROM " & Tabella, Connessione2)

452
Quindi verrà creata una tabella contenete i nomi dei campi presenti nella tabella stessa.
E i campi verranno aggiunti come nodi della voce della loro tabella di appartenenza.
For Each Riga2 As DataRow In schemaTable.Rows

TreeView1.Nodes(DataBaseCorrente).Nodes(TabellaCorrente).Nodes.Add(Riga2(0))
Next
Quindi verrà analizzata la tabella successiva di quello specifico database. Quando ha finito
di analizzare tutte le tabelle di quel database il loop andrà al database successivo e ripeterò
i due loop annidati.
L’utilizzo della parola chiave Using è dovuto al fatto che è necessario creare delle connes-
sioni nidificate per l’esecuzione delle query, e queste risorse vanno liberate prima della
connessione successiva altrimenti si potrebbe generare un’eccezione dovuta ad un numero
eccessivo di connessioni. D’altra parte ogni tabella va interrogata separatamente cosi come
ogni database, e per fare ciò è necessaria una nuova connessione.
Creare controlli personalizzati
453
Fin dagli albori di Visual Basic la possibilità di creare controlli personalizzati è stata una delle
caratteristiche più apprezzate dai programmatori, cosa che ha reso Visual Basic molto po-
polare presso questa comunità. Spesso è necessario creare controlli personalizzati in quanto
non è detto che fra gli innumerevoli controlli offerti da Visual Basic, ci sia quello che soddisfa
in pieno le nostre necessità. Inoltre il controllo personalizzato, come i controlli già disponibili
nell’ambiente di sviluppo, può essere incluso in qualsiasi progetto futuro, sfruttandone così
le caratteristiche riutilizzando il codice.
Per iniziare la nostra avventura nel mondo dei controlli personalizzati creiamo un nuovo
progetto dalla finestra che compare quando si avvia Visual Basic oppure dalla finestra prin-
cipale dell’ambiente di sviluppo selezionando dal menu File in alto a sinistra la voce Nuovo
Progetto (CTRL+N) dopo aver chiuso gli eventuali progetti aperti.
Al passaggio successivo scegliete la voce App Windows Forms (.NET Framework) come
di solito facciamo quando diamo inizio ad un nuovo progetto Windows Form.
Assegniamo adesso un nome descrittivo alla Soluzione (Una soluzione è il contenitore di
uno o più progetti) ad esempio “ProvaControllo”. Questa soluzione ci servirà per collaudare
il nostro controllo personalizzato, in quanto questi controlli non possono essere eseguiti
direttamente all’interno di Visual Studio.NET come fossero dei normali progetti.
La situazione iniziale è mostrata nella figura sottostante.
Fate click son il tasto DX del mouse sul nome che identifica la Soluzione e dalla voce Ag-
giungi scegliete Nuovo Progetto.
454
Dalla lista dei nuovi progetti identificate Libreria di controlli Windows Form (.NET Fra-
mework) come mostra la figura successiva e fate click sul pulsante Avanti in basso a de-
stra.
Assegnato un nome descrittivo al controllo che desiderate creare. In questo esempio utiliz-
zerò un nome generico.
Adesso la situazione dovrebbe essere come quella illustrata nella figura successiva.
455
Il progetto del controllo personalizzato è stato aggiunto alla soluzione.
Il progetto che appare visualizzato in grassetto è quello che partirà per primo quando verrà
avviata la soluzione. Dato che un progetto Libreria di controlli Windows Form non può essere
avviato come un Windows Form è necessario fare in modo che la soluzione venga avviata
dal progetto corretto. Nel nostro caso l’avvio è già impostato nel modo adeguato, ma se
questo non dovesse verificarsi fate click con il tasto desto sul nome che identifica la solu-
zione nella lista e scegliete la voce Imposta Progetti di avvio.
Selezionate il progetto di avvio, che ovviamente non può essere il controllo personalizzato
ma il progetto Windows Form che fa parte della soluzione, e quindi fate click sul pulsante
OK in basso nella finestra.
456
Per fare in modo che il progetto Windows Form possa accedere al controllo fate click con il
tato desto sulla voce che identifica il nome del Windows Form (nel nostro caso ProvaCon-
trollo) nella finestra Esplora Soluzioni e dal menu scegliete la voce Aggiungi. Quindi dal
sottomenu scegliete Riferimento.
Come mostra la figura successiva, fate click sulla voce Progetti e selezionate Soluzione.
Quindi nella lista centrale compare il nostro controllo personalizzato. Selezionatelo e fate
click sul pulsante OK ina basso nella finestra per portare a termine le operazioni.
457
Ora il controllo è disponibile nel nostro progetto come un normalissimo controllo al quale
siamo già abituati. Dalla finestra Esplora Soluzioni fate doppio click sulla voce che identifica
il vostro controllo personalizzato come mostra la figura sottostante e inserite il codice che
determina il funzionamento dell’oggetto.
458
Utilizzate il codice presente nel progetto “ProvaControllo” che trovate allegato come mate-
riale aggiunto del libro. Se non digitate nulla il vostro controllo non sarà visibile nella Casella
degli strumenti (CTRL+ALT+X) nella parte sinistra dell’ambiente di sviluppo.
Quindi può essere aggiunto ai vostri progetti come se fosse un normale controllo.
Aggiungere Proprietà al controllo utente.

Prima di andare oltre nello sviluppo del nostro controllo è opportuno sapere che ad un
controllo è possibile aggiungere Proprietà, Metodi ed Eventi, manipolabili dal programma-
tore esattamente come quelli di un controllo standard di Visual Basic.NET, con la variante
che in questo caso le caratteristiche dobbiamo crearle noi.
Una routine di proprietà, conosciuta anche come funzione di accesso ad una proprietà, è
una serie di istruzioni che consentono di modificare una proprietà personalizzata in un mo-
dulo o in una classe.
L’esempio che trovate nel materiale allegato al libro tratta di un semplice controllo che
genera un grafico a torta. A questo controllo è possibile passare, attraverso una matrice,
una serie di valori (massimo 12) che concorreranno a formare un grafico a torta. Ogni
spicchio sarà proporzionale a ciascun valore rappresentato.
Iniziamo ad analizzare il codice del progetto che rappresenta il controllo personalizzato, e
poi passeremo al codice del progetto che serve per verificare il funzionamento del controllo
stesso.
Innanzitutto è necessario importare queste due librerie.
Imports System.ComponentModel
Imports System.Math
459
La prima libreria è uno spazio dei nomi che contiene delle classi che vengono utilizzate per
implementare il comportamento di controlli in fase di progettazione e di esecuzione, ad
esempio, se voglio aggiungere una proprietà modificabile dalla finestra delle proprietà di un
controllo. Per accedere alla possibilità di visualizzare o non visualizzare una proprietà nella
lista delle proprietà di un controllo è necessario che la classe abbia un attributo chiamato:
<AttributeUsage(AttributeTargets.All)> Public Class UserControl1
Accanto alla dichiarazione delle classe. Poi troverete le variabili che devono essere accessi-
bili in tutta la classe.
Dim Valori(11) As Integer

Dim Percentuali(11) As Single
Dim Colori(11) As Color
Dim ControlSize1 As Integer = 300 'dimensioni normali del controllo
Dim LabelFontSize1 As Integer
Dim LabelFont1 As String
Dim LabelType1 As Boolean
Dim LabelDistance1 As Integer
Per creare una routine di proprietà è necessario utilizzare le parole chiave “Public Property”
e “End Property” che delimitano il codice che genera la proprietà. La Funzione deve essere
dello stesso tipo dei dati che vengono passati al controllo, ad esempio se invio al controllo
una serie di valori Integer per disegnare la torta, anche la funzione deve essere dello stesso
tipo.
Public Property Values As Integer()
La proprietà così com’è però non funziona senza le istruzioni Get e Set. Get recupera il
valore della proprietà, e Set imposta il valore di tale proprietà. In parole povere se devo
recuperare dei valori dal controllo è necessario scrivere il codice nella procedura Get, men-
tre se devo inviare valori al controllo devo scrivere il codice nella procedura Set.
Fra le istruzioni Get ed End Get non è necessario definire parametri.
Il codice che vedete nel box sottostante riceve 1 o più valori (fino a 12) attraverso una
matrice dinamica di nome Valore() e inserisce i valori ricevuti nella matrice Valori() per
utilizzarli nel codice del controllo. Tenete presente che una proprietà di un controllo può
impostare ma anche restituire valori, quindi per completare la Funzione inseriamo il codice
che restituisce il valore fra le parole Get e End Get.
Public Property Values As Integer()
Get
Return Valori
End Get
Set(ByVal Valore() As Integer) 'Assegna un valore alla proprietà
For j = 0 To Valore.Length - 1
Valori(j) = Valore(j)
Next
End Set
End Property
Se desiderate che la proprietà compaia anche nella finestra delle proprietà del controllo in
fase di progettazione inserite il codice che vedete nel box sottostante prima della funzione.
460
<EditorBrowsable(EditorBrowsableState.Always)> Public Property Values As Integer()
Se invece volete negare questa possibilità:
<EditorBrowsable(EditorBrowsableState.Never)> Public Property Values As Integer()
Le altre Proprietà del controllo ci danno rispettivamente la possibilità di impostare la dimen-

sione del controllo stesso, limitandola fra 300 e 500 pixel.
Public Property ControlSize As Integer
Get
Return ControlSize1
End Get
Set(ByVal Size1 As Integer)
If Size1 < 300 Then Size1 = 300

If Size1 > 500 Then Size1 = 500
ControlSize1 = Size1
End Set
End Property
Oppure di impostare la dimensione del carattere delle etichette dei valori che compaiono
sul grafico.
<EditorBrowsable(EditorBrowsableState.Always)> Public Property LabelFontSize As Integer
Get
Return LabelFontSize1
End Get
Set(ByVal _LabelFontSize As Integer) 'Assegna un valore alla proprietà
LabelFontSize1 = _LabelFontSize
End Set
End Property
Il tipo di carattere delle etichette.
<EditorBrowsable(EditorBrowsableState.Always)> Public Property LabelFont As String
Get
Return LabelFont1
End Get
Set(ByVal _LabelFont As String) 'Assegna un valore alla proprietà
LabelFont1 = _LabelFont
End Set
End Property
461
Questa proprietà invece permette di selezionare se sulle etichette devono essere riportati i
valori o le percentuali dei valori, riferiti alla percentuale che ogni valore assume rispetto al
totale dei valori. A questa proprietà è sufficiente assegnare un valore True o False.
<EditorBrowsable(EditorBrowsableState.Always)> Public Property LabelType As Boolean
Get
Return LabelType1
End Get
Set(ByVal _LabelType As Boolean) 'Assegna un valore alla proprietà
LabelType1 = _LabelType
End Set
End Property
Le ho chiamate in modo che i nomi siano vicini fra di loro nella finestra delle proprietà per
facilitare l’identificazione. Per vedere la finestra delle proprietà basta trascinare il controllo
dentro un form.
L’ultima proprietà è utile per posizionare le etichette a una distanza variabile dal centro
della torta.
<EditorBrowsable(EditorBrowsableState.Always)> Public Property LabelDistance As Integer
Get
Return LabelDistance1
End Get
Set(ByVal _LabelDistance As Integer) 'Assegna un valore alla proprietà

462
LabelDistance1 = _LabelDistance
End Set
End Property
Vediamo il codice che si trova nell’evento Load del controllo. Questo codice assegna i colori
ad una matrice che poi verranno utilizzati dalla torta per i suoi spicchi. I colori sono inver-
tibili a piacimento.
Private Sub UserControl1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
Colori(0) = Color.Red
Colori(1) = Color.Yellow
Colori(2) = Color.LightGreen
Colori(3) = Color.LightGray
Colori(4) = Color.MediumPurple
Colori(5) = Color.LightBlue
Colori(6) = Color.Lavender
Colori(7) = Color.LightSkyBlue
Colori(8) = Color.Magenta
Colori(9) = Color.ForestGreen
Colori(10) = Color.Navy
Colori(11) = Color.Tan
End Sub
Abbiamo visto come sia possibile aggiungere una proprietà ad un controllo. Adesso ci oc-
cuperemo invece di come sia possibile aggiungere un metodo. Questa possibilità risulta più
semplice che nel caso precedente, infatti basta aggiungere una routine Public.
Nel codice che trovate nel box successivo viene semplicemente cancellato tutto quello che
era visualizzato sul controllo in precedenza (magari una torta precedente), basandosi sulla
creazione di un rettangolo di grandezza uguale alla superfice del controllo, riempito dello
stesso colore dello sfondo delle finestre. Poi l’azione viene spostata sulla routine Calcola().
Public Sub RefreshControl()
Dim Rettangolo As New Rectangle(0, 0, ControlSize1, ControlSize1)

Disegno.FillRectangle(SystemBrushes.Control, Rettangolo)
Calcola()
End Sub
Questa routine entra in azione dopo che il controllo ha ricevuto il metodo RefreshControl(),
utilizza i dati ricevuti dal controllo tramite la proprietà Values e li elabora per creare il
grafico. Quella che vedete in queste pagine è la versione semplificata del controllo, interes-
sante ma con funzionalità ridotte, dato la complessità e la lunghezza del codice necessario
per realizzare il controllo (ci vorrebbe mezzo libro solo per lui). Magari quando avete un po'
di tempo potere apportare delle modifiche personali al controllo per migliorarne le presta-
zioni.
Se al controllo non viene inviata nessuna informazione sul quale carattere tipografico deve
utilizzare per le etichette, allora viene impostato “Verdana”. Allo stesso modo, se non viene
specificata la dimensione del carattere viene impostato il valore 10.
Private Sub Calcola()

463
If LabelFont1 = "" Then LabelFont1 = "Verdana"

If LabelFontSize1 < 0 Or LabelFontSize1 > 16 Then LabelFontSize1 = 10
Vengono eseguite alcune operazioni preliminari, quale la creazione di variabili che verranno
utilizzate durante l’esecuzione del programma.
Dim Font1 As New Font(LabelFont1, LabelFontSize1, FontStyle.Bold)

Dim j As Integer
Dim k As Integer
Dim Etichette(11) As Integer
Me.Width = ControlSize1
Me.Height = ControlSize1
Dim SommaValori As Integer = 0
Per prima cosa viene fatta la somma dei valori ricevuti per metterli in relazioni alle percen-
tuali. La somma dei valori rappresenta il 100% della torta.
For j = 0 To Valori.Length - 1
If Valori(j) = 0 Then Exit For
SommaValori = SommaValori + Valori(j)
Next
Viene calcolata la percentuale dei valori. Quando trova un valore uguale a zero esce dal
ciclo For…Next e procede con il programma.
For j = 0 To Valori.Length - 1
If Valori(j) = 0 Then Exit For
Percentuali(j) = Round((Valori(j) / SommaValori * 100), 2)
Next
Memorizza il numero dei valori validi presenti nella matrice. Ricordo che è possibile passare
al controllo da 1 a 12 valori.
k = j
Adesso si calcola gli angoli che ciascun valore rappresenterà sul grafico a torta. Poi si calcola
la posizione delle etichette che si trovano a metà dell’angolo che rappresenta ciascun valore.
Si crea un matrice (PA) dove gli angoli sono rappresentati come somma del precedente. Ad
esempio la terza etichetta parte a meta del suo settore, ma come angolo di riferimento ha
la somma degli altri due che la precedono sommata alla metà del suo settore.
Dim Angoli(11) As Single
'Calcola gli angoli

For j = 0 To k - 1
Angoli(j) = Round(360 / SommaValori * Valori(j), 2)
Next
For j = 0 To k - 1
Etichette(j) = Round(Angoli(j) / 2, 2)
Next
Dim PA(11) As Double

464
For j = 1 To k - 1
PA(j) = PA(j - 1) + Angoli(j - 1)
Etichette(j) = Etichette(j) + PA(j)
Next
Poi si passa a disegnare la torta in senso orario. Viene disegnato uno spicchio che poi viene
sommato al secondo e così via fino al giro completo.
Dim Rettangolo As New Rectangle(0, 0, ControlSize1, ControlSize1)

Dim AngoloPartenza As Single = 0.0F
For j = 0 To k - 1
If Angoli(j) = 0 Then Exit For
Dim Pennello As New SolidBrush(Colori(j))
Disegno.FillPie(Pennello, Rettangolo, AngoloPartenza, Angoli(j))
AngoloPartenza = AngoloPartenza + Angoli(j)
Next
A questo punto vengono disegnate le etichette di valori. Sono distribuite all’interno della
torta lungo un cerchio concentrico più piccolo di quello del grafico, e la loro distanza dal
centro è regolabile, ovviamente entro certi limiti, in quanto se troppo vicino al centro si
potrebbero sovrapporre, mentre se troppo lontane c’è il rischio che debordino dal controllo
e quindi non sarebbero visibili.
Dim Radianti As Double

Dim CoordinataX As Integer
Dim CoordinataY As Integer
Dim Testo As String

Dim RaggioControllo As Integer = Int(ControlSize1 / 2)

Dim RaggioEtichette As Integer
If LabelDistance1 < 80 Then LabelDistance1 = 80
If LabelDistance1 > (RaggioControllo - 20) Then
RaggioEtichette = 180
Else
RaggioEtichette = LabelDistance1
End If
Dim Rapporto As Double = RaggioEtichette / RaggioControllo
Questo ciclo disegna le etichette. Inoltre determina in base alla variabile LabelType1 se
deve visualizzare i valori o le percentuali relative.
For j = 0 To k - 1
Radianti = (2 * PI / 360) * Etichette(j)

465
CoordinataX = RaggioControllo + (ControlSize1 / 2 * Cos(Radianti) * Rapporto) + 20
CoordinataY = RaggioControllo + (ControlSize1 / 2 * Sin(Radianti) * Rapporto) - 10
If LabelType1 = True Then
Disegno.DrawString(Valori(j).ToString,
Font1, Brushes.Black, CoordinataX, CoordinataY, Formato)
Else
Testo = Percentuali(j).ToString + "%"
Disegno.DrawString(Testo, Font1, Brushes.Black,
CoordinataX, CoordinataY, Formato)
End If
Next
End Sub
Questa proprietà viene chiamata dal codice quando si deve resettare la torta prima di in-
viare altri valori.
Public Sub ResetValues()
Erase Valori
ReDim Valori(11)
End Sub
Adesso vediamo come utilizzare il controllo in fase di progettazione. È possibile farlo in due
modi. Il primo modo è quello classico di trascinare un controllo nel form dove lo vogliamo
utilizzare. Il secondo e crearlo da codice come oggetto senza effettuare alcun trascinamento
del controllo nel form. Nel progetto incluso nel codice allegato al libro sono presenti en-
trambi i metodi. Nel Form1 troviamo il caso dell’oggetto creato dal codice, mentre nel se-
condo si trova il metodo classico.
Iniziamo dal secondo caso. Nel box successivo è riportato il codice che si trova nella Classe
Form1 della soluzione ProvaControllo. Il Form presenta un pulsante che serve per far partire
l’elaborazione dei dati.
Option Explicit On
Public Class Form1
Dim Torte As New ControlloPersonalizzato.UserControl1
Torte.Location = New Point(50, 50)

'Torte.Size = New Size(400, 400)
Controls.AddRange(New Control() {Torte})
Torte.ControlSize = 400 'Grandezza del controllo sullo schermo

Torte.LabelFontSize = 12 'Grandezza del carattere
Torte.LabelType = True 'Percentuali o valori
Torte.LabelDistance = 160
Torte.Values = {3160, 4250, 870, 550, 1750}
Torte.RefreshControl() 'aggiorna
Exit Sub
Torte.ResetValues()
466
Torte.Values = {50, 110, 180, 75}
Torte.RefreshControl()
End Sub
End Class
Sfruttando la programmazione ad oggetti, creo un oggetto Torte che si basa sul nostro
controllo personalizzato.
Dim Torte As New ControlloPersonalizzato.UserControl1
Imposto la coordinata del punto di partenza nel Form del controllo. La seconda riga di codice
è opzionale. Serve per assegnare le dimensioni all’oggetto che, nel nostro caso, vengono
assegnate dalla proprietà personalizzata ControlSize.
Torte.Location = New Point(50, 50)

'Torte.Size = New Size(400, 400)
Aggiungo il controllo Torte all’insieme dei controlli.
Controls.AddRange(New Control() {Torte})
A questo punto assegna le proprietà e aziona il controllo.

Torte.Values = {3160, 4250, 870, 550, 1750}
Durante l’esecuzione di un programma, se si desidera inviare altri dati al controllo per una
nuova elaborazione è sufficiente inserire queste tre righe.
Torte.ResetValues()
Torte.Values = {50, 110, 180, 75}
Torte.RefreshControl()
Per quanto riguarda il metodo classico, dopo aver trascinato il nostro controllo dalla casella
degli strumenti all’interno del form, e sufficiente assegnare questo codice all’evento Click
di un pulsante. Quindi, allo stesso evento si aggiunge il codice del box successivo che è lo
stesso del caso precedente, per attivare il controllo.

Torte.Values = {3160, 4250, 870, 550, 1750}
Come mostra la figura successiva, si inserisce il controllo in un form, si assegna un nome,

se il controllo non è visibile sullo schermo cambiate lo stile del bordo giusto per identificarlo
meglio, poi si aggiunge il codice e si avvia il programma.
467
Nella figura sottostante si vede il controllo personalizzato in azione.

468
Informazioni e operazioni su File e Cartelle
Si tratta di un argomento particolarmente vasto, anche se a prima vista può non sembrare,
per il numero di comandi che disponiamo per agire su queste strutture. In questo capitolo
vengono affrontate solo le operazioni di base che sono comunque più che sufficienti per
coprire gli impieghi più comuni. Potete affrontare questo capitolo tranquillamente dopo che
avete visto l’intera sezione dei controlli al capitolo successivo per poi tornare a quest’argo-
mento in modo da avere maggiore dimestichezza con la programmazione.
Le righe di codice che seguono servono per recuperare il nome dell’utente che sta utiliz-
zando quel computer. Per avere una corretta comprensione dell’argomento sarebbe neces-
sario conoscere la filosofia di queste operazioni vista dal caro e vecchio DOS (roba del tempo
di Re Pipino, ma forse anche prima). Qui le chiamo “Cartelle” ma in realtà dovrebbero essere
chiamate Directory. Non utilizzo questo termine perché nessuno le chiama più come si chia-
mavano in origine.

Questo perché la cartella Documenti, come tante altre del vostro computer, si trovano in
un percorso così composto:
Dim Percorso As String = "C:\Users\" & NomeUtente & "\Documents\"
Se non fosse per queste righe il codice funzionerebbe solo nel vostro computer.
Questa prima parte del codice vi posizionerebbe all’interno della Cartella dei file dell’utente
(quella con il vostro nome che si trova sul Desktop tanto per intenderci)
Dim Percorso As String = "C:\Users\" & NomeUtente
E quindi per “entrare” nella cartella Documenti è necessario:
Adesso assegno un nome di fantasia alla cartella che voglio creare:
Dim NomeCartella As String = "CartellaProva"
Quindi per il momento, per creare una cartella, la situazione è questa:

A questo punto “lancio” il comando per creare la cartella:
My.Computer.FileSystem.CreateDirectory(Percorso & NomeCartella)
Per eliminare una cartella (o directory) invece è necessario procedere così:
My.Computer.FileSystem.DeleteDirectory(Percorso & NomeCartella,

FileIO.DeleteDirectoryOption.ThrowIfDirectoryNonEmpty)
Benché appaia su due righe il codice può essere scritto anche su una sola (se ci sta). Questa
nuova versione di Visual Basic permette di scrivere una riga di codice particolarmente lunga
in maniera più semplice delle versioni precedenti senza utilizzare simboli di accapo.
469
Questo comando permette di eliminare la cartella solo se è vuota, altrimenti crea un errore
(eccezione non gestita nel linguaggio corrente) che interrompe il flusso del programma. Per
maggiori informazioni fate riferimento alla gestione degli errori in Visual Basic.
Per anticiparvi la sorpresa potete ad esempio fare cosi:
Try 'trappola per errori

FileIO.DeleteDirectoryOption.ThrowIfDirectoryNonEmpty)
Catch err As System.Exception
MsgBox("secondo me la cartella non è vuota", vbOKOnly + vbInformation, "Info")
End Try
Le parti in color verde sono le note del programmatore.

Per eliminare una cartella e tutto il suo contenuto provate invece con questo codice:

FileIO.DeleteDirectoryOption.DeleteAllContents)
State attenti perché la cartella e quindi anche il suo contenuto non vanno nel
cestino di Windows. Utilizzate la massima attenzione quando usate questi
comandi.
Per fare ciò il comando è questo:

FileIO.UIOption.AllDialogs,
FileIO.RecycleOption.SendToRecycleBin,
FileIO.UICancelOption.ThrowException)
Questo codice fa apparire sullo schermo la classica finestra, alla quale siete più che abituati,
che chiede una conferma sul fatto che la cartella e tutto il suo contenuto vadano gettati nel
cestino. Le risposte che da l’utente, che quindi può anche annullare l’operazione, vanno
trattate come il caso precedente, perché possono creare delle eccezioni non gestite che
bloccherebbero il programma.
Copiare una Directory

Il codice d’esempio mostra come si fa a copiare una cartella che si trova dentro la cartella
Documenti (esempio precedente) e farne una copia sul Desktop. Ovviamente la destina-
zione può essere anche diversa dal Desktop.


Dim Percorso2 As String = "C:\Users\" & NomeUtente & "\Desktop\"
My.Computer.FileSystem.CopyDirectory(Percorso & NomeCartella,

Percorso2 & NomeCartella, True)
470
Questa volta è necessario creare una stringa con il percorso di destinazione (Percorso2) che
in questo caso è il Desktop. Il nome della cartella nella destinazione può essere anche
cambiato se desiderate, oppure mantenuto.
Il comando è:
My.Computer.FileSystem.CopyDirectory(Percorso & NomeCartella,

Per maggiore chiarezza ho allineato i parametri ma ricordate che il codice può essere scritto
anche tutto su una riga o interrotto in altra posizione rispetto agli esempi che vediamo in
queste pagine. Il valore “True” serve per visualizzare sullo schermo la barra di progresso.
Per spostare una Directory il comando è:
My.Computer.FileSystem.MoveDirectory(Percorso & NomeCartella,

Verifica dell’esistenza di una cartella

Se dovete verificare l’esistenza di una cartella prima di procedere con determinate opera-
zioni come ad esempio prima di procedere ad una copia dovete utilizzare questo codice:
If My.Computer.FileSystem.DirectoryExists(Percorso & NomeCartella) = True Then
'inserite qui le istruzioni che il computer deve eseguire se la cartella esiste.
End If
Non c’è bisogno di ricordare tutti sti giochini a memoria o se per il momento
valutate che il capitolo non sia interessante saltatelo pure a piè pari. Queste
operazioni possono risultare molto utili anche in futuro o quando svilupperete
programmi più impegnativi.
Cambiare nome a una cartella.

A volte può capitare che da programma sia necessario cambiare il nome ad una cartella.
Il codice che vedete qui sotto è un esempio per poterlo fare.


Dim NuovoNome As String = "Pippo"
My.Computer.FileSystem.RenameDirectory(Percorso & NomeCartella, NuovoNome)

471
Operazioni sui File
Quanto detto per le Directory vale anche per i file. Il codice che segue serve per eliminare
un file dalla cartella Documenti. Il file in questione si chiama Prova.txt che potete tranquil-
lamente creare facendo click con il tasto DX del mouse sul Desktop e dalla lista scegliete la
voce Nuovo – Documento di testo.
Se lasciate il file sul desktop utilizzate l’altra la stringa “Percorso2” dell’esercizio precedente
al posto di quella che vedete qui sotto.


Dim NomeFile As String = "Prova.txt"
My.Computer.FileSystem.DeleteFile(Percorso & NomeFile)
Se per l’eliminazione c’è bisogno di una conferma da parte dell’utente allora il comando
diventa.
My.Computer.FileSystem.DeleteFile(Percorso & NomeFile,

FileIO.UIOption.OnlyErrorDialogs,
FileIO.RecycleOption.SendToRecycleBin,
FileIO.UICancelOption.ThrowException)
Copia di File
Il codice completo dell’esercizio è visibile nel riquadro successivo. In questo caso viene
copiato un file dalla cartella Documenti al Desktop


Dim Percorso2 As String = "C:\Users\" & NomeUtente & "\Desktop\"
My.Computer.FileSystem.CopyFile(
Percorso & NomeFile, Percorso2 & NomeFile, overwrite:=False)
Il parametro overwrite serve ad evitare che nel caso sul Desktop esistesse già un file con
lo stesso nome, venga sovrascritto.
Spostare un file
Vale quanto detto per le cartelle (directory)il codice in questo caso e:
My.Computer.FileSystem.MoveFile(Percorso & NomeFile, Percorso2 & NomeFile)

472
Una trattazione completa di quest’argomento esula dallo scopo di questo libro
in quanto ognuno degli argomenti che troverete in queste pagine in realtà è
un pozzo senza fondo. È comunque importante sapere esattamente come si
chiama un argomento per poterlo facilmente cercare sulla documentazione
ufficiale della Microsoft.
Rinominare un file
Per cambiare il nome ad un file potete utilizzare il codice d’esempio riportato nel riquadro
successivo.


Dim NuovoNome As String = "Pippo.txt"
My.Computer.FileSystem.RenameFile(Percorso & NomeFile, NuovoNome)
Attenzione a come operate con i file e le cartelle. Potreste combinare un bel

casotto se eliminate a cuor leggero. Quindi operate sempre con una certa
prudenza.
Informazioni sui File

Per recuperare alcune informazioni sui file che possono essere utili in diverse applicazioni è
possibile utilizzare il seguente codice:


Dim NomeFile As String = "prova.txt"
Dim Info = My.Computer.FileSystem.GetFileInfo(Percorso & nomefile)
Dim Dimesione As String = Info.Length

Dim NomeCompleto As String = Info.FullName
Dim ultimoAccesso As String = Info.LastAccessTime
Dim UltimaModifica As String = Info.LastWriteTime
Vengono dichiarate alcune stringhe che conterranno le informazioni recuperate dal file in
questione. Sinceratevi che il file esista per evitare che il computer restituisca qualche ecce-
zione e si blocchi durante l’esecuzione.
473
Progetto FileInfo.
Il progetto che analizziamo in questo capitolo ci permette di avere informazioni su file e
cartelle, come ad esempio la data di creazione, quella di ultima modifica ecc. Lo spazio dei
nomi System.IO fornisce delle classi che offrono funzionalità per la gestione dei file e delle
cartelle (directory). Questo progetto è realizzato con due Listbox, un Button, un Textbox,
un ComboBox, due Label e un FolderBrowserDialog. All’avvio fate click sul pulsante Apri
cartella. È impostata come cartella inziale la cartella documenti, quindi potete fare un’altra
scelta o fare semplicemente click sul pulsante OK. La lista sottostante viene popolata con i
nomi dei file e delle cartelle presenti nella cartella scelta. Se selezionate un file o una Di-
rectory dalla lista avrete informazioni aggiuntive sulla selezione effettuata.
Nell’immagine sottostante si vede il progetto in funzione. Per effettuare una nuova interro-
gazione fate click sul pulsante Apri Cartella ed effettuare una nuova scelta.
Il codice completo del programma si trova nel box sottostante.
Option Explicit On
Imports System.IO
Public Class Form1

Dim TipoUnita(6) As String
474
TextBox1.ScrollBars = ScrollBars.Vertical
Dim Carattere = New Font("Verdana", 9)
TextBox1.Font = Carattere
ListBox1.Font = Carattere
Dim Drives = System.IO.DriveInfo.GetDrives()

For Each HDD In Drives
Try
ComboBox1.Items.Add(HDD.Name & " - Spazio totale: "
& Format(HDD.TotalSize, "##,##"))
Catch
Exit Try
End Try
Next
End Sub
Info_Disco()
'imposta percorso iniziale


PercorsoCartella = FolderBrowserDialog1.SelectedPath
Else
Exit Sub
End If
Label1.Text = "Cartelle: " &

Directory.GetDirectories(PercorsoCartella).Count.ToString
Label2.Text = "File: " & Directory.GetFiles(PercorsoCartella).Count.ToString
'Cerca le cartelle
For Each Oggetto As String In Directory.GetDirectories(PercorsoCartella)
ListBox1.Items.Add(My.Computer.FileSystem.GetDirectoryInfo(Oggetto))
Next
'Cerca i file
For Each Oggetto As String In Directory.GetFiles(PercorsoCartella)
ListBox1.Items.Add(My.Computer.FileSystem.GetFileInfo(Oggetto))
475
Next
End Sub
Private Sub Info_Disco()
TipoUnita(1) = "L'unità non dispone di una Directory Radice"

TipoUnita(2) = "Dispositivo di archiviazione rimovibile (USB)"
TipoUnita(3) = "L'unità è un disco rigido."
TipoUnita(4) = "L'unità è un'unità di rete."
TipoUnita(5) = "CD/DVD-ROM."
TipoUnita(6) = "Disco RAM"
Dim HDDInfo = My.Computer.FileSystem.GetDriveInfo("C:\")
If HDDInfo.IsReady = True Then
Dim TipoDiscoFisso As String = HDDInfo.DriveType

Dim SpazioLibero As Int64 = Val(HDDInfo.TotalFreeSpace)
Dim SpazoTotale As Int64 = Val(HDDInfo.TotalSize)
Dim FormatoDisco As String = HDDInfo.DriveFormat
Dim EtichettaVolume As String = HDDInfo.VolumeLabel
TextBox1.Text = "Disco tipo : " & TipoUnita(TipoDiscoFisso) & vbCrLf &

"Spazio Libero: " & Format(SpazioLibero, "##,##") & " - bytes Liberi." & vbCrLf &
"Spazio Totale: " & Format(SpazoTotale, "##,##") & " - bytes" & vbCrLf &
"Formato Disco: " & FormatoDisco & vbCrLf &
"Etichetta di Volume: " & EtichettaVolume
End If
End Sub

Dim Oggetto As String = ListBox1.SelectedItem.ToString

Dim DI = New DirectoryInfo(Oggetto)
If DI.Exists Then 'è una cartella
Leggi_Cartella()
Else 'non è una cartella
Leggi_File()
End If
End Sub
Private Sub Leggi_Cartella()
Dim NomeCartella As String = ListBox1.SelectedItem.ToString

Dim Info = My.Computer.FileSystem.GetDirectoryInfo(NomeCartella)
ListBox2.Items.Add("Data Creazione: " & Info.CreationTime)
ListBox2.Items.Add("Data Ultimo Accesso: " & Info.LastAccessTime)
ListBox2.Items.Add("Data Ultima Modifica: " & Info.LastWriteTime)
End Sub
476
Private Sub Leggi_File()
Dim NomeFile As String = ListBox1.SelectedItem.ToString

Dim Info = My.Computer.FileSystem.GetFileInfo(NomeFile)
ListBox2.Items.Add("Estensione: " & Info.Extension)
ListBox2.Items.Add("Dimensione: " & Format(Info.Length, "##,##"))
Dim Attributi = File.GetAttributes(NomeFile)
If (Attributi And FileAttributes.ReadOnly) = FileAttributes.ReadOnly Then

ListBox2.Items.Add("Attributi: Sola Lettura")
End If
If (Attributi And FileAttributes.Archive) = FileAttributes.Archive Then

ListBox2.Items.Add("Attributi: Archivio")
End If
If (Attributi And FileAttributes.Hidden) = FileAttributes.Hidden Then

ListBox2.Items.Add("Attributi: Nascosto")
End If
If (Attributi And FileAttributes.System) = FileAttributes.System Then

ListBox2.Items.Add("Attributi: di Sistema")
End If
End Sub
End Class
Come prima cosa importo lo spazio dei nomi che mi permette di accedere alle classi neces-
sarie per avere informazioni suoi file.
Imports System.IO
Imposto il percorso iniziale e una matrice che serve per memorizzare il testo che descrive
il tipo di unità contenute nel computer, esempio disco fisso, lettore DVD ecc.

Dim TipoUnita(6) As String
Nell’evento Form_Load si trova il codice che vediamo nel box successivo.
TextBox1.ScrollBars = ScrollBars.Vertical
Dim Carattere = New Font("Verdana", 9)
TextBox1.Font = Carattere
477

Try
Catch
Exit Try
End Try
Next
End Sub
Questa parte di codice recupera i nomi di tutte le unità logiche presenti nel computer. Il
metodo GetDrives() crea una matrice dinamica di tipo DriveInfo che rappresenta le unità
logiche di un computer e le elenca nel ComboBox inclusa l’informazione dello spazio totale
di ciascuna unità.
Ripete un ciclo For Each per ogni elemento della matrice recuperando il nome e la dimen-
sione di ogni unità. Viene inserita anche una trappola per errori per evitare un eventuale
blocco del programma, se si dovesse verificare qualche eccezione nella lettura delle infor-
mazioni di una specifica unità.

Try
Catch
Exit Try
End Try
Next
Questa parte di codice viene eseguita appena si fa click sul pulsante Apri Cartella. Per
prima cosa viene eseguita la procedura Info_Disco() che valuta la tipologia di disco logico.
(vedi codice della procedura più avanti)
Info_Disco()
Quindi imposta come percorso iniziale quello della cartella Documenti del computer pren-
dendo il dato dalla variabile PercorsoCartella.
Viene assegnata alla variabile PercorsoCartella l’eventuale scelta fatta dall’utente. Se

l’utente annulla l’operazione dalla finestra del FolderBrowserDialog allora esce dalla proce-
dura senza andare oltre.
478
PercorsoCartella = FolderBrowserDialog1.SelectedPath
Else
Exit Sub
End If
Pulisce i due ListBox da eventuali elenchi precedenti.
Visualizza nella prima etichetta il numero di cartelle contenuto nel percorso specificato dalla
scelta dell’utente.
Label1.Text = "Cartelle: " &

Directory.GetDirectories(PercorsoCartella).Count.ToString
Nella seconda etichetta troviamo il numero dei file contenuti nella Directory selezionata
dall’utente.
Label2.Text = "File: " & Directory.GetFiles(PercorsoCartella).Count.ToString
Elenca nella lista tutte le cartelle presenti nel percorso selezionato dall’utente.
'Cerca le cartelle
For Each Oggetto As String In Directory.GetDirectories(PercorsoCartella)
ListBox1.Items.Add(My.Computer.FileSystem.GetDirectoryInfo(Oggetto))
Next
Terminate le cartelle elenca i file, come nel buon vecchio MS-DOS.
For Each Oggetto As String In Directory.GetFiles(PercorsoCartella)
ListBox1.Items.Add(My.Computer.FileSystem.GetFileInfo(Oggetto))
Next
Questa istruzione rappresenta una matrice con dentro i nomi delle directory.
Directory.GetDirectories(PercorsoCartella)
Stessa cosa con i file.
Directory.GetFiles(PercorsoCartella)
La procedura Info_Disco invece ricava le informazioni sull’unità del disco fisso del computer.
Private Sub Info_Disco()

479
TipoUnita(1) = "L'unità non dispone di una Directory Radice"
TipoUnita(2) = "Dispositivo di archiviazione rimovibile (USB)"
TipoUnita(3) = "L'unità è un disco rigido."
TipoUnita(4) = "L'unità è un'unità di rete."
TipoUnita(5) = "CD/DVD-ROM."
TipoUnita(6) = "Disco RAM"


End If
DriveInfo è una classe che fornisce accesso alle informazioni di un’unità, come ad esempio
lo spazio totale, quello libero, o il formato del file system del disco. Il metodo GetDriveInfo
restituisce un oggetto che contiene queste informazioni. Per quanto riguarda il tipo di disco,
il metodo restituisce un codice riportato in una matrice (TipoUnita) che viene sfruttata per
dare una descrizione all’informazione, dato che questa restituisce dei numeri che vanno da
1 a 6.
Tenete presente che le unità logiche nel computer sono identificate dal sistema operativo
come ai tempi del vecchio MS-DOS. (C:\) corrisponde alla prima unità logica fissa. Le unità
per i dischetti (A:\) e (B:\) oggi non sono più utilizzate, mentre un’unità CD-DVD è alta-
mente probabile che si identifichi con la lettera (D:\). Questo però dipende anche da quante
unità logiche sono presenti nel computer. Oggi è possibile, ad esempio, inserire nelle porte
USB presenti nel computer memorie di massa che fino a qualche anno fa non esistevano.
Anche queste una volta inserite saranno identificate da una lettera dell’alfabeto.
L’istruzione successiva verifica prima di iniziare l’interrogazione se il drive è pronto
Altrimenti si genera un errore se si va ad eseguire le righe successive. Quindi ricava tutte

le informazioni che caratterizzano il disco logico in questione. Qui invece di Integer per i
numeri vengono utilizzate variabili INT64 in quanto i valori possono quasi certamente su-
perare i limiti di una variabile Integer creando un overflow e bloccando il programma.

480
Viene creata una stringa con tutte le informazioni e visualizzata nel textbox. Il comando
vbCrLf serve per mandare accapo un testo in un textbox MultiLine.

Quando cambia la selezione nel Listbox1 è necessario, dato che il computer andrà a cercare
le informazioni sull’oggetto selezionato, sapere se questo è un file o una cartella in quanto
il recupero delle informazioni è diverso. Quindi con la Classe DirectoryInfo si va a controllare
se si tratta di una cartella. Se la risposta è affermativa verrà eseguita la procedura corri-
spondente, altrimenti verrà eseguita la procedura riservata ai files.

Dim Oggetto As String = ListBox1.SelectedItem.ToString

Dim DI = New DirectoryInfo(Oggetto)
If DI.Exists Then 'è una cartella
Leggi_Cartella()
Else 'non è una cartella
Leggi_File()
End If
End Sub
Nel caso di una cartella si interroga col il metodo GetDirectoryInfo. Prima si recupera nome
e percorso della cartella dalla ListBox1.
Dim NomeCartella As String = ListBox1.SelectedItem.ToString
Viene creato un oggetto DirectoryInfo per la cartella specificata nella stringa NomeCartella.
Dim Info = My.Computer.FileSystem.GetDirectoryInfo(NomeCartella)
Per visualizzare le caratteristiche di una cartella, come la data di creazione, dell’ultimo ac-
cesso e dell’ultima modifica, si aggiungono queste informazioni alla ListBox2. Vengono can-
cellati eventuali valori presenti nella ListBox2.
Nel caso di un file si interroga con il metodo GetFileInfo. Si recupera il nome e il percorso
del file dalla ListBox1
Dim NomeFile As String = ListBox1.SelectedItem.ToString
Si crea un oggetto FileInfo per recuperare le informazioni del file.

481
Dim Info = My.Computer.FileSystem.GetFileInfo(NomeFile)
E si recupera le informazioni aggiungendole alla ListBox2.
ListBox2.Items.Add("Estensione: " & Info.Extension)
ListBox2.Items.Add("Dimensione: " & Format(Info.Length, "##,##"))
Viene creato un oggetto FileAttribute dal metodo GetAttributes.
Dim Attributi = File.GetAttributes(NomeFile)
Per recuperare informazioni sui quattro attributi canonici dei file, Archivio, Sola Lettura,
Nascosto e di Sistema.
If (Attributi And FileAttributes.ReadOnly) = FileAttributes.ReadOnly Then

ListBox2.Items.Add("Attributi: Sola Lettura")
End If
If (Attributi And FileAttributes.Archive) = FileAttributes.Archive Then

ListBox2.Items.Add("Attributi: Archivio")
End If
If (Attributi And FileAttributes.Hidden) = FileAttributes.Hidden Then

ListBox2.Items.Add("Attributi: Nascosto")
End If
If (Attributi And FileAttributes.System) = FileAttributes.System Then

ListBox2.Items.Add("Attributi: di Sistema")
End If
482
Visual Basic & Word
So che può sembrare un’accoppiata strana, ma vi garantisco che questo connubio può avere
molte applicazioni, ad esempio è possibile creare una serie di lettere personalizzate dal
contenuto variabile da inviare ad una lista di distribuzione estratta da un database, e cen-
tinaia di altre applicazioni, che possono venirvi in mente quando avrete visto i “miracoli”
che questa abbinata può fare. Questo esercizio mostra molte caratteristiche di questa fun-
zionalità che possono essere utilizzate come spunto per permettervi di riadattarle alle vostre
specifiche necessità. Come in altri argomenti, ripeto nuovamente, che non è possibile vi-
sionare tutte le possibilità che questo strumento offre.
Anche se per l’esercizio esiste il codice già completo nel materiale allegato è necessario che
vi dia alcune spiegazioni per evitare insuccessi. Innanzitutto, create un nuovo progetto
facendo click sul menu File e scegliendo la voce Nuovo-Progetto.
Quindi come mostra la figura sottostante seguite i passaggi già visti.
Date un nome al nuovo progetto, magari diverso da quello in figura dato che si riferisce ad
un progetto già esistente se avete scaricato il codice d’esempio allegato al libro.
Fate click in basso a destra sul pulsante Crea per creare il progetto.
Una volta creato il nuovo progetto fate click sul menu Progetto e quindi dalla lista scegliete
la voce Proprietà come mostrato nella figura successiva per aggiungere i riferimenti ne-
cessari altrimenti il progetto non funzionerà.
Visual Basic & Word
483
Aggiungete i riferimenti necessari per il funzionamento del progetto, in questo caso dai
riferimenti COM e fra le librerie dei tipi cercate Microsoft Word 16.0 Object Library,
tenendo presente che il numero della versione varia al variare della versione di Word in-
stallata sul vostro computer. Nel nostro caso si riferisce a Word 2019.
Qualora non fosse disponibile è probabile che sul vostro computer non sia installato qualche
componente aggiuntivo come quando abbiamo visto nel capitolo di Microsoft Access. Prov-
vedete a procurarvelo e installarlo.
Salvate il progetto come mostra la figura successiva.
484
Adesso chiudete la scheda delle Proprietà.
Il progetto finito ha l’aspetto che vedete nella figura successiva. È composto da un TextBox
in versione MultiLine, ovvero abilitato dalla finestra delle proprietà a scrivere su più righe
che ci servirà per visualizzare un testo ripreso da un qualsiasi file di testo presente sul
computer.
Inoltre, abbiamo un PictureBox e tre pulsanti. Il funzionamento è semplice: attraverso il

pulsante Scegli File di Testo potremo aprire sullo schermo un qualsiasi file di testo formato
.txt disponibile sul nostro computer.
Con il pulsante Scegli Immagine è possibile fare apparire una qualsiasi immagine nel
PictureBox che si trova subito accanto. A questo punto facendo click sul pulsante Crea
Visual Basic & Word
485
Documento Word verrà inserito il testo e l’immagine in un nuovo documento Word al
quale verrà automaticamente assegnato un nome e quindi salvato.
Il tutto è stato volutamente semplificato in quanto, per quanto si tratta del salvataggio,
dovreste aggiungere opportune istruzioni per impedire che si verifichi qualche errore se il
file è già stato salvato. Al momento del successivo salvataggio troverebbe un file con lo
stesso nome. Consultate il capitolo che tratta delle operazioni sui file e sulle cartelle per
maggiori informazioni. Il codice completo dell’esercizio si trova nel riquadro sottostante:
Option Explicit On
Imports System.IO
Imports Microsoft.Office.Interop.Word
Public Class Form1

Dim NomeDocumento As String = "DocumentoWordeVisualBasic.docx"
Me.Text = "VisualBasic.Net e Word"
End Sub
Private Sub PulsanteCrea_Click(sender As Object, e As EventArgs) Handles

PulsanteCrea.Click
Dim ApplicazioneWord As Application

Dim Documento As Document
Dim Stringa1 As Paragraph
ApplicazioneWord = CreateObject("Word.Application")
ApplicazioneWord.Visible = True
'Crea un documento Word

Documento = ApplicazioneWord.Documents.Add()
'Aggiunge un paragrafo all'inizio del documento

Documento.Content.Paragraphs.Add()
Stringa1 = Documento.Content.Paragraphs.Add()
Stringa1.Range.Font.Name = "Verdana"
Stringa1.Range.Font.Bold = True
Stringa1.Range.Font.Size = 14
Stringa1.Range.Text = "Titolo della Pagina"
Stringa1.Range.Paragraphs.Alignment = WdParagraphAlignment.wdAlignParagraphCenter
486
' Dichiaro di volere inserire un altro paragrafo dopo
Stringa1.Range.InsertParagraphAfter()
Stringa2.Range.Font.Bold = False
Stringa2.Range.Text = "Questa è un'immagine (almeno credo)"
Stringa2.Range.Paragraphs.Alignment = WdParagraphAlignment.wdAlignParagraphJustify
Stringa3.Range.Text = TextBox1.Text
Try
Stringa4.Range.InlineShapes.AddPicture(PercorsoImmagine, True, True)
Catch
End Try
'*** Aggiunge un intestazione al documento ***
For Each section As Section In Documento.Sections
Dim Intestazione As Range = section.Headers(WdHeaderFooterIndex.wdHeaderFooterPrimary).Range
Intestazione.Font.ColorIndex = WdColorIndex.wdDarkRed
Intestazione.Font.Size = 12
Intestazione.Text = "Intestazione"
Next
'Aggiunge un piè di pagina al documento

Dim PiediPagina As Range =
section.Footers(WdHeaderFooterIndex.wdHeaderFooterPrimary).Range
PiediPagina.Font.ColorIndex = WdColorIndex.wdDarkRed
PiediPagina.Font.Size = 12
PiediPagina.Text = "edizionifutura.com"
Next
'Salva il documento con un nome

Documento.SaveAs("C:\Users\" & NomeUtente & "\Documents\" & NomeDocumento)
Visual Basic & Word
487
End Sub

OpenFileDialog1.Filter = "Immagini (*.jpg)|*.jpg|Bitmap (*.bmp)|*.bmp|Tutti i
File(*.*)|*.*"
PercorsoImmagine = LCase(OpenFileDialog1.FileName)
PictureBox1.Image = Image.FromFile(PercorsoImmagine)
End If
End Sub
Private Sub Button1_Click_1(sender As Object, e As EventArgs) Handles Button1.Click
Dim nomeFile As String

End If
End Sub
End Class
Per cominciare vanno importate le librerie per la gestione dei file e per l’utilizzo delle fun-
zionalità di Word.
Imports System.IO
Imports Microsoft.Office.Interop.Word
Quindi vanno definite le variabili che varranno per tutto il Form1.
Public Class Form1

488
Dim NomeDocumento As String = "DocumentoWordeVisualBasic.docx"
La parte del codice che si trova nel riquadro sottostante l’abbiamo già incontrata nel capitolo
che tratta delle finestre di dialogo, in questo caso OpenFileDialog, quindi se avete qualche
dubbio in proposti consultatelo.
Private Sub Button1_Click_1(sender As Object, e As EventArgs) Handles Button1.Click
Dim nomeFile As String

End If
End Sub
Anche la successiva parte del codice è una vecchia conoscenza; l’abbiamo già vista quando
affrontavamo l’argomento PictureBox.

OpenFileDialog1.Filter = "Immagini (*.jpg)|*.jpg|Bitmap (*.bmp)|*.bmp|Tutti i
File(*.*)|*.*"
PercorsoImmagine = LCase(OpenFileDialog1.FileName)
PictureBox1.Image = Image.FromFile(PercorsoImmagine)
End If
End Sub
La parte del codice che sta all’interno dell’evento click del pulsante Crea ha invece bisogno
qui qualche delucidazione. Quando viene premuto il pulsante Crea Documento Word,
dopo che abbiamo acquisito testo e immagine con il codice visto in precedenza, metto il
puntatore del mouse in attesa.
Visual Basic & Word
489
Dichiaro gli elementi in questo caso un oggetto applicazione di Word.
Dim ApplicazioneWord As Application
Un documento di Word.
Dim Documento As Document
Quattro paragrafi.

Avvio la creazione dell’oggetto e lo rendo visibile. A fine procedura comparirà sullo schermo
il documento. Se la proprietà fosse impostata su False non apparirebbe nulla sullo schermo
ma il documento di Word verrebbe creato ugualmente (cercate nella vostra Cartella Docu-
menti.)
ApplicazioneWord = CreateObject("Word.Application")
ApplicazioneWord.Visible = True
Creo il documento Word vero e proprio.
Documento = ApplicazioneWord.Documents.Add()
Aggiunge un paragrafo all'inizio del documento.
Documento.Content.Paragraphs.Add()
Crea un paragrafo.
Quelle che seguono sono le caratteristiche assegnate al paragrafo.
Stringa1.Range.Text = "Titolo della Pagina"
Gestisce l’allineamento di un paragrafo. Non spostatela in altra posizione rispetto al codice

del suo paragrafo altrimenti non funziona.
Dichiaro di volere inserire un altro paragrafo dopo
Aggiungo un nuovo paragrafo all’oggetto documento.
490
E definisco le caratteristiche del nuovo paragrafo. Il testo va inserito nella proprietà Text
dell’oggetto Stringa2 che non è una semplice stringa di testo ma rappresenta un paragrafo
con le sue caratteristiche.
Stringa2.Range.Font.Bold = False
Stringa2.Range.Text = "Questa è un'immagine (almeno credo)"
Stringa2.Range.Paragraphs.Alignment = WdParagraphAlignment.wdAlignParagraphJustify
Dichiaro nuovamente di volere inserire un altro paragrafo dopo
Aggiungo un terzo paragrafo. Stavolta aggiungo il testo che si trova nel TextBox1
Stringa3.Range.Text = TextBox1.Text
Nel quarto paragrafo inserisco l’immagine
Con un ciclo che serve a catturare gli errori qualora si verificassero.
Try
Stringa4.Range.InlineShapes.AddPicture(PercorsoImmagine, True, True)
Catch
End Try
Allineo l’immagine.
Questa sezione di codice invece aggiunge un testo all’intestazione di ogni pagina del docu-
mento.
Dim Intestazione As Range = section.Headers(WdHeaderFooterIndex.wdHeaderFooterPrimary).Range

Intestazione.Font.ColorIndex = WdColorIndex.wdDarkRed
Intestazione.Font.Size = 12
Intestazione.Text = "Intestazione"
Next
Questo invece aggiunge un piè di pagina ad ogni pagina del documento. Omettete pure
nelle vostre applicazioni quelle parti di codice le cui caratteristiche non vi necessitano per
quella specifica applicazione.
Visual Basic & Word
491
'Aggiunge un piè di pagina al documento

Dim PiediPagina As Range = section.Footers(WdHeaderFooterIndex.wdHeaderFooterPrimary).Range
PiediPagina.Font.ColorIndex = WdColorIndex.wdDarkRed
PiediPagina.Font.Size = 12
PiediPagina.Text = "edizionifutura.com"
Next
Salva il documento di Word con un nome.
Documento.SaveAs("C:\Users\" & NomeUtente & "\Documents\" & NomeDocumento)
Il puntatore del mouse ritorna ad essere una freccia.
Come per altri casi trattasi di pozzo senza fondo quindi se desiderate spingervi oltre con-
sultate la documentazione ufficiale della Microsoft.
492
Visual Basic & Excel
Anche Excel ha un debole per Visual Basic e viceversa, nel senso che esattamente per
quanto visto con Word anche in questo caso è possibile creare documenti, salvarli e cento-
mila altre diavolerie che qualcuno di voi saprà senz’altro fare quando si trova Excel fra le
mani. Quindi per motivi ovvi non starò qui a spiegarvi come funziona Excel, e se proprio vi
volete togliere questa curiosità vi rimando al libro “Excel da Principiante a Esperto” scritto
da me dove troverete una vasta esposizione delle funzionalità di Excel.
Questo tipo di programma che va sotto la categoria dei “Fogli Elettronici” o “Fogli di Calcolo”
è veramente versatile e si adatta velocemente ai mille problemi che è possibile incontrare
nel lavoro quotidiano.
Per sviluppare questo esercizio ho utilizzato Excel per realizzare un bilancio Entrate/Uscite
che vuole essere da spunto per eventuali vostre idee.
Quindi supponendo che conosciate lo strumento in questione partiamo per la nostra avven-
tura creando un nuovo progetto con i passaggi già visti in precedenza e assegnate un nome
al progetto. Il codice completo è disponibile con il materiale allegato al libro se non volete
digitare tutto il codice dall’inizio.
Quando il progetto viene generato fate click sul menu Progetto e dalla lista selezionate la
voce Proprietà del progetto in questione come mostra la figura successiva.
Qualora mancasse il riferimento mostrato nella figura successiva vale quello

che è stato detto per Word e Access. Probabilmente non è installato Excel sul
vostro computer oppure mancano delle librerie scaricabili gratuitamente dal
sito della Microsoft.
Quindi andate alla scheda Riferimenti per aggiungere quello che ci vuole per fare in modo
che Visual Basic interloquisca con Excel. Fate click sul pulsante Aggiungi in basso a destra
ricordando che per ogni nuovo progetto che cominciate è necessario sempre aggiungere
quei riferimenti che non sono di “serie” nell’ambiente di sviluppo di Visual Basic.
493
Il riferimento in questione si chiama Microsoft Excel 16.0 Object Library quindi selezio-
natelo e fate click sul pulsante OK in basso a destra nella finestra.
Come si vede nella figura successiva il progetto a livello estetico è composto solo da un
pulsante che provvederà a fare partire tutta la procedura.
494
Quando avvierete il progetto il risultato finale è simile a quello della figura successiva.
Quindi, avendo una mezza idea di quello che sarà il risultato finale andiamo ad analizzare
il codice dell’esercizio.
Option Explicit On
Imports Microsoft.Office.Interop.Excel
Public Class Form1

495
Dim NomeDocumento As String = "ExceleVisualBasic.xlsx"
End Sub
Dim j As Integer
Dim ApplicazioneExcel As Application

Dim CartellaExcel As Workbook
Dim Foglio As Worksheet
ApplicazioneExcel = CreateObject("Excel.Application")
ApplicazioneExcel.Visible = True
CartellaExcel = ApplicazioneExcel.Workbooks.Add
Foglio = CartellaExcel.Sheets.Add
Foglio.Cells(1, 1).value = "Bilancio"

Foglio.Cells(2, 1).value = "Mese"
Foglio.Cells(2, 2).value = "Entrate"
Foglio.Cells(2, 3).value = "Uscite"
Foglio.Cells(2, 4).value = "Saldo"
Foglio.Cells(3, 1).value = "Gennaio"
Foglio.Cells(4, 1).value = "Febbraio"
Foglio.Cells(5, 1).value = "Marzo"
Foglio.Cells(6, 1).value = "Aprile"
Foglio.Cells(7, 1).value = "Maggio"
Foglio.Cells(8, 1).value = "Giugno"
Foglio.Cells(9, 1).value = "Luglio"
Foglio.Cells(10, 1).value = "Agosto"
Foglio.Cells(11, 1).value = "Settembre"
Foglio.Cells(12, 1).value = "Ottobre"
Foglio.Cells(13, 1).value = "Novembre"
Foglio.Cells(14, 1).value = "Dicembre"
'Formatta il Titolo
With Foglio.Range("A1")
.Font.Name = "Verdana"
.Font.Size = 18
.Font.Bold = True
.VerticalAlignment = XlVAlign.xlVAlignCenter
.HorizontalAlignment = XlHAlign.xlHAlignCenter
End With
' Formatta la testata delle colonne

With Foglio.Range("A2", "E2")
.Font.Name = "Calibri"
.Font.Bold = True
.Font.Size = 14
496
End With
'Riempio le due colonne B e C di numeri pseudo Casuali
For j = 3 To 13
Foglio.Cells(j, 2).value = Int(Rnd() * 1000)

Next j
'Formula dei totali della colonna

Foglio.Range("B14").Formula = "=SUM(B3:B13) "
Foglio.Range("B14").NumberFormat = "##,##.00"
Foglio.Range("C14").Formula = "=SUM(C3:C13) "

Foglio.Range("C14").NumberFormat = "##,##.00"
'Crea La formula dei Saldi

For j = 3 To 14
Foglio.Range("D" & j).Formula = "=B" & j & "- C" & j & " "
Next j
Foglio.Range("A1", "E1").EntireColumn.AutoFit()
'nome del foglio che compare in basso

Foglio.Name = "Bilancio 2019"

CartellaExcel.SaveAs("C:\Users\" & NomeUtente & "\Documents\" & NomeDocumento)
End Sub
End Class
Innanzitutto nello spazio dei nomi è necessario importare la libreria in questione:
Imports Microsoft.Office.Interop.Excel
Questa parte di codice è una vecchia conoscenza e serve per recuperare il nome dell’utente
nel computer che sta eseguendo il programma. Inoltre crea una variabile che assegna un
nome al documento di Excel che salveremo.
Public Class Form1

Dim NomeDocumento As String = "ExceleVisualBasic.xlsx"
La routine dell’evento Click del pulsante invece è abbastanza nutrita di codice.

L’operazione può essere lunghetta…
Creo una variabile che mi serve per un loop più avanti…

497
Dim j As Integer
Dichiaro l’applicazione Excel, la cartella di lavoro, ovvero l’insieme dei fogli che Excel può
contenere, e un foglio singolo.
Dim ApplicazioneExcel As Application

Dim CartellaExcel As Workbook
Dim Foglio As Worksheet
Creo l’oggetto applicazione di Excel e la rendo visibile. Come nel caso di Word a seconda
dell’applicazione che volete realizzare può essere tenuta anche invisibile all’operatore.
ApplicazioneExcel = CreateObject("Excel.Application")
ApplicazioneExcel.Visible = True
Creo la cartella di lavoro.
CartellaExcel = ApplicazioneExcel.Workbooks.Add
Aggiungo un foglio alla cartella di lavoro.
Foglio = CartellaExcel.Sheets.Add
Inserisco i valori nelle relative celle.
Foglio.Cells(1, 1).value = "Bilancio"

Foglio.Cells(2, 1).value = "Mese"
Foglio.Cells(2, 2).value = "Entrate"
Foglio.Cells(2, 3).value = "Uscite"
Foglio.Cells(2, 4).value = "Saldo"
Foglio.Cells(3, 1).value = "Gennaio"
Foglio.Cells(4, 1).value = "Febbraio"
Foglio.Cells(5, 1).value = "Marzo"
Foglio.Cells(6, 1).value = "Aprile"
Foglio.Cells(7, 1).value = "Maggio"
Foglio.Cells(8, 1).value = "Giugno"
Foglio.Cells(9, 1).value = "Luglio"
Foglio.Cells(10, 1).value = "Agosto"
Foglio.Cells(11, 1).value = "Settembre"
Foglio.Cells(12, 1).value = "Ottobre"
Foglio.Cells(13, 1).value = "Novembre"
Foglio.Cells(14, 1).value = "Dicembre"
Formatto il titolo del Foglio
'Formatta il Titolo
With Foglio.Range("A1")
.Font.Name = "Verdana"
.Font.Size = 18
.Font.Bold = True
End With
E anche la testa delle colonne
' Formatta la testata delle colonne

With Foglio.Range("A2", "E2")
.Font.Name = "Calibri"
498
.Font.Bold = True
.Font.Size = 14
End With
Riempio le due colonne B e C di numeri pseudo Casuali
For j = 3 To 13

Next j
Creo una formula nella posizione B14 e C14 del foglio di calcolo dove verrà visualizzato il
totale della colonna Entrate e della colonna Uscite e do un formato ai risultati.
Foglio.Range("B14").Formula = "=SUM(B3:B13) "

Foglio.Range("B14").NumberFormat = "##,##.00"
Foglio.Range("C14").Formula = "=SUM(C3:C13) "

Foglio.Range("C14").NumberFormat = "##,##.00"
Maggiori informazioni sui formati è possibile ricavarle direttamente da Excel nel riquadro
Numeri. Quando si apre la scheda che vedete nella figura sottostante scegliete la scheda
Numero e andate su Personalizzato per visionare i formati disponibili.
Creo dinamicamente la formula dei saldi. Potevo anche scrivere tutte le formule ma ho
preferito fare così modificando con una variabile dinamica, che si incrementa ad ogni ciclo,
499
il valore delle coordinate delle celle e quindi anche delle formule, tenendo presente che la
formula in ogni cella avrebbe questo formato =B3-C3 e ripetuta per tutte le celle successive
quindi (=B4-C4 e così via)
'Crea La formula dei Saldi

For j = 3 To 14
Foglio.Range("D" & j).Formula = "=B" & j & "- C" & j & " "
Next j
Adatto automaticamente la larghezza delle celle al loro contenuto.
Foglio.Range("A1", "E1").EntireColumn.AutoFit()
Infine dò un nome alla linguetta del foglio che compare in basso su Excel.
'nome del foglio che compare in basso

Foglio.Name = "Bilancio 2019"
E quindi salvo il documento. Cercatelo nella Cartella Documenti del vostro computer.

CartellaExcel.SaveAs("C:\Users\" & NomeUtente & "\Documents\" & NomeDocumento)
500
La Stampa con Visual Basic
Come già accennato nel capitolo delle Finestre di Dialogo, la stampa con Visual Basic merita
un capitolo a sé, in quanto si tratta di un argomento particolarmente complesso. Va detto,
innanzi tutto, che esistono dei componenti aggiuntivi di terze parti che facilitano la stampa
rispetto alle funzionalità incluse in Visual Basic, che a prima vista in effetti risultano piutto-
sto complesse, tanto che buona parte dei programmatori opta quasi subito per l’adozione
di queste soluzioni alternative. Io vi suggerisco di studiarvi invece questo capitolo prima di
trarre delle conclusioni in quanto queste “soluzioni alternative” spesso e volentieri hanno
un costo che non giustifica il risultato finale, anche se in alcuni casi arrivano al risultato
molto prima delle funzionalità di stampa incluse in Visual Basic.
Per stampare avete bisogno sostanzialmente di tre controlli presenti fra i tanti disponibili in
Visual Basic:
• PrintDialog che viene utilizzato per effettuare la scelta della stampante

• PrintDocument serve per la stampa del testo e degli elementi grafici presenti in una
pagina.
• PrintPreviewDialog che viene utilizzato per visualizzare l’anteprima di stampa,
prima che il testo venga realmente stampato.
Quindi per iniziare la nostra avventura è necessario includere in un Form questi tre controlli.
L’esempio che viene mostrato in questa capitolo è particolarmente complesso perché prova
a coprire quanti più argomenti possibile, in modo da fornire un quadro abbastanza ampio
di quello che rappresenta la stampa in Visual Basic.
Ovviamente ai dati statici del progetto, come i dati dei clienti e dei prodotti, vanno sostituite
variabili magari prelevate da un database di Access, MySQL o SQLServer, e quindi questa
parte del progetto spetta a voi.
Il progetto presenta una casella combinata (ComboBox) e due pulsanti. La casella combi-
nata serve per scegliere la tipologia del documento da stampare, in questo caso Fattura o
documento di trasporto ecc., mentre i pulsanti servono per lanciare la stampa su carta o in
PDF.
Nell’evento click del pulsante Stampa troverete questa parte di codice:
PrintPreviewDialog1.ControlBox = True
PrintPreviewDialog1.UseAntiAlias = True
PrintPreviewDialog1.WindowState = FormWindowState.Maximized
Tenete presente che il controllo PrintPreviewDialog serve per generare l’anteprima di

stampa, anche se la stampa può essere effettuata senza generare l’anteprima.
Questa riga di codice serve per consentire al sistema operativo di smussare i caratteri.
Serve per visualizzare la casella di controllo sulla barra del titolo della finestra (in pratica in
alto a destra comparirà o meno la X per chiudere la finestra).
Questo comando ottiene o imposta il documento da visualizzare sull’anteprima, che nel

nostro caso viene definito dal controllo PrintDocumenti1. Praticamente il computer prima di
stampare deve eseguire tutto il codice che si trova sotto questo controllo.
La finestra dell’anteprima deve comparire massimizzata a tutto schermo.

501
Fa comparire fisicamente la finestra dell’anteprima. Se la proprietà Document del controllo
stesso non è inizializzata ovviamente non comparirà nulla nella finestra di anteprima.
Tutto il resto del codice si trova nell’evento PrintPage del controllo PrintDocument1 che si
genera facendo doppio click sul controllo in basso nella finestra di progettazione. Se avete
dubbi controllate il codice allegato al libro.
Private Sub PrintDocument1_PrintPage(sender As Object, e As PrintPageEventArgs) Handles

PrintDocument1.PrintPage
Questa parte del codice gestisce la tipologia di caratteri e lo spessore degli elementi grafici
presenti nella stampa della pagina. Per maggiori informazioni potete consultare il capitolo
che tratta del disegno con Visual Basic.

Dim Font6 As New Font("Calibri", 12, FontStyle.Bold)
'Riga dei Riquadri

Dim RigaNera As New Pen(Color.Black, 1)
Dim RigaGrigia As New Pen(Color.LightGray, 1)
Dichiaro un gruppo di variabili:
Dim RigheperPagina As Integer

Dim Y As Integer 'coordinata y di stampa
Dim j As Integer

Questa variabile rappresenta il numero di righe di una fattura, che ad esempio, vengono
stampate in una pagina. Ad esempio, 30 articoli per pagina prima di andare a pagina nuova.
Viene calcolata dal programma a seconda della grandezza del carattere scelto nella stampa.
Dim Y As Integer
La variabile Y viene utilizzata per determinare in qual punto della pagina stampare, si rife-
risce a un punto sulla verticale. (come l’asse delle Y in un grafico)

Questo rappresenta il totale delle righe in una fattura. Dipende da quanti articoli si trovano
nella fattura e di solito viene calcolato, quando recupero i dati da un database, dal numero
di righe presenti in un controllo tipo DataGridView.
L’ultima la variabile j serve più in là nel programma. Non ci sarebbe neanche bisogno di
dichiararla, ma le versioni antecedenti alla 2017 di VB.NET non dichiarano automaticamente
le variabili coinvolte in un ciclo For…Next.
Questa parte di codice invece:
Dim MargineSinistro As Integer = 30

Dim AltezzaPagina As Integer = e.PageBounds.Height
Dim LarghezzaPagina As Integer = e.PageBounds.Width
Dim AltezzaFont3 As Integer = Int(Font3.GetHeight(e.Graphics))
Dim Interlinea As Integer
502
Crea una variabile che poi servirà per allineare rispetto al margine di 30 punti gli elementi
grafici.
Queste due variabili che seguono sono state utilizzate per rendere il programma più leggi-
bile. Recupera dalle impostazioni della pagina quanto è alta la pagina in punti.
Recupera dalle impostazioni della pagina quanto è larga la pagina in punti.

Recupera l’altezza del font in punti. Questo può essere utili per adattare il numero delle
righe che vengono stampante per pagina a seconda della grandezza del carattere. Più
grande è il carattere minore sarà il numero delle righe che possono essere stampate in una
pagina.
Questa variabile servirà per memorizzare il passo fra le righe (interlinea.)

Il codice che segue è un esempio di come sia possibile stampare un logo o un’immagine,
che si trova da qualche parte nel vostro computer, e inserirla nella stampa di un documento.
Questo ovviamente è solo un esempio. Ulteriori considerazioni le troverete nel capitolo che
riguarda il disegno di un’immagine con VB.NET. Non dovreste avere difficoltà a interpretare
queste linee di codice.
Dim ImmagineLogo As Image = Image.FromFile(PercorsoProgramma & "\Logo.jpg")
e.Graphics.DrawImage(ImmagineLogo, MargineSinistro, 40, 200, 34)
Questa parte di codice crea un rettangolo dove poi si andrà ad inserire i dati che riguardano
l’azienda.
Dim RiquadroAzienda As New Rectangle(New Point(MargineSinistro, 75), New Size(320, 100))

Dim FormatoAzienda As New StringFormat(StringFormatFlags.FitBlackBox)
'Imposta l'allineamento verticale della stringa rispetto al box

FormatoAzienda.LineAlignment = StringAlignment.Center
'imposta l'allineamento Orizzontale della stringa rispetto al box

FormatoAzienda.Alignment = StringAlignment.Near
In questa parte invece stampa fisicamente il riquadro con i dati dell’azienda. La stringa con
i dati dell’azienda l’ho omessa ma si trova nel codice nell’esempio.
'Disegna il box
e.Graphics.DrawRectangle(Pens.White, RiquadroAzienda)
'Disegna la stringa inserendola dentro al box
e.Graphics.DrawString(DatiAzienda, Font4, Brushes.Black,
RectangleF.op_Implicit(RiquadroAzienda), FormatoAzienda)
Segue tutta una parte di codice di facile interpretazione che serve sostanzialmente a creare
i riquadri con le informazioni e a scriverci dentro le stesse.
503
Questa istruzione calcola quante righe posso entrare nella pagina basandosi sullo spazio già
occupato da tutti i riquadri che abbiamo già stampato, diviso la grandezza del carattere con
cui vengono stampate le righe degli articoli in fattura.
RigheperPagina = Int((AltezzaRiquadroArticoli - 40) / Font3.GetHeight(e.Graphics))
L’interlinea in questo caso è uguale all’altezza del carattere utilizzato.
Interlinea = Font3.GetHeight(e.Graphics)
Questa parte riguarda il primo loop, ovvero il ciclo si ripete per ogni articolo presente in
fattura. Ovviamente qui i dati sono statici. Nel codice di esempio troverete, nei commenti,
le righe di codice che servono per collegarsi con un controllo DataGridView.
'Codice Articolo - Colonna 0

e.Graphics.DrawString("0125874 ", Font4, Brushes.Black, MargineSinistro, Y)
' Descrizione - Colonna 1

e.Graphics.DrawString("PROGRAMMARE IN VISUALBASIC 2019 - PARTENDO DA ZERO",
Font4, Brushes.Black, 132, Y)
'Unità Di misura -Colonna 2

e.Graphics.DrawString("NR", Font4, Brushes.Black, 497, Y)
'Quantità - Colonna 6
QuantitaRiga = 15
e.Graphics.DrawString(Format(QuantitaRiga, "##,##"),
Font4, Brushes.Black, 555, Y, FormatoStringa)
'Prezzo Unitario
PrezzoUnitarioRiga = 39.5
e.Graphics.DrawString(Format(PrezzoUnitarioRiga, "##.00"),
'Sconto Cliente
ScontoRiga = 30
e.Graphics.DrawString(Format(ScontoRiga, FormatoZero), Font4,
Brushes.Black, 655, Y, FormatoStringa)
'Imponibile
ImponibileRiga = QuantitaRiga * PrezzoUnitarioRiga
ImponibileRiga = ImponibileRiga - (ImponibileRiga / 100 * ScontoRiga)
e.Graphics.DrawString(Format(ImponibileRiga, "##,##.00"),
'Aliquota %
VAT = 0
e.Graphics.DrawString(VAT, Font4, Brushes.Black, 746, Y, FormatoStringa)
'Codice Aliquota
e.Graphics.DrawString("40", Font4, Brushes.Black, 770, Y, FormatoStringa)
Y = Y + Interlinea 'incrementa il passo di stampa

504
La variabile riga viene incrementata ad ogni riga stampata. Quando raggiunge l’ultima riga
esce da questo ciclo e termina la stampa.
Riga = Riga + 1
'quando la riga di stampa è arrivata alla fine della griglia degli articoli
' stampa il piè di pagina
If Riga = TotaleRighe Then
Exit For
End If
Next j
Il resto del codice stampa il piè di pagina, ovvero tutte le informazioni che si trovano dopo
le righe degli articoli della fattura, oltre ad un secondo loop che stampa le aliquote iva
qualora ne fossero presenti più di una nel documento.
Questa che segue è una della parti più importanti. Quando termina la parte del codice che
riguarda il piè di pagina e si arriva all’etichetta (Uscita:), se dopo i vari incrementi della
variabile riga, che viene incrementata per ogni articolo stampato nel documento, il totale
delle righe è ancora maggiore significa che ci sono ulteriori articoli da stampare e quindi
necessitiamo di un’ulteriore pagina.
Uscita:
'nel caso che il numero degli articoli sia elevato e il documento necessiti di altre pagine
If TotaleRighe > Riga Then
NumeroPagina = NumeroPagina + 1
Else
e.HasMorePages = False
Riga = 0
NumeroPagina = 1
End If
Viene generata una nuova pagina e, per ogni nuova pagina, viene ripetuta tutta la parte
del codice che sta nell’evento PrintPage del controllo PrintDocument1.
Se invece il totale delle righe risulta essere uguale alla variabile riga allora non c’è bisogno
di ulteriori pagine.
In questo modo siete in grado di stampare anche documenti molto complessi. La parte più
lunga quando si sviluppa un programma di stampa sta nel posizionare correttamente tutti
gli elementi nel foglio, cosa che spesso necessita di molti tentativi. Fortunatamente dispo-
niamo dell’anteprima di stampa che ci permette di risparmiare carta.
Riepilogando il funzionamento essenziale della procedura avremo:
505
Importo la libreria che contiene gli oggetti grafici:
Dichiaro le variabili accessibili da tutte le procedure di questo Form. Vanno dichiarate in

questa posizione perché sono presenti in diversi punti del programma.
Public Class Form2
Dim Riga As Integer

Dim NumeroPagina As Integer
Dim NumeroAliquote As Integer = 1
Riga è una variabile che viene incrementata tutte le volte che stampa una riga per valutare
a che punto si trova la stampa. Attenzione, le sole righe che vengono ripetute nel docu-
mento, in questo caso le righe dei prodotti della fattura (potrebbe essere anche una lista di
nomi).
Dim Riga As Integer
è una variabile che memorizza il numero della pagina che viene stampata (compare sulla
stampa)
Dim NumeroPagina As Integer
In questa parte di codice vengono inizializzate le variabili e il controllo per l’anteprima della
pagina.
Riga = 0
NumeroPagina = 1
End Sub
Questa è la procedura principale che disegna fisicamente la pagina:
Private Sub PrintDocument1_PrintPage(sender As Object, e As PrintPageEventArgs)

Handles PrintDocument1.PrintPage
'*******************************************
'********* Definisce i font ************
'********* e altri elementi grafici *******
'*******************************************
Dim RigaNera As New Pen(Color.Black, 1)
Dim RigaGrigia As New Pen(Color.LightGray, 1)
Dichiara altre variabili che verranno utilizzate in questa procedura

Dim Y As Integer
506
Dim j As Integer
'Margini della Pagina


Poi disegna alcuni riquadri e altri elementi grafici, riquadri, immagini, linee ecc.
'Disegna il Logo con l'intestazione della ditta inserire ***** il codice qui
A questo punto acquisisce il numero degli elementi da stampare, ad esempio se disponete

di una lista con tante righe di informazioni viene recuperato il totale di queste righe dal
controllo DataGridView inserita nel Form.
Calcola il numero delle righe per pagina in base al font utilizzato
RigheperPagina = Int((AltezzaRiquadroArticoli - 40) / Font3.GetHeight(e.Graphics))

' spazio fra riga e riga
Interlinea = Font3.GetHeight(e.Graphics)
Questo è il loop principale. Dopo aver stampato l’intestazione del documento ne stampa le
righe delle informazioni. Questo loop viene eseguito fino a quando non si raggiunge il limite
massimo per pagina, contenuto nella variabile RigheperPagina oppure quando la Riga di
stampa, ovvero quella che è stata appena stampata, raggiunge il Totale delle righe (Totale-
Righe) da stampare.
'*** Stampa dettagli del documento (inserire qui il codice)
Y = Y + Interlinea 'incrementa il passo di stampa

Riga = Riga + 1
'quando la riga di stampa è arrivata alla fine della griglia degli articoli
' stampa il piè di pagina
If Riga = TotaleRighe Then
Exit For
End If
Next j
In questa zona del programma va inserito il codice che riepiloga i totali.

'********************-*****************
'***** Stampa Riepilogo e totali *****
'*************************************
Questo è il secondo loop. È su esempio nel caso vi trovaste a gestire una altro riepilogo di
dati.
For j = 0 To NumeroAliquote - 1
507
'**************************
' Riepilogo aliquote IVA **
'**************************
' Stampa dettagli aliquote iva inserite il codice qui
Y = Y + 20
Next j
Quando nel caso che il numero degli articoli sia elevato e il documento necessiti di altre
pagine. Tenete presente che:
TotaleRighe Rappresenta il numero totale delle righe del documento ottenuto dalla Da-
taGridView che li visualizza a schermo.
Riga È una variabile che conta quante righe sono già stampate
RigheperPagina È il calcolo approssimativo di quante righe possono entrare in un pagina
tenendo presente la grandezza del carattere utilizzata.
Interlinea Dentro questa variabile troverete quanto vale la distanza fra riga e riga
tenendo presente il tipo di carattere (Font) utilizzato per la stampa delle
righe di riepilogo.
Quando il computer alla fine della procedura incontra questa parte di codice valuta se il
totale delle righe è ancora maggiore della numero di righe già stampate.
If TotaleRighe > Riga Then
Else
Riga = 0
NumeroPagina = 1
End If
End Sub
End Class
Se la risposta è affermativa allora incrementa il contatore delle pagine e genera un nuova

pagina, ovvero ripete daccapo tutto il codice che trova nell’evento PrintPage del controllo
PrintDocument1.
altrimenti resetta le variabili per un’eventuale stampa successiva.
Riga = 0
NumeroPagina = 1
508
Stampa di un documento in PDF
Stampare un documento in formato PDF non è un’operazione complessa. Vale quando detto
fin qui con poche varianti sul tema. Il codice qui si seguito crea un file dove viene memo-
rizzato in formato PDF il documento che compare nell’anteprima di pagina come ad esempio
un documento come quello del caso precedente. L’unica cosa che cambia sono queste righe
di programma:
La prima riga sceglie come stampante di destinazione il componente Microsoft Print to PDF
presente fra le stampanti nel sistema operativo Windows 10.
PrintDocument1.PrinterSettings.PrinterName = "Microsoft Print to PDF"

PrintDialog1.Document = PrintDocument1
PrintDocument1.DefaultPageSettings.PrinterSettings.PrintToFile = True
PrintDocument1.DefaultPageSettings.PrinterSettings.PrintFileName = PercorsoFilePDF
PrintDocument1.Print() 'Stampa il file PDF
Imposta la stampante:
Assegna per la stampa il documento che si trova nel controllo PrintDocument1

Attiva la stampa su file. Quando si stampa con un qualsiasi programma, nella finestra di
dialogo, avrete senz’altro notato un riquadro con un segno di spunta che riporta: Stampa
su File. Normalmente questa caratteristica è impostata su False.
Stampa il file con nome e percorso specificato nella stringa PercorsoFilePDF

Avvia l’operazione della creazione del file.

PrintDocument1.Print()
Il resto del codice qui di seguito semplicemente crea un nome valido per il file che state
stampando. Dato che il programma, da dove proviene questo codice, era stato studiato in
origine per la fatturazione, prende la data odierna, il numero della fattura e la tipologia del
documento, ovvero fattura o documento di trasporto ecc., e miscelando queste tre infor-
mazioni crea un nome del file che il computer può visualizzare facilmente in ordine di data.
Ad esempio se la data del documento è 25/03/2021 la prima parte del nome del file diventa
“20210325”. In questo modo quando si apre la cartella dove si trovano questi documenti il
computer li mette naturalmente in ordine di data cominciando dall’anno, il mese e il giorno.

Dim PercorsoFilePDF As String
Dim Tipofile As String = Documento()
'LeggiCliente()
Riga = 0
NumeroPagina = 1
Dim DataDocumento As Date = "24/03/2021" 'per esempio

509
'Inverte anno,mese e giorno nella data per assegnare il nome al file
Dim DataDoc As String = Format(DataDocumento, "yyyyMMdd")

Dim AnnoDocumento As Integer = Format(DataDocumento, "yyyy")
'Formatta il numero del documento per renderlo a lunghezza fissa
Dim NumeroDoc As String = Format(NumeroDocumento, "000000")
'Assegna il nome al file PDF che deve essere stampato
NomeFile = DataDoc & Tipofile & NumeroDoc & ".pdf"
'Assegna il percorso al File

PercorsoFile = "C:\Users\" & NomeUtente & "\Documents\Documenti Emessi\" &
AnnoDocumento & "\"
Dim Esiste As Boolean
'Verifica l'esistenza di una cartella e se necessario la crea

Esiste = System.IO.Directory.Exists(PercorsoFile)
If Esiste = False Then
My.Computer.FileSystem.CreateDirectory(PercorsoFile)
End If
'A questo punto alla stringa viene aggiunto anche il nome del
'file oltre che il percorso
PercorsoFilePDF = PercorsoFile & NomeFile
'*******************************
'** Stampa PDF per Windows 10***
'*******************************
PrintDocument1.Print() 'Stampa il file PDF
MsgBox("operazione conclusa con successo", 48, "Messaggio")
Questa parte di codice crea il nome del file da salvare:

Dim AnnoDocumento As Integer = Format(DataDocumento, "yyyy")
'Formatta il numero del documento per renderlo a lunghezza fissa
'Assegna il nome al file PDF che deve essere stampato
'Assegna il percorso al File

AnnoDocumento & "\"
Formatta una data in senso inverso a quello a cui siamo abituati, Anno, Mese e Giorno.
Formatta un numero e lo rende a lunghezza fissa (lo si evince dal numero degli zeri) riem-
piendo con degli zeri la lunghezza mancante, ad esempio 125 lo trasforma in “000125”
Crea una stringa che rappresenta il nome del file concatenando le informazioni:
510
Specifica il percorso del file, ovvero in quale cartella finirà quel file.
AnnoDocumento & "\"
Questa parte di codice crea la cartella Documenti Emessi nel caso non esistesse.
Dim Esiste As Boolean
'Verifica l'esistenza di una cartella e se necessario la crea

Esiste = System.IO.Directory.Exists(PercorsoFile)
If Esiste = False Then
My.Computer.FileSystem.CreateDirectory(PercorsoFile)
End If
Stampa documento XPS

Si tratta di un file in un formato che somiglia al formato PDF ma creato secondo alcuni
standard della Microsoft. Windows ha un programma che legge questo formato. Per salvare
un file in questo formato è sufficiente sostituire con queste righe di codice quelle dell’esem-
pio precedente.
PrintDocument1.PrinterSettings.PrinterName = "Microsoft XPS Document Writer"

XML
511
XML
Conosciuto anche come Extensible Markup Language, è un “linguaggio” strutturato basato
su metadati che aggiungono ulteriori informazioni al contenuto dei dati stessi, conferendogli
un contesto descrittivo. In sintesi è un linguaggio creato per scambiare dati fra applicazioni.
Linguaggio fra virgolette perché non si tratta di un vero e proprio linguaggio di program-
mazione come si intende normalmente, ma piuttosto di una serie di “marcatori” strutturati
che incorniciano i dati e danno maggiori informazioni sugli stessi, ad esempio se un dato
provenisse dal campo indirizzo di una tabella potrebbe trovarsi incorniciato nel seguente
modo:
<Indirizzo>VIA GUGLIELMO MARCONI, 32</Indirizzo>
Un file XML su può aprire anche col Blocco Note di Windows, perché in pratica si tratta di
un normale file di testo con estensione .xml anziché .txt
In un file XML la sede di un’azienda potrebbe, ad esempio, essere identificata così:
<Sede>
<Indirizzo>VIA GUGLIELMO MARCONI</Indirizzo>
<NumeroCivico>32</NumeroCivico>
<CAP>40137</CAP>
<Comune>BOLOGNA</Comune>
<Provincia>BO</Provincia>
<Nazione>IT</Nazione>
</Sede>
Quindi ci sono forti analogie con il linguaggio HTML, quello utilizzato per costruire pagine
Web per intenderci. È presente un tag di apertura e uno di chiusura (si riconosce dal simbolo
/) entro i quali sono presenti i dati.
Ci sono altri tag che racchiudono blocchi di informazioni, come ad esempio <Sede> e
</Sede> oppure tag che identificano una ripetizione di linee come ad esempio le righe di
una fattura che contengono la lista dei prodotti.
<DettaglioLinee>
<NumeroLinea>8</NumeroLinea>
<CodiceArticolo>
<CodiceTipo>ISBN</CodiceTipo>
<CodiceValore>978-88-89600-60-3</CodiceValore>
</CodiceArticolo>
<Descrizione>DIVENTA PROGRAMMATORE PARTENDO DA ZERO</Descrizione>
<Quantita>39.00</Quantita>
<UnitaMisura>NR</UnitaMisura>
<PrezzoUnitario>17.775</PrezzoUnitario>
<PrezzoTotale>693.22</PrezzoTotale>
<AliquotaIVA>0.00</AliquotaIVA>
<Natura>N5</Natura>
</DettaglioLinee>
<DettaglioLinee>
<NumeroLinea>9</NumeroLinea>
<CodiceArticolo>
</CodiceArticolo>
<Descrizione>EXCEL 2016 - DA PRINCIPIANTE A ESPERTO</Descrizione>
512
<Natura>N5</Natura>
</DettaglioLinee>
In questo caso ogni riga della fattura corrisponde ad un articolo che avrà un prezzo, una
quantità, un’unità di misura e via discorrendo. Ogni riga della fattura è identificata con tutto
ciò che si trova entro questi due Tag.
<DettaglioLinee>
</DettaglioLinee>
L’articolo in questione può essere identificato da una tipologia di codice e da un codice.
<CodiceArticolo>
</CodiceArticolo>
E quindi da altre caratteristiche proprie come la descrizione, unità di misura, prezzo e altro.

La cosa importante è ricordare che quando si trova il tag che identifica una caratteristica ci
deve essere la sua controparte di chiusura, che può essere sulla stessa riga se i dati sono
limitati ad una caratteristica come ad esempio il prezzo, oppure può essere anche molto
lontana se definisce un blocco di informazioni come ad esempio:
<DettaglioLinee>
<CodiceArticolo>
</CodiceArticolo>
</DettaglioLinee>
Proprio perché possono identificare e delimitare un blocco anche piuttosto corposo di infor-
mazioni.
Un file XML ha una struttura estremamente variabile che dipende da come sono strutturati
i dati. Ad esempio, una fattura elettronica è articolata in una miriade di blocchi, ma è pos-
sibile identificarne due fra i principali, la testata (Header) e il corpo (Body) delle informa-
zioni. Quando i documenti adottando uno standard risulta molto più facile classificarli e
consultarli o creare dei programmi di analisi dei dati ad hoc.
XML
513
<?xml version="1.0" encoding="utf-8"?>

<ns xmlns="FatturaElettronica">
<FatturaElettronicaHeader>
………………
………………
</FatturaElettronicaHeader>
<FatturaElettronicaBody>
………………
………………
</FatturaElettronicaBody>
</ns>
Nel codice allegato al libro ho proposto due progetti, uno piuttosto semplice che analizza e
crea uno schema XML della struttura di un database e lo salva in un file XML, mentre l’altro
un po' più complesso, dove oltre alla struttura vengono allegati anche i dati.
Il progetto presenta tre button, tre textbox e una listbox. Non scenderò in dettagli sullo
standard XML e su tutte le considerazioni del caso, ma cercherò di limitarmi al minimo
indispensabile per diventare subito produttivi. Come esempio viene utilizzato il database
world che si trova nel server MySQL che avete installato sulla macchina dove sviluppate. Il
programma funziona con tutti i database, purché non particolarmente voluminosi in quanto
la generazione del file XML necessiterebbe di diverso tempo. Il codice completo del progetto
e riportato nel box successivo.
Imports System.Xml
Public Class Form1

USERID = "root"
ServerName = "127.0.0.1"
t_IndirizzoIP.Text = ServerName
p_XML.Enabled = False
p_Disconnetti.Enabled = False
End Sub
514

Try
Connessione.Open()
Exit Sub
End Try
'Legge la lista dei Database presenti nel Server

Next
End Using 'Chiude la connessione e libera le risorse.
If ListBox1.Items.Count > 0 Then p_XML.Enabled = True
p_Disconnetti.Enabled = True
End Sub
Private Sub p_XML_Click(sender As Object, e As EventArgs) Handles p_XML.Click
If ListBox1.SelectedIndex = -1 Then Exit Sub


'gestione del nome del file

Dim NomeFile As String = Database & ".xml"
XML
515
Dim settings As New XmlWriterSettings()

settings.Indent = True
'per scrivere ogni attributo in una nuova riga con un livello aggiuntivo di rientro:
settings.NewLineOnAttributes = True
'scelgo come carattere di indentazione TAB
settings.IndentChars = (ControlChars.Tab)
'Serve per far apparire la dicitura <?xml version="1.0" encoding="utf-8"?>
settings.OmitXmlDeclaration = False
Dim writer As XmlWriter = XmlWriter.Create(Percorso & NomeFile, settings)

writer.WriteStartElement("ns", NomeFile)
writer.WriteStartElement("Database") 'apre scrivendo il nome del database
writer.WriteElementString("Nome", ListBox1.Items(ListBox1.SelectedIndex))
writer.WriteEndElement() ' chiude tag database
Dim Connessione As New MySqlConnection(StringaConnessione)
Try
Connessione.Open()
Exit Sub
End Try
'Legge la lista delle tabelle presenti nel database

Dim ListaTabelle As DataTable = Connessione.GetSchema("Tables")
Connessione.Close()
Dim Comando As MySqlCommand

Dim LettoreDati As MySqlDataReader
Dim NomeTabella As String
'Leggi i nomi delle tabelle

For Each Riga As DataRow In ListaTabelle.Rows
writer.WriteStartElement("Tabella")
writer.WriteElementString("Nome", Riga("Table_Name"))
NomeTabella = Riga("Table_Name")
StringaSQL = "Select * FROM " & Riga("Table_Name")
Connessione.Open()

LettoreDati = Comando.ExecuteReader()
Dim SchemaTabella As New DataTable

'leggi la lista dei campi nella tabella
SchemaTabella = LettoreDati.GetSchemaTable()
Dim NomeCampo As String = " "
Do While LettoreDati.Read()
writer.WriteStartElement("Record") 'apertura tag per ogni record

516
For Each Riga1 As DataRow In SchemaTabella.Rows 'Ripete i campi per ogni record
NomeCampo = Riga1(0).ToString
Try
writer.WriteElementString(NomeCampo, LettoreDati.GetString(NomeCampo))
Catch
writer.WriteElementString(NomeCampo, " ")
End Try
Next
writer.WriteEndElement() 'chiusura tag per ogni record

Loop
writer.WriteEndElement() ' Tag di chiusura di una tabella
Comando = Nothing
LettoreDati = Nothing
Connessione = Nothing
writer.Flush()
Next
writer.WriteEndElement()
writer.WriteEndDocument()'Tag di chiusura dell'intero documento
If Not (writer Is Nothing) Then

writer.Close()
End If
MsgBox("File creato regolarmente", vbOKOnly, "Messaggio")
End Sub
Private Sub p_Disconnetti_Click(sender As Object, e As EventArgs)

Handles p_Disconnetti.Click
p_Disconnetti.Enabled = False
p_XML.Enabled = False
End Sub
End Class
Innanzitutto vanno importate queste due librerie che permettono rispettivamente di colle-
garsi ad un server MySQL e di accedere agli oggetti XML di Visual Basic.
Imports System.Xml
Adesso analizziamo le parti salienti. Questo codice può essere utilizzato come base per
vostri progetti futuri o per modifiche che rendano ancora migliore il progetto stesso.
La prima parte del codice ci permette di collegarci al server per prendere la lista dei data-
base e visualizzarli nella listbox.
XML
517

Try
Connessione.Open()
Exit Sub
End Try
'Legge la lista dei Database presenti nel Server

Next
End Using 'Chiude la connessione e libera le risorse.
If ListBox1.Items.Count > 0 Then p_XML.Enabled = True
p_Disconnetti.Enabled = True
End Sub
Viene creata in memoria una tabella che recupera la lista dei database dall’oggetto connes-
sione, e quindi la passa alla listbox.
Next
Adesso passiamo alla parte più importante che serve appunto per generare il file XML.
Innanzitutto, se nessun database è selezionato dalla lista, questa linea di codice impedisce
semplicemente di andare avanti nel programma.
518
If ListBox1.SelectedIndex = -1 Then Exit Sub
Quindi dopo aver preparato la connessione ai dati, crea una stringa col percorso del file
dopo la generazione, che di solito è la cartella Documenti del computer. Questo percorso
può essere modificato a piacimento a secondo delle vostre necessità o preferenze.
Nella variabile Database viene memorizzato il nome del database per la connessione.

Dim NomeFile As String = Database & ".xml"
Questa riga di codice permette di accedere alle impostazioni del generatore XML, dopo aver
creato un oggetto che si chiama settings. (potete anche chiamarlo impostazioni o come
desiderate)
Dim settings As New XmlWriterSettings()
Le impostazioni più importanti sono quelle riportate nel box successivo.
La riga successiva serve per scrivere, nel file XML, ogni attributo in una nuova riga con un
livello aggiuntivo di rientro. L’indentazione serve per rientrare le righe del codice esatta-
mente come si fa in Visual Basic per rendere più leggibile il codice. Inoltre viene impostato
che ciascun attributo sia disposto su righe diverse con un livello aggiuntivo di rientro. (Lo
spazio che c’è fra il margine sinistro e la riga di codice)
Scelgo come carattere di indentazione il tasto TAB.
Fa in modo di non omettere la dichiarazione inziale di un file XML, che fa capire che quello
che segue ha un formato XML.
<?xml version="1.0" encoding="utf-8"?>
Creo un oggetto di nome writer che servirà per scrivere il file XML. Vengono assegnate
all’oggetto il percorso e il nome del file, che per semplicità è lo stesso del database, e le
impostazioni fatte nelle righe precedenti.
Dim writer As XmlWriter = XmlWriter.Create(Percorso & NomeFile, settings)
Viene aggiunto un tag con il nome del file all’interno del documento XML.
XML
519
writer.WriteStartElement("ns", NomeFile)
Queste tre linee di codice,
writer.WriteStartElement("Database") 'apre scrivendo il nome del database

writer.WriteElementString("Nome", ListBox1.Items(ListBox1.SelectedIndex))
writer.WriteEndElement() ' chiude tag database
generano nel file una struttura simile a questa:
<Database>
<Nome>world</Nome>
</Database>
La prima riga di codice da inizio al blocco delle informazioni <Database>

La seconda inserisce il nome del database mentre la terza chiude il blocco di informazioni.
In un file XML possono esserci molti blocchi che racchiudono una categoria di informazioni,
blocchi che possono contenere anche svariate altre informazioni nidificate come vedremo
più avanti. In questo caso l’unica informazione contenuta nel blocco è il nome del database.
Dopo la connessione prepara una tabella con la lista delle tabelle presenti nel database
selezionato, come nel caso precedente, solo che questa volta non la elenca nella listbox ma
la tiene in memoria, visto che all’utente questa informazione non è necessaria.
Dim ListaTabelle As DataTable = Connessione.GetSchema("Tables")
Inizia un loop che termina quando ha ripetuto una certa procedura per ogni tabella presente
nel database.
For Each Riga As DataRow In ListaTabelle.Rows
Per ogni tabella è necessario raggruppare i vari record, ogni record come vedete presenta
più campi. Quindi il valore di ogni campo viene riportato nella struttura e identificato con i
relativi tag. Tutti i record vengono ripetuti fino all’ultimo record di una tabella, quindi tro-
veremo il tag di chiusura per passare alla tabella successiva. Nell’esempio sottostante, per
semplicità, si vedono solo i primi due record della tabella. Ogni campo è delimitato dal suo
tag come cosi i record e le tabelle. Per quanto riguarda quest’ultimi, dato che contengono
più dati strutturati al loro interno, è probabile che il tag di chiusura sia anche piuttosto
distante da quello di apertura.
<Tabella>
<Tabella>city</Tabella>
<Record>
<ID>1</ID>
<Name>Kabul</Name>
<CountryCode>AFG</CountryCode>
<District>Kabol</District>
<Population>1780000</Population>
</Record>
<Record>
<ID>2</ID>
<Name>Qandahar</Name>
<CountryCode>AFG</CountryCode>
<District>Qandahar</District>
520
<Population>237500</Population>
</Record>
</Tabella>
Attenzione al fatto che aperture e chiusure devono tornare altrimenti è probabile che Visual
Basic restituisca un errore impedendo la creazione del file risultante. Perdersi fra i vari tag
è più facile di quanto non crediate.
writer.WriteStartElement("Tabella")
writer.WriteElementString("Nome", Riga("Table_Name"))
Le prossime righe recuperano il nome della tabella e creano un comando SQL che serve per
recuperare i dati dalla tabella stessa, ovvero i dati e i nomi dei campi.
NomeTabella = Riga("Table_Name")
StringaSQL = "Select * FROM " & Riga("Table_Name")
Si crea una connessione utilizzando la stringa che abbiamo visto prima, tenendo presente
che il lettore dati è un oggetto della classe MySqlDataReader, dichiarato prima del loop. Per
ogni tabella viene ripetuta questa procedura. Con le due righe successive viene recuperato
lo schema della tabella, ovvero il nome dei campi che si trovano nella tabella.
Dim LettoreDati As MySqlDataReader

Connessione.Open()
LettoreDati = Comando.ExecuteReader()
Dim SchemaTabella As New DataTable
SchemaTabella = LettoreDati.GetSchemaTable()
Questo loop si ripete fino a quando non ha letto tutti i record della tabella, e crea dei tag di
apertura e di chiusura con il nome del campo e il relativo contenuto. Da notare che, nel
caso un campo assumesse il valore Null, ovvero e sempre stato vuoto fin dalla sua crea-
zione, lo scrittore dei dati XML può generare un’eccezione e bloccare l’esecuzione del pro-
gramma. Quindi, è necessario inserire un blocco Try, Catch, End Try per porre rimedio a
questo problema.
Do While LettoreDati.Read()
writer.WriteStartElement("Record") 'apertura tag per ogni record
For Each Riga1 As DataRow In SchemaTabella.Rows 'Ripete i campi per ogni record
NomeCampo = Riga1(0).ToString
Try
writer.WriteElementString(NomeCampo, LettoreDati.GetString(NomeCampo))
Catch
XML
521
writer.WriteElementString(NomeCampo, " ")
End Try
Next
writer.WriteEndElement() 'chiusura tag per ogni record
Loop
Al termine del loop interno inserisce il tag di chiusura della tabella. Elimina la connessione
e il lettore dei dati i modo da resettarli per la connessione successiva, e ripete il ciclo prin-
cipale, identificato con Next, per la tabella successiva. Quando ha finito le tabelle del data-
base inserisce il tag di chiusura nel documento e invia i dati al generatore di file XML. Quindi
crea il file vero e proprio e termina la procedura. Viene rifatta la connessione al database
perché questa accede alla singola tabella per verificarne le caratteristiche.
writer.WriteEndElement() ' Tag di chiusura di una tabella
Comando = Nothing
LettoreDati = Nothing
Connessione = Nothing
writer.Flush()
Next
writer.WriteEndElement()
writer.WriteEndDocument()'Tag di chiusura dell'intero documento

writer.Close()
End If
Andate adesso nella cartella dove l’applicazione ha salvato il file e verificate il funziona-
mento dell’applicazione.
Il metodo Flush() scarica il contenuto del buffer dei dati che si sono accumulati nell’oggetto
XmlWriter. Questo oggetto fornisce un metodo veloce per generare flussi di dati o, come
nel nostro caso, file contenenti dati formattati come XML.
writer.Flush()
Il metodo Close() chiude l’oggetto writer e scrive i dati scaricati dal buffer dei dati nel file
XML. Queste righe fanno un controllo per verificare che l’oggetto non sia già stato chiuso.

writer.Close()
End If
I metodi principali per scrivere gli elementi sono: WriteElementString che scrive un ele-
mento che contiene una stringa di caratteri.
Stringa1 = "Database"
Stringa2 = "World"
writer.WriteElementString(Stringa1, Stringa2)
522
Risultato:
<Database>World</Database>
Il metodo WriteStartElement utilizzato insieme al metodo WriteEndElement. Esempio:
Stringa1 = "Database"
writer.WriteStartElement(Stringa1) 'apre tag

………………
writer.WriteEndElement() ' chiude tag
Risultato:
<Database>
………………
</Database>
Quando viene chiamato il metodo WriteEndDocument() chiude qualsiasi elemento o attri-

buto aperto e riporta il writer allo stato iniziale. Esempio:
writer.WriteEndDocument()
writer.Flush()
writer.Close()
Distribuire un’applicazione
523
Quando un progetto è terminato se lo si vuole installare su altri computer o distribuire ad
un cliente o agli amici è necessario creare quello che in gergo viene chiamato il Setup del
programma. Fate click sul menu Compilazione in alto nella finestra e dalla lista scegliete
la voce Pubblica seguita dal nome del vostro progetto.
Al passaggio successivo fate click sul pulsante Avanti.
Come mostra la figura successiva potete creare un pacchetto di installazione per distribuirlo
attraverso il un CD-ROM o DVD-ROM ma sono possibili anche altre soluzioni che trascure-
remo al momento.
524
Fate click sulla casella di opzione Non controllare la disponibilità di aggiornamenti e

quindi fate click sul pulsante Avanti.
525
Verificate in quale cartella viene posizionato il pacchetto di installazione, che di solito è
dentro la cartella del progetto, e quindi fate click sul pulsante Fine in basso nella finestra.
Al termine della procedura che di solito dura pochi secondi a seconda anche della consi-
stenza del programma, si apre automaticamente sullo schermo la finestra dove si trovano
i file che verranno utilizzati per l’installazione. Il programma Setup provvederà all’installa-
zione della vostra applicazione.
Ovviamente è inutile farla partire dal vostro computer in quanto il funzionamento è assicu-
rato. Se volete verificare veramente che tutto funzioni come si deve, dovete installarlo su
un computer che non sia il vostro dove è probabile che manchi qualche componente che
dovrete provvedere ad installare in modo indipendente, come ad esempio le librerie Con-
nector.net di MySQL.
526
Appendici
Le parole chiave in Visual Basic.
Questo elenco riporta le parole chiave del linguaggio Visual Basic che non possono essere
utilizzate per identificare variabili o altri elementi di programmazione come ad esempio
routine o funzioni, perché genererebbero degli errori. È possibile superare questa restrizione
racchiudendo il nome tra parentesi quadre [].
Esempio: Dim [And] As String
AddHandler AddressOf Alias And

AndAlso As Boolean ByRef
Byte ByVal Call Case
Catch CBool CByte CChar
CDate CDbl CDec Char
CInt Class CLng CObj
Const Continue CSByte CShort
CSng CStr CType CUInt
CULng CUShort Date Decimal
Declare Default Dim DirectCast
Do DoubleEach Else ElseIf
End EndIf Enum Erase
Erroree Event File False
Finally For (in For…Next) For Each…Next Friend
Function Get GetType GetXMLNamespace
Global GoSub GoTo Handles
If() Implements Imports In
Inherits Integer Interface Is
IsNot Let Lib Like
Long Loop Me Mod
Module MustInherit MustOverride MyBase
MyClass NameOf Narrowing New
Next Not Nothing NotInheritable
NotOverridable Oggetto Of On
Operator Opzione Optional Or
OrElse Out Overloads Overridable
Overrides ParamArray Partial Private
Property Protected Public RaiseEvent
Appendici
527
ReadOnly ReDim REM RemoveHandler
Resume Return SByte Set
Shadows Shared Short Single
Static Step Stop String
Structure Sub SyncLock Then
Throw Per True Try
TryCast TypeOf…Is UInteger ULong
UShort Using Variant Wend
When While Widening With
WithEvents WriteOnly Xor #Const
#Else #ElseIf #End #If
= & &= *
*= / /= \
\= ^ ^= +
+= - -= >>
>>= << <<=
Parole chiave non riservate

Le seguenti parole chiave non sono riservate e possono essere usate come nomi degli ele-
menti di programmazione. Vi consiglio di non utilizzarle comunque poiché questa opera-
zione potrebbe complicare la lettura del codice e causare errori difficili da rilevare.
Aggregate Ansi Assembly Async

Auto Await Binary Compare
Personalizzato Distinct Equals Explicit
From Group By Group Join Into
IsFalse IsTrue Iteratore Join
Key Mid Off Order By
Preserve Skip Skip While Strict
Take Take While per Unicode
Until Where Yield #ExternalSource
#Region
528
Risorse
Sito documentazione ufficiale Microsoft:
https://docs.microsoft.com/it-it/dotnet/api/
https://docs.microsoft.com/it-it/dotnet/api/?view=netframework-4.8
MySQL:
https://www.mysql.com/it/
https://www.mysql.com/it/downloads/
Access Runtime Library

Versione Installer:
https://www.microsoft.com/it-IT/download/details.aspx?id=50040
Versione A Portata di Click (Office 365/2019)

Cercare su un motore di ricerca: Office Runtime a Portata di Click
Richiesta del codice di esempio:

Indice
529
Indice
Casella Combinata · 148

Casella degli strumenti · 17; 115; 158; 202
A Catch · 287; 291; 356; 358; 359; 360; 361; 363;
366; 368; 369; 370; 416; 469
Abs · 66 CBool · 87
Access · 2; 213; 215; 216; 218; 227; 228; 238; 241; CByte · 87
243; 248; 249; 250; 254; 255; 256; 259; 260; CDate · 88
263; 266; 267; 270; 273; 275; 277; 278; 279; CDbl · 88; 94
283; 284; 285; 287; 314; 321; 335; 338; 339; 348 CDec · 88
Addizione · 62 Ceiling · 109
AllowPrintToFile · 170; 172 CenterScreen · 28
AllowUserToResizeColumns · 383; 388 ChangeUICues
AllowUserToResizeRows · 290; 383; 388 Evento · 211
AlternatingRowsDefaultCellStyle · 290; 383; 388 Char · 61
Applicazione Windows Forms · 53 CheckBox · 136; 139
Array · 109; 110; 112; 113 Chiave Primaria · 224
Asc · 87; 372; 373 Chr · 88; 89
ASCII · 372 CInt · 89; 109
Attributi CLng · 89
Attributi dei File · 481 Close · 163; 165; 166; 170; 172; 173; 289; 291; 292;
AutoSize · 136 293; 294; 295; 296; 297; 298; 299; 358; 359;
AVG · 347; 348 360; 361; 362; 363; 364; 365; 366; 367; 369;
370; 376; 416
Codice · 22; 238; 360
CollapseAll · 450
B ColorDialog · 168
ComboBox · 148; 292; 293; 295; 297; 359; 360; 364
BackColor · 119; 127; 129; 131; 136 CommandBuilder · 299; 359; 361; 365
BackColorChanged · 211 Compilazione · 33; 523
Backup · 403; 404; 405 ConnectionString · 355
Barra degli Strumenti · 197 Const · 59; 378
BeginUpdate · 444; 445; 446; 447; 449; 451 ContextMenu
Boolean · 61; 391; 392; 393; 394 Proprietà · 211
Booleano · 81; 85; 86; 87 ContextMenuChanged
BorderStyle Evento · 211
Proprietà · 211 ContextMenuStrip
BorderStyleChanged · 211 Proprietà · 211
Brush · 424; 425 ContextMenuStripChanged
Brushes · 171; 174; 300; 301; 302; 303; 419; 420; Evento · 211
421; 422; 423; 425; 502; 503 ControlBox · 32
Button · 117; 153; 158; 168; 172; 199 Controlli · 22; 115
Byte · 61; 88; 526 Controllo · 76; 90; 92; 128; 158; 160; 174; 413
ByVal · 98; 99; 368 CopyDirectory · 469; 470
Cos · 69
Cosh · 69
C costante · 59
Create · 115; 147; 148; 153; 158; 175; 256; 259;
Campi · 214; 218 319; 322; 340; 347; 349
Campo · 134; 238; 323; 324; 337
530
CreateGraphics() · 419; 420; 421; 422; 423; 424; Dock
425; 426; 427; 428 Proprietà · 211
CSng · 89 DockChanged
CStr · 90 Evento · 211
Cursor · 119; 148; 364; 365; 368; 369; 370; 378; DoDragDrop · 208; 209; 210
379 DOS · 2; 313; 468
CursorChanged Double · 57; 61; 62; 68; 95; 98; 99; 104; 105; 106;
Evento · 211 107; 108; 148; 293; 295; 297; 298; 324; 373
DoubleClick · 46; 49
Drag · 208
D DragDrop
Evento · 208; 209; 210
Data e Ora · 75 DragDropEffect · 210
DataAdapter · 358 DragEnter
DataGridView · 288; 289; 299; 302; 356; 357; 358; Evento · 208; 209; 210
367; 370 DragLeave
DataSet · 288; 292; 293; 294; 296; 297; 298; 358; Evento · 211
359; 360; 361; 363; 364; 365; 369; 370; 376; DragOver
382; 383; 384; 385; 386; 387; 388 Evento · 211
DataSource · 288; 292; 293; 358; 359; 360; 363; DrawEllipse · 424
369; 370; 382; 383; 385; 386; 387 DrawIcon · 427
Date · 21; 53; 57; 61; 75; 82; 94; 144; 146; 147; DrawImage · 427; 428
218; 237; 251; 368; 482; 508 DrawLine · 419; 420; 425
DateAdd · 76 DrawPolygon · 423
DateDiff · 77; 78 DrawRectangle · 421; 422; 424; 426
DatePart · 78 DrawString · 424; 425; 426
DateSerial · 79; 80 DriveInfo · 474; 477; 479
DateTimePicker · 142; 144; 145; 146; 368 Drop · 208; 210; 321; 349
DateValue · 80 DropDown · 148; 150; 384
Day · 81 DropDownButton · 441
DayOfWeek · 147 DropDownClosed · 382; 383; 386; 387
DayOfYear · 147 DropDownList · 148; 150; 382; 385
DBNULL · 376
Debug · 35
Decimal · 61 E
DefaultCellStyle · 290; 291; 383; 384; 387; 388
Dim · 57; 58; 62; 68; 94; 95; 104; 105; 106; 107; Elevamento a potenza · 62
108; 109; 112; 113; 148; 149; 151; 154; 159; Ellisse · 423
160; 161; 162; 163; 164; 165; 170; 171; 172; Else · 100; 101; 102; 103; 104; 138; 376
173; 291; 292; 293; 294; 295; 296; 297; 298; Empty · 86; 87
299; 300; 301; 302; 355; 357; 358; 359; 360; Enabled · 119; 124; 135; 138; 163; 164; 166; 170;
361; 362; 363; 364; 365; 366;367; 368; 369; 370; 172; 192; 205; 206; 207
372; 373; 376; 378; 379; 380; 468; 469; 470; EnabledChanged
471; 472 Evento · 211
Directory · 468; 469; 470; 471 End · 46; 47; 55; 56; 96; 98; 99; 100; 101; 102; 103;
DirectoryInfo 104; 108; 112; 124; 125; 138; 148; 150; 152;
Classe · 475; 480 154; 159; 163; 164; 166; 170; 171; 172; 173;
DisplayMember · 292; 293; 359; 360; 363; 382; 174; 181; 206; 207; 287; 291; 300; 301; 303;
383; 385; 386; 387 356; 358; 359; 360; 361; 363; 365; 366; 367;
DisplayStyle · 199 369; 370; 372; 373; 376; 377; 379; 416; 469; 470
Divisione · 62 End Function · 98; 99
DO Until · 107 End Sub · 46; 47; 56; 96; 112; 138; 148; 150; 152;
DO While · 107 154; 159; 163; 164; 170; 171; 181; 206; 207;
Indice
531
300; 301; 358; 359; 361; 363; 365; 366; 367; 179; 190; 191; 194; 197; 202; 205; 206; 287;
369; 376; 379 356; 360; 362; 364; 366; 367; 371; 377; 378; 380
EndUpdate · 445; 446; 447; 449; 451 Form di Avvio · 178
Enter (Evento) · 374 Form MDI · 175; 177; 194
Errori · 76 Format · 70; 94; 95; 144; 300; 302; 368; 369; 370
ErrorProvider · 373; 374; 375; 376 FormatCurrency · 90
Esplora Risorse · 24 FormatDateTime · 91
Esplora Server · 281; 315 FormatNumber · 91
Esplora Soluzioni · 17; 20; 21; 38; 41; 42; 45; 48; FormatPercent · 92
175; 194; 195; 296; 377 FormBorderStyle · 32
Espressione · 80; 82; 83; 84; 85; 86; 87; 88; 90; 91; FormMDI · 177; 179; 180; 417
92; 93 Funzioni · 87
Eventi · 46 Funzioni trigonometriche · 68
evento · 46; 47; 49; 56; 127; 128; 129; 130; 131;
132; 133; 138; 140; 142; 145; 147; 148; 150;
153; 158; 162; 166; 172; 174; 191; 196; 201; G
202; 206; 207; 303; 367; 371; 372
Excel · 2; 9; 213; 214; 215; 228; 260; 261; 262; 263; Get · 459; 460; 461; 526
273; 274; 329; 335 GetAttributes · 476; 481
ExecuteNonQuery · 291; 292; 366; 367 GetDataPresent · 208; 209; 210
ExpandAll · 445; 446; 447; 450 GetDirectoryInfo
Metodo · 474; 475; 478; 480
GetDriveInfo
F Metodo · 475; 479
GetDrives
False · 30; 31; 32; 61; 81; 84; 85; 86; 87; 124; 135; Metodo · 474; 477
136; 138; 140; 163; 164; 165; 166; 170; 172; GetFileInfo
192; 206; 207; 290; 471 Metodo · 472; 474; 476; 478; 480; 481
FileAttribute · 481 GiveFeedback
FileSystem · 468; 469; 470; 471; 472 Evento · 211
Fill · 292; 293; 294; 296; 297; 298; 358; 359; 360; GotFocus · 127; 128; 134; 374
361; 363; 364; 365; 369; 370; 376 Evento · 211
Find · 433 GoTo · 97; 98
Finestra · 45 Graphics · 171; 173; 174; 300; 301; 302; 303; 419;
Finestra del codice · 45 420; 421; 422; 423; 424; 425; 426; 427; 428;
FlatStyle · 119 501; 502; 503; 506
Floor · 109 Graphics.DrawLine · 300; 302
Flush · 516; 521; 522 Graphics.DrawString · 171; 174; 300; 301; 302; 303
FolderBrowserDialog · 437 GroupBox · 140; 141
Font · 127; 136; 167; 171; 173; 174; 290; 300; 301;
424; 425; 426; 434; 436; 437; 485; 486; 489;
490; 491; 495; 497; 498; 501; 505; 507 H
FontChanged
Evento · 211 Height · 25; 26; 170; 171; 172; 173; 290; 300; 302
FontDialog · 167 Hex · 93
FontStyle · 171; 173; 300; 301; 424; 425; 434; 436; Hour · 80; 81
437; 501; 505
For · 104; 105; 107; 110; 112; 171; 174; 300; 302
ForeColorChanged
Evento · 211
I
Form · 23; 25; 29; 38; 39; 49; 55; 64; 116; 130; 131;
132; 135; 136; 137; 139; 140; 142; 144; 147; ID · 218; 283; 287; 290; 291; 292; 296; 297; 298;
153; 158; 162; 168; 172; 175; 176; 177; 178; 348; 355; 363; 364; 365; 366; 367; 376
532
If · 100; 101; 102; 103; 104; 108; 138; 154; 155; Evento · 212
159; 160; 163; 164; 165; 166; 170; 171; 172; Leave (Evento) · 374
173; 174; 206; 207; 291; 299; 300; 301; 302; Len · 73; 95
303; 366; 367; 372; 373; 376; 377; 470 Like · 345
Image · 119; 121; 159; 160; 161; 192; 200 ListBox · 150
ImageAndText · 200 Load · 47; 56; 96; 112; 127; 132; 137; 148; 149;
ImageList · 439; 440; 443; 444; 448; 450 151; 154; 159; 163; 170; 172; 181; 191; 205;
Imports · 62; 162; 164; 169; 171; 181; 205; 299; 358; 371
355; 357; 378; 412 LocationChanged
IN · 346; 347 Evento · 212
Indentazione · 518 log · 66
Indexes · 327 Log10 · 67
IndexOf (Metodo) · 374; 375 logaritmo · 66; 67
Indice · 213; 529 Long · 76
Indicizzato · 220; 238 LostFocus · 130; 131; 134; 374
Indirizzo IP · 354; 355 LTrim · 75
InputBox · 156; 157
InStr · 72
Int · 66; 67; 108; 109; 110; 112; 155; 171; 173; 300; M
302
Integer · 57; 58; 61; 74; 78; 80; 81; 82; 83; 87; 94; Maggiore · 23; 101; 249; 255; 345; 346
105; 106; 107; 109; 112; 113; 154; 170; 171; Maschere · 268
172; 173; 293; 295; 297; 298; 299; 300; 301; 372 Mask
Intero · 89 Proprietà · 429; 430; 431
Interval · 205; 206 MaskedTextBox · 373; 429; 430; 432; 433
IS NULL · 346 MaskFull · 430; 431; 432; 433
IsDate · 85 MaskInputRejected · 430; 431; 432
IsEmpty · 85; 86 Math · 62; 109
IsNull · 87 Matrice · 109; 110; 112; 113; 114; 422
IsNumeric · 86 MaxDate
Item · 291; 292; 296; 297; 300; 302; 363; 364; 366; Proprietà · 146
376; 377 MaximizeBox · 30
Items · 150; 151; 152; 198; 203; 398; 399; 400; Maximized · 29; 179; 206; 207
401; 402; 418; 438; 441; 442; 514; 515; 516; MaxLength · 127; 132; 371
517; 518; 519 Menu · 14; 175; 181
MenuStrip · 185
MessageBox · 154
K Mid · 73; 95
Migrazione · 405
KeyDown MinDate
Evento · 212; 431; 432 Proprietà · 146
KeyPress · 371 MinimizeBox · 30
Evento · 212; 431; 432 Minore · 101; 249; 346
KeyUp Modified
Evento · 212 Proprietà · 212
ModifiedChanged
Evento · 212
L Moltiplicazione · 62
Month · 81; 147
Label · 135 MonthName · 81
Layout · 233; 243 MouseClick
LCase · 72; 95 Evento · 212
Leave MouseDoubleClick
Indice
533
Evento · 212
MouseDown
O
Evento · 208; 209; 210; 212
MouseEnter Object · 56; 61; 112; 113; 134; 146; 148; 149; 150;
Evento · 212 151; 152; 154; 159; 163; 170; 171; 181; 205;
MouseHover 206; 207; 299; 300; 358; 366; 367; 391; 417;
Evento · 212 420; 430; 431; 432; 434; 435; 438; 483; 485;
MouseLeave 487; 488; 493; 495; 501; 505
Evento · 212 Oggetto · 158; 228; 380
MouseMove OleDbCommandBuilder · 293; 294; 297; 298
Evento · 212 OleDbConnection · 287
MouseUp OleDbException · 291
Evento · 212 OpenFileDialog · 158; 161; 162; 169; 172; 426; 434;
MoveDirectory · 470 436; 437; 488
MsgBox · 49; 107; 108; 109; 112; 124; 291; 356; Option Explicit · 60; 62; 112; 113; 146; 148; 149;
358; 359; 360; 361; 363; 366; 367; 368; 369; 151; 159; 162; 164; 169; 357; 378; 390; 417;
370; 416; 469 485; 494
Multiline · 127; 162 Option Strict · 62
MultiLine · 169; 484 OR · 102; 103; 345
My.User.Name · 161; 162; 164; 170; 171; 468; 469;
470; 471; 472
MySQL · 213; 270; 277; 304; 305; 306; 310; 311; P
313; 314; 315; 316; 317; 320; 334; 339; 342;
343; 347; 349; 350; 351; 355; 356; 379; 412; 416 PageSettings · 438
MySql.Data · 351; 355; 357; 391 PageSetupDialog · 438
MySql.Data.dll · 352; 353 ParentChanged
MySqlCommand · 358; 359; 360; 363; 366; 367; Evento · 212
369; 370 Parentesi graffa
MySqlConnection · 355; 358; 368; 369 ALT+123 / ALT+125 · 196
MySqlDataAdapter · 358; 359; 360; 361; 363; 364; Password · 283; 287; 355
365 PasswordChar · 127; 134; 136
MySqlDataReader · 400; 401; 515; 520 PDF
MySqlException · 360; 361; 366; 416 Documento PDF · 500; 508; 509; 510
PictureBox · 158; 160; 161
Pixel · 25
N Point · 422; 423; 426; 502
Poligono · 422
Name · 24; 25; 123; 136; 145; 199; 204; 344; 345; Pow · 67
346; 347; 348; 358; 359; 360; 361; 362; 363; PreviewKeyDown
364; 365; 367; 368 Evento · 212
Next · 74; 104; 105; 106; 107; 110; 112; 171; 174; PrintDialog · 169; 172; 299
301; 302; 303; 308; 309; 310; 311; 312; 340; 341 PrintDocument · 169; 174
Nodes · 445; 446; 447; 449; 450; 451; 452 PrintDocumentPreview · 169
nodo · 445; 448; 450 PrinterSettings · 438
Normal · 31 PrintPage · 171; 174; 300; 303; 501; 504; 505; 507
Now · 82; 94; 95 PrintPreviewDialog · 500
Null · 72; 80; 84; 86; 87; 93 Private · 46; 47; 55; 56; 96; 98; 99; 112; 138; 148;
Numeri casuali · 109 149; 150; 151; 152; 154; 159; 163; 170; 171;
NumericUpDown · 147 181; 205; 206; 207; 299; 300; 358; 359; 360;
362; 363; 364; 366; 367; 368; 376
Private Sub · 46; 47; 56; 96; 112; 138; 148; 149;
150; 151; 152; 154; 159; 163; 170; 171; 181;
534
205; 206; 207; 299; 300; 358; 359; 360; 362; SByte · 61
363; 364; 366; 367; 368; 376 Scorciatoie da tastiera · 189
Progetto · 20; 29; 33; 34; 39; 42; 52; 53; 63; 143; Second · 82
175; 177; 194; 351; 379 Select · 108; 337
ProgressBar · 204 SELECT · 288; 292; 293; 294; 296; 297; 298; 337;
Proprietà · 22; 28; 119; 123; 127; 136; 137; 140; 343; 344; 345; 346; 347; 348; 350; 358; 359;
175; 177; 190; 286; 351; 353 360; 361; 363; 364; 365; 367; 368; 376; 382;
Public · 55; 96; 98; 112; 148; 149; 151; 154; 159; 383; 384; 385; 386; 387; 389; 400; 401; 449; 451
162; 169; 181; 205; 296; 299; 357; 377; 378 Select Case · 108
Public Class · 55; 112; 148; 149; 151; 154; 159; 162; SelectCommand
169; 181; 205; 299; 357 Proprietà · 288; 292; 358; 359; 360; 363; 369;
Pulsante di Opzione · 139 370; 382; 383; 384; 385; 386; 387; 389
SelectedIndex · 150; 151; 152; 382; 383; 386; 387;
399; 400; 514; 515; 518; 519
Q SelectedIndexChanged · 148; 150; 152
SelectedValue · 293; 294; 295; 296; 297; 298; 360;
Query · 213; 244; 250; 255; 268; 316; 317; 325; 362; 363; 364; 365; 376; 382; 383; 384; 386;
331; 336; 337; 338; 339; 346; 347; 348; 367 387; 388
SelectionFont · 433; 434; 436; 437
SelectionHangingIndent · 433
SelectionIndent · 433
R SelectionRightIndent · 433
Separator · 184
RadioButton · 139; 140; 141 Server · 266; 306; 313; 314; 315; 316; 318; 340;
Randomize · 109 351; 355; 379
ReadOnly · 127; 135; 148 Set · 358; 459; 460; 461; 462; 527
ReadOnlyChanged Setup · 523; 525
Evento · 212 Short · 61; 144
Record · 214; 296; 339; 362; 369; 370 ShortCutKeys · 189
Relazioni · 228; 240; 258; 329 ShowDialog · 159; 160; 163; 165; 170; 172; 173;
Report · 213; 268 299; 300; 379; 380; 427; 434; 435; 436; 437;
Repos · 34 438; 487; 488; 500; 501; 505
Resize ShowNetwork · 170; 172
Evento · 212; 382; 450 Sin · 68
Restore · 404; 405 Single · 61; 171; 173; 300; 301
Rettangolo · 421; 422; 424; 425; 426 Sinh · 69
Return · 98; 99 Sizable · 32
Rich Text File · 433 Size · 23; 25; 29; 119; 140
RichTextBox · 433; 436 SizeChanged
root · 315; 317; 318; 354; 355; 357; 378; 379; 391 Evento · 212
RowHeadersWidth · 290; 383; 388 SolidBrush · 424; 425; 426
RowsDefaultCellStyle · 290; 383; 388 Sottrazione · 62
RowTemplate · 290; 383; 388 Source · 33; 34; 283; 286; 287; 355
RTF · Vedi Rich Text File Space · 73
RTrim · 75 Split · 161; 162; 164; 170; 171; 468; 469; 470; 471;
Runtime · 23; 285; 371; 412; 416 472
SQL · 255; 256; 288; 292; 293; 294; 296; 298; 314;
316; 317; 320; 324; 328; 331; 332; 335; 337;
S 338; 339; 342; 343; 345; 346; 348; 349; 350;
358; 359; 360; 361; 363; 367; 368; 370; 413
Save · 315 Stampa · 118; 170; 171; 172; 174; 299; 303
SaveFile · 433; 435; 437 StartPosition · 27
SaveFileDialog · 162 StatusBar · 202
Indice
535
StatusLabel · 204 295; 296; 297; 298; 361; 362; 363; 364; 365;
StatusStrip · 202 367; 368; 369; 370; 376; 377
StrComp · 74 TextAlign · 119; 123; 127; 136; 200
StrConv · 73; 74 TextBox · 126; 127; 145; 146; 148; 150; 153; 168;
StreamReader · 163; 165; 170; 172 295; 297; 367; 371; 376; 377
StreamWriter · 163; 165 TextMaskFormat · 431
String · 57; 59; 61; 94; 95; 98; 104; 107; 108; 109; Then · 100; 101; 102; 103; 104; 108; 138; 154; 155;
112; 113; 149; 151; 154; 159; 160; 161; 162; 159; 160; 163; 165; 166; 170; 171; 172; 174;
163; 164; 170; 171; 172; 173; 288; 291; 292; 206; 207; 291; 299; 300; 301; 302; 303; 366;
293; 294; 295; 296; 297; 298; 300; 301; 355; 372; 373; 376; 470
357; 358; 359; 360; 361; 362; 363; 366; 367; Tick · 206; 207
368; 373; 376; 378; 379; 391;395; 417; 418; 424; Timer · 205; 206; 207
425; 426; 427; 434; 435; 437; 468; 469; 470; TimeSerial · 82; 83
471; 472; 485; 487; 488; 495; 496; 508; 509 ToolStrip · 197; 198; 203; 440; 441
Stringa · 69; 72; 73; 74; 75; 77; 78; 80; 81; 82; 84; ToolTip · 190
85; 86; 87; 88; 90; 93; 94 ToolTipText · 190; 191; 205
StrReverse · 75 trappola per errori · 287; 369; 370; 416; 469
Strumenti · 20; 115; 191; 228; 240; 258; 278; 284; TreeView · 439; 444; 447; 450; 451
314 Trim · 75; 95; 293; 295; 297; 298; 391; 393
Struttura · 224; 237; 238; 244; 251; 256 True · 30; 61; 84; 85; 86; 87; 104; 107; 135; 136;
StyleChanged 137; 138; 140; 148; 150; 162; 163; 166; 170;
Evento · 212 171; 172; 174; 192; 205; 206; 207; 290; 301;
Sub · 171; 174; 291; 300; 302; 356; 358; 359; 361; 303; 372; 373; 469; 470
363; 366; 369; 370; 372; 377; 378; 379; 380; 416 Try · 287; 291; 356; 358; 359; 360; 361; 363; 366;
Sub Main · 377; 378; 379; 380 368; 369; 370; 392; 393; 394; 395; 396; 416;
System.ComponentModel · 374; 375; 458 418; 469; 486; 490
System.Drawing · 169; 171; 299; 419; 421; 427;
505
System.Exception · 291; 356; 358; 359; 361; 363; U
366; 368; 369; 370; 416; 469
System.IO · 162; 164; 169; 171; 378; 417; 473; 474; UCase · 75; 95
476; 477; 485; 487; 509; 510 UInteger · 61
System.Math · 62; 67; 113 ULong · 61
System.Net · 397; 417 Unità logiche · 477; 479
System.Xml · 513; 516 update · 365
SystemColorsChanged Update · 294; 295; 298; 299; 361; 362; 365; 416
Evento · 212 UShort · 61
Using · 398; 399; 400; 401; 449; 452; 514; 517; 527
Utenti · 257; 258; 317
T
tabella · 84; 90; 91; 92 V
Tabella · 236; 293; 294; 295; 296; 297; 298; 349;
360; 361; 362; 364; 365; 376; 377 Val · 94; 95; 104; 293; 295; 297; 298; 373
TabIndexChanged Validated · 373; 374; 375; 376
Evento · 212 Eventi · 211
TabStopChanged Evento · 212
Evento · 212 Validating · 373; 374; 375
Tan · 69 Evento · 211; 212
Tanh · 69 Value · 146; 147; 148; 206; 207; 291; 292; 300;
Text · 28; 118; 127; 132; 136; 137; 141; 146; 148; 302; 366; 368
150; 152; 154; 159; 163; 164; 165; 166; 170; ValueChanged · 145; 147; 148
172; 188; 191; 200; 205; 206; 207; 288; 293;
536
ValueMember · 292; 293; 359; 360; 363; 382; 383; WindowState · 29; 31; 206; 207
385; 386; 387 Word · 2; 9; 47; 433; 436; 482; 483; 485; 487; 488;
ValueMembrer · 360 489; 491; 492; 497
Values · 331 WorkBench · 349
Variabile · 69; 70; 76; 85; 86; 87 WriteElementString · 515; 516; 519; 520; 521
Variant · 74; 77; 80; 82; 83; 84 WriteEndDocument · 516; 521; 522
View · 316; 335; 336; 337 WriteEndElement · 515; 516; 519; 521; 522
Views · 335; 337 WriteStartElement · 515; 519; 520; 522
Visible · 136; 140
VisibleChanged
Evento · 212 X
XML · 270; 511; 512; 513; 514; 516; 517; 518; 519;
W 520; 521
XPS
Weekday · 83; 84 Documento XPS · 510
WeekdayName · 83; 84
While · 106; 107
Width · 25; 26; 170; 172; 173; 300 Y
Windows Form · 21; 39; 40; 63; 116; 143; 175; 176;
194; 195 Year · 84; 94; 147

Visual Basic - Net 2019 Partendo Da Zero - Giuseppe Scozzari

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Visual Basic - Net 2019 Partendo Da Zero - Giuseppe Scozzari

Caricato da

Copyright:

Formati disponibili

Copyright © EDIZIONIFUTURA.

Versione Cartacea: ISBN-13: 978-88-89600-82-5

Autore: Giuseppe Scozzari

Microsoft©, MS-DOS©, Windows©95, Windows©98, Windows© ME, Windows© NT, Win-

L’autore: Giuseppe Scozzari

Chiudete invece le finestre, se eventualmente dovessero comparire sullo schermo, oppure

Non riempite lo schermo di finestre inutili piene di informazioni che vi distolgono

Dato che questo libro è espressamente dedicato a coloro che la programmazione

La finestra delle proprietà riassume le caratteristiche di un oggetto o controllo in modo da

La proprietà StartPosition indica la posizione di partenza della finestra (form) quando si

Il comando è anche disponibile sulla barra degli strumenti.

Se il valore di proprietà viene impostato su Maximized al momento dell’avvio del pro-

Impostando le due proprietà su False, al momento dell’avvio del programma, si verificherà

Quindi fate doppio click sulla cartella Source.

Fate doppio click e identificate la cartella bin.

All’interno di bin trovate la cartella Debug come mostra la figura successiva.

Un’altra operazione di un certo interesse è quella di escludere, senza eliminare da un pro-

I file momentaneamente esclusi dal progetto si possono visualizzare solamente se si fa click

Cercate nella lista l’evento DoubleClick e selezionatelo.

Errori nella selezione dell’evento

Meglio non cancellare il codice relativo all’evento FormPrincipale_Load.

Ritornare alla progettazione

MsgBox("Bravo hai fatto doppio click")

Ignorate per il momento tutti quei suggerimenti che compaiono in automatico

Avviate il progetto con il pulsante Avvia sulla barra degli strumenti.

Ed ecco il risultato dell’operazione. Il primo programma funziona perfettamente.

Psicologia del programmatore

Come si scrive il codice

Date un nome al progetto come nel nostro caso SecondoProgetto

Public Class Form1

Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load

Note alla programmazione o commenti

Nella figura sottostante troverete un esempio di assegnazione.

Const Pippo As String = “Pippo”

se la variabile è di valore numerico. Oppure:

Se la variabile è una stringa.

Ad esempio, se durante la stesura di un programma chiamiamo una variabile sommatotale

Tipo Visual Basic Quali dati possono contenere

Byte Da 0 a 255 (senza segno)

Char (carattere Da 0 a 65535 (senza segno)

Decimal Da 0 a +/-79.228.162.514.264.337.593.543.950.335 (+/-7,9...E+28)

Double (virgola mobile Da -1,79769313486231570E+308 a -4,94065645841246544E-324 per i

Integer Da -2.147.483.648 a 2.147.483.647 (con segno)

Long (valore long Da -9.223.372.036.854.775.808 a 9.223.372.036.854.775.807

Object In una variabile di tipo Object è possibile memorizzare qualsiasi

SByte Da -128 a 127 (con segno)

Short (valore short Da -32.768 a 32.767 (con segno)

Single (virgola mobile Da -3,4028235E+38 a -1,401298E-45 per i valori negativi;

String Da 0 a circa 2 miliardi di caratteri

UInteger Da 0 a 4.294.967.295 (senza segno)

ULong Da 0 a 18.446.744.073.709.551.615 (1,8...E+19) (senza segno)

UShort Da 0 a 65.535 (senza segno)

Per maggior chiarezza.

Totale = a + b Somma algebrica

Quindi dichiarate le variabili che utilizzeremo per prova

Arrestate l’esecuzione del programma.

Provate con altre espressioni e controllatene il risultato

Totale = ((a+b)/(a*b)) + Sqrt((a^2) + (b^2))

Totale = ((a + b) / (a * b)) + Sqrt(a ^ 2 + b ^ 2)

Questa assolutamente no:

Non vuole essere una lezione di matematica, ma va ricordato che un pro-

Altre funzioni matematiche

Restituisce il valore assoluto di un’espressione, ovvero