Visual Basic 6 Base

CORSO DI VISUAL BASIC 6.0 Lezione n.
Introduzione alla
Programmazione Visuale
Evoluzione del vecchio Basic: Premessa
L’obiettivo di questo corso è di fornire quanti più suggerimenti e chiavi di

lettura a chi è neofita della programmazione. Chi invece ha già dimestichezza
con la programmazione Basic, ma non ha mai utilizzato l’ambiente visuale,
potrà approfondire nei dettagli ciò che già conosceva in modo superficiale.
Per introdurvi nel modo migliore alla programmazione visuale, partiamo dal
vecchio Basic, delineandone le seguenti caratteristiche:
- era un linguaggio di programmazione di natura interpretata e ideale per i

principianti, prendeva il nome di GW-BASIC; esisteva al tempo dei Pc
IBM compatibili tipo (M24 dell’olivetti e M240);
- Offriva un ambiente di programmazione MS-DOS molto lento e aveva
soltanto l’interfaccia testuale;
- Non era dotato di un compilatore e quindi non permetteva la generazione
di un file autonomo eseguibile al di fuori dell’ambiente di
programmazione
Dal Gw-Basic si è passati al QBASIC, con le seguenti caratteristiche:
- si è evoluto rispetto al Gw-Basic, in quanto dotato di un ambiente di

sviluppo in modalità finestra, ma l’esecuzione del programma
avveniva sempre in modalità Ms-dos (cioè testuale);
- era dotato di un compilatore, in grado di trasformare il codice
sorgente in codice eseguibile al di fuori dell’ambiente di sviluppo;
Matura la prima versione di Visual Basic for Ms-Dos 1.0, e da questa

versione se ne sono avute altre 5 per arrivare alla versione oggetto del corso
che state seguendo lezione per lezione: Microsoft Visual Basic 6.0
Le caratteristiche della prima versione di Visual Basic 1.0 sono le seguenti:
Spalluzzi Francesco - Manuali.Net © 2005 Tutti i diritti riservati 1

CORSO DI VISUAL BASIC 6.0 Lezione n. 1
- E’ rimasta sempre la possibilità di creare l’applicazione con interfaccia

testuale;
- La novità è stata quella di avere un ambiente di disegno per costruire le
form similari a quelle del Visual Basic 6.0
- Un compilatore per distribuire l’eseguibile dell’applicazione.
Nelle varie versioni di VB che si sono succedute, la tecnica di fondo di creazione

dei programmi windows è stata quella ‘di trascinare e rilasciare gli oggetti
grafici sul form’ “Si dice che l’applicazione Windows appare davanti ai
nostri occhi mentre aggiungiamo gli oggetti dalla casella degli
strumenti”
In una tabella rappresentiamo l’evoluzione del vecchio Basic, riproducendo i

vari ambienti di programmazione
Ambiente di programmazione GW-BASIC
Ambiente di programmazione QBASIC 4.5

Ambiente di programmazione Visual Basic 1.0
MICROSOFT VISUAL BASIC 6.0 – Versione oggetto del corso
Dall’interfaccia testuale all’interfaccia grafica stile Windows
Ogni applicazione che realizziamo con Visual Basic presenterà le seguenti

caratteristiche:
• Alto grado di interazione da parte dell’utente, grazie ai vari elementi

grafici che formano gli oggetti della finestra attiva
• La meccanica di programmazione, ossia l’aggiunta di codice permette
l’interazione dell’utente con l’interfaccia grafica creata: Svolgerà,
attraverso il codice sorgente una serie di compiti (o comportamenti) per
la quale è stata progettata l’applicazione.

• Il codice sorgente verrà attivato in base ad una serie di eventi

scatenati dall’utente ,attraverso sempre l’interfaccia grafica
Costruire una GUI (Graphic User Interface) non efficiente e corretta,

comporterà un non apprezzamento del programma da parte dell’utente finale e
il programmatore sarà tempestato di telefonate. L’efficienza sottolinea anche
l’uso di corrette procedure di progettazione, codifica e manutenzione dello
stesso, in modo che in uno spazio temporale ampio, sia possibile modellare la
stessa interfaccia grafica con quel che l’utente desidererà svolgere al passo con
i tempi.
Prima dell’era della telefonia mobile un programma gestionale contatti, non

prevedeva la diversificazione di contatti con telefonia fissa e quelli con telefonia
mobile. Se tale gestionale fosse stato creato, prima di tale avvento, con una
GUI non efficiente e corretta, i tempi di adeguamento dell’applicazione al
Know-How tecnologico sarebbero abbastanza lunghi e l’utente finale si farebbe
realizzare l’applicazione da un’azienda concorrente.
Concetto di evento
Nel paragrafo precedente è stato detto che un programma Visual Basic

consiste nell’interfaccia visiva, con sopra localizzati controlli. All’atto di
esecuzione del programma l’utente interagirà con la Gui. Questo in
quale modalità?
A tal proposito il programmatore svilupperà porzioni di codice da associare a

ciascun controllo; diamo così la definizione di evento.
Un evento è un’attività che avviene durante l’esecuzione di un programma, e

tutti i programmi windows rispondono a degli eventi. Basti pensare, quando
con il clic del mouse, sul pulsante Start, viene visualizzato il menu di avvio
di tutti i programmi. L’azione ‘Visualizza menu di avvio’ è associata al
clic dello strumento di puntamento o all’associazione di tasti di scelta
rapida Cltrl+Escape.
Quando parleremo di Visual Basic avanzato, faremo riferimento al

trucco che ci permetterà di visualizzare il menu di Start di Windows via
codice.
Ad esempio se apriamo l’applicazione Notepad e selezioniamo Apri dal

menu file, si apre una finestra di dialogo.

Domanda: Con quale libreria possiamo visualizzare la finestra di

dialogo Apri comune a tutti i programmi Windows? A tale domanda
risponderemo durante il prosieguo delle lezioni successive.

Le basi della
programmazione
Concetto di variabile e costante e tipi di dati
Si definisce variabile, un luogo di memorizzazione temporanea per i dati

del programma. Può contenere parole, numeri, date. In Visual Basic esiste
una variabile di tipo oggetto che espone proprietà, metodi, eventi.
Al concetto di variabile è legato il tipo di dato da memorizzare. Come il vecchio

Basic, esiste l’istruzione Dim (che significa dimensione). Questa istruzione
riserva lo spazio di memoria per la variabile quando si esegue un programma e
permette a Visual Basic di sapere che tipo di dati vedrà in seguito.
Implicitamente si parla anche di dichiarazione obbligatoria delle variabili:

consiste nell’imporre a Visual Basic di generare errore quando, per errori di
digitazione del nome, si vuole creare una variabile non dichiarata
Esempio: Se con l’istruzione Dim creiamo la variabile numero e vi associamo

un tipo di dato (ad esempio intero – o integer), e poi durante la digitazione del
codice di programma sbagliamo a scrivere il nome della variabile (anziché
numero scriviamo numeri), se è indicata la clausola Option Explicit, Visual
Basic genererà un errore
Nella cartella filmati esiste un filmato avi ‘OptionExplicit.avi’ che

filmerà quanto detto a parole
La dichiarazione obbligatoria delle variabili permetterà di razionalizzare lo

spazio di memoria Ram.
Esempio: Se non usassimo tale clausola, le variabili che Visual Basic creerà,
potranno essere infinite, ovvero:
Numero (è la variabile dichiarata con l’istruzione Dim)
Gli errori di digitazione del nome della variabile comporterebbero la creazione

di altre variabili, che però non saranno tipizzate (ossia non sarà assegnato loro

un tipo di dati da memorizzare). Le variabili non tipizzate, cioè di tipo Varìant,

occuperanno più spazio di memoria.
Un programma può contenere delle variabili che memorizzano valori che non
cambiano mai. Il loro uso è similare alle variabili, ma non si può ovviamente
modificare il suo valore in fase di esecuzione. Stiamo parlando di costanti
Nella cartella filmati abbiamo costanti.avi, che vi spiegherà passo

passo la dichiarazione di costanti e l’errore generato nel caso si
desidera modificare tale valore durante l’esecuzione di un programma.
Nella riproduzione del filmato costanti.avi, se si ha la necessità di modificare un

valore di una variabile costante, occorre creare una variabile ordinaria dello
stesso tipo della costante, e con un’istruzione di assegnazione procedere alla
modifica:
Option Explicit
Const numero as Integer=46
Sub Main
Dim dato as Integer
dato=numero
dato=dato+67
msgbox(“valore di numero costante:” & numero)
msgbox(“valore di numero modificato:” & dato)
End Sub
Codice per modificare il valore di una costante dichiarata
Ciò che genererà un errore a livello di compilazione, è l’istruzione di

assegnazione
numero=numero+78
Concludiamo il paragrafo con la riproduzione di una tabella, nella quale

rappresentiamo i vari tipi di dati ammessi da Visual Basic nella dichiarazione
delle variabili o costanti
Tipo di dato Esempio di Range valori Spazio occupato

dichiarazione
Integer Dim numero Da -32768 a 32767 2 byte
(Intero) as Integer
Long Dim numero Da -2.147.483.648 a 2.147.483.6477 4 byte
as Long
Single Dim numero Da -3,402823E38 a -1,401298E-45 per valori 4 byte
as Single negativi; da 1,401298E-45 a 3,402823E38 per
valori positivi

Double Dim numero Da -1,79769313486232E308 a 8 byte

as Double -4,94065645841247E-324 per valori negativi; da
4,94065645841247E-324 a
1,79769313486232E308 per valori positivi.
Decimal Dim numero +/-79.228.162.514.264.337.593.543.950.335 14 byte
as Decimal senza virgola;
+/-7,9228162514264337593543950335 con 28
decimali; il numero minore diverso da zero è
+/-0,0000000000000000000000000001
Date Dim Dall'1 gennaio 100 al 31 dicembre 9999 8 byte
compleanno as
Date
Object Dim frm as Qualsiasi riferimento Object 4 byte

Object
String Dim cognome Da 0 a circa 2 miliardi 10 byte+

(Lunghezza as String lunghezza della
Variabile) stringa
String Dim cognome Da 1 a circa 65.400 Lunghezza

(Lunghezza as String stringa
Fissa)
Variant (con Dim datonum Qualsiasi valore numerico fino all'intervallo di un 16 byte
numeri) Double
Variant (con Dim Stesso intervallo di String a lunghezza variabile 22

caratteri) datocarattere Byte+lunghezza
carattere
Definito Type arch L'intervallo di ciascun elemento è identico a quello Numero richiesto
dall’utente Cognome as del relativo tipo di dati sopraelencato. degli elementi
utilizzando string*20
type Nome as
string*20
End type
Dim dato as
Arch
Boolean Dim flag as True o False 2 byte
Boolean
Byte Dim dato as Da 0 a 255 1 byte

Byte
Array, matrici e array di controllo
Chi è veterano di programmazione conosce già il concetto di Array. Chi invece

no, deve sapere che sono gruppi di dati con le seguenti caratteristiche:
• questi dati sono ordinati

• e ogni dato che lo precede e lo succede è omogeneo
Esempio:

Se abbiamo n temperature rilevate in un certo momento, è sconsigliato creare

n variabili ordinarie (ad esempio di tipo intero), ma utilizzeremo allo scopo un
array (volgarmente detto vettore).
• Gli elementi omogenei sono le n temperature,

• l’ordinamento di questi dati può essere alfabetico per dati alfanumerici
(ossia stringhe e numeri) o numerico (ordine crescente o descrescente)
Nell’esempio, essendo le temperature grandezze numeriche, l’ordinamento è di

tipo crescente (dalla temperatura più bassa rilevata in una certa città alla
temperatura più alta)
Queste strutture di dati possono essere monodimensionali (e vengono

chiamati, come già precisato, vettori), bidimensionali (e vengono chiamati
matrici, tipo quelle che si studiano in matematica), e così via fino ad arrivare
ad un massimo di 60 dimensioni
Come si dichiara, in modo semplice, un array in Visual Basic?
A livello di modulo si ha:
Dim nomi(20) as String
Con questa semplice dichiarazione , si creano array di tipo statico.
L’uso degli array statici comporta al programmatore il problema che non è

possibile modificare la sua dimensione in fase di esecuzione dell’applicazione
(c.d. operazione di ridimensionamento).
L’operazione di ridimensionamento è possibile soltanto se si creano array

dinamici. Essi sono sempre strutture di dati ordinate e omogenee, per le quali è
possibile cambiare la dimensione (numero di elementi memorizzabili) in fase di
esecuzione. I programmatori li utilizzano anche nelle applicazioni, per le quali
non si conosce, con esattezza quanti elementi la struttura dell’array deve
memorizzare. (possono essere 10 elementi, 20 elementi, ecc ecc).
L’array dinamico si crea sempre con l’istruzione dim, e la riga di codice

precedente diventa
Dim nomi() As String
Il ridimensionamento può avvenire in una o più parti dell’applicazione. Si

utilizza a tale scopo l’istruzione redim. Esempio:
Redim nomi(100) As String

Quando si crea un’array statico, si nota durante la stesura del codice, ciò che
osservate nella figura in basso:
Se non si specifica l’indice inferiore dell’array, Visual Basic presume che sia 0, a
meno che non si utilizzi un’istruzione Option Base 1 all’inizio di ogni modulo.
Nella creazione degli array dinamici, si può specificare l’indice inferiore, quando
si utilizza l’istruzione redim
Redim nomi (1 to 20) As String
L’indice inferiore dell’array viene fissato a uno e l’istruzione di assegnazione
Nomi(0)=”Giorgio”
genera a run-time l’errore 9 ‘Subscript out of range’, in quanto l’indice inferiore

è stato fissato a 1, e non più a zero.
Tale errore viene generato anche quando si supera l’indice superiore dell’array
o della matrice.
Diciamo qualcosa sulla matrice dei controlli (ossia degli oggetti definiti sul form
che hanno tutti la stessa proprietà Name).
Se su un form avessimo un oggetto etichetta che ha la proprietà Name

lbletichetta
Per creare un’array di controlli, basta aggiungere un’altra etichetta e assegnarli

la stessa proprietà name. Visual Basic in questa situazione ci propone l’alert

Rispondendo si alla domanda di voler creare un’array di controllo, tutti i

controlli con la stessa proprietà Name (ossia oggetti etichetta) verranno
indicizzati (partendo con l’indice inferiore 0)
Per accedere alle sue proprietà caratteristiche si utilizzerà la proprietà name

base
Lbletichetta(indice).nomeproprietà
Per assegnare un valore alle sue proprietà
Lbletichetta(indice).nomeproprietà=<valore>
Cicli e strutture decisionali
Capita sovente di dover eseguire un gruppo di istruzioni un numero imprecisato

di volte, un numero di volte conosciuto a priori prima di iniziare ad eseguire il
loop (classico ciclo for).
Partiamo con un esempio
Sub Main
Dim inizio as Integer
Dim fine as Integer
Fine=10
For inizio=1 to fine
Msgbox(“Ciao Francesco” & “ “ & inizio & “ “ & “volta”)
Next inizio
End Sub
……….

Il ciclo For viene utilizzato ogni qual volta si conosce a priori il numero di volte
che un gruppo di istruzioni devono essere ciclate. La variabile inizio stabilisce
la posizione iniziale dalla quale partire; La variabile fine invece il numero di
volte in cui il loop delle istruzioni comprese deve essere eseguito
Consideriamo il caso in cui non conosciamo in modo preciso il numero di volte

in cui il loop delle istruzioni comprese debba essere eseguito. Il ciclo for non
può essere la struttura iterativa da utilizzare in quanto non conosciamo il
valore della variabile fine.
Visual Basic mette a disposizione degli sviluppatori altre due strutture

iterative con le sue varianti:
While Condizione
Istruzione 1
Istruzione 2
Istruzione 3
….
Istruzione k
….
Istruzione n
Wend
Do
Istruzione 1
Istruzione 2
Istruzione 3
….
Istruzione k
….
Istruzione n
Loop until condizione
Do while condizione
Istruzione 1
Istruzione 2
Istruzione 3
…
Istruzione k
…
Istruzione n
Loop
Do
Istruzione 1
Istruzione 2
Istruzione 3
…
Istruzione k
…
Istruzione n
Loop while condizione
La struttura iterativa While condizione ….. Wend e la struttura Do while

condizione …. Loop sono simili: Il funzionamento è il seguente: Le istruzioni
comprese nel ciclo vengono eseguite finché la condizione è True (vera). Si dice
anche che è “una struttura iterativa che cicla per vero” In altre parole se
la condizione impostata all’inizio del ciclo risultasse già falsa, le istruzioni
comprese non verranno eseguite neanche una volta.
L’esempio classico è dato dal seguente problema: Dati dei numeri eseguire
la loro somma. Tra i dati di ingresso non viene fornita l’informazione di quanti
numeri il problema ha bisogno per calcolarne la somma. La struttura iterativa
For..Next non può essere utilizzata. Però la struttura iterativa While… Wend o
Do while condizione ….. Loop possono essere utilizzate in maniera indifferente.
Basta impostare opportunamente la condizione (c.d. espressione booleana)(1),

altrimenti si rischia di creare un loop senza uscita che farebbe bloccare
l’applicazione
(1) L’espressione booleana è un’espressione che assume due valori vero (True)
o Falso (False) è può essere qualsiasi espressione numerica
A=20 A<=20 A>=20 A>0 A<0
Sono tutte espressioni, e se ne possono impostarne delle altre a seconda

dell’applicazione che si sta realizzando, ma restituiscono solo un valore vero o
falso.
Per il problema formulato in neretto (c.d. esempio classico) la condizione da

impostare è la seguente
…..
Scelta=”S”
While scelta=”S”
Istruzione 1
Istruzione 2
Istruzione 3
…
Istruzione k
…
Istruzione n
Wend
Il codice Visual Basic è il seguente

Sub Main()
Dim scelta As String
Dim cts As Integer
Dim numero As Integer
scelta = "S"
While scelta = "S"
numero = InputBox("Inserisci un numero:")
cts = cts + numero
scelta = InputBox("Vuoi continuare S/N:")
Wend
MsgBox ("somma:" & cts)
End Sub
Poi esiste la struttura iterativa Do….. Loop Until condizione. Questa struttura
iterativa ha la condizione impostata alla fine. Almeno una volta il loop delle
istruzioni viene eseguito. Si dice anche che questa struttura iterativa cicla
per falso. Finchè la condizione risulta falsa, le istruzioni comprese vengono
eseguite, altrimenti termina il ciclo
Dello stesso problema forniamo il codice Visual Basic, applicando tale struttura
iterativa
Sub Main()
Dim scelta As String
Dim cts As Integer
Dim numero As Integer
Do
numero = InputBox("Inserisci un numero:")
cts = cts + numero
scelta = InputBox("Vuoi continuare S/N:")
Loop Until scelta = "N"
End Sub
Al problema formulato per l’applicazione della struttura iterativa For…Next può

essere adatta anche una di queste altre strutture iterative.. Ad esempio Do
while condizione…… Loop
Sub Main()
Dim ct as integer
Do while ct<=10
ct=ct+1
Msgbox(“Ciao Francesco” & “ “ & ct & “ “ & “volta”)
Loop
End Sub
Le strutture di controllo che permettono al programma di effettuare delle scelte

sono dette ‘Strutture decisionali’ e annoveriamo:
• If…Then… Else (o scelta a due vie). Se è vera l’espressione impostata

viene eseguito un blocco di istruzioni, altrimenti il blocco impostato dopo
la clausola Else
• Select case (detta anche struttura decisionale multipla)
Problema classico: Realizziamo in modulo standard di Visual Basic un menu di

voci e applichiamo indifferentemente la prima struttura di controllo decisionale
o la seconda (detta struttura decisionale multipla).
La struttura di controllo Select Case può essere sviluppata con una serie di If ..
Then… Else

Struttura di un
progetto VB
Tipologie di applicazioni creabili con Visual Basic 6.0
Un progetto Visual Basic è costituito da un’insieme di file, costituenti nella

globalità l’applicazione stessa. Possiamo avere:
• Uno o più file contenenti codice (c.d. moduli standard) o definizioni di

proprietà, metodi personalizzati per creare nuovi oggetti (c.d. moduli di
classe)
• Uno o più file detti moduli di form (ossia moduli contenenti la descrizione
dell’interfaccia grafica dell’applicazione, ovvero i controlli localizzati sopra
i form, gli eventi associati) Possono contenere anche dichiarazioni di
variabili, costanti, tipi di dati personalizzati, routine esterne)
• Altri file, che possono essere aggiunti al progetto dipendono dalla
versione di Visual Basic (Enterprise o Professional) tipo creazione di
documenti Activex o Controlli utente con la relativa finestra di
progettazione. A questi file corrisponderà un’estensione diversa.
Per i moduli standard è stata associata, per compatibilità con il vecchio Basic,
l’estensione Bas; per i moduli di classe l’estensione cls; per i moduli di form
hanno estensione frm.
Altre estensioni di file aggiungibili ad un progetto di VB possono essere Dsr

