Programmare con Visual Basic 6

Visual Basic è un linguaggio di programmazione WUI (Windows User Interface) di casa Microsoft, abbastanza potente e molto semplice nella sintassi e nelle funzionalità, adatto quindi sia al neofita che allo sviluppatore professionista.

Visual Basic, da ora in po semplicemente VB, nasce dal vecchio Basic, sempre di casa Microsoft, come versione avanzata con interfaccia visuale (da qui il suo nome attuale); il vecchio Basic, infatti, nasce e muore in ambiente DOS. VB è attualmente e definitivamente arrivato alla versione 6.0: la versione successiva, in uso da già qualche anno, fa parte della piattaforma .NET e pur conservando la maggior parte delle caratteristiche, può definirsi un linguaggio a se stante: VB è quindi differente da VB.NET.

VB è un tipo di programmazione detta event driven, ovvero basata sugli eventi. Vedremo in seguito cosa vuol dire questa affermazione.

VB è acquistabile col pacchetto Microsoft Visual Studio 6.0 oppure separatamente. Il prezzo varia spesso e con l’avvento di .NET è decisamente calato, ma non è certo accessibile a chi è solo un curioso, bensì a coloro che intendono fare della programmazione la propria professione.

L’installazione del pacchetto completo o del singolo software è davvero semplice, è sufficiente seguire le istruzioni del Wizard di installazione, inserire i dati richiesti, il numero di serie del prodotto (in genere si trova all’interno della copertina del CD acquistato oppure su di un documento interno alla custodia) e lasciare che il Wizard faccia il resto. Al termine riavviare il sistema anche se non richiesto.

Nel corso della guida impareremo come si compone l’ambiente di sviluppo, tratteremo le componenti principali del prodotto e della sintassi, impareremo a programmare ad eventi con l’utilizzo degli oggetti (Rif. capitoli successivi), impareremo a manipolare file di testo, XML e database Microsoft Access (preferibilmente versione 2000).

Buona lettura!

Interfaccia e ambiente di sviluppo

Una volta eseguita ed andata a buon fine l’installazione, per accedere all’ambiente di sviluppo di VB partire dal menu

Start / Programmi / Microsoft Visual Studio 6.0 / Microsoft Visual Basic 6.0

la prima richiesta fatta da VB è di scegliere il tipo di progetto tramite la finestra documentata nell’immagine seguente:

La voce selezionata per default è EXE standard ovvero un classico progetto VB. Non preoccupatevi delle altre voci, si tratta in un modo o nell’altro di componenti avanzati che tratteremo in una versione avanzata della guida.

Confermate quindi, cliccando il tasto Apri la scelta di un nuovo EXE standard. L’interfaccia completa del programma, documentata con una serie di commenti aggiunti in rosso, è visualizzabile cliccando questo link.

Probabilmente non tutte le definizione degli elementi dell’interfaccia saranno chiare a tutti immediatamente, ma prego i lettori di non preoccuparsi perchè ogni nozione sarà esaurita prima nel corso della guida.

Le Form e gli oggetti di un modulo VB

Le Form sono gli elementi madre di un programma VB, o in generale di qualsiasi software di sviluppo e linguaggio di programmazione WUI. Si tratta di finestre molto comuni, classiche di Windows: un esempio è la finestra delle proprietà di Internet Explorer, oppure delle proprietà del Desktop, ecc…

Su di una Form vengono posizionati i vari elementi per la manipolazione dei dati o per la realizzazione di applicazioni non basate su di un database. In questo paragrafo vedremo i principali oggetti (che chiameremo prevalentemente controlli) per la realizzazione di un modulo VB.

Torniamo un attimo all’interfaccia di VB e guardiamo sulla sinistra dell’immagine la barra Generale in cui sono contenuti una serie di icone; da qui possiamo, con un doppio click o facendo il drag’ n’ drop (trascinamento) dell’icona sulla Form stessa, inserire controlli da manipolare via codice. Facciamo un semplice esempio che vede coinvolti i tre controlli più utilizzati in VB, ovvero la TextBox (casella di testo per l’inserimento di dati), la Label (semplice area in cui inserire descrizioni) ed il CommandButton (bottone di comando per l’esecuzione di una routine o di uno script VB).

Si crei quindi un nuovo progetto EXE standard; dalla Finestra delle Proprietà sulla destra dell’IDE di sviluppo si vada a modificare la proprietà Name della Form e la si chiami frmPrimoProg. Prima di proseguire tengo a sottolineare la modalità di assegnazione dei nomi ai controlli delle Form ed alle Form stesse: si utilizza un suffisso in minuscolo e poi il nome da assegnare con la maiuscola iniziale; prego inoltre di assegnare alle Form ed ai progetti nomi significativi, per due buoni motivi:

