Visual Studio .net

IL Visual Basic

L'ambiente di programmazione

Il form

I controlli

la finestra delle proprietà

Il codice

L'esecuzione

Visual Basic viene definito dalla Microsoft come un "Sistema di programmazione per Windows". Il termine "sistema" viene utilizzato ad indicare il fatto che si tratta di un insieme di componenti che vengono forniti insieme, ed insieme operano, nell'ambito della programmazione. Vediamo perciò prima di tutto che cosa si intende per "programmazione": con tale parola si identifica la branca dell'informatica che si occupa di creare programmi software. Ogni programma che si utilizza sul proprio computer – dal sistema operativo Windows, a Word o ad Excel – sono stati prodotti utilizzando la programmazione. Lo scopo della programmazione è quello di produrre file eseguibili (file di estensione EXE), che possono poi essere eseguiti dall'utente, per rispondere alle sue esigenze.

Visual Basic si occupa di programmazione mettendo a disposizione dell'utente (non l'utente finale del programma da creare, ma l'"utente-sviluppatore" che crea il programma) un insieme di strumenti, che sono poi quelli "classici" di tutti i sistemi di programmazione. Vediamoli:
• un linguaggio di programmazione: costituisce la parte fondamentale. Il linguaggio di programmazione è l'insieme di regole "grammaticali" attraverso cui si "disegna" il programma che si vuole creare e gli si spiega come fare ciò che deve fare. Visual Basic, in quanto applicazione Windows  è facile da usare, infatti si serve degli strumenti classici di Windows, come i pulsanti o le finestre: la vera parte da imparare è proprio il linguaggio. A sua volta, il linguaggio di Visual Basic può essere scomposto in due grandi famiglie, come sempre distinte ma interagenti:
– la scrittura del codice,
– la costruzione dell'interfaccia.
Il codice costituisce il linguaggio in senso più stretto: il suo significato sarà più chiaro non appena ne vedremo i primi esempi. Nei linguaggi di vecchio tipo (ante-Windows) il codice costituiva praticamente l'unica cosa da creare (anche l'interfaccia veniva creata attraverso il codice, peraltro con notevole difficoltà, sugli stessi vostri banchi io ho studiato il vecchio Basic e il Cobol). Con l'avvento di Windows, l'interfaccia, che pure assume un rilievo ed una complessità assai maggiori, può essere costruita graficamente (con il mouse), in modo assai più semplice ... e più divertente.
L'insieme di file che contengono il codice e descrivono l'interfaccia del programma da creare costituiscono i file "sorgenti" del programma stesso.
• un sistema di esecuzione e debug: Visual Basic permette di eseguire il programma man mano che lo si sta costruendo, in modo da metterlo a punto, ad esempio verificando passo passo il funzionamento (il valore delle variabili, gli effetti delle scelte dell'utente), potendolo fermare, correggere e far proseguire o ripartire. Tutte queste operazioni, assolutamente fondamentali visto che non esiste un programma che funzioni al primo colpo, sono note con il termine di "debug".
• un compilatore: una volta che il programma funziona all'interno di Visual Basic, esso deve essere trasformato in un file eseguibile autonomo (o quasi). "Compilare" il programma significa appunto creare tale file. Una volta creato, il file eseguibile non può essere più modificato. Se si trova un errore, si può tuttavia correggerlo nel codice sorgente e poi ricompilarlo.
• una guida in linea: costituisce un aspetto fondamentale anche per lo sviluppatore più esperto, che non è tale perché "sa tutto a memoria" quanto piuttosto perché sa sempre dove andare a recuperare l'informazione che gli occorre, all'interno della guida che Visual Basic gli offre.

Penso sia ora il caso di provare con un primo esempio. Lanciamo Visual studio e scegliamo nuovo progetto da questa fineestra.

Impostiamo un nome per il nostro progetto che, se non cambierete la cartella di destinazione, verrà salvato automaticamente nella cartella Visual Studio Project . Dato l'ok vi troverete davanti alla finestra che rappresenta l'ambiente di programmazione Visual Basic.

Al centro vedete il form. I forms costituiscono l'interfaccia dell'applicazione, cioè quello che dell'applicazione "si vede". Esse contengono tutto ciò in cui l'utente può scrivere, premere, selezionare o muovere con il mouse, ecc. È ben difficile che un'applicazione non contenga alcun form, non fosse altro per dare all'utente un modo per vedere cosa l'applicazione fa, ed un pulsante per chiuderla .
Si noti come esistano almeno due famiglie di form:
il form che sarà l'oggetto principale dell'interfaccia del vostro progetto perchè sarà contenitori di tutti gli oggetti che vorrete mostrare all'utente: i controlli.

Nel nostro primo esempio noi useremo 2 tipi di controlli:
• un'etichetta (label), dove si scrive del testo che in genere dà informazioni all'utente (e che l'utente deve solo leggere)
• un pulsante (command button), che è una delle cose più "classiche" di Windows, con su scritto "Cliccami"
I controlli possono essere di tanti altri tipi. In seguito vedremo quelli più consueti in Visual Basic

  Per disegnare gli oggetti nel form, occorre selezionare gli appositi strumenti dalla sasella degli strumenti a sinistra nell'immagine, nel caso questa non sia visualizzata sul vostro monitor, scegliete viualizza casella degli strumenti dal menu. Gli oggetti si disegnano sul form utilizzando il mouse come fosse  la nostra matita, quindi tenendo premuto il tasto Sx e rilasciandolo quando il controllo ha raggiunto la dimensione desiderata. Sulla destra in alto la scheda Esplora soluzioni  e sotto la scheda delle proprietà. Quest'ultima evidenzia le proprietà, quindi le caratteristiche degli oggetti del nostro progetto, in particolare di quello evidenziato in quel momento, quindi nell'esempio indica le proprietà della label (etichetta) ammanigliata (selezionata-evidenziata).

Procedendo con il nostro esempio, supponiamo che il nostro obiettivo sia quello di realizzare un programma che permetta all'utente di cliccare un pulsante e ricevere un messaggio di conferma, un saluto.

Le fasi di realizzazione dunque saranno tre: una, la prima l'abbiamo già vista e consiste nel disegno dell'interfaccia, poi si deve continuare con la definizione delle proprietà. Si può visualizzare la scheda delle proprietà cliccando con il tastoDx dle mouse l'oggetto e selezionando Proprietà. Ogni oggetto ha molte proprietà  che ne fissano il colore, le dimensioni, la posizione sulla scheda, il carattere (se compare del testo), e un numero incredibile di altre cose che non sarà necessario sempre andare ad impostare, vediamo quali sono le proprietà che sicuramente dovremo andare a modificare:

• name: definisce il nome dell'oggetto

• text: definisce il valore dell'oggetto, il contenuto che apparirà  nella finestra all'utente.

La sintassi per accedere alle proprietà degli oggetti dal codice è:

NomeControllo.NomeProprietà

Ma ora vediamo come arrivare al codice e come collegare questo all'interfaccia.
L'evento di premere il pulsante non lo chiamo io, ma ha un nome dato da Visual Basic, che è  "Click". Quello che il programma deve fare quando tale evento si verifica è, come abbiamo detto, una procedura evento, il cui nome ha la sintassi:

NomeOggetto_NomeEvento

Quindi tutto dipenderà da cosa scriveremo in questa procedura. Intanto per scrivere il codice ci si deve spostare nella scheda codice lasciando quindi la scheda progettazione. Si può accedere alla finestra codice dalla linguetta apposita oppure direttamente facendo doppio click sull'oggetto al quale è collegata la procedura d'evento, nel nostro caso il bottone:

Quella che vediamo in questo esempio è una banale istruzione di assegnazione, cioè assegniamo alla proprietà text della label il contenuto indicato tra apici.

Vediamo ora un secondo esempio in cui utilizzeremo un altro controllo: la casella di testo.  Nel text box l'utente può scrivere direttamente in fase di esecuzione oltre che il programmatore come per la label , può scriovere "via codice" . Il fatto che l'utente possa scrivere nella casella di testo, fa di questo controllo un utile strumento da utilizzare per l'immissione degli input dall'utente. Se ad esempio volessimo simulare il funzionamento di una calcolatrice, come vedete nell'immagine,

avremmo bisogno di due caselle di testo che l'utente utilizzerà per immettere i numeri che saranno oggetto dell'operazione scelta attraverso l'evento Click dei relativi pulsanti. A ciascuno di quei pulsanti sarà collegato il codice indicato nel fumetto, che si differenzierà solo per l'operatore aritmetico + - * /.  Anche in questo caso si tratta di una istruzione di assegnazione che attribuisce alla proprietà text della label la somma dei valori numerici delle proprietà text delle due caselle di testo. Per questo motivo è stata usata la funzione VAL() questa restituisce il valore numerico di una stringa.All'inverso la funzione Cstr converte in stringa un valore numerico.

Durante la fase di progettazione dell'applicazione – quando cioè ci troviamo all'interno di Visual Basic – abbiamo a disposizione tre modalità di Visual Basic stesso, e cioè:
* la modalità progettazione (design) in cui l'applicazione viene costruita, si disegnano le schede e i controlli, si impostano le proprietà che si desidera fissare e si scrive il codice;
* la modalità esecuzione (run) in cui si esegue l'applicazione come se fosse finita, pur restando all'interno di Visual Basic;
* la modalità interruzione (break) in cui si sospende temporaneamente l'esecuzione dell'applicazione in modo da fare tipicamente una delle due seguenti cose:
– verificare il contenuto di alcune variabili o il valore di alcune proprietà, tramite l'apposita "finestra di verifica" (debug window) in modo da cercare di capire se variabili e proprietà contengono davvero quello che ci si aspetta;
– modificare parti del codice (in fase di interruzione è possibile modificare buona parte del codice; se si dovesse incorrere in qualcosa che non può essere modificato in questa fase – per esempio la dichiarazione di nuove variabili globali – Visual Basic avverte che sarà necessario fermare l'esecuzione e ripartire dall'inizio).
Attraverso questi  tre pulsanti possiamo passare da una modalità all'altra:

Il primo pulsante passa da design a run, cioè fa partire il programma, come se fosse un eseguibile (scelta rapida con F5).
Il secondo pulsante impone una pausa (da run a break).
Il terzo pulsante ferma il programma (sia esso in run o in break) e lo riporta in design, come se l'utente scegliesse un (ipotetico) pulsante Chiudi

Cos'è una variabile

La dichiarazione delle variabili

I tipi di variabile

Esempio di uso di variabili

Anche Visual Basic, come tutti i linguaggi di programmazione, prevede l'uso delle variabili, queste sono dei nomi, che noi definiamo, in grado di memorizzare dei valori (ad esempio dei numeri o dei testi).
Nei nostri primi due esempi non abbiamo usato variabili, perché non era strettamente indispensabile. Tuttavia possiamo notare che abbiamo utilizzato la proprietà Text della label risultato o la proprietà text del controllo TxtPrimo. Può essere allora più elegante (in questo caso, in altri è invece non solo elegante, ma utile o indispensabile), memorizzare il testo scritto dall'utente in una variabile che potrà essere di tipo stringa se capace di accogliere testi (ma anche numeri trattati come fossero testi – notare che una variabile di tipo numerico non saprebbe fare viceversa, cioè accogliere testi, che non possono essere trattati come fossero numeri), o diversamente di tipo integer o  single se conterrà valori numerici. Mediante le variabili è possibile memorizzare dei valori testuali o numerici in strutture a cui il programma può accedere grazie a un nome assegnato loro in fase di creazione.

Ora vediamo come modificare uno dei nostri esercizi con l'utilizzo delle variabili. Prendiamo ad esempio questo:

Private Sub btnCALCOLAx_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnCALCOLAx.Click

Dim x as single

L'istruzione condizionale

If ...Then...Else

If...Then...ElseIf

La funzione IsNumeric

La concatenazione di stringhe

Esempio

Raramente i programmi prevedono la sola esecuzione sequenziale di istruzioni. Per di più i programmi devono eseguire operazioni diverse in risposta a condizioni diverse. Ad esempio, un programma potrebbe dover verificare il giorno della settimana ed eseguire un'operazione diversa in base al giorno. L'istruzione If...Then consente di valutare una condizione e di eseguire sezioni di codice diverse in base ai risultati di tale condizione.

 Vi sono due forme differenti: la più semplice è l’istruzione singola, su unica linea, If – Then, che viene scritta come segue:

If espressione logica Then istruzione eseguibile

L’istruzione eseguibile andrà in esecuzione solo se l’espressione logica è vera, altrimenti si passerà alla successiva istruzione del codice del programma; se l’istruzione eseguibile non appare sulla medesima linea dell’espressione logica, è necessaria un’istruzione End If
Esempio 1
If x < 0 then y =0

Esempio 2
If reddito <= 14000 then
Tasse = 0.2*stipendio
Netto = stipendio – tasse
End If

Un blocco If – Then –Else  invece consente di eseguire uno tra due diversi blocchi di istruzioni, a seconda del risultato del test logico. Esso permette una forma di ramificazione più ampia di quella che si ottiene con un singolo blocco If – Then:
 

If espressione logica Then
………………….
istruzioni eseguibili
………………….
Else
………………….
istruzioni eseguibili
………………….
End If

Se l’espressione logica è vera, viene eseguito il primo gruppo di istruzioni, altrimenti viene eseguito
il secondo. Perciò viene eseguito solo uno dei due gruppi di istruzioni.
In forma più generale, il blocco if – Then – Else può essere scritto come:
 

If espressione logica1 then
………………….
istruzioni eseguibili
………………….
ElseIf espressione logica2 then
………………….
istruzioni eseguibili
………………….
Elseif espressione logica i-esima then
………………….
istruzioni eseguibili
………………….
Else
………………….
istruzioni eseguibili
………………….
End If

Ora vi propongo un esercizio svolto in cui ho utilizzato l'istruzione condizionale if ...then ...else e una funzione predefinita di Visual Basic, IsNumeric( ) che restituisce VERO se la variabile passata come argomento è un numero e restituisce falso in caso contrario.

Questa l'interfaccia che prevede per l'utente uno spazio per digitare quello che vuole, un testo o un numero, un bottone per avviare il codice (CLICCA) una label per visualizzare il messaggio in risposta all'utente, e un altro bottone che permetta di riazzerare le proprietà degli oggetti per poter proporre nuovi input da elaborare.

Il codice necessario è questo, potete poi ricopiarlo per provare voi stessi:

Voglio farvi notare inoltre l'utilizzo della   "&" nell'assegnazione del contenuto alla proprietà text della label, questa operazione si chiama "concatenazione" ovvero si può attaccare ad una stringa il valore di una variabile: questa tecnica risulta essere molto utile per comunicare gli output all'utente.

La funzione InputBox ( )

La funzione MsgBox ( )

Finora abbiamo sempre previsto l'uso di textbox per l'inserimento di dati (input) da parte dell'utente, ma andando avanti sicuramente vi troverete davanti a problemi in cui sarebbe davvero difficile utilizzare quel tipo di controllo. Prendiamo ad esempio il caso in cui si volesse realizzare un progetto che calcoli la media dei voti di un allievo non sapendo ha quante prove questo si fosse sottoposto: non sapremmo quante textbox disegnare! A questo punto entrano in gioco le funzioni per finestre di dialogo elementari: per l'input, la InputBox( ) e per l'output la MsgBox ( )
• InputBox: si utilizza per mostrare semplici finestre di dialogo che richiedono all’utente di inserire un dato (che è appunto il valore restituito dalla funzione). La sintassi è:

nomevariabile=InputBox("Inserisci il valore della variabile")

Nella variabile "nomevariabile", andrà a finire quello che l'utente scrive nella casella bianca della finestra qui a lato.

• MsgBox: si utilizza invece per mostrare una finestra che manda semplicemente  un messaggio all’utente, ad esempio "la media dei voti è...5" concatenando alla stringa di messaggio il contenuto di una variabile(5) al quale l'utente deve solo confermare cliccando sull'OK, oppure dandogli la possibilità di scegliere tra due opzioni (OK/Annulla, Sì/No). Il valore restituito dalla funzione è proprio il pulsante scelto a cui corrisponde una codice.

La ripetizione POST_condizionale

La ripetizione PRE_condizionale

L'istruzione Do...Loop Until

L'istruzione Do...Loop While

Le istruzioni Derivate

L'istruzione For ... Next

Abbiamo finora conosciuto 2 strutture di controllo: la struttura sequenziale, e la struttura alernativa. La terza struttura fondamentale della programmazione strutturata è la ripetizione (CICLO) Per ciclo si intende un meccanismo per il quale un blocco di istruzioni viene eseguito più di una volta, e più precisamente:
• un numero di volte noto a priori: istruzione  For... Next
• un numero di volte non noto a priori:istruzione  Do... Loop Until
Nel secondo caso è evidente che occorre prevedere una condizione (sempre del tipo che dia come risultato Vero o Falso) per permettere al ciclo di fermarsi. In caso contrario il ciclo continuerebbe all’infinito. I cicli sono fondamentali, in quanto esistono moltissime operazioni, che tipicamente fa un’applicazione, che richiedono di essere eseguite più volte.
Le istruzioni di controllo eseguite una sola volta (che cioè non generano dei cicli) sono rappresentate dall’istruzione If... Then ... Else che abbiamo già visto nelle lezioni precedenti e dall’istruzione Select Case, che vi  illustrerò in una lezione più avanti. Qui sotto vi mostro gli algoritmi che mettono a confronto la ripetizione post-condizionale e pre-condizionale con le relative traduzioni in Visual Basic. Cliccate le immagini per leggere i due file riassuntivi in formato Pdf (stampabile), oppure cliccate qui per provare le stesse istruzioni nel progetto Visual basic: Progetto RIPETIZIONI

   Ripetizione POST-Condizionale                                           Ripetizione PRE-Condizionale

Come potete vedere, nei casi esposti sopra non si conosce dapprima il necessario numero di ripetizioni, vediamo cosa accade se invece lo si conosce dal principio. Per questi casi si utilizza l'istruzione for...next La sintassi di For... Next è la seguente:

For Contatore = Inizio To Fine [ Step Incremento ]
         [BloccoIstruzioni]
[Exit For]
        [BloccoIstruzioni]
Next [Contatore]
 

dove:
• Inizio To Fine specificano il valore iniziale e finale che assumerà Contatore, procedendo di Incremento in Incremento;
• se Incremento è omesso, vale 1; se invece è negativo, allora il ciclo va a ritroso, e Inizio deve essere maggiore di Fine;
• Exit For permette di uscire da un ciclo a metà (per esempio perché ho trovato in anticipo ciò che stato cercando, e non voglio perdere tempo ad arrivare fino alla fine).

 

L'istruzione Select Case

Esempio

Select case rappresenta una versione migliorata di un normale If... Then nei casi in cui:
• occorre valutare in sequenza un numero elevato di condizioni (tante clausole ElseIf se si usasse l’If normale), e
• tutte le condizioni sono da valutare rispetto alla stessa variabile (o espressione di variabili).

Select funziona dunque leggendo una prima (ed unica) volta il valore di una variabile e confrontandolo in sequenza con i valori dei vari Case, fin tanto che non ne trova uno uguale, cioè in cui il confronto restituisca Vero. La sintassi è dunque la seguente:

Select Case EspressioneTest
       [Case Espressione1
                  [Blocco istruzioni-1] ]
      [Case Espressione2
                 [Blocco istruzioni -2] ]
      [Case Else
                 [Blocco istruzioni -n] ]
End Select

dove:
• EspressioneTest  o variabile di controllo è l’espressione da valutare.

• Espressione1 o valori1, ecc. sono i valori con cui si confronta il risultato di EspressioneTest.
Possiamo  indicare un solo valore, più valori separati da virgola, un intervallo di valori (se sono lettere, vale l’ordine alfabetico) separati dalla parola chiave To, e anche  un valore che viene confrontato non con l’uguale, ma con un maggiore, un minore o un diverso, mediante la parola chiave Is: ad esempio Is >= 3 (Is è aggiunto automaticamente da Visual Basic ogni volta che uso >, <, >=, <=, <> [diverso])
 

• BloccoIstruzioni-1, ecc. è quello che viene eseguito se la corrispondente Espressione1 è verificata.
 

• L'ultimo Case Else (facoltativo) corrisponde a quello che si deve fare se nessuno dei Case precedenti è stato verificato.

Se volessi ottenere un risultato analogo con una struttura If dovrei ricorrere a tanti ElseIf, complicati dal fatto che non potrei usare la virgola per separare argomenti (dovrei usare degli Or) né il To per indicare intervalli (dovrei trasformarli in due condizioni unite da un And: If Lettera >= "A" And Lettera <= "Z"). E' importante ribadire però che Select funziona perché in tutti i confronti, quello che devo confrontare è sempre la stessa variabile: se così non fosse il ricorso a If sarebbe necessario.

Notare infine che se EspressioneTest soddisfa più di una Espressione, solo il BloccoIstruzioni corrispondente alla prima soddisfatta viene eseguito.

Vi mostro un banale esempio in cui viene usata l'istruzione Select Case per mostrare in output il la scelta digitata dall'utente.

     

La dichiarazione di un Array

La dichiarazione di una Matrice

Ridimensionamento di un Array

Il caricamento di un Array

Il caricamento di una Matrice

L'ordinamento di un Array

La ricerca sequenziale

La ricerca dicotomica

Se devo memorizzare più valori che sono in qualche modo parenti dal punto di vista logico, posso usare il concetto di vettore di variabili (array).
Ad esempio, se devo memorizzare le temperature di tutti i giorni in un mese, non è particolarmente pratico definire 31 variabili:
Dim Temperatura1 As Single
Dim Temperatura2 As Single
...
Definisco allora un vettore di Single, fatto da 31 elementi:

Dim Temperatura(30) As Single

Il numero di elementi viene cioè indicato tra parentesi tonde, e prende il nome di Subscript. Ho scritto 30 perché gli elementi sono per impostazione definita numerati a partire da 0 (e quindi il trentunesimo elemento ha il numero 30).
Ai singoli elementi si accede semplicemente usando il loro indice:
Temperatura(0) = 23.7
Temperatura(Giorno) = 25 'L'indice può essere una variabile (in questo caso Giorno), o anche un'espressione o come nel primo esempio, semplicemente possiamo indicare il numero corrispondente alla posizione.
Se poi le temperature da memorizzare sono la minima e la massima, allora di vettori me ne servono due, o meglio mi serve una matrice di 31 righe per 2 colonne (in inglese è ancora array):
Dim Temperatura(30,1) As Single
Se non so a priori quanti elementi conterrà il mio array, posso dichiararlo senza precisarlo:
Dim A() As Single
Prima di usarlo, devo dichiarare il numero di elementi, mediante l'enunciato ReDim:
ReDim A(30)
Il bello è che ora posso ridimensionare tutte le volte che voglio il mio array, purché cambi solo il numero di elementi, e non il numero di dimensioni che ho dato al primo uso di ReDim . Basta che scriva:
ReDim A(60)
(ma non posso scrivere ReDim A(60,2) perché non posso aggiungere a posteriori un'altra dimensione.)

Usando ReDim senza nient'altro, perdo tutti valori che avessi già memorizzato nell'array (essa ritorna piena di 0 se fatta di tipi numerici, o di stringhe nulle se di tipo String).
Se, come spesso accade quando si ingrandisce un'array, voglio mantenere i valori precedenti, devo usare la parola chiave aggiuntiva Preserve:
ReDim Preserve A(60)
Sia ReDim sia Preserve possono essere usati anche per diminuire il numero di elementi (in tal caso naturalmente, anche se uso Preserve, perdo gli elementi che decido di togliere).


Vediamo ora un esempio di progetto in cui si prevede la memorizzazione delle temperature giornaliere di una settimana in un array e di produrre in output la temperatura media.

Quando si cominciano ad utilizzare gli array, nasce l'esigenza di ordinare gli elementi che lo compongono,(SORT) o di ricercare un elemento all'interno dell'array stesso (RICERCA) Esistono vari algoritmi sia per l'ordinamento che per la ricerca.

ORDINAMENTO CON METODO DI SOSTITUZIONE

Questo metodo è forse uno dei più semplici, ma visto che prevede lo scorrimento di tutto l'array più volte, è adatto nei casi in cui l'array è di dimensioni contenute. In pratica, partendo dal primo elemento, ogni elemento viene confrontato con tutti gli altri e laddove risultasse maggiore viene scambiato di posizione con il successivo (questo in caso di ordinamento crescente). La stessa procedura viene utilizzata indifferentemente per ordinare un array di valori numerici o di stringhe.  Per effettuare lo scambio di posizione, si utilizza una variabile di comodo che nell'esempio abbiamo chiamato temp.

In questo esempio vedete come con tre semplici procedure è possibile prevedere il caricamento di un array, la visualizzazione e l'ordinamento di un array di numeri. Ovviamente una volta ordinato basterà cliccare ancora su Visualizza per vedere l'array ordinato.

RICERCA SEQUENZIALE

La ricerca sequenziale consiste nel leggere tutte le componenti degli array, confrontarle con il valore dell'elemento cercato e nel caso in cui si trovi corrispondenza tra i due elementi, si interromperà la ricerca, altrimenti, si procederà fino alla fine. Nell' esempio che vi propongo, dopo aver caricato i nomi il sesso e l'età di n elementi in due array paralleli, ho previsto la ricerca per nome, restituendo TRUE (vero) se l'elemento inserito è presente nell'array, con le relative informazioni contenute negli array paralleli, età e sesso.

RICERCA DICOTOMICA

E' un altro metodo di ricerca che può essere  utilizzato solo se l'array è ordinato.  Si procede dividendo l'array in due parti ed escludendo dal controllo la parte dell'array che sicuramente non conterrà l'elemento cercato. La divisione in parti dell'array, procede fino a quando non viene trovato l'elemento cercato oppure fino a che rimarranno 2 soli elementi e sarà quindi opportuno inviare il messaggio "ELEMENTO NON PRESENTE IN ARRAY" Qui di seguito vi mostro il codice per integrare l'esercizio già visto precedente con un bottone per la ricerca dicotomica.

LE MATRICI

Per Matrice si intende un array a due (o più dimensioni), cioè un insieme di elementi dello stesso tipo individuabili all'interno della matrice da una coppia di indici, uno per la riga e uno per la colonna. Quindi avremo in fase di dichiarazione

dim m(nr,nc) as integer per dichiarare una matrice dove  nc indica il valore massimo che può avere l'indice j (colonne) e nr il valore massimo di i (righe).

Il caricamento di una matrice prevederà quindi l'uso di due cicli for :

for i = 0 to nr

    for j = 0 to nc

       m(i,j)=inputbox("inserisci elemento")

    next j

next i

Quando è necessario arricchire l'interfaccia grafica di un software, si può utilizzare il controllo della barra degli strumenti di Visual Basic: Picture Box

Il procedimento per inserire un immagine in un form è questo:

1) Selezionare dalla barra degli strumenti: e disegnare nel form un riquadro dove inseriremo l'immagine.

2)selezionato il riquadro con il tastoDX, accediamo alla finestra delle proprietà dove andiamo ad impostare la proprietà image: selezioniamo risorsa locale, come nell'immagine, e procediamo importando un'immagine tra quelle memorizzate nel nostro hard disk o altro supporto.

 il risultato che otterremo sarà il seguente:

Quando ho necessità di visualizzare a video un elenco, come ad esempio il contenuto di un array, posso utilizzare un oggetto di Visual Basic che è la List Box in sostituzione del metodo di cancatenazione di stringa, che abbiamo visto nella lezione precedente. La lista, o casella di riepilogo, viene gestita da visual basic come un array con indice che parte da 0. Come gli altri controlli, per gestire questi oggetti dobbiamo conoscerne i principali metodi:

• Items.Add (elemento) Aggiunge un elemento alla lista
• Items.Remove (elemento) Rimuove un elemento dalla lista
   

dove elemento può essere una variabile, può essere una componente di array ( VET(I) ) o una stringa ( "CIAO"). Per visualizzare tutte le componenti di un array, si userà dunque la seguente sintassi:

                  For I = 0 To N-1

                  listbox1.ITEMS.ADD (Vett(I))

                  next I

Le principali proprietà della ListBox:

• SelectedItem Contiene il valore dell'elemento puntato in quel momento dall'utente
• SelectedIndex Contiene il valore dell'indice corrispondente alla posizione dell'elemento puntato
• Items.Count Restituisce il numero degli elementi della lista (la sua dimensione)
• Sorted  è la proprietà che se impostata a True, ordina alfabeticamente gli elementi della lista, che mantengono questo ordine anche con l'inserimento di un elemento nella lista.

Queste proprietà, possono quindi essere utili se utilizzate come indici dell'array lista quando necessario.

La Combo Box appare come la combinazione di un text box e una lista. Questa funziona come la lista, con l'unica differenza che si può effettuare una scelta oltre che dall'elenco, digitando nel text box.

Quando si realizzano software utilizzando il linguaggio di programmazione Visual basic, può essere necessario prevedere un'interfaccia grafica costituita da più form. Visual studio .net, gestisce questi form considerandoli variabili, pertanto è necessario dichiarare per ciascun form del progetto, una variabile, secondo la seguente sintassi:

                  Public <nome variabile> as New <Nome Form>

Da notare che la parola riservata Dim tipica della dichiarazione delle variabili, è sostituita da Public. Questo perchè la variabile dichiarata deve essere pubblica, ovvero visibile da tutti i form del progetto.

Come tutte le variabili pubbliche, questa deve essere dichiarata in un apposita area appunto visibile a tutti i form, che viene definita MODULO.

Vediamo ora i passi necessari per inserire un modulo e un nuovo form in un progetto:

Dalla barra dei menu, selezionare PROGETTO - Aggiungi Windows Form / Aggiungi Modulo

un nuovo form/modulo verrà creato e potrà essere rinominato.

La finestra Modulo appare come un foglio bianco come la finestra del codice che già conosciamo.

Dunque dopo aver creato un secondo Form, che supponiamo abbiamo lasciato nominare di default Form2 si procede con la dichiarazione di tale form nel modulo:

                                           Module Module1

                                                       Public f1 As New Form1

                                                       Public f2 As New  Form2

                                            End Module

A questo punto sarà possibile prevedere per l'utente la possibilità di passare da un form all'altro predisponendo l'apposito codice. Per far apparire in primo piano un form, si deve utilizzare la seguente istruzione:

                                              f2.Show()

 Questa tradotta indica al secondo form dichiarato come F2 di essere mostrato a video. Il risultato sarà il seguente al cliccare del bottone :

Come si nota, è stato messo in primo piano il secondo form, ma il primo è comunque restato a video se pur in secondo piano. Per evitare il sovrapporsi di tutti i form, è necessario prima di mostrare un form, prima provvedere all'oscuramento dal video del form attivo, utilizzando l'istruzione:

                                                Me.Hide( )

Me indica l'oggetto attivo quindi nel nostro caso per l'appunto il form1. Il risultato dunque sarà il seguente:

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click

     Me.Hide()

     f2.Show()

End Sub

Questi due controlli sono molto utili in quanto permettono di rappresentare graficamente nel Form scelte opzionali da offrire all'utente. In particolare i radio button   sono utilizzati quando la scelta offerta all'utente è esclusiva ovvero, tra una serie di scelte l'utente può sceglierne una soltanto, escludendo automaticamente tutte le altre. Spesso utilizzando i radio button, i programmatori usano un altro controllo, il Group box che permette di raggruppare una serie di radio button in modo che su uno stesso form si possano prevedere più possibilità di scelte esclusive. In questo caso si procede prima col disegnare il group box, all'interno del quale verranno poi inseriti i radio button.

I Check box invece, si usano quando l'utente può scegliere più di una opzione ed utilizzando il metodo del "segno di spunta"  esprime un'opzione del tipo vero-falso. Questi appaiono così:

.

Accanto a ciascuno dei controlli su descritti, si può scrivere una descrizione dell'opzione impostando la proprietà text. La proprietà checked invece, che può assumere i valori true o false, indica rispettivamente se il controllo (radio ocheck) è selezionato o deselezionato.

Quando si devono risolvere problemi in cui le informazioni da elaborare devono essere conservate, le strutture già conosciute, come gli array, non bastano, infatti queste trattengono i dati solo fin quando è in esecuzione il programma, dunque allo spegnimento i dati caricati e manipolati negli array, si perdono. Nasce quindi la necessità di utilizzare i files che invece mantengono registrate le informazioni fino a quando l'utente stesso non deciderà di cancellarle. I Files vengono infatti memorizzati sulle memorie di massa, potremo quindi salvare le informazioni relative ai nostri contatti telefonici in un file su hard-disk, pendrive ecc.

Il metodo di organizzazione di un file, stabilisce la logica e le modalità con cui le informazioni sono memorizzate sui supporti fisici. I tipi di organizzazione sono:

• sequenziale
• Random ( ad accesso diretto)

In questa lezione proveremo a registrare le informazioni a riguardo dei nostri amici nome e numero di telefono in un file sequenziale, ove dunque le informazioni saranno registrate una di seguito all'altra, e potranno essere raggiunte solo scorrendole tutte dal principio alla fine.

       ...LEZIONE IN ALLESTIMENTO ...