(per i Data report e i Data Environment);
il codice relativo ad una finestra di progettazione Activex e controllo utente è
memorizzato in un file con estensione ctl;
Si può aggiungere infine un file con estensione res (detto file di risorse). In
questo file vengono memorizzate informazioni relative a stringhe, dati, e il
motivo della loro aggiunta ad un progetto VB sta nel fatto di aumentare le
prestazioni di esecuzione dell’applicazione, invece di caricare tutte le risorse
assieme al caricamento dei form.

Infatti è possibile creare un menu in italiano e poi a seconda delle altre lingue
tali voci di menu cambiano in base alla lingua scelta e tali informazioni possono
essere riprese dal file risorse.
All’avvio di Visual Basic viene avviato il Project Template, ossia una finestra di
dialogo dove vengono riportate tutte le tipologie di applicazioni realizzabili.
Esse variano con la versione installata sul proprio Personal Computer.
Presentiamo nella figura qui sotto il Project Template di Visual Basic 6.0
versione Enterprise:
TIPOLOGIE DI APPLICAZIONI REALIZZABILI
Abbiamo:
Standard-Exe Crea un file eseguibile e l’applicazione può essere eseguita fuori

dall’ambiente di sviluppo; Ovviamente sul pc dove viene distribuita
l’applicazione occorre che siano correttamente installate le librerie utilizzate,
come quelle di Visual Basic run time 6.0 (scaricabili da internet o installabili con
Microsoft Office). L’installazione delle librerie utilizzate nel progetto può essere
effettuata quando si lancia il setup creato con il pakage di installazione (utilità
estremamente importante per la distribuzione delle applicazioni in VB6);
ActiveX Control Si realizza un controllo utente personalizzato e quando viene

compilato può essere utilizzato in tutte le applicazioni che supportino tale
tecnologia (esempio Access, Word, Excel,pagina Web, e altri ambienti di
sviluppo diversi da Microsoft);
Diverse creazioni guidate per realizzare tipologie di applicazioni professionali;
Tipologie di applicazioni per Internet (Dhtml Application e IIS Application);
ActiveX Dll Si realizzeranno librerie di collegamento dinamico, esportabili in

diverse applicazioni (tipo Office e le stesse applicazioni realizzate in Visual
Basic).

Nel prosieguo delle lezioni daremo cenni sugli ActiveX Document Dll e ActiveX
Document Exe e qualcosa sull’architettura di una IIS Application (ossia
un’applicazione in linguaggio Active Server Page con Visual Basic integrato,
eseguibile in Internet Information Service (componente di windows 2000,xp
professional, 2003 server).
Un’applicazione Dhtml è la combinazione di Html dinamico con codice visual

basic compilato. Si crea quindi un’applicazione molto interattiva basata sul
browser Web e valorizzata sul computer client che ha installato Microsoft
Internet Explorer.
Il Project Explorer (o struttura del progetto VB6)
Quando noi dal Project template, clicchiamo sull’icona Standard-Exe ,

allora nella finestra Project Explorer (o Esplora progetto), abbiamo:
Con lo short-cut Ctrl+R, viene attivata la finestra Esplora Progetto
Dalla figura rappresentata, notiamo il nome di default di progetto (Project1) e

la creazione automatica dell’oggetto Form (il cui nome di default è
Form1)
Se dovessimo cliccare con il tasto destro del mouse sul nome del progetto, dal
menu contestuale che appare possiamo aggiungere un nuovo oggetto (vedi
figura)

Osservazione: Non tutti questi oggetti saranno discussi nel prosieguo

del corso, ma soltanto l’oggetto Form, Mdi Form, Module, Class Module,
User Control, Data Report, DataEnvironment. Si può anche aggiungere
un oggetto già disponibile sul supporto di memoria di massa (cliccando
sulla voce Aggiungi file…, si aprirà una finestra di dialogo per mezzo
della quale selezionare il file, esplorando il file system)
Dalla lista di riepilogo, Cerca in, è possibile selezionare il percorso di

memorizzazione dell’oggetto da aggiungere; mentre nella lista di riepilogo Tipo
file è possibile notare l’elenco delle estensioni di file generati con l’ambiente di
sviluppo.
Poi abbiamo un pulsante per ritornare al livello superiore della cartella
corrente, e un pulsante per creare una nuova cartella
I form, i moduli standard, i moduli di classe
L’oggetto Form risulta essere elemento chiave di un’applicazione VB; non a

caso, quando si crea un’applicazione Windows, appare per impostazione
predefinita, nella finestra di esplorazione progetto che abbiamo
rappresentato nel paragrafo precedente.
Oggetto principale di un’applicazione Windows
Il form (finestra dell’applicazione) e i controlli che possono essere trascinati

hanno la caratteristica di essere oggetti, e per questo motivo espongono una

serie di attributi (o proprietà), reagiscono a dei metodi, e provocano degli

eventi.
A questo oggetto principale, possono essere aggiunti oggetti dello stesso tipo
(ossia altri form, o form già creati e salvati con l’estensione frm), oppure altri
elementi come:
I moduli standard (ossia file con estensione bas). Un modulo standard

rappresenta l’area di codice dove vengono dichiarate le variabili, costanti, le
funzioni (o function) e le routine (o subroutine)
Oltre ai moduli standard possono essere aggiunti i c.d. moduli di classe (o

file con estensione cls). Nell’area di codice che appare scriveremo le
dichiarazioni di variabili, costanti, funzioni e routine, che assieme
implementeranno la creazione e gestione di un oggetto personalizzato con una
serie di proprietà, metodi, ed eventi
La finestra di Esplorazione Progetto (Project Explorer) e i tre oggetti

base (form, modulo standard, modulo di classe)
La mia applicazione in Visual Basic
Alterniamo, alla lettura delle prime tre lezioni del corso, un esempio classico
per avviarvi a progettare un’interfaccia grafica molto semplice:
• con un casella di testo

• con un’etichetta con un valore già preimpostato;
• con un pulsante di comando
Nella cartella esempi trovate un file zippato applicsaluto.zip nel quale trovate il
file di progetto, l’applicazione Stand-alone (eseguibile fuori dall’ambiente di
sviluppo di VB6), l’interfaccia grafica dell’applicazione (frmsaluto.frm).
Gli unici commenti che dobbiamo fare sono:
Nella finestra proprietà del form imposteremo la proprietà Caption

“Applicazione saluto”

La form in figura, prima di impostare le proprietà
• MDICHILD
• MaxButton
• MinButton
al valore False, aveva i tre pulsanti classici di una finestra Windows:
Primo pulsante Riduci ad Icona

Secondo pulsante Con un clic si visualizza a tutto schermo la form; Con un
successivo clic si visualizza a forma normale la form.
Adesso in figura ha un solo pulsante per chiudere la finestra e di conseguenza

l’applicazione che si sta eseguendo.
Abbiamo impostato la proprietà Caption per denominare la barra del

titolo della Form. – In questa fattispecie si chiama ‘Applicazione saluto’

In quest’ultima figura abbiamo sintetizzato l’interfaccia grafica finale che dovrà

avere l’applicazione, prima di essere eseguita.
Il pulsante di comando preso dalla casetta degli attrezzi (c.d. Toolbox) ha

una proprietà che si chiama Caption. Impostando tale proprietà
appare, come in figura una scritta sul pulsante che rappresenta la
funzione che dovrà svolgere Visual Basic all’evento OnClick
Per scrivere la scritta [Ciao + il contenuto della casella di testo, che

immetterà l’utente all’esecuzione dell’applicazione], si scriveranno le
seguenti righe di codice

Per attivare la finestra di codice per configurare l’evento OnClick sul

pulsante, basta fare doppio clic sull’oggetto pulsante sulla Form.
Lblsaluto, come txtsaluto rappresentano la proprietà Name. E’ una proprietà

che restituisce il nome usato per identificare l’oggetto all’interno
dell’applicazione. E’ utile durante la stesura del codice per accedere con la Dot
Notation (o Notazione punto) alle proprietà da cambiare in fase di run-time (o
esecuzione) dell’applicazione
OSSERVAZIONE
L’accorgimento per far eseguire il codice associato all’evento OnClick del

pulsante, mediante scorciatoia della tastiera, è l’impostazione della proprietà
Caption, in questo modo, dalla relativa finestra delle proprietà dell’oggetto:
&Saluto
La scritta sul pulsante di comando sarà Saluto
All’esecuzione dell’applicaziome, dopo aver digitato nella casella di testo il

nome e cognome, apparirà (con Alt+S) il testo ‘Ciao Spalluzzi Francesco’
nell’oggetto etichetta (Lblsaluto)
Per eseguire da tastiera detto codice basta premere contemporaneamente

Alt+l’iniziale della scritta del pulsante (in questo caso la S maiuscola)

Per eseguire l’applicazione dall’ambiente di sviluppo, basta premere il tasto di

funzione F5 direttamente dalla tastiera del Pc
Applicazione saluto in fase di esecuzione
Nella cartella filmati troverete un file Avi che vi guiderà a creare l’esercizio
commentato in quest’ultimo paragrafo della terza lezione del corso ‘prima
applicazione VB6.avi’

Creazione di una form
I form e i controlli intrinseci disposti sulla Toolbox (o casella degli strumenti)
Apriamo il paragrafo con l’osservazione della seguente immagine:
E’ un form dove disporre i vari controlli richiesti dall’applicazione. Questi

controlli vengono presi della Cassetta degli attrezzi (o Toolbox)
Osservazione:
Un’applicazione in Visual Basic 6, contenente soltanto i controlli presi

dalla ToolBox, funziona correttamente solo con il file di run-time
MSVBVM60.DLL. Ha bisogno di poca memoria per essere eseguita, a
differenza di applicazioni contenente controlli di terze parti, le quali per
funzionare hanno bisogni di moduli OCX (o ActiveX) aggiuntivi e come tale
richiedono più memoria.
Un’applicazione realizzata soltanto con i controlli presi dalla ToolBox è

facilmente portabile da un Personal Computer a un altro, per il semplice fatto
che richiede solo quella dll, scritta in rosso.

Ogni controllo intrinseco che vedete nella ToolBox, per essere portato su una
form, richiede una procedura, che io divido in due tempi:
• Selezionare il controllo da portare su una form

• Con il puntatore del mouse sul form, attraverso la tecnica di
trascinamento, disegniamo il controllo stesso, definendone l’altezza, la
larghezza e la posizione
Nella cartella filmati esiste un file.avi che si chiama Disegnacontrollo.avi. Vi

spiega passo passo la tecnica di disegno dei controlli intrinseci
La proprietà di un controllo che definisce l’altezza prende il nome di Height

La proprietà di un controllo che definisce la larghezza prende il nome di Width
Le proprietà un controllo che definiscono la posizione sul form sono due: Left
e Top

Tali proprietà sono espresse in un’unità di misura predefinita di Visual Basic:

ossia in twip (centimetro logico)
Proprietà comuni dei vari controlli
Sebbene tutti i controlli intrinseci siano diversi per le funzioni che assolvono
durante l’esecuzione dell’applicazione, presentano una serie di proprietà
comuni:
Controlli Proprietà Comuni

Label
PictureBox Left,Top, Width,Height
TextBox
Frame ForeColor,BackColor
CommandButton
Checkbox Caption e Text
OptionButton
ComboBox(*) Parent e Container
ListBox
HScrollBar ENABLED VISIBLE
VScrollBar
Timer hWnd
DriveListBox
DirListBox Tabstop TabIndex
FileListBox
Shape MousePointer MouseIcon
Line
Image TAG
Data
Ole INDEX,Appareance, Align,BorderStyle,ToolTip
(*) Non necessariamente tutti i controlli elencati supportino tutte e 4 le

proprietà comuni di prima fascia (Left,Top,Width,Height). L’esempio classico è
quello della casella Combinata (o ComboBox), la cui proprietà Height può
essere letta, ma non modificata in fase di esecuzione dell’applicazione.
L’altezza dipende dagli attributi dei caratteri del controllo
L’altra osservazione da sollevare è che ci sono controlli intrinseci invisibili in

fase di esecuzione (come Timer), che sebbene in fase di progettazione
supportino quelle 4 proprietà comuni, non sono supportate in fase di
esecuzione (ovvero non possono essere lette o modificate da programma)
Le proprietà ForeColor e BackColor influenzano rispettivamente il colore

del testo e il colore di sfondo

La maggior parte degli oggetti visibili (tra quelli elencati nella

precedente tabella) supportano entrambe le proprietà. Le osservazioni
anche qui non mancano:
• I colori di alcuni controlli, ad esempio delle barre di scorrimento sono

dettati direttamente dalle impostazioni di sistema operativo, e come tale
le proprietà ForeColor e Backcolor non li troverete nella finestra delle
proprietà
• In altri gli effetti di queste due proprietà dipendono da altre proprietà dei
controlli stessi: si fa l’esempio del controllo etichetta e del Controllo
Pulsante di Comando
Il controllo Etichetta ha una proprietà che si chiama BackStyle. Se impostata

a zero(Trasparent), non ha effetto la proprietà BackColor
I controlli CommandButton espongono una proprietà BackColor, ma non una
proprietà ForeColor. Il colore si sfondo è attivo solo se la proprietà Style
è impostata a 1(Graphical)
In un’appendice di questo corso torneremo a discutere di queste

proprietà che accomunano i vari controlli intrinseci.
Creazione dinamica di un controllo
La creazione dinamica di un controllo (sempre intrinseco) può essere raggiunta

secondo due modalità:
La prima modalità l’approfondiremo nel corso delle lezioni successive (trattando

approfonditamente gli array di controlli)
L’oggetto Form espone un’insieme (detto collection) di nome Controls. Con la

Versione 6 del linguaggio Visual Basic, questa collection è stata
arricchita del Metodo Add. E’ proprio attraverso questo metodo che si
creano dinamicamente controlli in fase di esecuzione.
La riga di codice è la seguente
Set newobj=Controls.Add(ProgId, Name [,Container])
ProgId è il nome di classe del controllo

Name è il nome che desiderate assegnare al controllo (esso deve essere
univoco, altrimenti viene generato l’errore 727)
Container è un riferimento opzionale (ecco perché inserito tra parentesi
quadre) I due controlli intrinseci contenitore sono PictureBox o Frame. Se viene
omesso tale riferimento, i controlli creati dinamicamente occuperanno la
superficie del form.

NewObj è una variabile oggetto, come spiegato nella lezione 2 sulle basi della
programmazione.
Gli eventi associati ai controlli intrinseci
Gli eventi che possono essere associati ai controlli intrinseci li vediamo nella
finestra di codice, in questo modo:
1) Posizioniamo il controllo Etichetta sul form

2) Poi con il tasto destro del mouse sul controllo aggiunto, selezioniamo la
voce Codice
Ecco una finestra dalla quale scorreranno tutti i possibili eventi registrati per
quel controllo
Dalla prima lista di riepilogo scegliamo il nome del controllo aggiunto,

dall’altra dove adesso c’è scritto Declarations, saranno pronti tutti gli eventi
associati a quel controllo.
Elenco dei possibili eventi
Esempio: Creiamo un form con un controllo etichetta e associando l’evento

OnClick a quest’ultimo, definiamo il seguente comportamento: ‘Cambiare la
proprietà Caption e colorare il testo di rosso, aumentando di 15 la dimensione

del carattere
Il form con il controllo Etichetta aggiunto
Il comportamento o l’evento OnClick associato è dettato dalle seguenti righe di

codice:
Righe di codice associate all’evento OnClick
Cliccando con il mouse sulla scritta Ciao, apparirà in modo grafico, ciò che è
stato scritto sotto forma codice. Il clic del mouse genera l’evento OnClick
associato all’oggetto Label (etichetta)

Gestire gli array di

record con VB6
Creare una struttura definita dall’utente
Nelle prime lezioni abbiamo trattato l’argomento dei tipi di dati che Visual Basic
mette a disposizione quando dichiariamo le variabili
Possiamo, attraverso questi tipi di dati, creare un nostro tipo di dati

personalizzato. Ciò avviene con l’enunciato Type <nome struttura>….. End
type. Tale enunciato è possibile dichiararlo a livello di modulo standard, modulo
di classe, ma non a livello di form, altrimenti in quest’ultimo caso genera errore
di compilazione
Esempio: Creiamo una struttura dati composta dai seguenti elementi
Type archivio
Cognome As String*30
Nome As String*30
Indirizzo As String*30
End type
Ricordiamo che questa operazione definisce un tipo, ma la variabile ancora non

esiste. Va dichiarata con l’istruzione Dim
Dimensionare dinamicamente un array di record
Si definisce record una riga logica e completa di informazioni. Con l’istruzione

Dim possiamo attraverso il tipo di dati definito con Type..End Type creare una
struttura denominata Array di record
Dim arrayrec(1..20) as Archivio
Con questa riga di codice si dichiara in modo statico l’array di record, in quanto
viene assegnata a priori la dimensione (ossia di quanti elementi è costituito)

Possiamo con Visual Basic 6.0 compiere un passo in avanti: dimensionare

dinamicamente l’array , ossia non fornire, con l’istruzione Dim, il numero di
elementi, ma poterlo fornire successivamente con l’istruzione Redim
Così avremo:
Dim arrayrec() as Archivio
…..
…..
Numelem=Inputbox(“Quanti elementi inserire:”)

Redim arrayRec(Numelem)
Grazie alla dimensione dinamica di un’array di record, non sprechiamo

allocazioni di memoria non utilizzate
N.b Se non si usa l’istruzione Redim, la struttura dati dichiarata con la variabile
arrayrec non risulta disponibile per la memorizzazione dei dati.
Gestire l’aggiornamento e la cancellazione di un elemento
L’aggiornamento e la cancellazione di un elemento presuppone che già

abbiamo già riempito l’array di record visto nei paragrafi precedenti.
L’aggiornamento è un’operazione che comporta:
- la ricerca dell’elemento nella struttura dati definita

- l’inserimento del nuovo elemento
- l’assegnazione al posto del vecchio elemento quello nuovo
Nella struttura dell’array di record
Type archivio
Cognome As String
Nome As String
Città As String
End type
L’unico campo, che nella realtà, è suscettibile di modifiche è il campo città.
Per trovare un elemento, all’interno di un array di record, occorre scrivere le

seguenti righe di codice

Prima di far ciò descriviamo due funzioni importantissime di Visual Basic, che
trovano applicazione per array o matrici
Esse sono Lbound e Ubound
Lbound restuisce l’indice inferiore dell’array o matrice. Può essere 0 se non è

indicata la direttiva Option Base 1
Se invece è indicata tale direttiva Lbound restituisce 1 come indice inferiore
Ubound invece restituisce l’indice superiore dell’array o della matrice (ossia il

numero complessivo degli elementi)
Option Explicit
Option Base 1
Type archivio
cognome As String
nome As String
city As String
End Type
Dim numelem As Integer

Dim arrayrec() As archivio
Sub main()
Dim stringa As String
Dim j As Integer
Dim stringat As String
Dim indice As Integer
Dim modcity As String
Dim citynew As String
Dim MODIFICATO As String
numelem = 5
'Assegnare dei valori all'array di record
ReDim arrayrec(numelem)
arrayrec(1).cognome = "Rossi"
arrayrec(1).nome = "Marco"
arrayrec(1).city = "Bari"
arrayrec(2).cognome = "Rizzi"
arrayrec(2).city = "Barletta"
arrayrec(3).cognome = "Romino"
arrayrec(3).city = "Giovinazzo"
arrayrec(4).cognome = "Ricchiuti"
arrayrec(4).city = "Bari"
arrayrec(5).cognome = "Retoldo"
arrayrec(5).nome = "Luigi"
arrayrec(5).city = "Trani"
'Procedere alla modifica della città
For j = 1 To UBound(arrayrec)
stringa = Str(j) & " " & arrayrec(j).cognome & vbCrLf
stringat = stringat + stringa
Next j
stringat = "Elenco cognomi" & vbCrLf & stringat
indice = InputBox(stringat)
modcity = "Città da modificare per:" & arrayrec(indice).cognome & vbCrLf
modcity = modcity & vbCrLf & "Città vecchia:" & arrayrec(indice).city & vbCrLf
citynew = InputBox(modcity, "Nuova città")
'Modifica della città vecchia con la città nuova
arrayrec(indice).city = citynew
'ARRAY MODIFCATO
MODIFICATO = "COGNOME:" & arrayrec(indice).cognome & vbCrLf
MODIFICATO = MODIFICATO & vbCrLf & "NOME:" & arrayrec(indice).nome &
vbCrLf
MODIFICATO = MODIFICATO & vbCrLf & "CITTA':" & arrayrec(indice).city
MsgBox MODIFICATO, , "DATI MODIFICATI"
End Sub
Nell’esecuzione di questo codice viene solo descritto l’accesso all’array di record