1. in fase di progettazione è difficile cambiare un nome ad un controllo per via dei riferimenti che VB crea automaticamente in una serie di file di configurazione
2. per non trovarvi in difficoltà quando non sapere un controllo a che scopo lo avete creato se non riuscite ad identificarlo facilmente e subito da un nome che abia un senso logico

Si modifichi inoltre la proprietà Caption (la scritta che compare sul titolo della Form) in "La mia prima Form!".

Quelli che vedete cerchiati in rosso nell’immagine seguente sono rispettivamente i controlli per l’inserimento di una Label, di una TextBox e di un CommandButton. Inserite sulla Form uno per ognuno dei controlli descritti fino ad ottenere il seguente effetto in fase di sviluppo:

Bisogna ammettere che cosi è piuttosto bruttina… va modificata un pochino!

Cliccando una singola volta su un controllo sulla Form compaiono attorno al controllo i puntini blu di selezione ed è possibile modificarne le dimensioni. Inoltre si assegnino, dalla Finestra delle Proprietà, i seguenti nomi e le seguenti diciture testuali ai tre controlli:

• TextBox
• Name: txtTesto
• Text: nessun testo
• Label
• Name: lblRisultato
• Caption: nessun testo
• CommandButton
• Name: cmdEsegui
• Caption: Esegui

fino ad ottenere il seguente risultato:

Direi che va già meglio 🙂

Passiamo ad un primo esempio di codice ed anche se farò riferimento ad elementi del linguaggio non ancora spiegati, ho la presunzione che anche il lettore meno avvezzo non avrà difficoltà a capire.

Eccoci finalmente di fronte alla spiegazione di programmazione event driven, ovvero basata (letteralmente guidata) sugli eventi. Al click sul CommandButton verrà eseguito uno script VB: il click è l’evento!

Si faccia doppio click sul CommandButton e si accederà al codice del bottone di comando, già composto dal seguente codice:

Private Sub cmdEsegui_Click()

End Sub

In VB questa è una Sub che tratteremo più avanti. All’interno di questa Sub, che comunque è l’elemento madre di un programma o di una singola fase di un programma VB, andremo ad inserire il codice che verrà eseguito al click sul CommadButton:

' Questo è un commento!
' VB non esegue tutto ciò che è preceduto
' dal singolo apice ma lo tratta come un
' promemoria per lo sviluppatore

Private Sub cmdEsegui_Click()
    If txtTesto.Text = "" Then
        lblRisultato.Caption = "Inserisci un testo"
    Else
        lblRisultato.Caption = txtTesto.Text
    End If
End Sub

Anche se non abbiamo ancora affrontato le istruzioni condizionali credo sia intuibile il fatto che il programma ragionerà cosi: se la casella di testo contiene un valore vuoto allora scrivi nella Label un messaggio che indichi all’utente di inserire un testo, oppure scrivi il contenuto della casella di teso.

Per avviare il programma si faccia click sul pulsante Play cerchiato in rosso nell’interfaccia di VB, oppure si prema il tasto F5 sulla tastiera.

Nei prossimi capitoli abbandoniamo un attimo le componenti visuali di VB per dedicarci al codice, alla sintassi ed agli elementi del linguaggio.

Variabili, costanti, tipi di dato e operatori

Prima di passare alle fasi più divertenti del linguaggio è necessario dedicare un capitolo all’apprendimento delle componenti base del linguaggio.

Le variabili sono delle aree di memoria virtuali che il programma va a occupare nel sistema operativo che lo esegue; la peculiarità delle variabili è che sono valori suscettibili a cambiamenti a seconda di condizioni, eventi, azioni degli utenti, ecc… Per dichiarare una variabile si usa la parola chiave Dim.

Le costanti sono simili alle variabili, con la differenza che, come il termine lascia intuire, non sono aree di memorie suscettibili dinamicamente a cambiamenti e si utilizza, per la dichiarazione, la parola chiave Const.

Se le variabili e le costanti sono praticamente la stessa cosa, con la differenza che le variabili sono suscettibili a cambiamenti e le costanti no, perchè si utilizza una sintassi differente per la dichiarazione? La risposta è semplice: Const occupa un’area di memoria inferiore rispetto a Dim, quindi si evita di sovraccaricare inutilmente il sistema.

I tipi di dato sono elementi di VB che consentono di definire a priori se una variabile è di tipo numerico, stringa, ecc… Non è obbligatorio tipizzare una variabile, ma è consigliabile per il motivo che il programma non deve andare a sovraccaricare il buffer dell’interprete per stabilire come trattare un valore, sapendolo a priori grazie alla tipizzazione.

Gli operatori sono simboli che vengono utilizzati per effettuare uguaglianze, operazioni matematiche, implementare condizioni avanzate, ecc…

Facciamo un esempio di dichiarazione e tipizzazione di una variabile. Si crei un nuovo progetto EXE standard e si acceda al codice senza passare per il doppio click su un elemento della Form o sulla Form stessa, ma semplicemente dal menu

Visualizza / Codice

e si inserisca il seguente codice:

Option Explicit
Dim testo As String
Dim numero As Integer

in questo modo abbiamo le variabili testo di tipo stringa e numero di tipo numerico intero.

La clausola Option Explicit serve a VB a sovraccaricare meno il buffer dell’interprete del programma in fase di localizzazione delle variabili.

Si inserisca un CommandButton sulla Form e gli si assegni la proprietà Name cmdVariabili (a voi la scelta di modificarne la Caption, non importa, è solo un esempio) ed al doppio click si inserisca il seguente codice:

Private Sub cmdVariabili_Click()
    testo = "Hello, World!"
    numero = 5
    MsgBox testo, vbOKOnly, "Messaggio da VB"
    MsgBox numero, vbOKOnly, "Altro messaggio da VB"
End Sub

Si avvii il programma premendo F5 ed al click sul CommandButton verranno lanciate due finestre di messaggio consecutive: la prima stampa a video la variabile testo e la seconda stampa a video la variabile numero.

Questo semplice esempio per sottolineare un aspetto molto importante: una variabile di tipo String va valorizzata tra doppi apici mentre una variabile di tipo Integer va valorizzata, solo con numeri, senza apici.

Si cancellino le variabili testo e numero dalla parte generale del codice e si inseriscano le seguenti:

Option Explicit
Dim a As String
Dim b As String
Dim c As String

Si cancelli il codice appena proposto dalla Sub cmdVariabili_Click() e si inserisca il seguente:

Private Sub cmdVariabili_Click()
    a = "10"
    b = "5"
    c = a + b
    Debug.Print c
End Sub

Debug.Print lancia il risultato dell’operazione nella Finestra Immediata dell’ambiente di sviluppo che compare al volo all’esecuzione dello script. Abbiamo messo in pratica un esempio errato di calcolatrice, dato la somma delle variabili sarà 105 e non 15… come fare? Usiamo il tipo Integer!

Si modifichi la parte generale del codice come segue:

Option Explicit
Dim a As Integer
Dim b As Integer
Dim c As Integer

e la parte relativa alla Sub come segue:

Private Sub cmdVariabili_Click()
    a = 10
    b = 5
    c = a + b
    Debug.Print c
End Sub

Ora è tutto ok!

Concludiamo questo capitolo con una panoramica sugli operatori.

Operatori di assegnazione

• = (uguale a…)
• < (minore di…)
• > (maggiore di…)
• <= (minore o uguale a…)
• >= (maggiore o uguale a…)
• <> (diverso da…)

Operatori matematici

• + (effettua una somma)
• – (effettua una sottrazione)
• * (effettua una moltiplicazione)
• / (effettua una divisione)

Operatori di stringa

• & (concatena due stringhe)
• + (concatena due stringhe ma si usa la &)

Operatori logici

• AND (indica che due condizioni devono essere entrambe vere)
• OR (indica che solo una delle due condizioni dev’essere vera)

Istruzioni condizionali

In un linguaggio di programmazione esistono strutture di controllo come le istruzioni condizionali che servono, come visto nei capitoli precedenti, a stabilire per l’appunto condizioni per scatenare una routine o un’altra a seconda del risultato della condizione.

VB utilizza il costrutto If – Then – Else per effettuare controlli. La sintassi base è la seguente:

If <em>condizione</em> Then
    <em>espressione</em>
Else
    <em>espressione alternativa</em>
End If

Vediamo un esempio. Si crei un nuovo EXE standard e si assegni alla Form il Name frmIstrCond; si inserisca un CommandButton e lo si chiami cmdIstrCond.

Nella parte generale si inserisca il seguente codice:

Option Explicit
Dim a As Integer
Dim b As Integer

e nella Sub il seguente codice:

Private Sub cmdIstrCond_Click()
    a = 10
    b = 10
    If a = b Then
        Debug.Print "A è uguale a B"
    Else
        Debug.Print "A è diverso da B"
    End If
End Sub

Essendo A e B impostate entrambe a 10, il risultato sarà A è uguale a B.

VB, come tutti i linguaggi di programmazione possiede una clausola per ampliare il raggio condizionale, ovvero ElseIf. Facciamo un esempio chiarificatore.

Si inserisca nella Sub il seguente codce:

Private Sub cmdIstrCond_Click()
    a = 10
    If a = 10 Then
        Debug.Print "A è uguale a 10"
    ElseIf a < 10 Then
        Debug.Print "A è minore di"
    Else
        Debug.Print "A è diverso da 10"
    End If
End Sub

Il risultato sarà A è uguale a 10.

Esiste un altro costrutto per la generazione di condizioni, il Select Case. La sintassi base è la seguente:

Select Case <em>condizione</em>
    Case 0: <em>espressione 0</em>
    Case 1: <em>espressione 1</em>
    Case 2: <em>espressione 2</em>
    Case Else
        <em>tutti gli altri casi</em>
End Select

Vedremo dei casi di studio col Select Case nei capitoli successivi.

Istruzioni di iterazione

Le istruzioni di iterazione fanno parte delle istruzioni di controllo dei linguaggi di programmazione e servono, come il nome lascia ad intendere, a ripetere una fase del programma N volte finchè non si raggiunge la condizione stabilita dallo sviluppatore in modo statico o dinamico.

Fanno parte delle istruzioni di iterazione, detti anche cicli, i costrutti

• For – Next
• For Each – Next
• While
• Do While – Loop

Esaminiamoli singolarmente.

Il ciclo For – Next ripete un’istruzione sulla base di una variabile di tipo Integer che parte da un valore predefinito, in genere zero (0) e si perpetua fino ad un valore maggiore, ad esempio nove (9) ripetendo quindi il ciclo da 0 a 9 per un totale di 10 ripetizioni.

La sintassi base è la seguente:

For <em>inizio</em> To <em>fine</em>
    <em>espressione da ripetere N volte</em>
Next

Vediamo un esempio concreto. Si crei un nuovo EXE standard e si inserisca sulla form un bottone di comando a cui assegnare il nome cmdFor ed una Label di nome lblFor. Consiglio di ingrandire un po la Label in altezza rispetto alle sue dimensioni di default, in modo da visualizzare correttamente il risultato.

Nella parte generale del codice inserire il seguente codice:

Option Explicit
Dim i As Integer

Nella Sub, invece, inserire il seguente codice:

Private Sub cmdFor_Click()
    i = 0
    For i = 0 To 9
        lblFor.Caption = lblFor.Caption & i & vbCrLf
    Next
End Sub

Facciamo la conoscenza con l’elemento vbCrLf che rappresenta il ritorno a capo in VB. Se avessimo ciclato solo

lblFor.Caption = lblFor.Caption & i

avremmo avuto come risultato

0123456789

con l’utilizzo di vbCrLf avremo invece

0
1
2
3
4
5
6
7
8
9

Il ciclo For Each – Next si differenzia da For – Next per il motivo che il primo ricerca ogni occorrenza di un elemento in un elemento madre. La sintassi base è la seguente:

For Each <em>elemento</em> In <em>elementi</em>
    <em>espressione da ripetere N volte</em>
Next <em>elemento</em>

Tratteremo questo ciclo più avanti nel corso della guida appena spiegati altri elementi, senza dei quali un esempio non avrebbe senso e rischierebbe, addirittura, di confondere le idee al lettore.

Il ciclo While esegue un’istruzione (o un’espressione) fin quando una condizione è vera. La sintassi base è la seguente:

While <em>condizione</em>
    <em>espressione da ripetere N volte</em>
Wend

Tratteremo approfonditamente While nel capitolo dedicato ai database.

Il ciclo Do While – Loop si differenzia ben poco da While, quindi ci limiteremo a vedere un esempio sintattico e poi lo abbandoneremo:

Do While <em>condizione</em>
    <em>espressione da ripetere N volte</em>
Loop

Gli Array

Si definisce Array un agglomerato di dati, statici o dinamici, archiviati in una variabile speciale in forma tabellare.

Un classico esempio di Array è rappresentato dai giorni della settimana, ma vediamo prima un esempio sintattico teorico:

Dim nome_array(numero_elementi)
    nome_array(0) = "<em>valore</em>"
    nome_array(1) = "<em>valore</em>"
    nome_array(2) = "<em>valore</em>"

Si crei un nuovo EXE standard e si inserisca una Label di nome lblArr da ingrandire come nell’esempio del capitolo precedente, ed un bottone di comando da chiamare cmdArr.

Si inserisca nella porzione generale il seguente codice

Option Explicit
Dim settimana(7) As String

e nella Sub il seguente codice:

Private Sub cmdArr_Click()
    settimana(0) = "Lunedi"
    settimana(1) = "Martedi"
    settimana(2) = "Mercoledi"
    settimana(3) = "Giovedi"
    settimana(4) = "Venerdi"
    settimana(5) = "Sabato"
    settimana(6) = "Domenica"

    ' Qui sotto richiameremo l'Array

End Sub

Ampliamo il codice con questa riga, da inserire sotto al commento:

Debug.Print settimana(5)

Il risultato sarà Sabato perchè si è puntato all’indice equivalente. Si inserisca poi, al posto della precedente riga, il seguente codice:

Dim i As Integer
i = 0
For i = 0 To UBound(settimana)
    lblArr.Caption = lblArr.Caption & settimana(i) & vbCrLf
Next

Dichiaro al volo una variabile che imposto come contatore ed effettuo un ciclo sulla lunghezza dell’Array

UBound(settimana)

restituisce la lunghezza di un Array. Stampo poi a video il risultato passando all’Array la variabile che fa da contatore che, come abbiamo visto nel capitolo precedente, assume un valore differente ad ogni iterazione del ciclo

settimana(i)

equivale a scrivere:

lblArr.Caption = ""
lblArr.Caption = lblArr.Caption & settimana(0)
lblArr.Caption = lblArr.Caption & settimana(1)
lblArr.Caption = lblArr.Caption & settimana(2)
lblArr.Caption = lblArr.Caption & settimana(3)
lblArr.Caption = lblArr.Caption & settimana(4)
lblArr.Caption = lblArr.Caption & settimana(5)
lblArr.Caption = lblArr.Caption & settimana(6)

Funzioni e Sub

Gli elementi madre di un programma, quelli a cui è delegato il compito di contenere e gestire le routine e gli script VB che vengono lanciati allo scatenarsi di un evento, sono le Funzioni e le Sub.

Spesso non si fa molta distinzione tra questi elementi, dato che svolgono un ruolo abbastanza simile. La differenza tra loro è che una Funzione raccoglie una serie di operazioni, o script, che insieme formano una routine e restituisce un valore; una Sub è un programma all’interno di un programma e cosi via fino al software finale. Altra differenza è che solo una Sub viene chiamata allo scatenarsi di un evento, mentre una Funzione viene chiamata all’interno di una Sub al verificarsi di una data condizione o a prescindere.

Sia le Funzioni che le Sub possono essere pubbliche o private: pubbliche quando sono visibili a tutto il programma ed a tutte le Form e generalmente vengono inserite in un modulo di classe esterno; private quando fanno parte della Form in cui nascono, vivono e muoiono. Si utilizzano le parole chiave Public e Private e se omesse VB da per scontato che si tratta di una Funzione o di una Sub privata.

La sintassi di una Funzione pubblica è la seguente:

Public Function <em>NomeFunzione</em> (<em>argomento</em> As <em>tipo</em>)
     <em>istruzioni</em>
End Function

La sintassi di una Funzione privata è la seguente:

Private Function <em>NomeFunzione</em> (<em>argomento</em> As <em>tipo</em>)
     <em>istruzioni</em>
End Function

ed è possibile omettere la parola chiave Private.

Sintatticamente parlando per eseguire una Sub non bisogna far altro che sostituire la parola chiave Function con Sub e chiudere il blocco con End Sub al posto di End Function.

Per chiamare una Funzione o una Sub dall’esterno o all’interno di un’altra Funzione o Sub, basta far riferimento al nome e passare tra parentesi gli eventuali valori da assegnare agli argomenti (o parametri, o ancora variabili, che dir si voglia); è possibile utilizzare la parola chiave opzionale Call prima del nome della Funzione o Sub che sia.

Facciamo un esempio tanto chiarificatore quanto inutile ai fini pratici della realizzazione di un programma. Si crei un nuovo EXE standard e si acceda al codice della Form dal menu

Visualizza / Codice

e si inserisca il codice per la seguente Funzione:

Private Function Messaggio(testo As String)
    MsgBox testo
End Function

Alla Funzione Messaggio() passo la variabile testo di tipo String che rappresenta il testo del messaggio che lanceremo. Si acceda poi alla Funzione / evento Form_Load() semplicemente facendo doppio click in un punto qualsiasi della Form dalla visualizzazione struttura e si richiami la Funzione Messaggio() come segue:

Private Sub Form_Load()
    Call Messaggio("Benvenuto!")
End Sub

In questa fase valorizzo la variabile testo inserendo materialmente il messaggio di benvenuto: il risultato sarà infatti una MsgBox con la scritta Benvenuto!

Gestione delle stringhe

Sia questo che il prossimo capitolo entrano nel dettaglio del codice VB per imparare a gestire due elementi fondamentali per qualsiasi linguaggio di programmazione: la manipolazione delle stringhe e la gestione delle date.

Iniziamo con le stringhe.

VB dispone di una nutrita schiera di interessanti Funzioni per la manipolazione delle stringhe: capita in moltissimi programmi di dover sostituire determinati caratteri in una stringa, di dividere una stringa in più stringhe in base ad un determinato criterio, di controllare la lunghezza di una stringa, di farci restituire solo parte di una stringa, e tante altre esigenze che devono essere soddisfatte.

Iniziamo con la Funzione Replace() che serve a sostituire caratteri all’interno di una stringa. Come vedremo più avanti parlando dei database, è importante, sia in fase di inserimento dei dati che in lettura, controllare che non ci siano all’interno di una stringa dei singoli apici… capita però che quegli apici siano lì nella stringa ad uno scopo: se ho un utente che si chiama D’Alessio non posso cambiargli il nome in DAlessio… insomma, non sono mica il responsabile dell’anagrafe! Posso però sostituire il singolo apice con due singoli apici in modo da non dar fastidio al database e far comparire comunque l’apice lì dove serve. La sintassi per una simile operazione è la seguente:

Replace("D'Alessio", "'", "''")

In pratica Replace() accetta i seguenti parametri:

Replace(<em>stringa</em>, <em>carattere da sostituire</em>, <em>carattere sostitutivo</em>)