con indice uguale a quello che si vede nella finestra di dialogo msgbox
Poi l’istruzione di modifica è in pratica un’operazione di assegnazione
Arrayrec(indice).city=citynew
L’operazione di cancellazione comporta la scrittura delle seguenti righe di

codice
Ammettiamo di scegliere dall’elenco dei dati
codice cognome
visualizzati nella finestra di dialogo
un valore pari a indice
arrayrec(indice).cognome=””
arrayrec(indice).nome=””
arrayrec(indice).city=””
‘Visualizziamo nuovamente l’array di record

For j = 1 To UBound(arrayrec)
Flag=false
if indice=j then
flag=true
end if
If flag=false
stringa = Str(j) & " " & arrayrec(j).cognome & vbCrLf
stringat = stringat + stringa
end if
Next j
stringat = "Elenco cognomi" & vbCrLf & stringat
MsgBox (stringat)
Come potete verificare voi stessi, non avviene una redifinizione dell’indice, ma
non viene praticamente visualizzato l’arrayrec(indice) con i campi
cognome,nome,city nullo.

Gestione grafica con

Visual Basic
Sui Controlli Immagine e PictureBox
Entrambi i controlli svolgono il medesimo ruolo: Permettono di collocare su

un form immagini recuperate da un file grafico.
Supportano i seguenti tipi di file grafici:
• Bitmpap dall’estensione Bmp;

• Puntatori (cursori) dall’estensione Cur;
• File nel formato Graphics Interchange Format dall’estensione Gif;
• Icone dall’estensione Ico;
• File JPEG dall’estensione JPG o Jpeg;
• Meta-file grafici dall’estensione WMF;
Una proprietà importante dei due controlli intrinseci di grafica è Picture.
Dalla finestra di proprietà del controllo, è possibile fare doppio clic su tale
proprietà, e selezionare. dal nostro Hard disk, uno dei tipi di file grafici elencati
in precedenza, per caricarlo nel controllo.
A run-time (ossia in modalità di esecuzione dell’applicazione) è possibile

assegnare a tale proprietà il file grafico da caricare con la funzione LoadPicture.
Tale funzione viene utilizzata anche per assegnare uno sfondo ad un form.
Infatti una delle proprietà modificabili del form è proprio Picture. Anche in
questo caso è di lettura e scrittura (ossia è possibile fare l’operazione di
assegnazione con la funzione LoadPicture in modalità di esecuzione
dell’applicazione).
Una demo per comprenderne il concetto (nella sotto-cartella filmati della

cartella vb6 c’è il filmato avi form_picture)

Viene settata la proprietà Picture dell’oggetto Form e si imposta uno sfondo con
l’immagine realizzata con un qualsiasi programma di grafica.
Il controllo immagine ha due proprietà Width e Height. Prima di impostare tali

proprietà è necessario assegnare il valore booleano True alla proprietà Stretch
Questa proprietà permetterà di ridimensionare l’elemento grafico

contenuto nel controllo immagine, allorquando si ridimensionerà
quest’ultimo.
Vediamo una demo per capire la funzione della proprietà Stretch del controllo
Immagine. (Aprire il file avi Stretch_Picture nella sotto-cartella Filmati della
cartella vb6)
Impostando prima le dimensioni del controllo Image, senza aver

impostato la proprietà Picture e impostando successivamente la
proprietà Stretch al valore true, avverrà un ridimensionamento
dell’elemento grafico alle dimensioni del controllo Image.
Gli elementi differenziatori di questo controllo sono i seguenti:
• La casella Immagine (o Picturebox) è un controllo molto flessibile; la

motivazione sta nella serie di metodi e proprietà che supporta rispetto al
controllo Immagine;
• Il controllo Immagine è più efficiente e funziona al meglio nelle
applicazioni che girano sui pc poco veloci.

Dato il fatto che attualmente i computer risultano molto veloci, sarà difficile
verificare l’efficienza o meno tra i due controlli. A meno che si scrivano
applicazioni per computer meno recenti, si consiglia di utilizzare il controllo
casella Immagine per sfruttare la sua flessibilità.
Sui controlli Linea e forma
Oltre questi due controlli per caricare elementi grafici su un form, ne esistono
altri due per disegnare:
Essi sono i seguenti: Controllo Linea (o Line) e Controllo Forma (o shape)
Una volta trascinato il Controllo linea, sul Form, dalla casella degli strumenti, si
disegnano linee alla stessa maniera di utilizzare Macromedia Fireworks.
Le sue proprietà caratteristiche sono:
BorderStyle determina il formato della linea; Per impostazione predefinita, dalla

finestra di proprietà, si osserva che è assegnata la costante 1-Solid
BorderColor per colorare la linea
BorderWidth per determinarne lo spessore della linea in punti (1/72 di pollice)
X1,Y1,X2,Y2, proprietà queste che determinano le coordinate degli estremi del

segmento. Due coordinate definiscono sul form un punto e un segmento è
definito da due punti.
Nella tabella seguente rappresentiamo le costanti che la proprietà BorderStyle

può assumere
Costante Descrizione
1 – Solid Linea continua
2 – Dash Linea tratteggiata
3 – Dot Linea punteggiata
4 – Dash Dot Ogni trattino è seguito da un punto
5 – Dash – Dot Dot Ogni trattino è seguito da due punti
A differenza del controllo Linea che disegna soltanto linee, il controllo forma (o
shape) supporta il disegno di figure geometriche diverse, a seconda della
costante enumerativa assegnata alla proprietà shape.
In questa tabella rappresentiamo quali sono le costanti enumerative della

proprietà shape

0 – Rectangle Rettangolo
1 – Square Quadrato
2 – Oval Disegna ellisse
3 – Circle Cerchio
4 – RoundRectangle Rettangolo con angoli smussati
5 – Rounded square Quadrato con angoli smussati
Realizziamo un applicazione che permette di scegliere da due liste di riepilogo

la forma da disegnare e l’impostazione della proprietà FillStyle.
La proprietà Fillstyle disegna il motivo interno della forma
Interfaccia grafica dell’applicazione da realizzare
I controlli aggiunti sul form sono:
• Un controllo Line, opportunamente impostate delle proprietà deve venir

uguale a quello che si vede in figura
• Una label con tale scritta (basta impostare la proprietà Capton)
• Un’altra label con Forme da disegnare
• Un’altra label con la proprietà Caption uguale a Forma
• Un’altra label con la proprietà Caption uguale a Motivo
• Due liste di riepilogo che memorizzano rispettivamente sia le forme da
disegnare che i motivi interni alla forma da applicare.
• Un controllo shape (Controllo chiave dell’applicazione)
Due eventi OnClick sulle due liste di riepilogo
Un’inizializzazione di tali liste avviene con l’evento Load associato all’oggetto

Form
Il metodo per caricare tali valori, che si vedono in figura, si chiama AddItem

Per applicare la forma al controllo shape basta scrivere la seguente riga di

codice
Form1.shape1.Fillstyle=List2.ListIndex
La proprietà ListIndex dell’oggetto List2 restituisce la posizione

dell’elemento, nella lista, selezionato con un clic sinistro del mouse
Metodi grafici di VB6
Nel paragrafo precedente abbiamo visto due controlli che ci hanno permesso di
disegnare linee e forme. Inoltre Visual Basic ci permette di disegnare anche con
l’uso di metodi grafici.
Questi metodi grafici li rappresentiamo in questa piccola tabella:
Metodo Pset
Metodo Line
Metodo Circle
Grazie a questi metodi, utilizzati con l’oggetto Form, si possono disegnare linee
e forme senza l’uso di controlli in fase di esecuzione dell’applicazione
Vediamo la sintassi dei vari metodi:
Metodo Pset [nomeoggettoform].Pset [step] (intX,intY) [,colore]
Il metodo Pset imposta un punto di un oggetto su un colore

specificato.
Il nome dell’oggetto può essere facoltativo; se viene omesso il metodo

grafico agirà sull’oggetto form o casella immagine che ha lo stato
attivo
Lo stato attivo di un controllo, ad esempio di un form, è rappresentato dalla

barra del titolo evidenziata

Attraverso le righe di codice associate all’evento OnClick del pulsante di

comando sono riuscito a simulare lo stato attivo dell’oggetto Form.
Private Sub Command1_Click()

Dim obj As Form1
Set obj = New Form1
obj.Show
End Sub
Noterete in figura che il nuovo form ha il colore della barra del titolo più
marcata; mentre la barra del titolo del primo Form ha un colore più pallido e
ciò significa che non ha lo stato attivo, ma può essere dato, con un clic del
mouse sulla barra, da parte dell’utente
Ritornando al metodo Pset:
Il pixel di coordinate 0,0 (rappresentato dai due parametri intX,intY) fa

riferimento al pixel nel vertice superiore sinistro del form.
Esempio: pset(100,100) attiva un pixel (ossia un punto) nelle coordinate

intX=100 e intY=100
Vediamolo in figura
Dalla figura, Noterete un puntino (che è il pixel disegnato sull’oggetto form)

con il metodo Pset
Il colore del pixel disegnato è dato dal parametro ForeColor dell’oggetto Form
o dell’oggetto casella immagine

Abbiamo impostato la proprietà ForeColor dell’oggetto Form al valore

esadecimale che rappresenta il colore rosso
Disegnando adesso lo stesso pixel con il metodo Pset, prenderà il nuovo colore
impostato con tale proprietà
Noterete in figura il pixel rosso disegnato con il metodo Pset
Anche il metodo Pset ha il parametro Color. I valori che il parametro Color può
assumere sono le costanti intrinseche di Visual Basic per i colori:
Se invece si adotta lo stesso colore dello sfondo del form, il pixel disegnato
viene disattivato

vbBlack Nero
vbRed Rosso
vbGreen Verde
vbYellow Giallo
vbBlue Blue
vbMagenta Color Magenta
vbWhite Bianco
vbCyan Color Ciano
COSTANTI INTRINSECHE COLORI
E’ possibile disegnare con Pset utilizzando il ciclo for
Esempio:
for intX=1 to 40000

form1.pset (intx,250),vbRed
next IntX
Risultato delle righe di codice
Osservazione: Utilizzando il ciclo for si uniscono più pixel alla volta e si ottiene
una linea del colore indicato dalla costante intrinseca (vedi tabella costanti
colori)
Questa osservazione introduce l’uso dell’altro metodo grafico dell’oggetto Form

o del controllo Casella immagine), ossia il metodo Line
Tale metodo disegna segmenti in modo più efficiente
La sintassi è la seguente
Nomeoggetto.Line (intX1,intY1) – (intX2,intY2),colore,[B] [F]

Il parametro B (che sta per box) disegna un rettangolo ; il parametro

F(Fill) permette di riempire la figura disegnata dello stesso colore dei
bordi
Esempio: Disegnare un rettangolo di colore verde
Il codice da scrivere è il seguente

Dim X As Integer
For X = 1 To 1000
Form1.Line (X, 100)-(X + 150, 450), vbGreen, BF
Next X
End Sub
Il risultato:
Se omettessimo il parametro F, avremmo disegnato solo i bordi della figura

geometrica, senza effettuare nessun riempimento di quest’ultima
Abbiamo disegnato un rettangolo senza effettuare il riempimento (omesso il

parametro Fill). Il codice è il seguente:

Form1.Line (100, 100)-(1000, 350), vbGreen, B
End Sub
Ci sono altri metodi grafici che disegnano anche forme curvilinee (ossia cerchi o
ellissi)
Chi ha studiato geometria euclidea, conosce la definizione di ellisse. Si definisce

ellisse un cerchio allungato, che forma un ovale.
Proviamo, con il metodo Circle dell’oggetto Form o del controllo casella

immagine, a disegnare un ellisse
Il metodo circle ha molti parametri noi diamo per il fine di questo corso questa
sintassi:
form1.Circle [step] (intX,intY) sngraggio, [colore],,,,,sngaspetto
Il parametro sngaspetto definisce il c.d. rapporto di eccentricità dell’ellisse

stesso. Serve da moltiplicatore del raggio nelle due direzioni, verticale e
orizzontale. Il rapporto di eccentricità è chiamato anche rapporto di aspetto.
Un rapporto di aspetto 4, significa che l’asse verticale è 4 volte quello
orizzontale. Un rapporto di 0,2 significa che l’ellisse è 5 volte più larga
che alta.
Form1.circle (1000,1250),600,,,,(4/10/2) (1)

Form1.circle(2750,1250),600,,,,4 (2)
La prima ellisse (1) è quella disegnata in orizzontale
La seconda ellisse (2) è quella disegnata in verticale
Adesso proviamo a disegnare una circonferenza dato il raggio.
Sempre dalla geometria euclidea, si definisce raggio la distanza di un punto

qualsiasi della circonferenza dal centro che ha coordinate intX, intY
L’enunciato
Form1.circle(1000,1000),600,vbred disegnerà un cerchio con i bordi

rossi. Se volessimo disegnare anche il riempimento è la proprietà
Backcolor dell’oggetto form a determinarla. Basta però che non si
imposti tale proprietà con lo stesso valore della costante Color del
metodo Circle.

La proprietà DrawWidth dlel’oggetto Form determina lo spessore dei bordi del

cerchio disegnato
Se il parametro sngaspetto ha un valore inferiore all’unità, il

circolo(ellisse) disegnato si allungherà orizzontalmente; se è maggiore
dell’unità, l’allungamento sarà verticale; se è uguale a uno si disegnerà
un circolo perfetto (ottenendo una circonferenza)
Controlli per aggiungere suoni, filmati o animazioni Flash
Visual basic è un linguaggio di programmazione visuale che non crea solo

applicazioni aziendali o dette anche in gergo ‘gestionali’, ma anche applicazioni
carine di intrattenimento, tipo l’interfaccia per ascoltare un brano
musicale in formato wav, mp3,cda, un filmato avi, e grazie anche al Flash
Player di Macromedia, il controllo, da Visual Basic, di un’animazione
compilata in swf
I controlli per ascoltare file musicali è
• Windows Media Player

• Microsoft Multimedia Controllo 6.0
Ho progettato un’interfaccia grafica per avere un lettore Cd realizzato con il

linguaggio di programmazione Visual Basic

Interfaccia grafica per realizzare un lettore Cd
Sul form esistono i seguenti controlli:
3 etichette per visualizzare rispettivamente le scritte

- Lettore cd
- Lista tracce audio
- Unità lettore cd (nome assegnato logicamente dal sistema operativo es d, e,
f)
1 casella di testo per inserire il nome del drive (lettore cd) dove è stato inserito
il cd audio per l’ascolto
Una casella di riepilogo per gestire che traccia audio si desidera ascoltare
1 pulsante di comando per aggiungere tracce
1 pulsante di comando per chiudere l’ascolto della traccia corrente e

deselezionare il nome della traccia all’interno della casella di riepilogo
Questa interfaccia grafica consta del seguente codice:

CODICE PER GESTIRE L’APPLICAZIONE
Gli eventi sono stati associati ai due pulsanti di comando
• cmd_aggtracce (nome del pulsante di comando con etichetta Aggiungi tracce)

• cmd_scaricatraccie (nome del pulsante di comando con etichetta Chiudi)
E’ stato associato l’evento chiave alla lista di riepilogo list_tracceaudio
Come funziona l’applicazione
Basta inserire il nome dell’unità dove si trova il cd nella relativa casella di testo
Premere il pulsante di comando sino a contenere la traccia che si vuole
ascoltare
Selezionare la traccia audio dalla lista di riepilogo (1)
Si attiverà il controllo multimedia con i relativi pulsanti; cliccare sul pulsante
Play simile a quello che si trova su tutti i comuni video registratori
(1)
Quando si preme il pulsante Aggiungi tracce naturalmente si segue la struttura
dei file che stanno sul cd audio
Track01.cda Track02.cda Track03.cda Track04.cda…. Track08.cda…

Track10.cda
Da 0 a 8 (9 tracce) avranno Track0K.cda

Da 9 in poi avranno track[indice della traccia nella casella di riepilogo].cda

Di quanto descritto testualmente trovate il codice all’interno dell’evento

cmd_aggtraccie_OnClick
Se il numero di tracce aggiunte (list_tracceaudio.ListCount) è inferiore o uguale

a 8 (0 a 8 sono 9 tracce) viene assegnata alla variabile nome la seguente
stringa
Nome= track & “0” & listtracceaudio.ListCount+1
Viene aggiunta l’unità perché sul cd audio non troverete mai un nome di file
track00.cda
Se il numero di tracce aggiunte è maggiore di 8 (ossia viene aggiunta la

decima traccia, l’undicesima e così via) la stringa è simile solo che non è
concatenato il carattere 0
Con il metodo AddItem viene aggiunto il valore di nome alla lista delle tracce
audio
Nell’evento on click sull’elemento della lista selezionato viene gestito l’ascolto

della traccia audio
Funziona pressappoco così:
Se è la prima traccia (Track01.cda) ad essere ascoltata per prima, allora viene

assegnata alla proprietà filename del controllo mmcontrol1 la stringa
Txt_lett & “:\” & list_traccieaudio.List(list_traccieaudio.ListIndex) & “.cda”
Viene attivato il comando Open del controllo mmcontrol1
E’ salvata la posizione corrente della traccia che si sta ascoltando (L’elemento,

nella posizione 0 all’interno della lista, è la prima traccia)
Adesso occorre gestire l’ascolto in avanti e in indietro e sono stati preparati

opportunamente due cicli for uno di questi con la clausola step -1
decrementano il valore assunto da posizione; L’altro gestisce l’incremento del
valore assunto da posizione
Esempio se mi trovo alla 14 posizione e voglio ascoltare la 13 devo prima

scaricare la traccia che stavo ascoltando (premendo il pulsante Chiudi) e poi
selezionare la tredicesima. Il controllo mmcontrol1 arriva alla posizione 13 nel
cd audio e premendo il pulsante play posso ascoltarla.
Per concludere questo esercizio, vi devo suggerire come portare sul form il
controllo Microsoft Multimedia Controllo 6.0

Per prima cosa, basta fare tasto destro sulla casella degli strumenti
Si seleziona la voce Components o Componenti (per chi ha la versione in

Italiano di Visual Studio)
Da questa finestra di dialogo, con un segno di spunta al controllo, che si

desidera aggiungere alla casella degli strumenti (in questo caso Microsoft
Multimedia Control 6.0), confermare con Ok e detto controllo apparirà, come si
vede in figura:

Il controllo aggiunto appare ,in figura, accanto al controllo oggetti Ole
Un doppio clic su di esso apparirà sul form con stato attivo
Un controllo ActiveX aggiunto su un form
Per concludere l’argomento, apriamo una piccola parentesi sul controllo da

Visual Basic di un’animazione in Macromedia Flash.
Esempio: Ho disegnato un semplice sommario con due livelli: nel primo livello
ho inserito i titoli delle prime 5 lezioni; nel secondo i titoli delle successive 5
Layer1 1-5
Layer2 6-10
In questo caso, per controllare ,da Visual Basic, la visualizzazione di questo

filmato, occorre aggiungere sul form il controllo Shockwave Flash
Vediamo l’interfaccia grafica dell’applicazione

Interfaccia grafica dell’applicazione
Il codice per gestire l’applicazione è:
Private Sub Cmd_Layer2_Click()

ShockwaveFlash1.TGotoFrame "Lezione6-10", 10
ShockwaveFlash1.Play
End Sub
Private Sub cmd_play_Click()

ShockwaveFlash1.LoadMovie 0, "c:\testflavb6.swf"
End Sub
All’interno del file fla vi faccio vedere come ho strutturato l’animazione

Il contenuto che si vede nello stage sarà visualizzato nel controllo aggiunto sul
form quando si premerà il pulsante Layer 1-5
Il contenuto che si vede nello stage sarà visualizzato nel controllo aggiunto sul
form quando si premerà il pulsante Layer 6-10
Su ogni layer creato ho aggiunto l’azione di stop in modo tale che quando viene
caricato il movie non viene visualizzato il contenuto dello stage precedente.
Un commento alle righe di codice
Quando si premerà il pulsante Play verrà caricato il layer 0 (cioè il primo layer
del filmato) con il metodo LoadMovie. A tale metodo viene assegnato il
percorso dove si trova il file swf compilato con Macromedia Flash
Quando si premerà il secondo pulsante Layer 6-10 vengono eseguite due righe
di codice importanti
- Lo spostamento della testina di riproduzione del filmato al frame 10

- L’esecuzione del metodo Play caricherà il contenuto dello stage che si
trova al frame 10.
Il parametro 10 viene assegnato al metodo TGotoFrame dell’oggetto

ShockwaveFlash1
Durante l’esecuzione dell’applicazione dovrete ottenere

Premete il pulsante Play e otterrete quando si vede in figura
Premete il pulsante Layer 6-10 per ottenere lo spostamento della testina di

riproduzione del filmato al frame 10
Verrà rilasciato il file swf testflavb6.swf in modo che potrete ricostruire il

progetto di creazione dell’interfaccia con la vostra copia di Visual Basic 6.0
Ciò che abbiamo visto a proposito del controllo ShockwaveFlash è una dei tanti
aspetti della gestione del controllo (quello più semplice da realizzare).
Se volessi tornare al layer 1-5 devo aggiungere un pulsante home

all’interfaccia e aggiungere queste righe di codice
Private Sub Cmd_home_Click()

ShockwaveFlash1.TGotoFrame "Lezione1-5", 1
ShockwaveFlash1.Play
End Sub

Le Api di Windows
Natura delle librerie a collegamento dinamico
Siamo finalmente arrivati alla lezione un pochino, se non proprio delicata dal
titolo Le Api di Windows. Cercherò di usare un linguaggio molto semplice e
chiaro da comprendere senza utilizzare del tecnicismo per evitare che poi nella
pratica non si riesca a individuare l’applicazione in cui farne uso.
Dopo questa premessa, diciamo che Visual Basic, come qualsiasi altro
linguaggio di programmazione Visuale, estende le sue funzioni, avendo
accesso, attraverso questo strumento (c.d. Application Programmino
Interface di Windows), alle routine interne di Windows
Domanda: Dove troviamo le routine interne di Windows?
Le troviamo all’interno di DLL (Dynamic Link Library ossia nelle librerie

a collegamento dinamico)
Le Api di Windows non sono state create in Visual Basic, ma in C++ e

memorizzate in queste librerie.
Il compito di Visual Basic è quello di permettere l’accesso nelle

modalità, le quali saranno descritte nei dettagli dei paragrafi che
seguono.
Concludiamo il paragrafo spiegando la natura delle librerie a collegamento

dinamico.
Dal punto di vista dei programmatori, quando una routine (subroutine o

function che sia) è collegata dinamicamente all’applicazione, si afferma
che non è connessa a quest’ultima neanche dopo l’attività di
compilazione. La disponibilità avviene soltanto quando vengono
invocate dall’applicazione in esecuzione

In altri termini la funzione Api dichiarata in Visual Basic viene caricata per il
tempo necessario all’esecuzione, successivamente se non più necessaria, il
sistema operativo Windows la scarica, ottimizzando la gestione delle risorse
hardware.
Le librerie Dll comuni di Windows: user32.dll, gdi32.dll, kernel32.dll
Il sistema Operativo Windows si mantiene in esecuzione, se funzionano in

modo ottimale tutte le librerie a collegamento dinamico richiamate per ogni
tipo di operazione.
Il vantaggio di appoggiarsi a queste librerie all’interno di applicazioni VB o altro

ambiente di sviluppo che le supporta, è dato dalla portabilità delle routine
incluse anche se cambia la versione del sistema Operativo. Quindi
l’applicazione deve essere in grado di supportare le nuove funzionalità di
Windows senza dover ricompilare tutte le applicazioni che utilizzano le Api di
Windows.
Ci sono delle librerie di collegamento che funzionano in modo efficiente,

mediante le quali l’interfaccia grafica di Windows in tutte le sue operazioni,
risponde bene all’utente. Quelle più comuni sono:
User32.dll Contiene funzioni che controllano la GUI (Graphical User Interface –

Ambiente e interfaccia grafica utente) di Windows, tipo cursori, menu e finestre
di dialogo
Gdi32.dll Contiene funzioni che controllano l’Output sullo schermo e su altre

unità (E’ una dll che supporta funzioni grafiche)
L’ultima dll comune che annoveriamo rappresenta il cuore del funzionamento di

Windows: Supporta funzioni che controllano l’interfaccia grafica hardware e
software interna di Windows (tipo gestione dei processi, della memoria, file e
cartelle) Questa libreria è quella che si trova allo strato più basso del sistema
operativo. All’utente invece è visibile solo l’interfaccia grafica che si estrinseca
nell’uso del desktop e delle finestre.
Possiamo comprendere bene che ogni programma Windows ha delle sue dll
proprie, le quali possono far capo a quelle comuni; se non funziona una a
cascata non funzionerà più l’applicazione che le richiama.
Tutte le dll le troviamo nella cartella Windows\system
Connessione alle librerie Dll con l’enunciato Declare
Domanda: A che serve l’enunciato Declare? Esso serve a poter richiamare le

Api di Windows. Quelle interne del linguaggio Visual Basic non hanno bisogno di

questo enunciato, in quanto VB conosce il loro funzionamento e sa quali sono

gli argomenti necessari. Ogni Api di Windows ha dei propri argomenti da
passare, alcuni obbligatori, altri opzionali e i tipi di dati, vedremo, possono
trovare conflitto con quelli gestiti dal linguaggio con il quale si realizzano le
applicazioni che li richiamano.
Anche per le Api di windows si prospetta il discorso dell’area di validità pubblica

o privata. Se nell’enunciato Declare, viene scritto che la routine Api chiamata è
di tipo Pubblico, sarà visibile a tutta l’applicazione. Altrimenti sarà visibile solo
nel form o nel modulo dove è stata dichiarata.
Nell’ultimo paragrafo utilizzeremo lo strumento Visualizzatore Api per

semplificare di molto la scrittura, nel nostro programma vb, dell’enunciato
Declare con una semplice operazione di Copia e incolla.
Se si parte da zero nella conoscenza di Visual Basic, occorre avere a

disposizione una guida estensiva delle Api di Windows per poter essere in
grado di scriverla autonomamente, altrimenti occorre avere un testo che le
descriva e assieme questo valido strumento (Visualizzatore Api)
Gli argomenti delle funzioni o subroutine e i tipi di dati
Nelle routine o funzioni Api che possono essere richiamate, nell’enunciato

Declare possiamo incontrare i seguenti tipi di dati:
Any E’ un tipo di dati universale: Vengono passati per riferimento gli argomenti
con questo tipo di dati e non serve la parola ByVal (Il passaggio per valori e
per riferimento sarà chiaro tra 4 lezioni)
ATOM E’ l’integer di Visual Basic. E’ un tipo di dati che supporta dati interi
Sempre passati per valore con la clausola ByVal davanti al nome della variabile
BOOL E’ l’intero lungo di Visual Basic (Long) Come per il tipo di dati precedente
gli argomenti dichiarati vengono passati con la clausola ByVal (passaggio per
valore)
Char Dati tipo byte Anche in questo gli argomenti sono passati per valore
COLOREF Di tipo Long utilizzati per definire valori di colori. Gli argomenti sono
sempre passati per valore
DWORD Di tipo Long (interi), i cui argomenti, dichiarati nella Api chiamata,
sono sempre passati per valore
Null Di tipo long (interi) utilizzati per valori non inizializzati Gli argomenti sono
passati per valore

LPSTR, LPCSTR Corrispondenti dei dati di tipo string Anche in quest’ultimo caso
sono passati gli argomenti per valore.
STRUCTURE – Definizione di tipi di dati complessi
Si nota facilmente come i tipi di dati degli argomenti delle Api di

Windows riflettono in modo particolare l’ambiente di sviluppo con il
quale sono state scritte (il C++ - letto c plus plus) e differenti dai tipi
di dati esaminati con Visual Basic.
Il visualizzatore Api e esempi di chiamate
Concludiamo l’argomento sulle Api di Windows, trattando dello strumento

installato con Microsoft Visual Studio, denominato Visualizzatore Api
Avviamo detto strumento, l’interfaccia grafica la vediamo in figura
Visualizzatore Api
Nella casella di riepilogo Api type troviamo:

• tutte le costanti richiamate nelle api di windows dichiarate

• tutti gli enunciati Declare della maggior parte delle Api incluse
nelle Dll comuni che abbiamo trattato nei paragrafi precedenti di
questa lezione
• Nella sezione types sono richiamate la definizione di tipi di dati, a
cui un argomento presente nell’enunciato Declare può far
riferimento.
Per caricare la casella Api type, dal menu file occorre richiamare il file
testuale WinApi32.txt, come si vede in figura
A titolo di esempio possiamo vedere la dichiarazione dell’Api di windows che

crea una directory dato un pathname (o percorso di creazione)
Ecco la finestra di codice che riflette le informazioni prese dal visualizzatore Api

Cercate CreateDirectoryEx dal sezione declares del visualizzatore api e

copiatela in modulo standard.
Poi cercate nella sezione tipi Security_Attributes e definite un tipo di
dati personalizzato dall’utente.
Dichiarate due variabili una di tipo long e l’altra di tipo

security_attributes.
Le informazioni assegnate alla variabile secattr sono prese

direttamente dalla win32 sdk (facente parte di msdn library).
Il valore di reval se è maggiore di 0 significa che la directory è stata

creata con successo.
C:\CORSO è una cartella di modello. Nel senso che apitest verrà creata
con le informazioni prese da Corso. Es Se corso è di sola lettura, anche
apitest sarà con l’attributo di sola lettura.
Conoscere tutte le Api di Windows è un lavoro che richiede pazienza e

tempo di apprendimento, ma le alternative all’accesso diretto alle Api,
è dato dalla presenza di molte Dll che contengono già delle api
compilate tipo una che vedremo alla fine del corso Microsoft Shell
Controls Automation.

Visual Basic Avanzato

Parte Prima
Cenni sull’accesso ai database
Il punto di forza di Visual Basic è quello di gestire con strumenti semplici le basi
di dati di qualsiasi formato Dbf database creati con Visual Dbase della borland
oppure con le precedenti versioni di Dbase iii plus e Dbase IV sotto il
precedente sistema operativo Ms-Dos, Mdb database creati con l’applicativo
Microsoft Access nelle sue varie versioni Txt database in formato testo
e database più professionali come SQL Server.
Il controllo intrinseco, che si trova sulla casella degli strumenti di Visual Basic.
ossia il controllo Data permette di accedere a database tipo:
L’elenco che vedete in figura sono i formati di basi di dati ai quali il

controllo Data è abilitato a connettersi.
In questa tabella mostriamo le principali proprietà del controllo Data:
Proprietà Descrizione
Connect Scegliere dalla lista di riepilogo il formato di basi di
dati al quale connettersi

DatabaseName Indica il percorso di memorizzazione della nostra base

di dati
RecordSource Restituisce o assegna il nome della tabella,
dell’istruzione SQL e dell’oggetto query di un database
che li supporta (tipo Access)
Se impostiamo dall’elenco della proprietà Connect Access come formato di

database al quale connettersi, con la proprietà DatabaseName scegliamo di
utilizzare un base di dati nel formato di Access 2000
Impostiamo infine, dall’elenco prodotto dalla proprietà RecordSource, l’oggetto
da gestire tipo tabelle, query, o eseguire una determinata istruzione SQL Select
per la selezione dei record.
Visual Basic in sede di progettazione genera l’errore che verrà discusso nelle
lezioni successive, ma che in questo paragrafo ve ne mostriamo comunque
l’alert di errore:
Si riesce a tradurre che il database impostato con la proprietà DatabaseName

ha un formato non riconosciuto dal controllo Data. (errore 3343)
Il controllo data riconosce formati di database di Access nella versione 97 e il

motore di gestione è viene gestito dalla libreria Microsoft Dao 3.51. Sta di fatto
che quando aggiungiamo il controllo Data sul form, viene automaticamente
aggiunto un riferimento a tale libreria:
Dal menu Progetto –Riferimenti si ottiene tale finestra di dialogo che elenca
tutte le librerie necessarie a far funzionare correttamente l’applicazione

Domanda: Come possiamo creare un database in versione Access 97,

attraverso l’ide di Microsoft Visual Basic?
Con questa domanda abbandoniamo questo paragrafo, ma veniamo introdotti

perfettamente nell’utility che verrà descritta nel paragrafo successivo ☺
Visual Database Tools
Visual Database Tools è un’utility che semplifica molto la gestione di una base
di dati, e permette a chi sa smanettare con Sql (linguaggio standard per
creare,estrapolare,aggiornare,cancellare informazioni), di effettuare la
creazione della struttura di una tabella o di fare un’inserimento dati, di
interrogare la base di dati attraverso istruzioni del modulo DML DI SQL (Data
manipulation Language o Linguaggio di manipolazione dei dati, istruzione
Select, update, insert into per intenderci).
Come si accede a questa utilità?
Si accede dal menu Aggiunta (o Add-in per la versione Inglese di Visual Basic)
selezionando Visual Data Manager. Appare la seguente interfaccia grafica:
Per rispondere alla domanda formulata alla chiusura del paragrafo precedente
si procede nel modo seguente:
Si accede, attraverso questa interfaccia grafica, dal menu file, alla voce

Nella finestra successiva potrete dare un nome alla base di dati e premere il
pulsante salva
La finestra successiva rappresenta l’ambiente di lavoro per creare tabelle e

troviamo poi un’altra finestra che chiameremo finestra di console, per digitare
manualmente le istruzioni SQL.

Per creare una nuova tabella occorre cliccare con il tasto del destro del
mouse sulla prima finestra a sinistra e selezionare New Table.
Si accede ad una finestra di dialogo esemplificativa per creare la struttura delle

tabell; definendone il nome ed i campi; ad ogni campo assoceremo un tipo di
dato; (Vedi figura qui sotto)
Una volta aggiunti tutti campi per la tabella, che troveremo nella casella di
riepilogo Field List, si preme il pulsante Build the table (Costruisci la tabella)

Dal menu Utilità di Visual Data Manager c’è Data Form Designer
Questa utilità permette di generare un oggetto form e di aggiungerlo

automaticamente ad un progetto VB.
Premendo Build the Form, viene generato il form per la gestione della base di
dati associata alla tabella tabprova.
Il controllo Data sta nella parte bassa del form, tutte le caselle di testo sono
associate alla tabella tabprova e troviamo poi una serie di pulsanti:

Add: per aggiungere un record;

Dolete: per cancellare il record corrente;
Refresh: per aggiornare il valore di uno o più campi nel form;
Update: per aggiornare materialmente l’informazione nella tabella;
Close: per chiudere il form tabprova.
Al controllo data c’è una barra di navigazione che ci permette di andare al

primo record , ad ogni record successivo e all’ultimo record della tabella;
Nell’aggiunta del primo record si preme il pulsante Add e poi si compilano i

campi del form e si preme il pulsante Update. Per inserire ogni record
successivo al primo si preme il pulsante Add.
Il Data Environment
Il Data Environment è una finestra di progettazione che offre un ambiente

interattivo in grado di:
- facilitare l’accesso ai database di vario formato in fase di progettazione e,

a livello di programmazione, in fase di esecuzione dell’applicazione.
In fase di progettazione vengono impostati i valori delle proprietà di due

oggetti chiavi:
• Oggetto Connection
• Oggetto Command
In fase di progettazione, a livello di codice si possono programmare gli

eventi a cui il modello a oggetti Ado prevede (ma di questo non è
parliamo per il livello di cenni che stiamo dando su questo argomento)
Si possono trascinare gli oggetti Data Environment su form o report

per creare controlli ad accesso ai dati
A differenza del controllo Data, attraverso il Data Environment è possibile

accedere a database di access 97/2000/2003. Mentre per i database di access
superiori alla versione 97, il controllo Data solleva l’errore di formato
sconosciuto e si deve intervenire con il codice in modo da utilizzarlo anche
per la gestione di questi due formati.
Applicazione da realizzare: Impostare le proprietà connection dell’oggetto

DataEnvironment per accedere ad un database di Access 97. Impostare le
proprietà dell’oggetto Command per accedere all’oggetto tabella. Trascinare
l’oggetto command creato sul form, dovreste ottenere la seguente interfaccia
grafica:

La seconda parte dell’applicazione deve prevedere l’aggiunta di una barra di

navigazione con i tre pulsanti FIRST (Vai al primo record) Next (Vai al prossimo
record con verifica che non ci sono più record da leggere) e Last (Vai all’ultimo
record). Se si preme Last una seconda volta, l’oggetto DataEnvironment1,
programmaticamente deve spostare la lettura del db partendo dal primo
record.
Ecco l’interfaccia grafica con l’aggiunta di questi pulsanti
Ecco la parte di codice che gestisce l’applicazione
Option Explicit
Dim ct As Integer
Dim k As Integer
Dim k1 As Integer
Private Sub Cmd_First_Click()

DataEnvironment1.rsCommand1.MoveFirst
End Sub
Private Sub CMD_LAST_Click()

k1 = k1 + 1
If k1 = 2 Then
MsgBox ("Sei già all'ultimo record:")
DataEnvironment1.rsCommand1.MoveFirst
Exit Sub
End If
DataEnvironment1.rsCommand1.MoveLast
End Sub

Private Sub Cmd_Next_Click()

k=k+1
If k = ct Then
GoTo esci
Else
DataEnvironment1.rsCommand1.MoveNext
Exit Sub
End If
esci:
MsgBox ("Non ci sono più records da leggere")
Unload Form1
End Sub
Private Sub Form_Load()

ct = DataEnvironment1.rsCommand1.RecordCount
End Sub
L’oggetto RsCommand1 viene creato automaticamente dopo aver impostato le

proprietà dell’oggetto Command
I metodi moveNext, MoveFirst, MoveLast dell’oggetto RsCommand1 gestiscono

la lettura della tabella (oggetto del database di Access)
La proprietà RecordCount dell’oggetto RsCommand1 restituisce il numero di

record aggiunti alla tabella
Il metodo Unload Form1 distrugge l’oggetto Form1 e chiude definitivamente

l’applicazione
L’enunciato Exit Sub causa la chiusura anticipata dell’esecuzione del codice.
L’enunciato End al posto di Exit Sub ha lo stesso effetto del metodo Unload
Form1
Nella sottocartella filmati trovate una demo di come si configura l’ambiente di

progettazione DataEnvironment. Vi sarà utile quando creerete il progetto
esplicato nei dettagli (DataEnvironment.avi)
La finestra QueryBuilder
Questo strumento è stato aggiunto nelle edizioni di Visual Basic (Enterprise e

Professional). Si attiva il menu query esclusivamente mentre si crea in modo
interattivo una query SQL con Microsoft Query Builder
Vediamo una demo: Nella sottocartella filmati della cartella vb6 troverete
creaquery.avi

Il precitato strumento aiuta tutti coloro che non hanno mai smanettato con le
istruzioni del linguaggio Sql. Come si potrà osservare dalla riproduzione del
filmato, l’istruzione Sql viene generata automaticamente, dopo che l’utente ha
impostato campi, criterio di ordinamento su un campo della tabella, aiutandosi
con l’intuitiva interfaccia grafica a disposizione
Finestre di dialogo comuni e l’utilizzo dei Controlli standard di Windows
Questo paragrafo, rispetto a quello precedente non ha nessuna relazione e

vuole essere una pausa sull’argomento così vasto come la gestione delle basi di
dati con Microsoft Visual Basic.
Quando si opera con il sistema operativo Windows o con programmi compatibili

si è soliti incontrare determinate finestre di dialogo comuni:
Esse possono essere:
La scelta del font (ossia la finestra di dialogo per scegliere il tipo di carattere, la
sua dimensione, il colore)
La finestra di dialogo Apri e Salva nome file
La tavolozza dei colori di sistema (simile a quella che incontriamo in Wordpad,

Notepad, tutti i programmi di Office e altri programmi di grafica)
La visualizzazione di un file help con il metodo ShowHelp, dopo aver impostato

le proprietà HelpCommand e HelpFile
La finestra di dialogo Stampa con il metodo ShowPrinter
Tutta la gestione di queste finestre elencate sono incluse nel controllo

Microsoft Common Dialog Control 6.0 (che può essere aggiunto alla
casella degli strumenti mediante lo short Cut Ctrl+T che visualizza la
finestra Componenti)
Con l’aiuto della grafica creiamo un’applicazione che visualizzi tali finestre di
dialogo:

FINESTRA DI DIALOGO COLORI (Commondialog1.ShowColor)

Pulsante Tavolozza Colori
FINESTRA DI DIALOGO DI STAMPA (CommonDialog1.ShowPrinter)

Pulsante Finestra di dialogo di stampa
FINESTRA DI DIALOGO CARATTERE (CommonDialog1.ShowFont)

Pulsante FONT CARATTERE
FINESTRA DI DIALOGO APRI (CommonDialog1.ShowOpen)

Pulsante Finestra Apri

FINESTRA DI DIALOGO SALVA CON NOME (CommonDialog1.SHOWSAVE)

Pulsante Finestra Salva con Nome
Il codice per gestire tale applicazione molto semplice è quello che si vede in
figura:

Per l’utilizzo del metodo ShowFont dell’oggetto Commondialog1, se non viene

prima impostata la proprietà flags (cdlCFBoth) ,che visualizza la finestra di
dialogo caratteri disponibili per schermo e per stampante), si genera l’errore di
run-time 24574 (Nessun font risulta installato) all’esecuzione di tale
metodo.
Cenni di Excel con Visual Basic
Una delle frontiere, che ha reso popolare l’utilizzo di Visual Basic, è stata quella
di poter interagire con altri software microsoft e non. Il paragrafo s’intitola
Excel con Visual Basic
Dobbiamo spiegare in questo paragrafo soltanto il concetto di automazione.
L’automazione si ottiene con l’utilizzo della funzione CreateObject, attraverso la