Se ad esempio in una frase voglio sostituire un nome userò la Funzione Replace() come segue:

Replace("Pippo è un personaggio Disney", "Pippo", "Pluto")

ed eseguendolo con un Debug.Print

Debug.Print Replace("Pippo ...

riceverò la frase Pluto è un personaggio Disney.

Passiamo alla Funzione Split(). Split() divide una stringa in un Array (Rif. capitolo 7) di stringa; prendiamo la seguente stringa:

Luca#Ruggiero#Napoli

ho una serie di dati quali nome, cognome e città di appartenenza, ma in una forma irregolare e teoricamente illeggibile e scorretta grammaticalmente. Il carattere cancelletto (#) presente nella stringa mi consente di avere un utile riferimento per dividere la stringa come meglio conviene.

Si crei un nuovo EXE standard, si inserisca sulla Form una Label di nome lblSplit e si acceda alla Sub Form_Load(); nella parte generale si inserisca il seguente codice:

Option Explicit
Dim stringa As String
Dim s() As String
Dim i As Integer

dove s() è una stringa di tipo Array che utilizzerò per lo Split().

Nella Sub, invece, si inserisca il seguente codice:

Private Sub Form_Load()
    i = 0
    stringa = "Luca#Ruggiero#Napoli"
    s = Split(stringa, "#")
    For i = 0 To UBound(s)
        lblSplit.Caption = lblSplit.Caption & s(i) & vbCrLf
    Next
End Sub

Utilizzando la sintassi

Split(<em>stringa</em>, <em>carattere di riferimento</em>)

otterrò in output sulla Label

Luca
Ruggiero
Napoli

Ricordo che, come un Array, il conteggio degli item parte da zero (0) fino ad N.

Per controllare la lunghezza di una stringa esiste la Funzione Len() che accetta come parametro la stringa di cui, appunto, si vuole controllare la lunghezza. La sintassi è la seguente:

Len(<em>stringa</em>)

quindi

Debug.Print Len("Luca")

restituisce 4.

VB possiede tre Funzioni l’una figlia dell’altra che serve ad eliminare gli spazi superflui sulla sinistra, sulla destra o sia sulla sinistra che sulla destra di una stringa. Le Funzioni sono rispettivamente LTrim() (Left Trim), RTrim() (Right Trim) e Trim().

La sintassi è analoga per tutte e tre le Funzioni ed il funzionamento è quello appena descritto; facciamo un esempio con Trim(); la sua sintassi è:

Trim(<em>stringa</em>)

quindi

Debug.Print Trim("   Luca   ")

restituisce Luca senza gli spazi superflui.

Le Funzioni Left(), Right() e Mid() servono rispettivamente ad isolare da una stringa un certo numero di caratteri specificati. Andiamo per ordine e vediamo come usufruire delle funzionalità di tutte e tre.

Si crei un nuovo EXE standard e si inserisca nella parte generale il seguente codice:

Option Explicit
Dim stringa As String

che useremo per gli esempi di tutte e tre le funzioni appena accennate.

La sintassi di Left è la seguente:

Left(<em>stringa</em>, <em>numero di caratteri</em>)

Nel codice Form_Load() inseguire il seguente codice:

Private Sub Form_Load()
    stringa = "lukeonweb.net"
    Debug.Print Left(stringa, 4)
End Sub

La stringa lukeonweb.net viene parserizzata da Left() e restituisce solo i primi 4 caratteri, ovvero luke.

Il seguente codice illustra l’utilizzo della Funzione Right()

Private Sub Form_Load()
    stringa = "lukeonweb.net"
    Debug.Print Right(stringa, 4)
End Sub

Il risultato è .net.

In pratica Left() prende N caratteri specificati come secondo parametro tra parentesi a partire dalla sinistra della stringa, mentre Right() parte dalla destra.

Mid() invece non considera N caratteri a partire da sinistra ed N caratteri a partire da destra; un esempio:

Private Sub Form_Load()
    stringa = "lukeonweb.net"
    Debug.Print Mid(stringa, 5, 5)
End Sub

Il risultato è onweb.

Le stringhe possiedono ancora moltissime Funzioni, ma quelle spiegate in questo capitolo sono essenziali per affrontare la programmazione VB; rimando la spiegazione di altre Funzioni ad un corso più avanzato o ad un corso professionale.

Gestione delle date

La gestione delle date riveste un ruolo molto importante nell’ambito di un qualsiasi programma. VB mette a disposizione dello sviluppatore una serie di semplici e potenti Funzioni; elenchiamole:

• Date – restituisce la data in formato gg/mm/aaaa
• Time – restituisce l’orario in formato oo.mm.ss
• Now – restituisce la data e l’orario in formato gg/mm/aaaa oo.mm.ss
• FormatDateTime – restituisce vari formati della data anche in formato alfanumerico
• Day – restituisce il giorno della settimana accettando un oggetto Date
• Month – restituisce il mese dell’anno accettando un oggetto Date
• Year – restituisce l’anno accettando un oggetto Date
• Hour – restituisce l’ora accettando un oggetto Time
• Minute – restituisce i minuti accettando un oggetto Time
• Second – restituisce i secondi accettando un oggetto Time

Facciamo qualche esempio:

Debug.Print Date ' restituisce 31/10/2004

Debug.Print Time ' restituisce 15.00.00

Debug.Print Now ' restituisce 31/10/2004 15.00.00

Debug.Print FormatDateTime(Date, vbLongDate)
' restituisce domenica 31 ottobre 2004

Debug.Print Day(Date) ' restituisce 31

Debug.Print Month(Date) ' restituisce 10

Debug.Print Year(Date) ' restituisce 2004

Debug.Print Hour(Time) ' restituisce 15

Debug.Print Minute(Time) ' restituisce 00

Debug.Print Second(Time) ' restituisce 00

Funzioni di conversione e Funzioni predefinite

VB mette a disposizione dello sviluppatore una serie di Funzioni predefinite, alcune definite di conversione, che servono a convertire un tipo di dato in un’altro tipo, ed altre per la risoluzione di alcune problematiche in maniera semplice, veloce e potente. In questo capitolo affronteremo le principali.

Le Funzioni di conversione più famose sono CInt() e CStr() che convertono un dato rispettivamente in formato Integer ed in formato String. La sintassi è la seguente

Dim numero As String
numero = "5" ' è un numero ma in formato stringa
CInt(numero) ' restituisce numero = 5

Esistono altre Funzioni di conversione come CBool() che converte un dato in valore booleano, ovvero che restituisce True o False; CDate() che converte una stringa in una data; CCur() che converte un numero in formato valuta, ed altre.

Alcune Funzioni predefinite di VB molto comode sono FormatNumber() che separa con un punto le migliaia

Debug.Print FormatNumber(1000, 0) ' restituisce 1.000

FormatCurrency() che restituisce un numero con il simbolo dell’euro

Debug.Print FormatCurrency(1000, 1) ' restituisce € 1.000

Interazione con i database

VB è nato principalmente per la creazione di potenti interfacce che permettono la gestione locale o via rete (NON Internet) di dati residenti su una fonte di dati quale un database. Essendo un prodotto di casa Microsoft, VB preferisce lavorare con prodotti (DBMS, ovvero gestori di database) Microsoft come Access e SQL Server, ma lavora correttamente anche con DBMS di case differenti come Oracle.

In questo capitolo ci baseremo sull’interazione con Access, preferibilmente versione 2000 e do per scontato che il lettore abbia almeno un’infarinatura di base di SQL.

Per la connessione con una fonte di dati e la gestione dei dati ivi residenti, VB utilizza l’oggetto ADO (ActiveX Data Object) per l’interfacciamento tra il programma e la fonte di dati stessa. ADO mette a disposizione, tra l’altro, due oggetti fantastici, ovvero Connection per la gestione della connessione ed altre utility, e Recordset per la gestione fisica dei dati.

Si crei un nuovo EXE standard e si acceda al menu

Progetto / Riferimenti...

per l’importazione dei riferimenti ad ADO, selezionando le voci come nell’immagine seguente:

Si nomini la Form frmDatabase, si inseriscano due Label con Caption Nome e Cognome (non preoccupatevi di cambiare la proprietà Name) e due TextBox in cui svuotare la proprietà Text e modificare i nome come txtNome e txtCognome. Si aggiunga poi un CommandButton da nominare cmdInserisci e modificare la Caption in Inserisci. Questa Form ci consentirà di effettuare inserimenti nel database Access ce creeremo tra poco; l’immagine seguente mostra il risultato finela della Form:

Si salvi il progetto dal menu

File / Salva progetto con nome...

nella cartella test da creare sotto il drive C:

C:test

All’interno di questa cartella troverete fei file di progetto creati automaticamente da VB; aggiungete in questa cartella il file Access database.mdb al cui interno creare la tabella utenti in cui inserire i campi id (Contatore), nome (Testo) e cognome (Testo); appena espletata questa operazione tornare sulla Form in visualizzazione struttura, accedere al codice della Form ed inserire queste righe nella parte generale:

Option Explicit
Dim cn As ADODB.Connection
Dim rs As ADODB.Recordset
Dim stringa As String

I tipi di dato ADODB.Connection ed ADODB.Recordset sono stati aggiunti a VB per mezzo dell’importazione dei riferimenti come accennato in precedenza.

Doppio click sul CommandButto per accedere alla Sub in cui inserire il seguente codice:

Private Sub cmdInserisci_Click()
    If Len(Trim(txtNome.Text)) = 0 Then
        MsgBox "Inserire il nome", vbCritical, "ERRORE"
        txtNome.SetFocus
        Exit Sub
    End If
    If Len(Trim(txtCognome.Text)) = 0 Then
        MsgBox "Inserire il cognome", vbCritical, "ERRORE"
        txtCognome.SetFocus
        Exit Sub
    End If

    stringa = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source="
    stringa = stringa & "C:testdatabase.mdb"

    Set cn = New ADODB.Connection
    Set rs = New ADODB.Recordset

    cn.Open stringa
    rs.Open "utenti", cn, 3, 3

    rs.AddNew
        rs("nome") = txtNome.Text
        rs("cognome") = txtCognome.Text
    rs.Update

    Set cn = Nothing
    Set rs = Nothing

    MsgBox "Inserimento effettuato", vbOKOnly, "CONFERMA"
End Sub

A prima vista questo codice potrebbe destare qualche perplessità al lettore più inesperto, quindi affrontiamo le singole fasi della Sub.

Controllo che i campi nome e cognome siano stati compilati correttamente, utilizzando l’espressione Exit Sub per uscire dalla Sub qualora le condizioni non siano state soddisfatte e non si vuol permettere la continuazione della routine:

If Len(Trim(txtNome.Text)) = 0 Then
    MsgBox "Inserire il nome", vbCritical, "ERRORE"
    txtNome.SetFocus
    Exit Sub
End If
If Len(Trim(txtCognome.Text)) = 0 Then
    MsgBox "Inserire il cognome", vbCritical, "ERRORE"
    txtCognome.SetFocus
    Exit Sub
End If

A condizioni soddisfatte creo la stringa di connessione al database e la memorizzo nella variabile stringa:

stringa = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source="
stringa = stringa & "C:testdatabase.mdb"

Con la clausola Set imposto le variabili cn ed rs come nuove istanze degli oggetti Connection e Recordset:

Set cn = New ADODB.Connection
Set rs = New ADODB.Recordset

Apro la connessione al database ed il Recordset in modalità scrittura, passando al metodo Open il nome della tabella su cui voglio lavorare, il nome della connessione che sto utilizzando ed i cursori appropriati:

cn.Open stringa
rs.Open "utenti", cn, 3, 3

Utilizzo i metodi AddNew ed Update per aggiungere un nuovo record alla tabella e per aggiornarlo; passo poi al Recordset i campi della tabella e li valorizzo con le variabili contenenti i dati corrispondenti:

rs.AddNew
    rs("nome") = txtNome.Text
    rs("cognome") = txtCognome.Text
rs.Update

Pulisco la memoria del buffer dalle variabili contenenti la connessione ed il recordset, settandole sul valore speciale di VB Nothing:

Set cn = Nothing
Set rs = Nothing

In fine, ad operazioni espletate, lancio un messaggio di conferma:

MsgBox "Inserimento effettuato", vbOKOnly, "CONFERMA"

Vediamo adesso come leggere i dati dal database. Si aggiunga una nuova Form dal menu

Progetto / Inserisci form

si scelga Form e si confermi. Si assegni alla Form il nome frmLettura e si aggiunga una Label di nome lblDati grande quanto tutta la Form.

Si acceda all’evento Form_Load() della Form con un doppio click in un punto qualsiasi della Form stessa e si inserisca nella parte generale il seguente codice:

Option Explicit
Dim cn As ADODB.Connection
Dim rs As ADODB.Recordset
Dim stringa As String

In Form_Load(), invece, inserire il seguente codice:

Private Sub Form_Load()
    stringa = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source="
    stringa = stringa & "C:testdatabase.mdb"
    
    Set cn = New ADODB.Connection
    Set rs = New ADODB.Recordset

    cn.Open stringa
    rs.Open "SELECT * FROM utenti", cn, 1

    If rs.EOF Then
        lblDati.Caption = "Nessun dato"
    Else
        While rs.EOF = False
            lblDati.Caption = lblDati.Caption _
                            & rs("nome") & " " _
                            & rs("cognome") & vbCrLf
            rs.MoveNext
        Wend
    End If

    Set cn = Nothing
    Set rs = Nothing
End Sub

Gran parte del codice appena presentato non è molto differente da quello di esempio per l’inserimento: la stringa di connessione al database è la stessa, è necessario settare ed aprire, ed in fine svuotare, gli oggetti Connection e Recordset. Concentriamoci sulla lettura dei dati:

If rs.EOF Then
    lblDati.Caption = "Nessun dato"
Else
    While rs.EOF = False
        lblDati.Caption = lblDati.Caption _
                        & rs("nome") & " " _
                        & rs("cognome") & vbCrLf
        rs.MoveNext
    Wend
End If

La logica seguita è la seguente: se non ci sono dati nella tabella, ovvero se la lettura del Recordset arriva alla fine della tabella (EOF – End Of File) lancio un messaggio che avvisa che non sono stati trovati dati; altrimenti effettuo un ciclo e stampo a video nella Label tutti i record tirati fuori dalla stringa SQL

SELECT * FROM utenti

passata al Recordset impostato in lettura.