quale viene creato e restituito un riferimento a un oggetto ActiveX.
S’intende oggetto ActiveX, un oggetto che può essere esportato in altre

applicazioni o strumenti di programmazione.
L’oggetto ActiveX da esportare in Visual Basic è la libreria a collegamento

dinamico di Microsoft Excel
Possiamo gestire gli oggetti di Microsoft Excel in due modalità

Dim obj As Object
Set obj = CreateObject("Excel.Application")
obj.workbooks.Add
obj.Visible = True

End Sub
L’altra modalità è quella di aggiungere un riferimento alla libreria di Microsoft

Excel nell’applicazione di Visual Basic che si sta realizzando.
Dal menu Progetto si aggiunge il riferimento per mezzo di questa finestra di

dialogo:
e il codice per creare l’automazione

Dim obj As New Excel.Application
obj.Workbooks.Add
obj.Visible = True
End Sub
Da sviluppatore vi suggerisco di utilizzare la prima modalità. Così vi assicurate

di non generare errori sul computer del cliente, il quale potrebbe aver installato
una versione di Excel successiva a quella aggiunta come riferimento o più
vecchia.
Mentre con la prima si sfrutta l’indirizzo programmatico del nome di classe

dell’oggetto il quale è rimasto sempre Excel.Application
Alcuni con la prima modalità aggiungono il numero di versione, quindi

diventerebbe:
CreateObject(“Excel.Application.9”) per Excel 2000

Io da sviluppatore non vi suggerisco di mettere il numero di versione, in quanto

sarebbe equivalente ad aggiungere un riferimento alla libreria di Excel che il
cliente potrebbe non avere. Viene generato a run-time l’errore 429

Tradotto in italiano tale codice di errore, significa che il componente ActiveX

per il quale si vuole ottenere un riferimento non riesce a creare l’oggetto. E’
probabile che si è sbagliato a digitare correttamente il nome della classe
dell’oggetto o che tale oggetto non sia registrato correttamente nel registro di
configurazione di Windows.
Esempio: Creiamo l’interfaccia grafica a tre pulsanti:
• Primo Pulsante crea una nuova cartella di lavoro di Excel

• Secondo pulsante per chiudere la cartella creata
• Terzo pulsante per aprire la cartella cartella
Un primo passo per descrivere il concetto di automazione
Il codice che gestisce l’applicazione

La creazione di una cartella di lavoro di Excel si crea ottenendo il riferimento

all’oggetto Excel.Application.
Poi viene creato l’oggetto cartella attraverso il metodo Add dell’oggetto
Workbooks (c.d. cartella di lavoro)
Il metodo SaveAs,passando il pathname, memorizza il file Xls sul nostro
Personal Computer
Nell’evento Cmd_chiudi_OnClick si chiude l’applicazione di Excel con il metodo

Quit dell’oggetto Application. e si distruggono gli oggetti obj e cartella
Nell’evento cmd_Open_OnClick vengono eseguite le seguenti

operazioni:
Creazione dell’oggetto Excel.Application

Creazione dell’oggetto cartella, attraverso il metodo Open passando il
pathname del file xls già creato
Attraverso la proprietà Booleana (imposta il valore true) si rende
visibile la cartella di lavoro di Excel. Tale proprietà è a livello di
Excel.Application.
Cartella di lavoro di nome temp.xls

Fornire l’accesso a Internet ad un’applicazione
Visual Basic fornisce l’accesso a Internet con diversi controlli, ma in questo

paragrafo, descriviamo molto brevemente dell’oggetto WebBrowser (nelle
successive lezioni lo approfondiremo con altri dettagli).
Tale oggetto lo troviamo nella libreria Microsoft Internet Controls, il cui

riferimento in una ipotetica applicazione avviene attraverso una
finestra di dialogo accessibile con uno short-cut da tastiera Ctrl+T
(premuti contemporaneamente; il tasto Ctrl è il tasto Control che si
trova sotto il Caps Lock)
La finestra di proprietà di detto oggetto la rappresentiamo nella figura qui

sotto:
Step n° 1 : Aggiungiamo il controllo WebBrowser sul form

Step n° 2 Assegnare l’evento OnClick al pulsante di comando Libero.it
Il pulsante di comando Libero.it (il cui nome dato al controllo è Cmd_Url)

esegue il metodo navigate dell’oggetto WeBBrowser1
Step n° 3 Eseguire l’applicazione – L’oggetto WebBrowser permette di avere

l’accesso a Internet direttamente dall’applicazione Visual Basic

WebBrowser1.Navigate “http://www.libero.it” è il codice assegnato all’evento

Cmd_Url_OnClick
Oltre a utilizzare l’oggetto WebBrowser, esiste anche la libreria che supporta

l’interfaccia grafica proprio di Internet Explorer. Per utilizzare questa libreria
aggiungeremo il riferimento all’applicazione nel modo seguente:
Menu Progetti - > Riferimenti -> Dalla finestra di dialogo sceglieremo Microsoft
Internet Controls
Utilizzando il principio dell’automazione visto per Excel avremo

Dim obj As SHDocVw.InternetExplorer
Set obj = New SHDocVw.InternetExplorer
obj.Visible = True
End Sub
Concludiamo dicendo che, tali righe di codice visualizzeranno proprio il browser

di Internet Explorer


Visual Basic avanzato

Parte seconda
Controlli intrinseci avanzati
Sono rimasti da analizzare pochi controlli intrinseci della ToolBox, che definisco
avanzati perché permettono di effettuare operazioni molto professionali
C’è il combobox che è un controllo composto. Con l’aggettivo composto intendo

che è l’unione di una casella di testo e di una lista di riepilogo che vedremo
successivamente.
Vediamone il funzionamento
Partiamo da questa interfaccia grafica molto semplice:
Si osservi l’aggiunta del controllo Combobox1 (ha un identificativo Combo1);

di un pulsante di comando Aggiungi (cmd_aggiungi)
Praticamente eseguendo quest’applicazione si caricheranno degli elementi

all’interno del combobox1. Si selezionerà un elemento e premendo il tasto di
funzione F1 si procederà alla modifica dell’elemento selezionato
Il codice che esegue questo è:

Possiamo togliere il pulsante di comando e gestire con l’evento KeyDown del

controllo Combo, l’operazione di aggiungere un elemento alla lista facendo il
trapping (ossia premendo un tasto di funzione che questa volta ha valore
keycode=113 ossia F2 della tastiera)
Adesso facciamo il trapping (ossia catturiamo il tasto di funzione F3) per

effettuare la cancellazione dell’elemento.
La cancellazione di un elemento avviene con il metodo RemoveItem

(combo1.ListIndex) che rappresenta la posizione dell’elemento selezionato.

Il codice viene aggiornato in questo modo:
Poi abbiamo i controlli Checkbox e OptionButton (o Radio button). Essi sono

altri due controlli intrinseci che graficamente si presentano
Nei controlli Checkbox, se sono in numero maggiore di 1, possiamo conservare

la selezione del precedente controllo dello stesso tipo. Invece questo non
accade per gli option button, dove selezionandone uno, viene deselezionato
l’altro che perde lo stato attivo
Il controllo Oggetti Ole permette di incorporare o collegare oggetti e dati. Nella

fase di incorporazione oggetti e dati vengono memorizzati direttamente in
Visual Basic; mentre nella fase di collegamento, viene solo creato un
segnaposto in Visual Basic, mentre oggetti e dati collegati vengono gestiti e
memorizzati dall’applicazione in cui sono stati creati.
Il metodo chiave dell’oggetto Ole è InsertObjDlg
Quando viene eseguito tale metodo, appare una finestra di dialogo come
quella in figura:

Esempio: Proviamo a creare un oggetto nuovo ‘Documento di Word pad’,

visualizzato come icona, e confermiamo con Ok. Apparirà quanto vedete in
figura:
In un contenitore Ole può essere aggiunto solo un oggetto alla volta. Altrimenti
occorre aggiungere sul form più controlli Ole
Creazione di un ActiveX Document e di un ActiveX Exe Document
Il concetto di ActiveX Document non vi deve risultare nuovo, se vi rappresento

la seguente analogia di funzionamento:
Un documento di Word (con estensione doc) è definito tecnicamente un ActiveX

Document, ma dovete tenerlo distinto dall’applicazione che serve per realizzare
tale documento
Word document - > Winword.exe ( detta Word Application)
Visual Basic Document (ActiveX Document) visualizzabile attraverso altri

contenitori ActiveX (tipo Internet Explorer)
Quando un documento di Word viene visualizzato attraverso il contenitore

ActiveX di Internet Explorer, è l’applicazione di Winword.exe che fornisce tutti
gli oggetti a quest’ultimo per visualizzare e attivare il documento stesso.
Questa logica di funzionamento caratterizza anche la creazione di ActiveX

document con Visual Basic che possono essere di due tipi:

• Può essere creata una dll (ActiveX Document)

• Può essere di tipo exe (ActiveX Exe Document)
Creazione dal vero di un ActiveX Document
In questo paragrafo spiegheremo passo passo come si crea un ActiveX

Document con Visual Basic, dalla fase di progettazione sino alla fase di
esecuzione nell’applicazione contenitore del Browser Web
1^ Passo Aprire l’ambiente di sviluppo Microsoft Visual Basic
2^ Passo Scegliere dal Project Template il tipo di progetto da creare

ActoveX Document Dll
3^ Passo Visualizziamo in figura la finestra di progettazione (o Project

Explorer)
4^ Passo Facciamo Doppio clic sull’oggetto User Document1, che si vede

in figura

5^ Passo Aggiungiamo 2 etichette:
lbl_titolo -> PRIMO ACTIVEX DOCUMENT
lbl_url -> Url da visitare
Una casella di testo
Txt_url -> Casella di testo dove immettere l’indirizzo del sito
Un pulsante di comando
Cmd_naviga -> Pulsante di comando al quale associare le seguenti righe di
Codice

Attraverso la proprietà HyperLink dell’oggetto UserDocument possiamo

creare un activeX document che permette l’applicazione l’accesso a
Internet. Tale proprietà ha a sua volta il metodo NavigateTo
L’applicazione contenitore di Internet Explorer fornisce alcuni suoi

oggetti chiave all’applicazione activex document che si sta creando con
Visual Basic
6^ Passo Prima di passare al test vediamo in figura l’interfaccia grafica utente

realizzata
7^ PASSO Configuriamo l’operazione di Debugging nella Project Properties

(Dal menu Progetto scegliere la voce Project Properties)

PROJECT PROPERTIES
Dalla scheda Debugging possiamo scegliere l’user documents da

testare direttamente in Internet Explorer(applicazione contenitore)
Step n° 8: Facciamo L’F5 (ossia clicchiamo con il tasto di funzione F5, per
avviare l’applicazione)
OSSERVAZIONE: E’ l’applicazione dopo l’EXE Project Standard, che prima di

essere compilata può essere eseguita

Viene avviato Internet Explorer e al suo interno viene visualizzato Il

Visual Basic User Document con l’estensione vbd
Possiamo nella casella di testo inserire l’URL di Manuali.net e cliccare

sul pulsante Naviga. Verrà al suo interno visualizzato il sito di Internet
a cui l’Url si riferisce (http://www.manuali.net)

Visual Basic avanzato

Parte terza
Il modello ad oggetti ADO
L’architettura Ado presenta le seguenti caratteristiche:
• Presenza di un numero minore di collection rispetto all’architettura Dao

• Il minor numero di collection è compensato da un maggior numero di
proprietà, le quali permettono di supportare peculiarità specifiche di un
provider per l’accesso ai dati: trattasi del provider OleDb
Le collection che costituiscono l’architettura ADO sono:
• La collection Connection
• La collection Recordset
• La collection Command
Questi tre oggetti sono tra loro indipendenti, ma possono correlarsi attraverso
una proprietà comune che prende il nome di ActiveConnection
Adesso dobbiamo motivare la presenza dell’oggetto Connection. Con l’uso

dell’architettura Dao, se avessimo dovuto connetterci ad un database di access,
non era indispensabile conoscere la sua stringa di connessione
Basta scrivere in Dao, le seguenti righe di codice:
Const dbLangGeneral = ";LANGID=0x0409;CP=1252;COUNTRY=0"

…
dim db as dao.database
….
Set db=Dbengine.CreateDatabase(“c:\miodb.mdb”,dblanggeneral,dbversion40)
Con ADO, invece se dovessimo connetterci allo stesso formato di db, abbiamo
bisogno prima di configurare l’oggetto connection.

La configurazione avviene impostando quella che viene chiamata stringa di

connessione al database.
I parametri impostabili sono tanti, ma senza entrare troppo nei

dettagli (anche perché questa lezione richiederebbe un ciclo di lezioni),
diciamo che un modo per impostarla velocemente è quella di
aggiungere sul form un controllo. Proprio il controllo che verrà
descritto nel paragrafo successivo
Per il motivo che gli oggetti Ado elencati sono indipendenti tra loro,
l’oggetto Recordset ha la caratteristica di essere molto flessibile
rispetto a quello dell’oggetto Dao.
Con Ado abbiamo la possibilità di creare due tipi di recordset, senza

neanche aprire una connessione con la base di dati:
Recordset creati dal nulla (o stand-alone)

Recordset basati su file
Ecco perché si parla di recordset dissociati.
Dao, questo non lo permette affatto.
Il controllo Ado Data Control e i controlli associati a questo controllo
Abbiamo detto nel paragrafo precedente, che se dovessimo creare

semplicemente la stringa di connessione ai database con Ado, basterebbe che
aggiungessimo sul form un controllo activeX Ado data control (scelto dalla
finestra Componenti Ctrl+t).
Con la comoda interfaccia grafica possiamo generare in automatico la stringa di

connessione e poi scrivere queste righe di codice
…..
Dim objConn as Adodb.Connection
Set objConn=new Adodb.Connection
Objconn.Open Adodc1.ConnectionString
……
La properties Page del controllo Ado Data Control la possiamo osservare in

figura, qui in basso:

Premendo il pulsante Build si segue un wizard che genera automaticamente la

stringa di connessione, senza che dobbiamo digitarla manualmente quando
inizializziamo l’oggetto Connection e utilizziamo il metodo OpenConnection
A run-time basta che scriviamo le seguenti righe di codice
….
Set objconn=New Adodb.Connection
Objconn.OpenConnection Adodc1.ConnectionString,”Admin”,””
L’interfaccia che si vede in figura, ci introduce a parlare del controllo associato

Microsoft DataList Control 6.0 (Comprende due controlli associati
all’architettura Ado DataList e DataCombo)
Dopo aver configurato la scheda RecordSource del controllo Adodc1

Di qui si passa a configurare la finestra proprietà del controllo DataCombo
S’impostano le seguenti proprietà
DataSource Adodc1
DataField cognome
RowSource Adodc1
ListField cognomen
Ecco la finestra proprietà dell’oggetto DataCombo1

Visual Basic
avanzato:Procedure e
funzioni
Le Subroutine e le function Public e Private
Dall’Ide di Visual Basic possiamo inserire, nella finestra di moduli standard e di

classe, subroutine e function visibili o private (ossia che non saranno visibili ad
altri moduli aggiunti o a tutti i form aggiunti
Abbiamo questa situazione. Se proviamo, in una delle due finestre di modulo, a

creare una subroutine di tipo pubblico.
Quesito n° 1: La possiamo invocare anche in subroutine o function del secondo

modulo? O anche all’interno della finestra di codice dell’oggetto form1 o
Form2?
La riposta è affermativa.
Tutte le variabili di tipo pubblico sono visibili a tutti gli oggetti del progetto
(form, moduli di classe, moduli standard aggiunti)
Facciamo il test in questo modo:

Decidiamo quale oggetto far partire per primo all’avvio dell’applicazione e

possiamo verificare che la riga di codice Call saluto è visibile a tutto il progetto
Visualizziamo adesso il form che abbiamo scelto come Startup project

(es.form2)
Clicchiamo sul pulsante di comando, e verifichiamo se, la routine Saluto, creata

nel modulo 1, viene eseguita:

Per la prova del 9 facciamo lo startup project sul modulo 2 che ha routine Sub
Main () End sub..
Se non c’è Sub Main..End sub, nessun modulo funziona
Funziona il tutto, possiamo avanzare di livello sull’argomento passando al

paragrafo successivo, dove parleremo di passaggio di valori e per riferimento
ad una subroutine o function
DIFFERENZA TRA ROUTINE E FUNCTION: LA ROUTINE ESEGUE UN

GRUPPO DI ISTRUZIONI; UNA FUNCTION ESEGUIRE UN GRUPPO DI
ISTRUZIONI, MA RESTITUISCE UN VALORE DEI TIPI DI DATI VISTI
NELLE LEZIONI PRECEDENTI
Invece se riduciamo la visibilità di routine e function, dichiarandole private, non

saranno visibili tra moduli e form diversi
Se dichiarassimo una subroutine o function, all’interno dell’oggetto Form, per

richiamarle utilizzeremo sempre l’istruzione call e come argomento passeremo
il nome dell’oggetto Form.<nome routine>
Comunque se è di tipo private la subroutine o la function, essa non sarà visibile

da un form all’altro, o da un modulo ad un altro modulo.
Passaggio per valori e per riferimento
Domanda: Che significa che un argomento della subroutine viene passato per
valore, ossia con l’uso della clausola Byval?
Domanda: Che significa che un argomento della subroutine viene passato per
riferimento, ossia con l’uso della clausola ByRef?
Il passaggio per valore consente alla routine di accedere ad una copia della
variabile; di conseguenza il valore effettivo della variabile non può essere
modificato dalla routine passante
In un modulo abbiamo due routine:

Sub Main
Dim numero as integer
Numero=56
Call passavalore(numero)
Msgbox “valore:” & numero
End sub
Sub passavalore(byval dato)

Msgbox “valore passato:” & dato
Dato=dato+56
Msgbox(“dato modificato:” & dato)
End sub
Con queste due routine, la prova del nove la verifichiamo in questo modo:
dopo l’esecuzione della routine passavalore, il valore della variabile numero
sarà sempre 56 e non 112 come visualizzato dalla finestra di dialogo eseguita
in passavalore
Eseguendo il codice con il tasto di funzione F8 abbiamo
Si parte dalla subroutine principale Sub Main…
Viene assegnato il valore 56 alla variabile numero dichiarata di tipo

intero

Viene eseguita la subroutine passavalore e come argomento trasferisce il

contenuto della variabile numero
La subroutine passavalore accede ad una copia del valore di numero.

Ogni sua modifica all’interno non influirà sul valore di numero della
subroutine Main
Al contenuto di dato, passato dalla subroutine Main, è stato aggiunto 56 e la

somma visualizza ammonta a 112. Quando l’esecuzione passerà nuovamente
alla routine Main, la finestra di dialogo “valore di numero” sarà sempre uguale
a 56 e non al nuovo valore 112
La prova del 9 è stata verificato . Principio dimostrato
Il passaggio di un argomento per riferimento risulta essere il contrario

del primo tipo di passaggio (passaggio per valore). Nella subroutine a
cui accediamo davanti a tutti gli argomenti potremo mettere la
clausola byRef
Il passaggio per riferimento è l’impostazione predefinita di Visual Basic. Ecco

che davanti ai parametri della subroutine passante possiamo anche omettere di
indicare la clausola byRef.

La subroutine passante avrà accesso all’indirizzo e quindi alla variabile

effettiva. Ogni modifica, apportata all’interno, agli argomenti passati, quando
continuerà l’esecuzione della routine che l’ha invocata, si rifletterà anche nella
routine che l’ha invocata
Esaminiamo questa finestra di codice:
Passaggio per riferimento
La variabile Ris avrà valore 0 nella routine Main, ma quando terminerà

l’esecuzione della routine passavalore, assumerà il valore di
dato=dato+56
Restituzione di un’array da parte di una subroutine
Esercizio: Con la tecnica del passaggio di argomenti per riferimento, dobbiamo

passare un array ad una subroutine, effettuare un incremento di tutti gli
elementi di una costante (es. 56) e poi trasferire i valori alla routine principale
Finestra di codice

Tutti gli elementi dell’array numeri saranno incrementati di 56

Visual Basic
avanzato:La gestione
degli errori
Errori logici e errori sintattici
La gestione degli errori è un attività che porta il nome di ‘DEBUGGING”. Il

nostro obiettivo è quello di creare un applicazione senza bug (c.d. errore)
durante la fase di esecuzione. La loro presenza sarebbe un brutto biglietto da
visita per il cliente che riposto la fiducia nella nostra esperienza di sviluppatori
o programmatori
Una prima categoria di errori (o bugs) che si possono presentare sono quelli
sintattici. Si definisce errore di sintassi un errore nella grammatica del
linguaggio di programmazione.
Esempio Dobbiamo scrivere msgbox(“ciao mondo”) e scriviamo

msgbox1(“ciao mondo”). Il carattere in più rispetto alla versione
corretta della riga di codice genera un errore sintattico.
Spesso capita che questo genere di errori, Visual Basic li considera

errori di compilazione
Sbagliare msgbox con Msgbox1, viene interpretato da Visual Basic con

l’errore di compilazione con codice 35
In opzioni c’è una voce, la quale se viene spuntata permette il controllo

automatico della sintassi del codice mentre lo digitiamo.

La voce Auto Syntax Chek, tradotta in italiano è Controllo automatico

della sintassi. Se viene disattivata questa voce, gli errori di codifica
non verranno rilevati e saranno tutti generati in via di esecuzione
dell’applicazione.
Comunque non è solo questa la categoria di errori che si possono commettere.

Esiste l’altra categoria: i c.d. errori logici, difficilmente riscontrabili ma rilevabili
durante l’esecuzione dell’applicazione. Gli errori logici non vengono segnalati in
fase di compilazione. Dipendono dalla logica di programmazione.
Esempio: Abbiamo un form dati che prende i valori da un db; quando

effettuiamo delle assegnazioni, sovente capita questo errore:
txtCognome.text=indirizzo
txtnome.text=numerociv
txtindirizzo.text=cognome
In questo caso, dovunque siano messe queste righe di codice,

all’esecuzione non viene generato e quindi segnalato da vb nessun
errore sintattico o di run-time, ma se ne accorge il programmatore in
quanto non segue la logica del programma che sta sviluppando.
In finestre di codici più ricche, è arduo riconoscere dove si trovano, e occorre

fare numerosi test.
Errori di run-time
Gli errori di run-time capitano spesso quando il programmatore non adotta

enunciati di codice che li gestiscono. Esempio
Scrivo un form con due caselle di testo
Txtnumero.txt
Txtnumero1.txt

Lblrisultato.caption=txtnumero.txt/txtnumero1.txt
Questi sono errori di run-time che se non vengono gestiti bloccano applicazioni
di mole di codice.. Solo che quando si dà l’eseguibile o si distribuisce un
controllo utente rilasciato, questo controllo smette di funzionare e occorre
(‘richiamare a urla il programmatore’)
Vedremo nel prossimo paragrafo come gestire questo particolare errore e

rendere l’applicazione (molto semplice) efficiente, e senza nessun tipo di errore
Comunque errori sintattici non sono stati rilevati.
On Error goto…. Resume Next
Questo enunciato lo s’inserisce prima dell’istruzione che a run-time può

generare errore, tipo nell’applicazione precedente, prima di un’operazione di
divisione. Quando si programma occorre mettersi sempre nella mente distratta
dell’utente finale. Può digitare zero nella casella di testo, e quando viene
eseguita l’istruzione
Lblrisultato.caption=txtnumero.txt/txtnumero1.txt
Occorre controllare txtnumero1.txt, ma adesso vi suggerisco questo trucco

In questo modo la finestra di errore di run-time non appare, ma se volessimo

informare l’utente che ha inserito 0 ed una divisione per zero non può essere
eseguita. Può aiutare l’utente a capire perché il risultato dell’operazione non
viene scritto nella lblrisultato.caption
A tal proposito si utilizza la funzione Err
Ecco dove collocarla, vedete la finestra di codice in figura
Se volessimo evidenziare lo sfondo della casella di testo che ha generato

l’errore di runtime con codice 11

Il metodo SetFocus permette di far ritornare lo stato attivo al controllo al quale

viene applicato.

Visual Basic
avanzato:La librerie di
Visual Basic For
Application
La libreria di Visual Basic For Application (VBA)
In questa lezione conosceremo la riposta ad una domanda ‘Come fa

un’applicazione Visual Basic a funzionare correttamente? In altri termini
quali sono le librerie che vengono aggiunte quando si clicca su crea
progetto Exe Standard?
Dalla finestra di dialogo Riferimenti (Menu progetto-Riferimenti)

rileviamo la risposta a tale domanda:
Notiamo al primo posto che uno dei grandi moduli della libreria
MSVBVM60.DLL è denominato Visual Basic For Application (siglato
VBA).
Dall’Object Browser, selezionando la libreria in argomento vediamo da

quante classi è composta:

Permette di lavorare su tutti i tipi di dati di Visual Basic comprende

diverse classi di funzioni in varie aree:
Funzioni di conversione (Class Conversion)

Funzioni per lavorare con le date e l’ora (Class DateTime)
Funzioni matematiche (Class Math)
Funzioni per lavorare con le stringhe (Class Strings)
Funzioni finanziarie (Class Financial)
Funzioni informative (Class Information)
Funzioni per l’interattività con l’utente (Class Interaction)
Poi abbiamo due classi:
• una per creare un nuovo tipo di dati: le collection (esiste

proprio una classe vba apposita per gestirle con i metodi che
vediamo in figura);

Un’altra classe per gestire gli errori di run-time: La classe ErrObject
Una serie di costanti Class Constants
Una serie di costanti enumerative
Questa lezione è servita per descrivere la libreria di Visual Basic For

Application. Con questa libreria si possono fare tante cose, ma
occorrerebbero lezioni e lezioni al di fuori di questo corso.

Visual Basic
avanzato:Modificare
le proprietà di una
Form e il metodo
ShowFont
Tutorial Modificare le proprietà di una Form e il metodo ShowFont
Possiamo provare a modificare le proprietà BackColor e fontname e fontsize in

modalità run-time dell’oggetto Form.
Ciò grazie alle finestre di dialogo ShowFont, ShowColor del controllo Microsoft
Common dialog control 6.0
Presentiamo l’interfaccia grafica da realizzare
Ciò che vedete sul form (sull’angolo superiore sinistro) è il controllo Microsoft
Common Dialog control 6.0
Ci sono due pulsanti Cambia Colore form e il pulsante cambia carattere form.
Essi attivano rispettivamente due finestre di dialogo comuni. La finestra

modifica carattere, dimensione carattere, colore carattere, e la tavolozza colori
per modificare lo sfondo dell’oggetto Form

E’ stato scelto il colore azzurro (si vede da un quadrato concentrico

ombreggiato di grigio)
Proprietà BackColor impostata al valore CommonDialog1.Color
FINESTRA CARATTERE ARIAL-GRASSETTO-20 punti

Nell’ultima figura abbiamo visto che gli obiettivi che ci eravamo prefissati a
inizio lezione sono stati raggiunti positivamente
Area di codice

Visual Basic
avanzato:form.print
Tutorial: Il metodo print e il metodo Cls dell’oggetto Form
Per compatibilità con il vecchio Basic, le due istruzioni Print e Cls sono
diventate metodi dell’oggetto form e hanno conservato la medesima funzione,
quella rispettivamente di stampare qualcosa sul form, e di cancellare ciò che
viene stampato
Tipo 20 locate 2,10:print “Ciao mondo”
In codice Visual Basic diventa

Form2.CurrentX = 200
Form2.CurrentY = 200
Form2.Print "Ciao Mondo"
End Sub
Il metodo cls pulisce ciò che sta scritto sull’oggetto Form
Ecco il form2 pulito

Con il primo pulsante si scrive la scritta Ciao mondo alle coordinate currentX e
currentY
Con il secondo viene pulito l’oggetto form (vedetelo in figura)

Eserciziario di Visual
Basic: Parte Prima
ESERCIZIARIO 1: La mia prima applicazione con VB
Tutti coloro che scrivono corsi.., videocorsi, libri su Visual Basic partono con il
loro esempio classico Hello World, io invece voglio seguire la strada che la
prima applicazione Windows da creare con Visual Basic sia:
Date tre liste di riepilogo e due bottoni dobbiamo permettere all’utente di

inserire dei valori nella prima e nella seconda lista; poi premendo il primo
bottone verrà eseguita la somma del primo elemento della lista con l’elemento
corrispondente della seconda e verrà memorizzato nella terza.. Alla fine
premendo il secondo bottone otterremo la somma totale.
Infatti gli elementi memorizzati nella terza lista sono definite somme parziali
DISEGNO DELL’INTERFACCIA GRAFICA
A tutti i controlli, quando vengono aggiunti sul form, visual basic genera
automaticamente il valore della proprietà TabIndex. Infatti premendo il tasto
Tab della tastiera si passa da un controllo al successivo fino ad arrivare

all’ultimo controllo aggiunto.
In questo caso essendoci delle liste di riepilogo, lo stato attivo, all’avvio del
form, lo prende la prima lista di riepilogo
Infatti si disegna un piccolo rettangolo nella prima lista
Se non viene mai premuto il tasto Tab , detta lista conserva sempre lo stato
attivo
Come si apprende facilmente, consultando la guida MSDN Library di

microsoft, su tutti i controlli che hanno lo stato attivo, è possibile
catturare l’evento KeyDown
Catturando questo evento è possibile verificare se viene premuto il

tasto PageSu o PageGiù
L’evento KeyDown associato alla lista di riepilogo 1 si presenta
Private Sub List1_KeyDown(KeyCode As Integer, Shift As Integer)
Al valore KeyCode dobbiamo associare una struttura di controllo decisionale

come Select Case
Select Case KeyCode

Case Keycode=vbkeyPageUp
…….
…….
Case Keycode=vbkeyPageDown
……
……

Case Else
Msgbox(“Non hai premuto I tasti richiesti dall’applicazione”)
End Select
Dove ci sono i punti di sospensione, dobbiamo inserire le righe di codice che

effettueranno l’inserimento del dato immesso dall’utente da tastiera nella prima
o nella seconda lista
Per il blocco Case vbkeyPageUp le righe di codice sono:
valore = InputBox("Inserisci un numero:")

List1.List(List1.ListCount) = valore
Per il blocco case vbkeyPageDown le righe di codice sono:
valore = InputBox("Inserisci un numero:")

List2.List(List2.ListCount) = valore
OSSERVAZIONE
La proprietà ListCount di una qualsiasi lista di riepilogo fornisce il numero

complessivo di elementi della lista.
Per acquisire un dato da parte dell’utente con la tastiera , Visual Basic mette a
disposizione la funzione InputBox
Appare così la finestra di dialogo della funzione InputBox
Il codice che esce fuori, è frutto sempre di un’analisi accurata dei dati
ottenuti in via output con quelli attesi e verifica se l’algoritmo trovato
funziona e funzioni sempre e non in alcuni casi particolari.
Il codice si trova nel file pdf Esercizio1_Lez16.pdf
Nella cartella Eserciziario troverete l’eseguibile dell’applicazione

Esercizio1_Lez16.pdf
Dall’esempio classico di HelloWorld a questo esempio, l’obiettivo è

stimolare molto la fantasia nella programmazione orientata agli eventi
e all’uso opportuno di tutte le strutture di controllo alla base di ogni
linguaggio di programmazione visuale.
ESERCIZIARIO 2: Gestione di un file ad accesso sequenziale

L’esercizio che ci accingiamo a sviluppare in questo paragrafo ha l’obiettivo di

memorizzare qualsiasi informazione su un dispositivo di memoria di massa e
poter in un futuro remoto recuperare tali informazioni per successive
elaborazioni.
Il concetto legato a questo esercizio è la parola che si trova in qualsiasi

glossario d’informatica di base: ossia File
A seconda dell’accesso, stabilito in fase di programmazione, su un file,

distinguiamo:
• File ad accesso sequenziale, della cui gestione ci occuperemo in questo

paragrafo
• File ad accesso casuale, della cui gestione ci occuperemo nel paragrafo
successivo
Domanda: Che significa file sequenziale?
Un file sequenziale è un file in cui si legge e si scrive nell’ordine partendo

sempre dal suo principio. Essi sono facili da creare, ma possono risultare
scomodi da usare.
In contrapposizione ai file sequenziali, abbiamo detto che ci sono i file ad

accesso casuale; essi permettono di accedere in modo molto più rapido alle
informazioni desiderate, ma i programmi che li gestiscono sono piuttosto
complicati di quelli che usano il primo tipo di accesso (accesso sequenziale)
Quali sono i problemi dei quali occuparci nella gestione dei file sequenziali?
Primo passo: Definizione dei dati su cui operare
Secondo passo: Aprire il file sul dispositivo di massa e il programma utilizzerà

un Handle di file, detto canale per accedervi. Per l’apertura del file, sia che
l’accesso avvenga in modo sequenziale o casuale, Visual Basic utilizza
l’enunciato Open
Terzo passo: La scrittura delle informazioni, all’interno del file aperto, al quale
viene associato un Handle (canale), avviene attraverso l’enunciato
Print#<handle o canale>
OSSERVAZIONI TECNICHE
L’Handle di file o canale è un numero positivo maggiore di 0 e non superiore a

511. Ciò significa che non posso tener aperti più di 511 file
contemporaneamente.
L’intervallo da 1 a 255 incluso per aprire file che non sono accessibili da altre
applicazioni
L’intervallo da 256 a 511 incluso per aprire file che sono accessibili da altre
applicazioni
Si può usare a tal proposito la funzione Freefile() per conoscere l’handle di
canale libero e non utilizzato da nessuna istruzione Open.
Quarto Passo: Leggere le informazioni dal file aperto attraverso l’enunciato

Input#<handle di file>
Attraverso questi quattro passi è possibile memorizzare e aggiungere nuove

informazioni in questo file con accesso sequenziale e di poterle recuperare
(quindi visualizzare nell’interfaccia grafica le stesse informazioni dall’inizio alla
fine del file)
La gestione comunque comporta anche la possibilità
• di cancellare un gruppo logico di informazioni

• di poter aggiornare (in altre parole modificare) un dato compreso in un
gruppo logico di informazioni
• di ordinare il file secondo un dato compreso nel gruppo logico di
informazioni
• di elaborare il file secondo un certo criterio (tipo le query che si creano
con le basi di dati)
Quando la gestione delle informazioni diventa molto complessa è fortemente

consigliato utilizzare lo strumento professionale delle basi di dati con i software
applicativi in commercio.
ESERCIZIARIO 3: Gestione di un file ad accesso casuale
La gestione di un file ad accesso casuale comporta:
• la definizione di una struttura di dati definita dall’utente

• la definizione di un parametro importantissimo quale la lunghezza del
record
Per record intendiamo una riga logica del file (es. cognome, nome, indirizzo,
telefono, etc.) che contiene un gruppo di dati completo.
Il primo record di un file inizia dalla posizione 1, mentre tutti i record successivi
sono scritti a partire da locazioni con incrementi pari alla lunghezza del file
Esempio se il primo record ha lunghezza logica 120, il secondo record partirà

dalla posizione 121 a 240; così a seguire con questo criterio tutti gli altri.

I due enunciati di Visual Basic che permettono, rispettivamente, di

memorizzare un record in un file ad accesso casuale sono:
put#<numerofile o handle>,<intnumerorecord> variabile

Get#<numerofile o handle>,<intnumerorecord> variabile
La variabile può essere qualsiasi tipo di dati elementare (stringa, numero,

espressione booleana), un tipo di dato definito dall’utente (la combinazione di
tutti i tipi di dati elementari disponibili e permessi da Visual Basic), addirittura
una matrice.
Ciò che rende potente l’uso di questo particolare accesso ai file, è quello di
utilizzare qualsiasi tipo di variabile come singola unità.
Cognome, nome, indirizzo in un file ad accesso sequenziale non vengono visti

come singola unità, ma come tre campi uno sotto l’altro.
Un tipo di dati definito dall’utente viene dichiarato attraverso l’enunciato Type..

End Type a livello di modulo standard o modulo di classe.
Per aprire un file ad accesso casuale si usa sempre l’enunciato Open
Open “casuale.txt” for Random as #1
Per chiudere qualsiasi tipo di file ad accesso sequenziale o casuale si usa

l’enunciato Close con l’uso dell’handle di canale. Se viene omesso vengono
chiusi tutti i file aperti

Basic: Parte Prima
ESERCIZIARIO 4: Aggiungere un menu all’interno dell’applicazione
Un applicazione Windows che si rispetti ha, dopo la barra del titolo, un menu.
Si definisce menu un’insieme di azioni organizzati in più voci, per mezzo delle
quali è possibile accedere in maniera molto rapida a tutte le funzionalità
previste per l’applicazione che si sta realizzando.
Visual Basic all’interno del suo ambiente di sviluppo, ha uno strumento che ci
permette di creare, modificare, cancellare delle voci e disporle secondo un
certo nostro ordine. Lo strumento prende il nome di Editor di menu
L’editor di menu è accessibile per mezzo anche dello short cut da tastiera con
Ctrl+E
Nella sottocartella filmati della cartella del corso VB6, troverete il

filmato in formato avi che si chiama creamenu.avi Vi spiegherà passo
passo come aggiungere un menu all’applicazione con tale strumento
che vedete in figura.

ESERCIZIARIO 5: Aggiungere l’interattività ad un menu già esistente
Attraverso la demo abbiamo creato la seguente interfaccia grafica:
Il passo successivo, è quello di dare interattività al menu, che si vede

in figura
Su ogni voce, in sede di progettazione, basta cliccare sopra, che si apre

la finestra di codice con la generazione della routine evento OnClick
A titolo di esercizio possiamo aggiungere sul form il controllo

WebBrowser, già visto nelle lezioni precedenti.

Ecco l’interfaccia grafica con l’aggiunta di un menu di navigazione in

tre siti commerciali e il controllo WebBrowser per visualizzare al suo
interno il sito internet (c.d classica applicazione che dà l’accesso a
Internet)
ESERCIZIARIO 6: Come si avviano i vari componenti di Office?
Sempre con il principio di automazione, possiamo utilizzare la funzione

CreateObject per accedere ai vari componenti di Office, direttamente da Visual
Basic
Per aprire Microsoft Word, basta scrivere le seguenti righe di codice
…..
Dim objapplic As Object
Set objapplic = CreateObject("Word.Application")
objapplic.Visible = True
…..
Per aprire Microsoft Excel, basta scrivere le seguenti righe di codice (esse sono
di riepilogo a quelle già viste in una delle lezioni precedenti)

Set objapplic = CreateObject("Excel.Application")
objapplic.workbooks.Add
objapplic.Visible = True
End Sub
Attraverso l’oggetto Access.Application possiamo creare un nuovo database di

Access su disco Le righe di codice sono:


Set objapplic = CreateObject("Access.Application")
objapplic.NewCurrentDatabase ("c:\vb6.mdb")
objapplic.Quit
End Sub
La chiave di lettura di questo paragrafo: coloro che conoscono

approfonditamente i modelli ad oggetti dei vari componenti di Microsoft Office,
possono eseguire da Visual Basic una miriade di operazioni semplici, ma anche
complesse. Questo sempre grazie al concetto di automazione già visto nelle
lezioni precedenti.

Basic: Parte Prima
ESERCIZIARIO 7: Access 2000/Xp e il controllo Data
Con questo esercizio dobbiamo gestire l’errore di run-time 3343 “questo errore
in inglese recita Unrecognized Database Format”. Ciò significa che il controllo
Data, apparentemente non sia adatto a leggere database in formato access
2000,2002 (versione xp) e di Office System (versione 2003).
Ma se apportiamo delle modifiche all’applicazione che stiamo realizzando,

questo errore non verrà più sollevato da Visual Basic, per mezzo della libreria
di Accesso Dao.
Il controllo Data solleva tale errore perché è stato progettato per funzionare
con il Jet (motore di gestione dei database) Engine 3.5, mentre per accedere a
database con versione 2000 il motore di gestione è passato alla versione 3.6
Ecco ad ogni applicazione, per la quale vogliamo aggiungere il controllo Data

per l’accesso ai database, si devono compiere i seguenti passi:
1) Aggiungere un riferimento alla nuova libreria Dao Microsoft Dao 3.6

Object Library dalla finestra di dialogo Riferimenti (da menu Progetti-
Riferimenti)
2) Dichiarare una variabile di tipo Recordset
3) Dichiarare una variabile di tipo database
4) Aprire il recordset con il metodo Openrecordset dell’oggetto Database e
assegnarlo alla variabile di tipo Recordset
5) Assegnare la variabile Recordset istanziata alla proprietà Recordset del
controllo Data aggiunto sul form.
Ricordo che ogni controllo Data aggiunto, Visual Basic assegna un numero
progressivo (e avremo Data1, Data2, e così via)
Ammettiamo che la variabile Recordset istanziata sia rs, la riga di codice per
impostare la proprietà Recordset dell’oggetto Data1 è

Set data1.Recordset=rs
Vi ricordo che oltre al controllo Data per l’accesso ai db, esiste il controllo Ado
Data Control (che può essere aggiunto alla toolbox per mezzo della finestra
Componenti – Ctrl+T). Viene sollevato l’errore “Unrecognized Database
Format” nel caso si utilizzi il provider di accesso ai db Microsoft Jet.OLEDB.3.51
anziché il nuovo in versione 4.0. Il vecchio provider di accesso è quello
installato automaticamente con Visual Basic.
Dopo questi brevi indicazioni teoriche, possiamo creare l’interfaccia utente che
utilizzi il controllo Data per accedere ad un database Access in formato Access
2003
Il database in versione Access 2002-2003 ha questi oggetti creati
La struttura della tabella ‘tabella_acc03” ha i seguenti campi:
• cognome
• nome
• indirizzo
• telefono
• email
I nomi dei campi risulteranno le etichette della nostra interfaccia utente
Le caselle di testo saranno associate al controllo Data che andremo a

configurare in maniera programmatica.

Interfaccia grafica per l’inserimento dei dati nel database
Le righe di codice per il pulsante di comando Imposta sono:
Le righe di codice per il pulsante di comando Aggiungi sono:
Private Sub Cmd_Aggiungi_Click()

With Data1.Recordset
.AddNew
.Fields(0).Value = txtcognome.Text
.Fields(1).Value = txtnome.Text
.Fields(2).Value = txtindirizzo.Text
.Fields(3).Value = txttelefono.Text
.Fields(4).Value = txtemail.Text
.Update
End With
txtcognome.Text = ""
txtnome.Text = ""
txtindirizzo.Text = ""
txttelefono.Text = ""
txtemail.Text = ""
txtcognome.SetFocus
End Sub
Il costrutto With..End With viene utilizzato per rendere leggibile il codice

quando si gestiscono le impostazioni delle proprietà di qualsiasi oggetto.

Il metodo Setfocus dell’oggetto casella di testo permette di riprendere un

nuovo inserimento, partendo, in questo caso, dalla casella txtcognome
N.b. Il controllo Data, all’esecuzione dell’applicazione, non ci serve e quindi

impostiamo la proprietà Visible a False
ESERCIZIARIO 8: Il controllo FlexGrid
Partiamo da una piccola presentazione teorica sul controllo MsFlexGrid. E’ un

controllo non intrinseco, infatti non lo troviamo immediatamente nella casella
degli strumenti di Visual Basic. Ma per aggiungerlo a quest’ultima occorre
selezionarlo dalla finestra Componenti (CTRL+T).
Al solito lo aggiungiamo sul form è otteniamo quello che vediamo nella figura
qui in basso
Controllo Flexgrid (o griglia) – Nella casella degli strumenti è

rappresentato da un’icona gialla. Sul form appare simile ad un foglio di
Excel.
Quando viene prelevato il controllo dalla casella degli strumenti e aggiunto sul
form, MsFlexgrid1 (nome a cui dobbiamo sempre riferirci nel nostro codice) è
ad una sola colonna.
Le proprietà che ci permettono di impostare il numero di righe e il numero di

colonne della griglia sono: rows e cols
Tali proprietà sono di lettura e scrittura nel senso che permettono di

impostare e restituire due valori, che rispettivamente ci forniscono due
informazioni:
• numero di righe impostate

• e numero di colonne
Esempio: Proviamo a impostare una griglia di 3 colonne e 4 righe
Le righe di codice da scrivere sono
Msflexgrid1.cols=4
Msflexgrid1.rows=5
I valori assegnati alle proprietà cols e rows rispetto a quelli richiesti

dall’esempio sono sempre in ragione di una unità in più.

Otteniamo:
Nell’osservare bene la figura notiamo che i risultati richiesti dall’esempio sono

stati raggiunti. (3 colonne e 4 righe). Adesso proviamo a intestare le colonne
create (ossia le nominiamo in cognome,nome,indirizzo)
Le righe di codice a riguardo sono:
Msflexgrid1.textmatrix(0,1)=”cognome”
Msflexgrid1.textmatrix(0,2)=”nome”
Msflexgrid1.textmatrix(0,3)=”indirizzo”
Possiamo aggiungere tre etichette lbl_cognome, lbl_nome, lbl_indirizzo e tre

caselle di testo in un array di controllo txtvettore(0), txtvettore(1),
txtvettore(3).
Avremo l’interfaccia utente che si vede in figura
Il codice che gestisce l’interfaccia utente è il seguente:
Option Explicit
Dim numcolonne As Integer
Dim numrighe As Integer
Dim righeins As Integer
Private Sub Cmd_immetti_Click()

Dim colonne As Integer

righeins = righeins + 1
If righeins > numrighe Then
'aggiungiamo una nuova riga
MSFlexGrid1.Rows = righeins + 1
End If
For colonne = 1 To numcolonne
MSFlexGrid1.Col = colonne
MSFlexGrid1.Row = righeins
MSFlexGrid1.Text = txt_vettore(colonne - 1).Text
Next colonne
End Sub
Private Sub cmd_intesta_Click()

MSFlexGrid1.TextMatrix(0, 1) = "cognome"
MSFlexGrid1.TextMatrix(0, 2) = "nome"
MSFlexGrid1.TextMatrix(0, 3) = "indirizzo"
End Sub
Private Sub cmd_nuovo_Click()

'Maschera inserimento vuota
Dim numcampi As Integer
Dim j As Integer
numcampi = txt_vettore.Count
For j = 0 To numcampi - 1
txt_vettore(j).Text = ""
Next j
End Sub
Private Sub Form_Load()

'Impostazioni controllo MSFlexgrid
numcolonne = MSFlexGrid1.Cols - 1
numrighe = MSFlexGrid1.Rows - 1
'rendiamo a run-time la larghezza delle colonne modificabili
MSFlexGrid1.AllowUserResizing = flexResizeColumns
End Sub
Recuperiamo adesso una riga di dati dal controllo Flexgrid e la copiamo nella
maschera d’inserimento
Il codice che dovrà essere aggiunto a quello visto in precedenza è:

Private Sub MSFlexGrid1_Click()

Dim recsel As Integer
Dim colonne As Integer
Dim indice As Integer
recsel = MSFlexGrid1.RowSel
colonne = MSFlexGrid1.Cols - 1
For indice = 1 To colonne
MSFlexGrid1.Col = indice
MSFlexGrid1.Row = recsel
txt_vettore(indice - 1).Text = MSFlexGrid1.Text
Next indice
End Sub

Basic: Parte Seconda
ESERCIZIARIO 9: Aprire una maschera creata in Access da VB
L’esercizio di questo paragrafo richiede di accedere ad un oggetto maschera di

un db in formato access direttamente da Visual Basic
Come si realizza questo esercizio?
1) Per prima cosa occorre aprire Visual Basic e creare un progetto Exe
Standard;
2) Aggiungere come riferimento Microsoft v xx Access Object Library (dove
xx sta per versione installata sul vostro Personal Computer)
3) Aggiungere una casella di testo nella quale memorizzare il nome della
maschera che si desidera aprire
4) Un pulsante di comando per eseguire le seguenti righe di codice
Nella sotto-cartella esempi della cartella del corso VB6, c’è un

database che si chiama esercizio_db.mdb, la maschera da aprire è
masch_prodotti
Prima dell’indicazione delle righe di codice, rappresentiamo in figura

l’interfaccia grafica utente da realizzare
Il pulsante di comando si chiama cmd_aprimasch
Private Sub cmd_aprimasch_Click()

Dim OBJAPPLIC As Access.Application

Set OBJAPPLIC = New Access.Application

OBJAPPLIC.OpenCurrentDatabase ("C:\Documents and
settings\Utente
principale\desktop\corso\vb6\esempi\esercizio_db.mdb")
OBJAPPLIC.DoCmd.OpenForm txt_nomemasch.Text, acNormal, , ,
acFormEdit, acDialog
End Sub
ESERCIZIARIO 10: Applicazione con l’uso dei controlli intrinseci
Data una listbox di parole, l’interfaccia utente deve eseguire le seguenti

operazioni:
• Immissione dati nella lista

• Mettere in ordine alfabetico gli elementi della lista
• Permettere la cancellazione di un elemento (cognome e nome) dalla lista
L’interfaccia grafica utente da realizzare è la seguente:
Le righe di codice per gestire l’applicazione sono:
Option Explicit
Private Sub Cmd_Cancella_Click()

Dim msg As Integer
Dim INDICE As Integer
If lst_parole.ListIndex = -1 Then
msg = MsgBox("Non hai selezionato nessun elemento!", vbCritical)
Else
INDICE = lst_parole.ListIndex
lst_parole.RemoveItem INDICE
End If
End Sub

Private Sub Cmd_Immetti_Click()

Dim elemento As String
elemento = InputBox("Inserire una parola:")
lst_parole.AddItem elemento
End Sub
Private Sub cmd_ordina_Click()

Dim NUMELEMENTI As Integer
Dim TEMP As String
Dim J As Integer
Dim K As Integer
Dim VET() As String
NUMELEMENTI = lst_parole.ListCount
ReDim VET(NUMELEMENTI)
For J = 0 To NUMELEMENTI - 1
VET(J + 1) = lst_parole.List(J)
Next J
For J = 1 To NUMELEMENTI
For K = J + 1 To NUMELEMENTI
If VET(J) > VET(K) Then
TEMP = VET(J)
VET(J) = VET(K)
VET(K) = TEMP
End If
Next K
Next J
lst_parole.Clear
lst_parole.AddItem VET(J + 1)
Next J
End Sub
A titolo di esempio ho sviluppato il codice per ordinare una lista di riepilogo,

simile alla tecnica di ordinamento di un vettore monodimensionale (o array)
Comunque vi ricordo che in sede di aggiunta del controllo ListBox sul form, c’è
una proprietà sorted, che se viene impostata a true, ordina alfabeticamente e
automaticamente tutti gli elementi aggiunti alla lista con il metodo AddItem
Per cancellare un elemento dalla lista occorre prima selezionarlo
Se la proprietà index dovesse risultare uguale a -1, significa che non è stato
selezionato nessun elemento e genera un alert di errore
In caso la proprietà listIndex è diversa da -1, allora viene eseguito il metodo

removeItem indice dove indice è la posizione dell’elemento, nella lista,
selezionato.

La raccolta dei
trucchi di VB6[1]
Trucco n° 1: Le Api di Windows e il controllo dell’esistenza di una cartella
Dalla lezione 20 parte un ciclo di lezioni che fornirà a tutti i corsisti una serie di
trucchi utili da poter inserire nelle proprie applicazioni: non a caso il titolo della
lezione è La raccolta dei trucchi di VB6
Introduciamo questo ciclo di lezioni fornendo la funzione Api di Windows che

controlla l’esistenza di una cartella. Il dato di input del problema è fornire un
path name (o percorso) della cartella.
Oltre la funzione Api di Windows, che adesso forniremo, esiste una funzione
che si chiama GetATTR. Essa permette di ottenere la stessa informazione (cioè
dell’esistenza della cartella controllando che il path name fornito non
corrisponda ad un file bensì ad una cartella).
Le righe di codice di applicazione di detta funzione sono:
Function controllafolder(pathname As String) As Boolean

On Error Resume Next
controllafolder = GetAttr(pathname) And vbDirectory
End Function
Sub Main()
Dim pathname1 As String
Dim msg As Integer
pathname1 = InputBox("Inserisci percorso cartella:")
If controllafolder(pathname1) = False Then
msg = MsgBox("La cartella non esiste:", vbCritical)
Else
msg = MsgBox("La cartella:" & " " & pathname1 & " " & "esiste",
vbInformation)
End If

End Sub
Per provare detto trucco, basta aggiungere al progetto un modulo, fare un

copia incolla del codice dato nella finestra, e premere il tasto di funzione F5 per
l’esecuzione dell’applicazione
Utilizzando le Api di windows, per il controllo delle cartelle e di ogni operazioni

sui file, occorre far riferimento alla libreria di collegamento dinamico
Public Declare Function GetFileAttributes Lib "kernel32" Alias

"GetFileAttributesA" (ByVal pathfolder As String) As Long
Sub main()
Dim pathname1 As String
Dim msg As Integer
Dim codice_attributo As Long
pathname1 = InputBox("Inserisci percorso cartella:")
codice_attributo = GetFileAttributes(pathname1)
If codice_attributo = 16 Then
msg = MsgBox("La cartella:" & " " & pathname1 & " " & "esiste!!",
vbInformation)
Else
msg = MsgBox("La cartella non esiste!", vbCritical)
End If
End Sub

!" # $
% & ' &
%% ( ( !
*+
*+
) '
*+
*+
, # - ./ &
0 1 %% (
1 ( $
$ !
2 ' ' !
1 ' ( ' (! (

" 3 ' 4 5 ( 1 (
' + 6
2 $ ' 7&
8&9&: !
'
, &
7&9&
;
< $ = >
(
?
*+
?
+*+ 7
?*+ 9
?
@*+ ;
, ?
&?+&
?&?
@
?@
?
?+
?
A ' ' 3 B
, +&
+&+&
+ +&+&+& +&+&+&@ +&+&+&>
, +&
+&+&
7 +&+&+&
8 +&+&+&
9 +&+&+&
C
, +&
+&+&
;
) (
• ( &
• %% (

! " # $ !! ! $
$ %
!! & ! ' " ()
*
+ ! !
, % )
$ - ! $ . !!
-
+ ! .
! ! *+
*
/ $
! 0
/ $
! 0 $
!! ! *

0 $ - $
&
&& $ %
)$ % & )
$
%
& )
* % -
&2 )
!" # $ %$
& ' ( # )%*
+ ' %
# $ ' ( # , '
%


La raccolta dei
trucchi di VB6[4]
Trucco n° 4: Il controllo Internet Transfer Control e il codice Html
Il trucco che esamineremo in questo paragrafo è la possibilità di conoscere il

codice html di una pagina web salvata, ad esempio su uno spazio web
personale e di visualizzarla attraverso il controllo WebBrowser
L’interfaccia grafica utente è quella che si vede in figura
Una piccola descrizione: L’interfaccia grafica in figura consta di
• una casella di testo multi-riga (basta dalla pagina di proprietà

dell’oggetto impostare a true la proprietà multiline)
• due pulsanti di comando (Get html page) e un pulsante per visualizzare
la pagina Web attraverso il controllo WebBrowser

Dim htmlpage As String
Form1.Inet1.Cancel
Inet1.Protocol = icHTTP
htmlpage = Inet1.OpenURL("http://xoomer.virgilio.it/newit1/ecdl-start.htm")
Text1.Text = htmlpage
Open "c:\test.htm" For Output As #1
Print #1, Text1.Text
Close 1
End Sub

Form2.WebBrowser1.Visible = True
Form2.WebBrowser1.AddressBar = True
Form2.WebBrowser1.MenuBar = True
Form2.WebBrowser1.Navigate "file:///c:/test.htm"
Form2.Show 1
End Sub
Per eseguire questo trucco avete bisogno di creare un progetto con due form
Nel primo form realizzate l’interfaccia utente vista in figura, aggiungendo dalla
finestra componenti (Ctrl+T), il controllo Microsoft Internet Transfer Control
Commentando il codice associato al primo pulsante abbiamo:
• Chiudiamo con il metodo cancel ogni sessione di trasferimento in

qualsiasi modalità impostata con la proprietà protocol dell’oggetto Inet1
• Impostiamo la proprietà Protocol a IcHTTP
• Assegniamo ad una variabile di tipo stringa tutto il codice Html con il
metodo OpenUrl dell’oggetto Inet1 e passando come argomento un Url
della pagina web online
• Assegniamo il contenuto di tale variabile all’oggetto textbox1
• Creiamo come già sappiamo un file ad accesso sequenziale dove
memorizziamo il codice html ottenuto
Nel secondo form aggiungiamo il controllo WebBrowser
Attraverso il primo form visualizziamo il secondo e otterrete il seguente

risultato:


La raccolta dei
trucchi di VB6[5]
Trucco n° 5: Accesso ad un database protetto da Password
Capita sovente di aver creato un database di Access con Microsoft Office Access
e di proteggerlo con password.
Prendiamo come esempio il file mdb esercizio_db.mdb. Se esso viene

aperto con Microsoft Office Access, apparirà una finestra di richiesta
della Password. Solo dopo aver immesso quella giusta, l’applicazione
risulterà funzionante, altrimenti non conosceremo sino ad allora il
contenuto dei vari oggetti creati.
Domanda: Come si può con Visual Basic, aprire un database di access protetto
da password?
Il trucco che vedremo a tal proposito sta nella scrittura della stringa di
connessione con Ado (il modello ad oggetti più potente per accedere a
database di vario tipo, tra cui anche Access)
Dim cn As New Adodb.Connection

Cn.Provider=”Microsoft Jet 4.0 OLE DB Provider”
Cn.ConnectionString=”Data source=c:\esercizio_db.mdb”
Cn.Open
Se non viene impostata nella stringa di connessione anche la password di

accesso, viene generato da Ado tramite Visual Basic un errore a run-time

Prima di cn.Open, mancava la riga di codice
cn.Properties("Jet OLEDB:Database Password") = "corsovb6"
corsovb6 è la password di accesso al database esercizio_db.mdb
N.b. Per eseguire questo trucco occorre che abbiate sul vostro pc un database
di Access protetto con una password che avete scelto voi e cambiare alcuni
riferimenti che in questo trucco non ci sono:
tipo il path name del database sul vostro pc

la password da voi impostata attraverso l’applicativo di Access

La raccolta dei
trucchi di VB6[6]
Trucco n° 6: Lo sviluppo della proprietà sorted del controllo ListBox
Si chiude il ciclo delle lezioni sui trucchi di Visual Basic. Trattasi della funzione
che permette di ordinare una lista di riepilogo senza impostare a true la
proprietà sorted del controllo stesso.
Dobbiamo immaginare la lista di riepilogo come un’array monodimensionale (o

vettore) e applicare la tecnica di ordinamento oramai famosa e classica in tutti
i testi didattici di informatica di base
Private Sub cmd_ordina_Click()

Dim NUMELEMENTI As Integer
Dim TEMP As String
Dim J As Integer
Dim K As Integer
Dim VET() As String
NUMELEMENTI = lst_parole.ListCount
ReDim VET(NUMELEMENTI)
Next J
For J = 1 To NUMELEMENTI
For K = J + 1 To NUMELEMENTI
If VET(J) > VET(K) Then
TEMP = VET(J)
VET(J) = VET(K)
VET(K) = TEMP
End If
Next K
Next J
lst_parole.Clear

lst_parole.AddItem VET(J + 1)
Next J
End Sub
In questo trucco ci sono dei riferimenti teorici molto importanti:
La proprietà Listcount del controllo listBox ci restituisce il numero degli

elementi aggiunti
Abbiamo dichiarato un array dinamico con l’istruzione Dim
Una volta conosciuto il valore di ListCount (variabile ad ogni elemento
aggiunto), avviene il ridimensionamento della variabile array di tipo stringa.
Allocherà, se listcount dovesse essere 5, 5 cellette di memoria
Poi con le righe di codice
Next J
Avviene il caricamento degli elementi della lista nel variabile array vet
Indice parte da 0 perché il primo elemento della lista ha posizione 0
Solo che quando carichiamo il valore dell’array, lo mettiamo in posizione 1; ciò

è giustificato dalla scrittura vet(j+1)
Con un ciclo nidificato , ad ogni vet(j)>vet(k) avviene lo scambio per mezzo di

una variabile temporanea temp, sempre di tipo stringa
Alla fine di questi due cicli for, abbiamo il vettore ordinato e possiamo caricare
gli elementi nella lista, dopo averla pulita con il metodo Clear

I controlli per gestire

l’accesso ai file e
directory
DriveListBox, DirListBox, FileListBox
Questo gruppo di controlli intrinseci ci facilitano il lavoro per conoscere il

contenuto del file system di ogni supporto di memoria di massa (hard disk,
floppy, cd-rom) in base al valore di DriveListBox
Cominciamo col portare i tre controlli su un form
Adesso si tratta di compiere un’operazione di sincronizzazione tra questi tre

controlli, ossia selezionando l’unità drive si deve aggiornare automaticamente
la lista delle cartelle (DirListBox), selezionando una cartella con doppio clic, si
deve aggiornare la lista dei file ivi contenuti (FileListBox)
Per far ciò gli eventi Change associati a driveListBox e dirlistBox sono:
Private Sub Dir1_Change()

File1.Path = Dir1.Path
End Sub

Private Sub Drive1_Change()

Dir1.Path = Drive1.Drive
End Sub
Per conoscere il nome del file selezionato nel controllo FileListBox, basta
utilizzare la proprietà FileName
Quando verrà eseguita detta applicazione si può verificare il seguente errore

run-time caratteristico del controllo DriveListBox
Errore run-time 68
Tale errore viene generato per i seguenti dispositivi rimovibili: cd-rom e floppy.
Per l’hard disk in condizione di integrità, non genererà nessun errore, in quanto
è disco fisso e sempre pronto.
Dovendo gestire l’errore run-time 68, possiamo personalizzare l’alert in questo

modo
Per far visualizzare tale alert personalizzato occorre modificare le righe di

codice associate all’evento change del controllo Drive1

Attraverso l’enunciato On Error Resume Next possiamo catturare tutti gli errori
di run-time. Occorre solo saper (e non c’è una regola) localizzare, nel codice, al
punto giusto questo enunciato.
Poi c’è l’enunciato err con una serie di proprietà, tra cui number che ci fornirà il
codice di errore generato.
Siccome il codice di run-time generato è 68 digiteremo
If err.number=68 then
……
…..
End if

Come avviene la
distribuzione
dell’applicazione
Distribuire l’applicazione per conto terzi
L’operazione che stiamo per esaminare in questo paragrafo capita

frequentemente quando terminiamo di sviluppare l’applicazione e dobbiamo
consegnarla al nostro cliente che l’ha commissionata
Quando installiamo Microsoft Visual Studio o una copia retail di solo Visual
Basic, nel menu di start si aggiunge un link ad un Tool fondamentale:
TOOL PER DISTRIBUIRE LE NOSTRE APPLICAZIONI E’ Package & Deployment

Wizard
Pensiamo di voler distribuire l’applicazione con l’uso soltanto dei controlli

intrinseci.
Vi ricordo che è errato pensare che si possa passare al cliente solo il file
eseguibile creato (nome progetto.exe), attraverso l’IDE(Integrated
Development Environment o Ambiente di sviluppo integrato).
Occorre sempre utilizzare il tool Package Develoment Wizard, in quanto un

semplice programma, con l’uso dei controlli intrinseci (ossia soltanto quelli
presenti nella ToolBox), per il corretto funzionamento dipende da una libreria
fondamentale.

Tale libreria prende il nome di: MSVBVM60.DLL. (contiene numerosi file

ausiliari che servono all’applicazione eseguibile per poter funzionare)
In altre parole se funziona l’applicazione sul nostro Computer, mancando tale

libreria installata sul pc del nostro cliente, l’applicazione creata non funzionerà
proprio.
Ecco che la creazione guidata dei pacchetti di installazione servirà proprio a

gestire le dipendenze della nostra applicazioni di eventuali librerie aggiunte
oltre quella di base che è MSVBVM60.DLL
Durante questo corso ne abbiamo viste di librerie e controlli di terze parti

aggiunti.

Alcune librerie utili

nelle applicazioni
La libreria Microsoft Scripting Runtime
La libreria a collegamento dinamico, che prende il nome di Microsoft

Scripting Runtime, si chiama scrrun.dll
Viene impiegata per gestire al meglio:
1. Le matrici associative attraverso l’oggetto Dictionary;
2. i file system attraverso l’uso di filesystemObject o l’equivalente Oggetto

TextStream
3. Permette di capire se un file esiste su un supporto magnetico oppure no

e sulla base di una data cartella conoscere tutti i file attraverso la
collection Files, oppure riempire la collections folders(insieme di tutte le
cartelle conoscendo il nome dei drive (c:\ hard disk, a:\ floppy disk, d:
cd-rom e: eventuale altro cd-rom)
Esempio: Creazione di un’interfaccia che carica tutti i nomi assegnati alle varie
unità hardware (floppy, hard disk, lettori cd-rom); poi selezionando una di
queste unità, nella seconda lista vengono caricate tutte le cartelle,
selezionando a loro volta una di queste cartelle, vengono caricate nell’ultima
lista di riepilogo tutti i file contenuti

Interfaccia grafica dell’applicazione
Osservazione: In questo esempio di applicazione non si trovano

pulsanti, in quanto sono stati associati 3 eventi a catena:
L’evento di selezione di un elemento della prima lista riempie la

seconda lista. La selezione di un elemento della seconda lista riempie
la terza e ultima lista. L’evento che accomuna queste tre liste di
riepilogo è OnClick
Quando il form viene caricato, viene eseguito l’evento Form_Load:
Le righe di codice associate permettono di creare:
• un’istanza alla classe Scripting.FileSystemObject

• Poi avviene tramite l’istruzione set l’assegnazione della collection Drives

dell’oggetto Obj alla variabile ObjDrive
• Viene eseguito un for each nella collection Objdrive creata al punto 2
• Con il metodo AddItem della lista di riepilogo n° 1 vengono caricati i
nomi dei drive logici assegnati dal sistema Operativo (vedi proprietà
driveLetter)
Poi è stato associato l’evento OnClick alla prima lista di riepilogo

caricata secondo la procedura già spiegata in precedenza
Nella variabile lettera viene recuperata la root del nome del drive selezionato
attraverso la prima lista di riepilogo
Il contenuto di questa variabile diventa argomento del metodo GetFolder
dell’oggetto Obj (Scripting.FileSystemObject)
L’espressione Obj.GetFolder(lettera) viene assegnato all’oggetto Objfile di tipo
Folder
Viene eseguito un ciclo For Each per esaminare tutti i nomi delle sottocartelle
contenute nella root del drive selezionato nella prima lista di riepilogo
La stessa procedura viene applicata anche per recuperare i file della

sottocartella selezionata nella seconda lista di riepilogo.
Vediamo un’ultima figura per comprenderne gli effetti di questo esempio di

applicazione
Basta selezionare l’unità drive dell’hard disk (c:\), vengono caricate nella lista
di riepilogo tutte le cartelle (o folder) della root e poi selezionando una di quelle
cartelle, vengono caricate nell’ultima lista di riepilogo tutti i files in essa
contenuti
Nella cartella esempi del corso (\vb6\esempi) c’è un file zippato che si chiama
applicfolder.zip. In quel file troverete i sorgenti e il file eseguibile allo
scopo di avere subito una demo operativa dell’applicazione.


nelle applicazioni
La libreria Microsoft Script control 1.0
In un’applicazione di Visual Basic 6.0, aver aggiunto un riferimento alla libreria

che porta il nome del paragrafo della lezione 29-esima del corso, significa poter
imparare didatticamente, direttamente da una semplice applicazione, l’utilizzo
dei linguaggi di scripting più autorevoli del Web (c.d. linguaggi lato client)
come VBScript e Jscript.
In questo paragrafo, suddiviso in 3 steps, impareremo velocemente a crearci

un piccolo editor, in cui scriveremo il codice in VBScript in una casella di testo
multiriga, e premeremo un pulsante di comando per eseguirlo.
Primo steps:
- Avvio di Microsoft Visual Basic 6.0

- Creazione di un’applicazione Exe Standard
Su questo form posizioneremo una casella di testo multiriga

txtcodicevbs e un pulsante di comando Esegui (cmd_esegui)

Definizione dell’interfaccia di base
Steps n° 2
Aggiungere un riferimento alla libreria Microsoft Script Control 1.0
Scegliere Riferimenti dal menu Progetto

Scegliere la libreria Microsoft Script Control 1.0 e mettere un segno di

spunta al relativo checkbox e confermare con Ok. Da adesso in poi
Visual Basic conoscerà metodi, oggetti, ed eventi di questo ActiveX
Fatto questo è possibile associare all’evento OnClick, del pulsante di comando

aggiunto sul form, le seguenti righe di codice
Cuore dell’applicazione Tre righe di codice che permetteranno di eseguire del

codice VBScript all’interno dell’applicazione VB6
Steps n° 3
Esecuzione dell’applicazione

Nella casella di testo multiriga osservate le righe di codice da eseguire con il

linguaggio VBScript. Basta premere il pulsante Esegui script per esegure tale
codice


nelle applicazioni
La libreria Microsoft Shell Controls And Automation
La libreria Microsoft Shell Controls And Automation è la libreria compilata della

maggior parte delle chiamate ad Api di Windows che facilitano gran parte del
nostro lavoro. Ecco che la utilizzeremo nelle nostre applicazioni quando:
- Dobbiamo visualizzare la finestra di dialogo Sfoglia per cartelle:
Il codice per utilizzare tale libreria allo scopo di visualizzare detta finestra è
- Dobbiamo visualizzare dalla nostra applicazione il pannello di controllo

Il codice da utilizzare è il seguente
Il parametro da passare al metodo ControlPanelItem dell’oggetto Shell della

libreria Microsoft Shell Controls And Automation è il percorso del file con
estensione Cpl (che è un file di configurazione di ciascun elemento che
troviamo nel pannello di controllo di Windows)
Io sul mio pc ho un file di estensione del Pannello di controllo che si chiama

timedate.cpl (voi potete fare una ricerca sul vostro pc e verificare quali file di
estensioni del pannello di controllo avete in base al sistema operativo
installato)
Questo file, solitamente per i sistemi Xp sta nella cartella windows\system32 e

la riga di codice

Objshell.ControlPanelItem “c:\windows\system32\timedate.cpl” visualizzerà il

datario, la cui icona la troviamo anche nella system tray (o barra di sistema)
In figura vediamo ciò che viene visualizzato
Per ottenere la finestra Esplora risorse, utilizzeremo sempre questa libreria
Il codice è
ObjShell.Explore “c:\”
Visualizzerà

CONCLUSIONI:
Provate ad aggiungere dalla finestra di dialogo riferimenti, la predetta libreria e

divertitevi a utilizzare i restanti metodi non presi in considerazione. Servirà a
voi per stimolare a saper utilizzare i controlli
Il futuro di Visual Basic 6.0, sebbene sia stato un ambiente di sviluppo visuale
molto popolare, ha esaurito il suo ciclo di sviluppo ed è stato sostituito in modo
radicale dalla nuova piattaforma microsoft che porta da un paio di anni la sigla
.Net.
Leggevo recentemente su una rivista che molti sviluppatori vorrebbero creare

un clone freeware di Visual Basic e dare la possibilità a molti, che non vogliono
utilizzare ancora il sistema complesso di VB.NET, di fare esperienza ancora su
Visual Basic 6.0 Queste sono voci, il tempo ci darà ragione di cosa succederà.

Visual basic in trenta

lezioni: Test finale
TEST FINALE DEL CORSO DI VISUAL BASIC IN TRENTA LEZIONI: Premessa
Corsisti, non vi appesantisco più di tanto, perché il corso è già stato corredato,
come avete potuto notare, di esempi pratici e anche di alcuni filmati chiavi. E’
solo per stimolare la vostra curiosità nel trovare nelle trenta lezioni e altrove
anche la risposta.
Infatti nel lavoro di sviluppo, quando si è in difficoltà di come si svolgerà

qualsiasi operazione, non vi basterà il corso che è solo guida per fornirvi le
chiavi per far partire ‘macchina’, ma è esistono una miriade di strumenti, tipo
forum, portali su visual basic, il motore di ricerca, la msdn library online di
microsoft (anche se molto difficile alcune volte leggerla, perché molto vasta,
ma molto importante che ci sia – su di essa troverete gigabyte di informazioni
su Visual Basic e non solo).
Dopo questa doverosa premessa, risponderete a 10 domande:
1) Che cosa s’intende per form?

2) Cosa contiene la casella degli strumenti (o c.d. Toolbox)?
3) Come si cambia tipo ,dimensione e colore del carattere di una casella di
testo durante l’esecuzione dell’applicazione? Suggerimento (mi
bastano solo le righe di codice)
4) Quali sono i controlli intrinseci di VB, per mezzo dei quali si accede al file
system (file o cartelle su hard disk, cd-rom, floppy)?
5) Quali sono i metodi caratteristici dell’oggetto ListBox.? Per il controllo
ComboBox risultano essere uguali?
6) Osservate questo pezzo di codice e risponderete ad una domanda:
Option Explicit
Sub Main
Dim Cognome As String
Dim Nome As String
Dim City As String

Cognome=Inputbox(“Inserire il cognome:”)
Nome=Inputbox(“Inserire il nome:”)
City=Inputbox(“Inserire la città:”)
End Sub
Sub Visualizza
Dim stringaTesto As String
stringaTesto=”Dati inseriti:” & cognome & vbCrlf
stringaTesto=StringaTesto & nome & vbcrlf
stringTesto=StringaTesto & city
Msgbox(stringaTesto)
End Sub
Le domande sono:
• Dall’analisi del codice la routine Visualizza verrà eseguita oppure no?

In caso negativo quale istruzione manca per richiamare tale
subroutine?
7) Qual è il controllo intrinseco che permette di accedere ai database?

8) Quali sono le righe di codice che permettono di impostare le righe e le
colonne del controllo Flexgrid
9) Per inserire un valore all’interno del controllo Flexgrid nella cella (1,4)
quali sono le righe di codice
10) Con quale proprietà del controllo Flexgrid si può rendere modificabile la
larghezza delle colonne?

Visual basic in trenta

lezioni: Risposte al
Test finale
TEST FINALE DEL CORSO DI VISUAL BASIC IN TRENTA LEZIONI: Risposte
Spero siate riusciti, grazie a questo corso, a rispondere serenamente alle

domande che vi sono state poste nella lezione dedicata all’elenco delle 10
domande, e a considerare che non esauriscono tutto Visual Basic, in quanto è
l’esperienza di anni con questo strumento di programmazione, a farvi
comprendere la logica di funzionamento delle applicazioni stile Windows.
Comunque le risposte al test delle 10 domande sono:
1) Alla prima domanda, molto semplice ‘Cosa s’intende per form’ si

rispondeva semplice E’ l’oggetto chiave con il quale si progetteranno le
interfaccie grafiche utente di ogni applicazione Windows, sulla quale si
possono inserire controlli intrinseci e di terze parti detti oggetti.
2) La ToolBox (o detta anche casella degli strumenti) contiene una serie di
controlli intrinseci che possono essere predisposti sull’oggetto Form ed
essere personalizzati attraverso la finestra proprietà del controllo
Essi sono:
a. Casella Immagine (PictureBox)
b. Casella di testo (TextBox)
c. Casella di riepilogo (ListBox)
d. Casella combinata (ComboBox)
e. Pulsante di Comando (Command Button)
f. Controllo Immagine (Image)
g. Casella di controllo (CheckBox)
h. Pulsante di opzione (OptionButton)
i. Contenitore Ole (Ole Object)
j. DriveListBox, DirListBox,FileListBox gruppo di controlli per accesso
ai file e cartelle sul file system
E altri, ma già con questi potete già rendere funzionali le vostre applicazioni

3) Le righe di codice richieste sono:
form1.TextBox1.FontName=”Arial”
form1.TextBox1.Forecolor=vbred
form1.textbox1.fontsize=20
Ecco il risultato in base alle righe di codice
4) I controlli intrinseci,per mezzo dei quali si accede al file system sono tre:
• DriveListBox
• DirListBox
• FileListBox
Per farli funzionare, occorre, come è stato detto durante il corso, di

sincronizzare con il codice, che selezionando un drive (c:\,a:\,d:\, e:\ per
eventuali lettori cd o dvd) si carica la lista delle cartelle e doppio clic su una
cartella si deve caricare la lista dei files contenuti
5) I metodi caratteristici dell’oggetto ListBox sono:
Additem per aggiungere un elemento

List per accedere ad un elemento selezionato, la cui posizione all’interno è
data dalla proprietà ListIndex
RemoveItem per rimuovere un elemento conoscendo sempre il valore della
proprietà ListIndex
Quelli della casella combinata sono simili, in quanto la logica di

funzionamento è uguale.
6) Osservate questo pezzo di codice e risponderete ad una domanda:
Option Explicit
Sub Main
Dim Cognome As String
Dim Nome As String
Dim City As String
Cognome=Inputbox(“Inserire il cognome:”)
Nome=Inputbox(“Inserire il nome:”)
City=Inputbox(“Inserire la città:”)
End Sub
Sub Visualizza
Dim stringaTesto As String

stringaTesto=”Dati inseriti:” & cognome & vbCrlf

stringaTesto=StringaTesto & nome & vbcrlf
stringTesto=StringaTesto & city
Msgbox(stringaTesto)
End Sub
Le domande sono:
• Dall’analisi del codice la routine Visualizza verrà eseguita oppure no?

In caso negativo quale istruzione manca per richiamare tale
subroutine?
• Risposta: La routine non verrà mai visualizzata in quanto manca
l’istruzione Call con il nome della subroutine (in questo caso
visualizza) Comunque le variabili visualizzate all’interno della
subroutine visualizza non avranno contenuto, perché le variabili
dichiarate sono a livello di modulo. Una volta passato il controllo a
visualizza, esse perdono e non conservano più i valori acquisiti
all’interno della subroutine principale
7) Il controllo intrinseco che permette di accedere ai database è il controllo

Data. Tale controllo è stato progettato per leggere database con un motore di
accesso Jet Engine 3.5 Riuscirà a legere, facendo l’esempio di db in access,
quelli in formato Access 95,97. Dalla versione 2000 in poi tale controllo genera
l’errore 3343. Durante il corso si è discusso di come di gestirlo.
8) Le righe di codice sono:
msflexgrid1.cols=x
msflexgrid1.rows=y
9) Per inserire un valore nella cella (1,4)
Msflexgrid1.col=1
Msflexgrid1.row=4
Msflexgrid.text=valore
10) MSFlexGrid1.AllowUserResizing=flexResizeBoth

Visual Basic 6 Base

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 6 Base

Caricato da

Copyright:

Formati disponibili

CORSO DI VISUAL BASIC 6.0 Lezione n.

Evoluzione del vecchio Basic: Premessa

L’obiettivo di questo corso è di fornire quanti più suggerimenti e chiavi di

- era un linguaggio di programmazione di natura interpretata e ideale per i

Dal Gw-Basic si è passati al QBASIC, con le seguenti caratteristiche:

- si è evoluto rispetto al Gw-Basic, in quanto dotato di un ambiente di

Matura la prima versione di Visual Basic for Ms-Dos 1.0, e da questa

Le caratteristiche della prima versione di Visual Basic 1.0 sono le seguenti:

Spalluzzi Francesco - Manuali.Net © 2005 Tutti i diritti riservati 1

- E’ rimasta sempre la possibilità di creare l’applicazione con interfaccia

Nelle varie versioni di VB che si sono succedute, la tecnica di fondo di creazione

In una tabella rappresentiamo l’evoluzione del vecchio Basic, riproducendo i

Ambiente di programmazione GW-BASIC

Ambiente di programmazione QBASIC 4.5

Spalluzzi Francesco - Manuali.Net © 2005 Tutti i diritti riservati 2

Ambiente di programmazione Visual Basic 1.0

MICROSOFT VISUAL BASIC 6.0 – Versione oggetto del corso

Dall’interfaccia testuale all’interfaccia grafica stile Windows

Ogni applicazione che realizziamo con Visual Basic presenterà le seguenti

• Alto grado di interazione da parte dell’utente, grazie ai vari elementi

Spalluzzi Francesco - Manuali.Net © 2005 Tutti i diritti riservati 3

• Il codice sorgente verrà attivato in base ad una serie di eventi

Costruire una GUI (Graphic User Interface) non efficiente e corretta,

Prima dell’era della telefonia mobile un programma gestionale contatti, non

Nel paragrafo precedente è stato detto che un programma Visual Basic

A tal proposito il programmatore svilupperà porzioni di codice da associare a

Un evento è un’attività che avviene durante l’esecuzione di un programma, e

Quando parleremo di Visual Basic avanzato, faremo riferimento al

Ad esempio se apriamo l’applicazione Notepad e selezioniamo Apri dal

Spalluzzi Francesco - Manuali.Net © 2005 Tutti i diritti riservati 4

Domanda: Con quale libreria possiamo visualizzare la finestra di

Spalluzzi Francesco - Manuali.Net © 2005 Tutti i diritti riservati 5

Concetto di variabile e costante e tipi di dati

Si definisce variabile, un luogo di memorizzazione temporanea per i dati

Al concetto di variabile è legato il tipo di dato da memorizzare. Come il vecchio

Implicitamente si parla anche di dichiarazione obbligatoria delle variabili:

Esempio: Se con l’istruzione Dim creiamo la variabile numero e vi associamo

Nella cartella filmati esiste un filmato avi ‘OptionExplicit.avi’ che

La dichiarazione obbligatoria delle variabili permetterà di razionalizzare lo

Numero (è la variabile dichiarata con l’istruzione Dim)

Gli errori di digitazione del nome della variabile comporterebbero la creazione

Spalluzzi Francesco - Manuali.Net © 2005 Tutti i diritti riservati 1

un tipo di dati da memorizzare). Le variabili non tipizzate, cioè di tipo Varìant,

Nella cartella filmati abbiamo costanti.avi, che vi spiegherà passo

Nella riproduzione del filmato costanti.avi, se si ha la necessità di modificare un

Const numero as Integer=46

Codice per modificare il valore di una costante dichiarata

Ciò che genererà un errore a livello di compilazione, è l’istruzione di

Concludiamo il paragrafo con la riproduzione di una tabella, nella quale

Tipo di dato Esempio di Range valori Spazio occupato

Spalluzzi Francesco - Manuali.Net © 2005 Tutti i diritti riservati 2

Double Dim numero Da -1,79769313486232E308 a 8 byte

Object Dim frm as Qualsiasi riferimento Object 4 byte

String Dim cognome Da 0 a circa 2 miliardi 10 byte+

String Dim cognome Da 1 a circa 65.400 Lunghezza

Variant (con Dim Stesso intervallo di String a lunghezza variabile 22

Byte Dim dato as Da 0 a 255 1 byte

Array, matrici e array di controllo

Chi è veterano di programmazione conosce già il concetto di Array. Chi invece

• questi dati sono ordinati

Spalluzzi Francesco - Manuali.Net © 2005 Tutti i diritti riservati 3

Se abbiamo n temperature rilevate in un certo momento, è sconsigliato creare

• Gli elementi omogenei sono le n temperature,