vb_dot_net

http://guidepc.altervista.org

Visual Basic .NET: un nuovo linguaggio di programmazione

Visual Basic .NET uno dei linguaggi che fa parte della suite di sviluppo Visual Studio .NET: con essa Microsoft vuole segnare una svolta nel mondo della programmazione. E pare che le prerogative ci siano tutte: di questa famiglia di prodotti fa parte anche C#, il nuovo linguaggio che, secondo Microsoft, riesce a coniugare la semplicit di Visual Basic con la potenza propria del C++. La trattazione delle novit architetturali introdotte da Microsoft con Visual Studio .NET, come il Framework .NET, esula dagli obiettivi di questo corso, che si propone invece di analizzare nello specifico Visual Basic .NET: esso introduce talmente tanti cambiamenti rispetto alle versioni precedenti che da molti, e non a torto, considerato un nuovo linguaggio di programmazione piuttosto che un semplice aggiornamento.

Ora finalmente Visual Basic un linguaggio di programmazione orientato agli oggetti: ereditariet, polimorfismo e overloading non sono pi prerogative dei programmatori Java e C++. I tipi di dato sono stati modificati, per renderli conformi alle definizioni usate negli altri linguaggi; ad esempio, il tipo di dato Long stato sostituito da Integer (il vecchio Integer ora diventato Short). Anche per quanto riguarda la gestione degli errori, VB si ispirato a Java e C++, introducendo il costrutto Try Catch Finally. Un'altra importante novit il supporto nativo per la creazione e la gestione dei thread. La casella degli strumenti di VB, inoltre, stata ampliata includendo numerosi nuovi controlli utili, tra cui uno che permette di inserire un'icona nella System Tray, vicino all'orologio. I controlli per visualizzare le finestre di dialogo comuni e gli elementi dell'interfaccia di Windows, come la Toolbar, la Statusbar e la Listview, fanno ora parte dei componenti standard, cio sono utilizzabili senza dover ricorrere a controlli OCX aggiuntivi. La nuova versione di Visual Basic consente anche di creare applicazioni console, cio applicazioni eseguibili dalla riga di comando di MS-DOS. Come conseguenza di tutte queste innovazioni (e di molte altre che verranno analizzate in seguito), i progetti realizzati con le versioni precedenti di VB sono incompatibili con VB .NET , cio non possono essere aperti con quest'ultimo se non utilizzando una procedura di conversione che, per, nella maggior parte dei casi richiede anche degli interventi manuali. Anche il formato dei file, infatti, stato modificato: ora tutti i file che contengono il codice sorgente hanno estensione .vb. Per tale motivo non consigliabile cercare di aggiornare i propri programmi a VB .NET; al contrario, conveniente utilizzare questo linguaggio per la creazione dei nuovi software. In questo corso, rivolto a chi ha gi una minima conoscenza di Visual Basic, verranno analizzate ed esemplificate le principali novit di Visual Basic .NET, soprattutto rispetto alle versioni precedenti; non verranno invece trattate le nozioni di base, come il concetto di tipo di dato, la differenza tra funzioni e procedure, le strutture iterative, ecc. che hanno lo stesso significato che avevano nelle precedenti versioni di Visual Basic. Per maggiori informazioni su questi argomenti si rimanda pertanto al corso su Visual Basic.

I cambiamenti nei tipi di dato e nelle dichiarazioni Uno dei cambiamenti pi evidenti in Visual Basic .NET, rispetto alle versioni precedenti, riguarda i tipi di dato. Tale modifica si resa necessaria per rendere i tipi di dato di VB .NET formalmente uguali a quelli utilizzati in C# e in C++ (gli altri due linguaggi "principi" di Visual Studio .NET). Il tipo di dato Long stato sostituito da Integer, che quindi ora usato per la rappresentazione di numeri interi a 32 bit; il vecchio Integer di VB6 e delle versioni precedenti, usato per i numeri a 16 bit, diventato Short. In VB .NET il tipo Long serve per rappresentare i numeri a 64 bit. Comunque, per dichiarare questi tipi di dato, possibile utilizzare anche i nomi con cui sono identificati all'interno del framework: invece di Short di pu usare Int16, invece di Integer Int32 e al posto di Long Int64. Riassumendo, ad esempio:

Visual Basic 6 Visual Basic .NET

Dim I As Integer Dim I As Short oppure Dim I As Int16

Dim L As Long Dim L As Integer oppure Dim L As Int32


Relativamente alle espressioni booleane, bisogna evidenziare una importante novit. Utilizzando l'operatore Or tra due espressioni logiche: ad esempio A > 0 Or B = 5 , esse vengono sempre controllate entrambe, anche se, in realt, nel caso in cui A > 0 sia vera, non sarebbe necessario fare il controllo sulla B, dal momento che il risultato di tutta l'espressione sar comunque True. Per sopperire a tale mancanza, stato introdotto un nuovo operatore, OrElse: utilizzando quest'ultimo, A > 0 OrElse B = 5 , se la prima condizione vera la seconda non viene valutata. Analogamente, per quanto riguarda l'And, l'operatore AndAlso evita il controllo sulla seconda condizione se la prima falsa, poich il risultato finale sar sempre False. Le stringhe a lunghezza fis sa non sono pi supportate nel linguaggio. Non quindi pi possibile scrivere una dichiarazione come la seguente: Dim S As String * 10 La nuova versione del linguaggio introduce delle novit anche per quanto riguarda l'area di validit delle variabili: ora le variabili sono locali rispetto alla porzione di codice in cui vengono definite. Se, ad esempio, si dichiara una variabile all'interno di un ciclo For, essa non sar pi utilizzabile una volta usciti dal ciclo stesso. Si verifica quindi la seguente situazione: Dim I As Short For I = 0 To 10 Dim N As Integer .... Next I MsgBox("Il valore di N : " & N & ".") 'Errato: la variabile N non pi utilizzabile. Il tipo Currency stato eliminato; al suo posto possibile usare il nuovo tipo Decimal per i calcoli monetari e per calcoli a virgola fissa in cui la precisione riveste un'importanza particolare. Il tipo di dati Variant non esiste pi: al suo posto necessario usare il tipo Object, che comunque conserva tutte le caratteristiche del Variant , quindi pu essere utilizzato per memorizzare qualsiasi tipo di dato primitivo, nonch Empty, Null, Nothing, oppure come puntatore ad un oggetto. Anche la gestione degli array cambiata: ora gli array possono essere solo a base 0; non quindi pi possibile specificarne il limite inferiore. Un effetto collaterale di questa modifica che l'istruzione Option Base 1 non esiste pi. I tipi definiti dall'utente ora non si creano pi con il costrutto Type; al suo posto stata introdotta la parola chiave Structure. Ogni elemento all'interno della struttura deve essere dichiarato con Dim, Event, Friend, Private, o Public (ritorneremo su queste parole chiave pi avanti, quando parleremo delle classi in VB .NET). Ad esempio:

Visual Basic 6 Visual Basic .NET Public Type IMPIEGATO Nome As String Matricola As String End Type

Public Structure IMPIEGATO Dim Nome As String Dim Matricola As String End Structure

Una novit significativa introdotta dalle Structure di VB .NET la possibilit di definire Sub, Function e Property all'interno di una struttura. Riprendendo l'esempio sopra riportato, possibile aggiungere una Sub alla struttura IMPIEGATO che visualizzi una finestra contente le informazioni contenute nella struttura stessa: Public Structure IMPIEGATO Dim Nome As String Dim Matricola As String Sub Informazioni() 'Visualizza una MessageBox che contiene le informazioni contenute nella struttura. MsgBox("Nome dell'impiegato: " & Nome & vbCrLf & "Matricola: " & Matricola, MsgBoxStyle.Information) End Sub


End Structure Un utilizzo di questa struttura il seguente: Dim I As IMPIEGATO With I .Nome = "Marco Minerva" .Matricola = "232440" .Informazioni() 'Richiama la Sub definita nella struttura. End With Altre novit importanti sono state introdotte da VB .NET relativamente alla dichiarazione di costanti, variabili, procedure e funzioni. Innanzi tutto, finalmente possibile inizializzare una variabile nella sua dichiarazione. Ad esempio, sono valide le dichiarazioni seguenti: Dim Punti As Short = 10 Dim Nome As String = "Pippo" Nelle precedenti versioni di Visual Basic, se non diversamente specificato, i parametri di una funzione o di una procedura venivano passati per riferimento; in pratica, la parola chiave ByRef era predefinita. In VB .NET, invece, per default gli argomenti sono passati ad una funzione per valore (ByVal ); utilizzando l'editor di Visual Studio .NET, se nella dichiarazione di una Sub o di una Function non si specifica altrimenti, davanti ai nomi degli argomenti verr automaticamente aggiunto ByVal. Infine, se un parametro di una funzione dichiarato come Optional , obbligatorio specificare il valore che tale parametro assumer nel caso in cui non venga specificato quando si richiama la funzione stessa. Ad esempio:

Visual Basic 6 Visual Basic .NET

Private Sub DoSomething(frm As Form, Optional I As Integer) End Sub

Private Sub DoSomething(ByVal frm As Form, Optional ByVal I As Short = -1) End Sub

Un'ultima nota riguarda il modo di restituire un valore di una Function. Nelle precedenti versioni di Visual Basic, per restituire un valore era necessario scrivere = valore. In VB .NET, oltre a questo metodo, stato aggiunta la parola chiave Return, analoga a quanto gi esistente in C e in Java. Queste due funzioni sono quindi equivalenti: Private Function AreaTriangolo(ByVal Base As Double, ByVal Altezza As Double) As Double AreaTriangolo = (Base * Altezza) / 2 End Function Private Function AreaTriangolo(ByVal Base As Double, ByVal Altezza As Double) As Double Return (Base * Altezza) / 2 End Function L'unica differenza che, eseguendo l'istruzione Return, si uscir automaticamente della funzione. In altre parole, l'istruzione Return dell'esempio precedente equivale a: AreaTriangolo = (Base * Altezza) / 2 Exit Function

Utilizzo di classi in VB .NET Alla base di ogni linguaggio di programmazione orientato agli oggetti c' il concetto di classe. Chi ha gi usato le versioni precedenti di Visual Basic assocer immediatamente il concetto di classe a quello di modulo di classe. In effetti, le classi di VB .NET mantengono tutte le caratteristiche dei moduli di classe, ma ne aggiungono numerose altre (come verr evidenziato meglio nelle prossime Lezioni). In prima approssimazione, una classe una collezione di variabili, metodi e propriet; possibile creare una classe usando il costrutto Class:


Class Test Dim Nome As string 'Altre variabili. Public Sub VisualizzaNome() '... End Sub End Class Una classe anche un tipo, quindi pu essere assegnata ad una variabile: Dim Prova As New Test() 'La variabile Prova contiene un'istanza della classe Test. E' da notare l'uso della parola chiave New, necessaria perch la variabile che stiamo definendo si riferisce ad un oggetto (come in Visual Basic 6, infatti, le istanze degli oggetti sono create con New). Fatto questo, possibile utilizzare la classe utilizzando la comune sintassi di Visual Basic. Ad esempio: Prova.VisualizzaNome() L'evento Iniziatialize, generato quando si crea un'istanza della classe, non esiste pi: al suo posto possibile definire un costruttore della classe, cio un metodo che viene automaticamente richiamato quando si crea un'istanza della classe stessa; una delle caratteristiche pi importanti del costruttore che esso consente di specificare le propriet iniziali della classe (in questo senso pi versatile dell'evento Initialize). Il costruttore una particolare Sub il cui nome deve obbligatoriamente essere New. Riprendendo l'esempio precedente, vediamo come creare un costruttore per la classe Test: Class Test Dim Nome As string 'Altre variabili. Sub New(ByVal strNome As String) 'Imposta le propriet iniziali. Nome = strNome End Sub Public Sub VisualizzaNome() '... End Sub End Class Come possiamo vedere, la routine New prende come argomento la variabile strNome e la assegna alla sua variabile interna Nome. E' possibile definire un oggetto di tipo Test utilizzando il suo costruttore: Dim Prova As New Test("Marco") Mentre le Sub e le Function sono rimaste sostanzialmente immutate, la creazione di propriet di una classe diversa rispetto alle versioni precedenti. In VB6 si usavano due metodi, Property Set e Property Let, rispettivamente per assegnare e recuperare il valore di una propriet. In VB .NET, invece, stato tutto riunito in un unico metodo, che include sia il codice per recuperare sia quello per impostare il valore di una propriet; ad esempio: Public Property NomeUtente() As String Get Return Nome End Get Set(ByVal Value As String) Nome = Value End Set End Property Come si vede, questa propriet composta da due parti: il blocco Get, delimitato da Get End Get, e il blocco Set (Set End Set) . A parte queste differenze sintattiche, il comportamento dei due blocchi quello che ci si aspetta: con Get si restituisce il valore della propriet, mentre con Set si specifica un valore per essa. L'utilizzo di una propriet cos creata rimane lo stesso. Nella definizione di una routine, oltre a Public o Private , in VB .NET possibile usare, tra le altre, la nuova parola chiave Protected ; per maggiori informazioni sulle altre parole chiave si consiglia di consultare la Guida in linea di Visual Basic .NET. Definendo una routine di una classe come Public, essa sar visibile da tutti le istanze di quella classe; se, invece, si usa la parola chiave Private, tale routine non sar utilizzabile all'esterno della classe. Ad esempio:


Public Class Test '... '... Public Sub VisualizzaData() '... End Sub Private Function Formatta() As String '... End Function End Class Dim Prova As New Test() Prova.VisualizzaData() 'Corretto. Prova.Formatta() 'Errato: non possibile accedere alla funzione Formatta, perch Private. Infine, dichiarando una routine della classe Test come Protected, essa sar visibile a tutte le classi che ereditano da Test (questo concetto verr chiarito meglio nelle prossime Lezioni, quando si affronteranno i concetti di ereditariet, polimorfismo e overloading); questa routine non potr per essere utilizzata dalle istanze della classe. In pratica, Protected equivale a Private, con la differenza che il metodo visibile anche alle classi che ereditano da quella principale. Pi classi possono essere raggruppate in un unico Namespace. Ad esempio: Namespace Test Class Test1 '... End Class Class Test2 '... End Class End Namespace Con questo costrutto, per dichiarare un oggetto di tipo Test1 necessario scrivere, ad esempio: Dim Prova1 As New Test.Test1() Analogamente, per oggetti di tipo Test2: Dim Prova2 As New Test.Test2() Fatto questo, possibile accedere ai metodi ed alle propriet delle classi Test1 e Test2 nel modo consueto. I namespace sono sempre Public, mentre i componenti all'interno possono essere Public o Friend (impostazioni predefinita). E' possibile definire un namespace dentro un altro, ad esempio: Namespace N1 Namespace N2 Class Test1 '... End Class Class Test2 '... End Class End Namespace End Namespace Dim Prova1 As New N1.N2.Test1() Dim Prova2 As New N1.N2.Test2() Tutte le classi che compongono la piattaforma .NET sono organizzate in namespace. Ad esempio, la classe Form, da cui ereditano tutti i Windows form (argomento della Lezione 8) raggiungibile nel namespace Windows.System.Forms.Form. A questo punto si hanno tutti gli strumenti necessari per analizzare le caratteristiche di VB .NET che ne fanno un linguaggio di programmazione orientato agli oggetti: nelle prossime Lezioni parleremo di ereditariet, polimorfismo ed overloading.


Ereditariet Abbiamo detto pi volte che Visual Basic .NET un linguaggio di programmazione orientato agli oggetti. Avendo bene in mente il concetto di classe, analizziamo le caratteristiche fondamentali di questo paradigma di programmazione: ereditariet, polimorfismo ed overloading. Si definisce ereditariet la possibilit per una classe (detta classe derivata) di derivare da un'altra (la classe base), in modo tale che il tipo derivato possa utilizzare le variabili, i metodi, ecc. del tipo base. La parola chiave utilizzata per creare una relazione di eredit Inherits; questa istruzione deve obbligatoriamente essere sulla prima riga di codice dopo la definizione della classe. Si consideri l'esempio seguente: Public Class Persona Protected sNome As String Private iTelefono As Integer '... Public Property Nome() As String Get Return sNome End Get Set(ByVal Value As String) sNome = Value End Set End Property End Class Public Class Impiegato Inherits Persona Private sMatricola As String '... Public Property Matricola() As String Get Return sMatricola End Get Set(ByVal Value As String) sMatricola = Value End Set End Property End Class In questo stralcio di codice la classe Impiegato eredita dalla classe Persona: questo significa che nella classe Impiegato possibile utilizzare tutto ci che in Persona stato definito come Public, Protected o Friend, sia esso una variabile, una Sub, una Function o una Property. Ad esempio, all'interno di Impiegato possibile utilizzare sia la variabile sNome sia la propriet Nome, mentre la variabile iTelefono non visibile. Provando a dichiarare oggetti di tipo Persona e Impiegato, si ottiene quanto segue: Dim Imp As New Impiegato() Imp.Matricola = "389321" 'Corretto: Matricola una property della classe impiegato. Imp.Nome = "Marco" 'Corretto: Nome una property che la classe Impiegato eredita da Persona. Dim Pers As New Persona() Pers.Nome() = "Marco" 'Corretto: Matricola una property della classe Persona. Pers.Matricola = "389321" 'Errato: la property Matricola non visibile alla classe Persona. Se ora commentia mo la riga Inherits Persona nella classe Impiegato, otterremo un messaggio di errore relativo all'istruzione Imp.Nome = "Marco", dal momento che abbiamo eliminato l'ereditariet.

Polimorfismo l termina polimorfismo indica la possibilit di definire all'interno di pi classi metodi e propriet con lo stesso nome, in modo che, ad esempio, una classe derivata possa ridefinire un metodo della classe base con lo stesso nome. Vediamo subito un esempio di quanto detto:


Public Class ProdottoBase Private Const dIVA As Decimal = 0.2 '... Public Overridable Function IVA(ByVal Prezzo As Decimal) As Decimal 'Calcola l'IVA sul prezzo specificato. Return (Prezzo * dIVA) End Function End Class Public Class AltroProdotto Inherits ProdottoBase Private Const dIVA As Decimal = 0.18 Private Const Tassa As Decimal = 0.1 'Tassa sul prodotto. '... Public Overrides Function IVA(ByVal Prezzo As Decimal) As Decimal 'Calcola l'IVA sul prezzo specificato e aggiunge la tassa sul prodotto. Return (Prezzo * dIVA) + (Prezzo * Tassa) End Function End Class Notiamo che la Function IVA definita sia nella classe ProdottoBase sia nella classe AltroProdotto , che eredita da ProdottoBase. Il comportamento della funzione, tuttavia, diverso, dal momento che in AltroProdotto all'IVA viene aggiunta una tassa. A seconda che si dichiari un oggetto di tipo ProdottoBase o di tipo AltroProdotto, verr richiamata la funzione IVA corrispondente. Per fare questo abbiamo usato il polimorfismo; la funzione IVA nella classe base stata dichiarata usando la parola chiave Overridable: con essa si indica a Visual Basic che possibile avere un'altra definizione per la stessa funzione in una classe derivata. In AltroProdotto, infatti, IVA stata definita specificando Overrides: in tal modo si dice che tale funzione sovrascrive un metodo con lo stesso nome che stato definito nella classe base. C' anche un altro modo per sfruttare il polimorfismo, ovvero usando la parola chiave Shadows che, letteralmente, nasconde una definizione della classe base con lo stesso nome. L'esempio sopra riportato, usando Shadows, diventa: Public Class ProdottoBase Public Function IVA(ByVal Prezzo As Decimal) As Decimal ' End Function End Class Public Class AltroProdotto Inherits ProdottoBase Public Shadows Function IVA(ByVal Prezzo As Decimal) As Decimal ' End Function End Class Come si vede, nella classe base la parola chiave Overridable sparita, mentre in AltroProdotto la Function IVA preceduta da Shadows . E' importante notare che, usando la coppia Overridable e Overrides, il metodo che sovrascrive una routine della classe base deve avere non solo lo stesso nome, ma anche lo stesso numero di argomenti e dello stesso tipo. Invece, usando Shadows, possibile ridefinire un metodo modificandone il tipo, il numero di argomenti, ecc; con Shadows si pu addirittura nascondere una variabile della classe base con un intero metodo nella classe derivata. Questa rapida panoramica sul polimorfismo non pu coprire tutti gli aspetti della tematica, per approfondire i quali si rimanda alla Guida in linea. I concetti forniti sono comunque pi che sufficienti per utilizzare con successo il polimorfismo nei proprio programmi. Strettamente collegato con il polimorfismo l'overloadi ng, altra importante caratteristica dei linguaggi di programmazione orientati agli oggetti, che sar discussa nella prossima Lezione.


Overloading Overloading L'overloading , letteralmente sovraccaricamento, la possibilit di definire pi versioni di una procedura, utilizzando lo stesso nome ma un numero e/o un tipo diverso di argomenti: in fase di esecuzione, sulla base degli argomenti effettivamente passati alla routine, verr richiamata la procedura corretta; nella Guida in linea di Visual Basic sono specificati con precisione i passi che il compilatore esegue per risolvere l'overloading, cio per determinare qual la routine corretta da richiamare. Cerchiamo con un esempio di capire come funziona l'overloading: Public Class Test '... Public Sub Prova(ByVal Nome As String) MsgBox("Il nome specificato : " & Nome & ".") End Sub Public Sub Prova(ByVal Numero As Integer) MsgBox("Il numero specificato : " & Numero & ".") End Sub End Class Le due definizioni della Sub Prova differiscono per il tipo dell'argomento: String nel primo caso, Integer nel secondo. Se ora creiamo un'istanza della classe e proviamo a richiamare la routine Prova, otteniamo: Dim T As New Test() T.Prova("Marco") 'Visualizza il messaggio "Il nome specificato : Marco." T.Prova(104) 'Visualizza il messaggio "Il numero specificato : 104." Per indicare che una routine sfrutta l'overloading , ovvero che sono presenti pi definizioni per la stessa, si dovrebbe specificare la parola chiave Overloads, nel modo seguente: Public Overloads Sub Prova(ByVal Nome As String) Public Overloads Sub Prova(ByVal Numero As Integer) Tuttavia, il parametro Overloads predefinito, quindi anche omettendolo (come abbiamo fatto nella classe di esempio sopra riportata), Vis ual Basic sar in grado di gestire correttamente l'overloading. Un utilizzo classico dell'overloading nella definizione di un costruttore per una classe (abbiamo parlato del costruttore quando abbiamo introdotto il concetto di classe, nella Lezione 3). Supponiamo di avere una classe Giocatore, che, tra le altre cose, contiene il nome del giocatore: si vorrebbe dare la possibilit di definire il nome del giocatore nel momento in cui si crea un'istanza della classe; se il nome non viene specificato, dovrebbe essere impostato su "Anonimo". E' possibile realizzare quanto detto con l'overloading del costruttore: Public Class Giocatore Private NomeGiocatore As String Sub New() NomeGiocatore = "Anonimo" End Sub Sub New(ByVal sNome As String) NomeGiocatore = sNome End Sub '... End Class Supponiamo inoltre di avere una Property Nome che restituisce il nome del giocatore. Stando cos le cose, creando un'istanza della classe otterremo, ad esempio: Dim G As New Giocatore() 'Non si specifica il nome del giocatore: verr richiamato il costruttore "New()". MsgBox(G.Nome) 'Visualizza "Anonimo". Dim G2 As New Giocatore("Marco") 'Si specifica il nome del giocatore: verr richiamato il costruttore '"New(ByVal sNome As String)". MsgBox(G2.Nome) 'Visualizza "Marco". Notiamo che, nel caso di overloading del costruttore, non si deve mai utilizzare la parola chiave Overloads , altrimenti si


ottiene un messaggio di errore. Ora che abbiamo analizzato le principali novit di Visual Basic .NET, finalmente possibile cominciare ad utilizzare nella pratica questo linguaggio: nella prossima Lezione verr introdotto brevemente il nuovo ambiente di sviluppo di Visual Studio.

Il nuovo ambiente di sviluppo Sebbene sia possibile creare applicazioni VB .NET utilizzando un qualsiasi editor di testo e il compilatore da riga di comando che Microsoft distribuisce gratuitamente sul proprio sito Internet, Visual Studio .NET offre una serie di strumenti che permettono di incrementare molto la produttivit: consente di realizzare applicazioni in modo grafico, semplicemente trascinando e posizionando sul form gli elementi che si vogliono usare, dispone di tecnologie come il completamento automatico per velocizzare la scrittura del codice, ecc. Il nuovo ambiente di sviluppo di Microsoft, denominato Microsoft Development Environment, presenta cambiamenti significativi rispetto alle versioni precedenti di Visual Studio: ora un ambiente integrato che racchiude gli editor per tutti i linguaggi di programmazione supportati dalla piattaforma .NET. E' possibile realizzare applicazioni utilizzando pi linguaggi all'interno della stessa soluzione (vedremo pi avanti cosa si intende per "soluzione").

I diversi linguaggi di programmazione condividono anche la stessa organizzazione dei file sorgenti: essa risulter familiare a chi ha gi usato le precedenti versioni di Visual Studio, mentre potrebbe inizialmente disorientare coloro che hanno programmato solo con Visual Basic; in realt possibile trovare alcuni parallelismi tra l'organizzazione dei file di VB 6 e quella di Visual Studio .NET. Come gi accennato nella prima lezione, i file sorgente di VB .NET hanno tutti estensione .vb, indipendentemente dal fatto che siano form, moduli o moduli di classi. I sorgenti di una stessa applicazione sono raggruppati in progetti , proprio come nelle precedenti versioni. Infine, pi progetti possono essere inseriti all'interno della stessa soluzione, concetto che si avvicina abbastanza al gruppo di progetti di VB 6; la differenza sta nel fatto che nella medesima soluzione possibile includere progetti realizzati con diversi linguaggi di programmazione. Avviando per la prima volta Visual Studio .NET, verranno visualizzate nella parte centrale della finestra una serie di opzioni utili per personalizzare l'ambiente di sviluppo; esse saranno comunque accessibili anche in futuro all'interno della finestra Opti ons (Opzioni), raggiungibile con un clic sul menu Tools (Strumenti). Dopo aver effettuato le personalizzazioni del caso, facendo clic sul pulsante New Project (Nuovo progetto), verr visualizzata la finestra di dialogo omonima in cui, sulla sinistra, visibile una lista ad albero con una voce principale per ogni tipo di

progetto che possibile realizzare con Visual Studio .NET.

Selezionando Visual Basic projects (Progetti Visual Basic) sulla destra comparir l'elenco dei tipi di applicazioni Visual Basic: Windows Application (Applicazione Windows) corrispondente all'EXE Standard delle versioni precedenti. In questa stessa finestra anche possibile specificare il nome dell'applicazione e la posizione in cui salvarla. Accettiamo le impostazioni di default con un clic sul pulsante OK; verr creata un'applicazione per Windows composta da un Windows form: con questo termine si indica l'evoluzione del classico form di Visual Basic (la Windows form sar argomento della prossima Lezione). La struttura dei file che compongono la soluzione dovrebbe risultare simile a quella raffigurata nella figura seguente:

La finestra mostrata il Solution Explorer, che funziona in modo analogo alla Gestione progetti delle precedenti versioni di Visual Basic.


Facendo doppio clic sul nome della form (Form1.vb) sar visualizzata la finestra per l'immissione del codice sorgente; in alternativa al doppio clic possibile premere il tasto F7. L'editor del codice di Visual Basic .NET presenta innovazioni significative rispetto alle versioni precedenti, tutte rivolte all'aumento della produttivit dello sviluppatore. Tra le nuove funzioni si segnalano in particolare l'indentazione automatica del codice durante la digitazione e la "chiusura automatica" dei costrutti, per cui, ad esemp io, se si scrive un condizione If e si preme il tasto Invio, l'editor aggiunger la clausola End If e posizioner il cursore nella posizione corretta per la scrittura del codice facente parte dell'If stesso. Altre novit importanti sono relative all'organizzazione del codice sorgente: ora le varie parti del codice possono essere collassate ed espanse facendo clic rispettivamente sul simbolo - (meno) e + (pi) che viene automaticamente visualizzato a destra delle dichiarazione di un metodo, di un insieme di righe di commento, ecc. Inoltre, attraverso il nuovo costrutto #Region... #End Region possibile organizzare logicamente porzioni di codice che svolgono operazioni correlate. Ad esempio, all'interno di una classe: #Region " Matematica " Private Function Somma(ByVal A As Double, ByVal B As Double) As Double Return A + B End Function Private Function Sottrazione(ByVal A As Double, ByVal B As Double) As Double Return A - B End Function #End Region Scrivendo questo codice, accanto alla riga #Region " Matematica " comparir il segno - (meno); se ora proviamo a fare clic su tale simbolo, tutta la sezione di codice compresa in questa regione verr collassata nell'unica riga " Matematica ". Le novit di Visual Studio .NET non si fermano qui: anche possibile personalizzare l'ambiente di sviluppo tramite macro scritte con Visual Basic for Applications, utilizzando un editor analogo a quello disponibile in Office. La Lista dei task, inoltre, oltre a visualizzare gli errori presenti nel programma, consente di definire delle annotazioni all'interno del codice in modo da evidenziare, ad esempio, i punti da correggere, quelli da rivedere, le modifiche effettuate, ecc. Facendo doppio clic sull'annotazione visualizzata in questa finestra, verr automaticamente selezionata la riga di codice corrispondente. La Windows form parte prima Visual Basic .NET introduce un nuovo oggetto, la Windows form, che prende il posto del form delle versioni precedenti; i cambiamenti riguardano in particolare le funzionalit, le nuove caratteristiche e i nuovi metodi supportati. Le Windows form sono il componente fondamentale della piattaforma Microsoft .NET, rispondendo a quelli che sono i requisiti del paradigma della programmazione orientata agli oggetti. Esse consentono di sfruttare in maniera estremamente semplice tutte le caratteristiche di Windows 2000 e XP. Per utilizzare le Windows form necessario creare una Windows Application (Applicazione Windows), come abbiamo visto. Per aggiungere nuove form al progetto, fare clic con il tasto destro del mouse sul nome del progetto all'interno del Solution Explorer e scegliere Add (Aggiungi), quindi selezionare Add Windows form (Aggiungi Windows form). La Windows form concettualmente molto diversa dalla form di Visual Basic 6. Innanzi tutto nel codice di una Windows form possiamo notare la Sub New, che come abbiamo detto definisce il costruttore della classe: una Windows form, infatti, prima di tutto una classe, quindi per essa valgono tutte le considerazioni fatte in precedenza. Da notare che tale Sub non direttamente visibile nel codice, ma contenuta all'interno della regione Windows form designer generated code (Codice generato dal Windows form designer). Sotto la definizione della form, Public Class Form1 , compare l'istruzione Inherits System.Windows.Forms.Form: si tratta della classe base da cui ereditano tutte le Windows form. Essa fa parte della base class library, la libreria classi base di .NET. Come si pu vedere da tale istruzione, la classe Form contenuta nel namespace System.Windows.Forms . Altra novit rispetto alle versioni precedenti di Visual Basic la routine InitializeComponent, che contiene la definizione e le propriet di tutti gli elementi dell'interfaccia della form: mentre prima tali informa zioni erano contenute nell'intestazione del file .frm e non erano direttamente modificabili da Visual Basic, ora sono chiaramente visibili aprendo il codice della Windows form all'interno di Visual Studio .NET. La routine New pu essere usata per replicare le funzionalit dell'evento Form_Initialize, scrivendo il proprio codice dopo la chiamata a InitializeComponent. Facendo doppio clic sulla form, verr aperto l'editor del codice all'interno della routine Form1_Load, il cui significato lo stesso che aveva in VB 6. Dopo la lista degli argomenti dell'evento, di cui parleremo tra breve, si pu notare un nuovo


costrutto: Handles MyBase.Load. Con questa istruzione si indica a Visual Basic che la routine appena dichiarata gestisce l'evento Load del form; MyBase una parola chiave che permette di riferire la classe in cui ci si trova attualmente (abbiamo infatti detto che la Windows form una classe) . La conseguenza di questa novit che i nomi degli eventi in VB .NET non sono pi vincolati: possibile creare Sub con qualsiasi nome, a patto naturalmente che prevedano la corretta lista degli argomenti, e poi associarli a determinati eventi con il costrutto Handles oggetto.evento. Ad esempio, l'evento Load del form potrebbe essere gestito da una Sub Avvio cos definita: Private Sub Avvio(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load MsgBox("Hello World!") End Sub

Dopo aver scritto questo codice, eseguiamo il programma, premendo come di consueto il tasto F5: se non ci sono stati errori di digitazione, verr visualizzata la seguente finestra:

E' importante notare una cosa: a causa di un bug di Visual Studio .NET, potrebbe succedere che, premendo il tasto F5, il programma venga compilato ma non eseguito. In questo caso

sufficiente premere il tasto , quindi il tasto per avviare correttamente il programma. Vediamo ora le differenze negli argomenti inviati ad un evento. Innanzi tutto, in VB .NET tutti gli eventi prevedono degli argomenti, a differenza di quanto avveniva nelle versioni precedenti di Visual Basic, in cui eventi del tipo Form_Click e lo stesso Form_Load non avevano alcun argomento. Il primo argomento sempre di tipo System.Object e permette di identificare l'oggetto che ha generato l'evento: questa informazione utile, ad esempio, perch con la parola chiave Handles possibile associare pi oggetti alla stessa routine. Ad esempio, inseriamo due pulsanti sulla form, quindi premiamo il tasto F7 per visualizzare il codice del form e scriviamo: Private Sub Clic(ByVal sender As Object, ByVal e As EventArgs) Handles Button1.Click, Button2.Click If sender.Equals(Button1) Then MsgBox("E' stato fatto clic sul pulsante Button1.") ElseIf sender.Equals(Button2) Then MsgBox("E' stato fatto clic sul pulsante Button2.") End If End Sub La lista degli argomenti richiesti da un certo evento disponibile nella Guida in linea di Visual Basic .NET. Dopo la parola chiave Handles sono stati specificati due eventi, separati da una virgola; in generale, possibile specificarne un numero arbitrario, a patto che richiedano gli stessi argomenti. Poich la Sub Clic viene generata indifferentemente quando si fa clic su Button1 o su Button2 , necessario usare l'oggetto sender per sapere quale dei due pulsanti stato in realt premuto; per fare questo, si usa il metodo Equals dell'oggetto, che prende come argomento un altro oggetto e restituisce True se i due oggetti sono uguali. Il secondo argomento, nel caso dell'evento Load, di tipo EventArgs, anche se a seconda del tipo di evento pu essere diverso; ad esempio, nel caso degli eventi KeyDown, KeyUp, di tipo System.Windows.Forms.KeyEventArgs. Esso contiene informazioni di vario genere, dipendenti dal particolare tipo di evento a cui si riferisce. Per fare un esempio, proviamo a intercettare l'evento KeyPress della form; Innanzi tutto posizioniamoci sull'evento relativo. All'interno della finestra del codice, fare clic sulla ComboBox in alto a sinistra e selezionare (base class events): tale categoria raggruppa tutti gli eventi della classe base; fatto questo, nel ComboBox in alto a destra comparir la scritta (Declarations): fare clic su quest'ultima e scorrere l'elenco fino a selezionare l'evento KeyPress. All'interno dell'editor verr automaticamente aggiunta la seguente Sub per gestire l'evento: Private Sub Form1_KeyPress(ByVal sender As Object, ByVal e As System.Windows.Forms.KeyPressEventArgs) Handles MyBase.KeyPress End Sub Supponiamo di voler stampare un messaggio diverso a seconda che si digiti una consonante o una vocale. Il codice : Private Sub Form1_KeyPress(ByVal sender As Object, ByVal e As System.Windows.Forms.KeyPressEventArgs) Handles MyBase.KeyPress Select Case e.KeyChar

Case "A", "E", "I", "O", "U", "a", "e", "i", "o", "u" MsgBox("E' stata digitata una vocale.")


Case Else MsgBox("E' stata digitata una consonante.") End Select End Sub L'oggetto e, di tipo KeyPressEventArgs, contiene informazioni sul carattere premuto; in particolare, la propriet KeyChar restituisce il carattere che stato digitato. Quanto detto relativamente agli eventi valido per la form, ma pi in generale per tutti i controlli di Visual Basic .NET. Nella prossima Lezione continueremo l'analisi delle principali novit introdotte dalla Windows form.

La Windows form parte seconda Continuiamo la nostra breve analisi delle nuove caratteristiche della Windows form di VB .NET. Una delle cose pi importanti da notare che la propriet Caption stata rinominata in Text. Pi in generale, le propriet Caption di tutti i controlli sono state sostituite dalla propriet Text; a parte il nome diverso, comunque, le due propriet sono assolutamente analoghe. Abbiamo detto che una Windows form una classe: quindi possibile creare oggetti di tipo form e lavorare con essi come con qualunque altro oggetto. In particolare, quando si vuole aprire una form sopra un altro, necessario prima dichiarare un oggetto che abbia come tipo la form da visualizzare. Cerchiamo di spiegare meglio questo concetto con un esempio. Dopo aver creato una nuova soluzione aggiungiamo un secondo form al progetto corrente, oltre a quello che viene creato di default (e che ha nome Form1). Per fare questo, fare clic con il tasto destro del mouse sul nome del progetto all'interno del Solution Explorer e scegliere Add (Aggiungi), quindi selezionare Add Windows form (Aggiungi Windows form). Confermare le impostazioni della finestra di dialogo Add New Item (Aggiungi nuovo elemento) con un clic sul pulsante Open (Apri). Il nome del nuovo form Form2. Ora aggiungiamo un pulsante sul Form1: l'oggetto CommandButton stato rinominato in Button; impostiamone la propriet Text su "Apri secondo form". Facciamo quindi doppio clic sul pulsante per generare la routine che gestisce l'evento clic e scriviamo il codice seguente: Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click Dim frm As New Form2() 'Visualizza il Form2. frm.ShowDialog() End Sub La prima dichiarazione definisce un nuovo oggetto frm di tipo Form2 e, tramite la parola chiave New, ne crea una nuova istanza. L'istruzione successiva richiama il metodo ShowDialog di frm: esso corrisponde, nelle precedenti versioni di Visual Basic, al metodo Show con il parametro vbModal , cio visualizza il Form2 e blocca l'esecuzione di Form1 finch Form2 non viene chiuso. Invece, se vi vuole visualizzare il Form2 senza fermare Form1, necessario richiamare il metodo Show di frm. L'evento QueryUnload stato rinominato in Closing . Mentre in VB6, per annullare la chiusura della form, era necessario impostare su True la variabile Cancel che faceva parte degli argomenti di QueryUnload, per ottenere lo stesso effetto in VB .NET si deve agire sulla propriet e.Cancel, come potete osservare dall'esempio seguente: Private Sub Form1_Closing(ByVal sender As Object, ByVal e As System.ComponentModel.CancelEventArgs) Handles MyBase.Closing 'Annulla la chiusura del form. e.Cancel = True End Sub Per chiudere una form necessario richiamare il metodo Close della form stessa. Ad esempio, per fare in modo che premendo il pulsante Button1 la finestra venga chiusa, si deve scrivere il codice seguente: Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click Me.Close() End Sub La Windows form introduce numerose nuove propriet, consentendo di realizzare facilmente operazioni che prima erano possibili sono utilizzando le API di Windows, come impostare le dimensioni massima e minima della finestra (per determinare le quali sono disponibili rispettivamente le propriet MaximumSize e MinimunSize). Non essendo possibile analizzarle tutte, ci limiteremo ad illustrare le pi importanti e quelle che hanno subito cambiamenti rispetto alla versione precedenti di Visual Basic.

Innanzi tutto, le propriet AcceptButton e CancelButton consentono di impostare il pulsante il cui codice si vuole venga eseguito, rispettivamente, quando si premono i


tasti Invio oppure Esc. In pratica, queste due propriet sostituiscono le precedenti Accept e Cancel del controllo CommandButton . Per impostare tali propriet, fare clic sulla freccia posta sulla destra di AcceptButton oppure CancelButton nella finestra delle Propriet: verr visualizzata una lista da cui possibile selezionare il pulsante che si vuole associare. La propriet BorderStyle stata rinominata in FormBorderStyle, ma a parte il cambiamento di nome non ha subito altre modifiche. La propriet Menu consente di impostare un menu per il form. Anche il menu e i comandi di menu, infatti, in VB .NET sono trattati come oggetti. Questa propriet viene esposta perch possibile definire pi oggetti di tipo Menu nell'applicazione, visualizzando di volta in volta quello opportuno, ad esempio in risposta a determinate azioni dell'utente. I menu in VB .NET saranno trattati nella Lezione 13. Opacity consente di imp ostare la percentuale di trasparenza della form. La propriet StartUpPosition stata rinominata in StartPosition; la propriet CenterOwner ora si chiama CenterParent . TransparentKey permette di definire un colore che apparir trasparente quando verr disegnato sulla form. Ci sono poi altre nuove propriet supportate dalla form e dai controlli standard. Analizziamo anche in questo caso le pi significative. La propriet BackgroundImage consente di impostare un'immagine di sfondo. Se il file selezionato ha dimensioni inferiori a quelle del form, verr automaticamente affiancato fino a coprire l'intera finestra. La propriet Cursor sostituisce la propriet MousePointer. Per impostare un cursore necessario utilizzare la classe Cursors , come mostrato nell'esempio seguente: Me.Cursor = Cursors.WaitCursor 'Imposta la clessidra. Me.Cursor = Cursors.Default 'Ripristina il puntatore predefinito. Una propriet completamente nuova ContextMenu, con cui possibile associare un menu contestuale alla form, cio un menu che viene automaticamente richiamato quando si fa clic sulla form con il tasto destro del mouse. Ritorneremo su questo argomento quando parleremo della nuova gestione dei menu in VB .NET, nella Lezione 13. Ora che abbiamo preso familiarit con la Windows form, possiamo analizzare le novit dei controlli standard di VB .NET, che saranno trattate a partire dalla prossima Lezione.

TextBox Non possiamo descrivere in questa sede tutti i controlli di Visual Basic .NET; i soli controlli standard, infatti, sono almeno 45, contro i 20 di Visual Basic 6. Di conseguenza, ci limiteremo ad analizzare i nuovi oggetti introdotti da VB .NET e, brevemente, quelli che presentano cambiamenti significati rispetto alle versioni precedenti. Per ogni controllo analizzato, cominceremo con l'esporre le nuove propriet e i nuovi metodi di cui dispone; potrebbe sembrare un approccio noioso, ma dato che la maggior parte delle propriet e dei metodi hanno cambiato nome da VB 6 a VB .NET, questo l'unico modo per evitare di non ritrovare pi quello che serve quando si lavora con il nuovo ambiente di sviluppo. Uno dei controlli maggiormente potenziati la TextBox . La prima cosa da far notare che stato finalmente superato il limite dei 64.000 caratteri circa visualizzabili: ora possibile, teoricamente, inserire fino a 2 GB di informazioni in una singola casella di testo. Una delle propriet pi interessanti, peraltro comune a tutti i controlli, la propriet Anchor , che consente di adattare il controllo alle dimensioni della finestra. Per impostarla, fare clic sulla freccia visualizzata a destra di tale propriet: comparir una piccola finestra in cui selezionare, con un clic del mouse, i bordi della finestra a cui si vuole ancorare il controllo.

L'impostazione predefinita Top, Left, cio il controllo ancorato al bordo sinistro in alto: in pratica l'oggetto non viene adattato alle dimensioni della finestra, ma resta fisso nella sua posizione. Proviamo ad inserire una TextBox sulla form, in una posizione qualsiasi, e ad impostare la sua propriet Anchor su Top, Left, Right. Se ora proviamo a ridimensionare il form, anche in fase di progettazione, noteremo che la casella di testo di allunga o si riduce in accordo alle dimensioni della finestra. Analogamente, se posizioniamo la TextBox nella parte bassa del form e impostiamo Anchor su Bottom, Left, essa rimarr sempre alla stessa distanza dal bordo inferiore della finestra, qualunque dimensione essa abbia. Passando alle propriet specifiche della TextBox, AcceptsReturn e AcceptsTab consentono di stabilire se il controllo deve accettare, rispettivamente, i caratteri Invio e Tab. Ad esempio, la prima propriet utile quando si ha un controllo multilinea e si vuole fare in modo che, premendo il tasto Invio, venga inserita una nuova linea di testo; se, invece, AcceptsReturn False (impostazione predefinita), premendo Invio verr attivato il pulsante di default della form. AcceptsTab deve essere impostata su True se si vuole dare la possibilit di inserire caratteri di tabulazione nella TextBox, altrimenti la pressione del tasto Tab sposter lo stato attivo sul controllo successivo. Altra propriet importante Lines, che consente di definire le righe di testo della casella, nel caso in cui la propriet MultiLine sia impostata su True. Facendo clic sul pulsante con i tre puntini in corrispondenza della propriet Lines, verr visualizzato la finestra di dialogo String Collection Editor , in cui possibile digitare le righe che si vogliono visualizzare, separate da Invio.


Per quanto riguarda i metodi, citiamo qui solo i pi interessanti, rimandando alla consultazione della Guida in linea per l'elenco completo. Il metodo AppendText aggiunge il testo specificato alla fine del contenuto nella TextBox. I metodi Copy, Cut e Paste, rispettivamente, permettono di copiare, tagliare ed incollare il testo: le operazioni con gli Appunti di Windows, che prima si realizzavano tramite l'oggetto Clipboard, ora sono accessibili come metodi della TextBox. Il metodo Focus, comune a tutti i controlli, consente di spostare lo stato attivo sull'oggetto su cui viene richiamato. Il metodo Undo, infine, annulla l'ultima operazione e, di fatto, equivale alla pressione della combinazione di tasti CTRL+Z. Vediamo ora quali sono i principali eventi del controllo TextBox e come si gestiscono. L'evento Change stato rinominato in TextChanged. Ma gli eventi su cui vale la pena spendere qualche parola sono KeyDown, KeyUp e KeyPress: analizziamoli ricordando che le considerazioni che verranno fatte sono valide per tutti i controlli che possono generare gli eventi KeyDown, KeyUp e KeyPress. Per quanto riguarda i primi due, nelle precedenti versioni di Visual Basic essi avevano come parametri KeyCode e Shift, che permettevano di sapere quale carattere era stato premuto e, controllando il valore di Shift, se in combinazione con ALT, CTRL o SHIFT; inoltre, scrivendo all'interno dell'evento KeyCode = 0, era possibile annullare la digitazione. Tutte queste informazioni, in VB .NET, sono contenute nel parametro e, che di tipo System.Windows.Forms.KeyEventArgs: Private Sub TextBox1_KeyUp(ByVal sender As Object, ByVal e As System.Windows.Forms.KeyEventArgs) Handles TextBox1.KeyUp End Sub In particolare, per quanto riguarda gli eventi KeyUp e KeyDown, l'oggetto e espone le propriet KeyCode, Alt, Control e Shift, utili per sapere quale carattere stato premuto e se in combinazione con i tasti ALT, CTRL o SHIFT. Considerate l'esempio seguente: Private Sub TextBox1_KeyUp(ByVal sender As Object, ByVal e As System.Windows.Forms.KeyEventArgs) Handles TextBox1.KeyUp If e.KeyCode = Keys.F And e.Shift = True Then MsgBox("Premuta la combinazione SHIFT+F.") End If End Sub Keys un'enumerazione di tutti i caratteri della tastiera e pu quindi essere utilizzato per sapere quale carattere stato premuto: in questo esempio si controlla se e.KeyCode uguale a Keys.F, cio se stato premuto il carattere F. e.Shift = True, invece, usato per sapere se insieme al tasto F stato premuto anche SHIFT. Il parametro e dell'evento KeyPress, invece, espone tra le altre le propriet KeyChar e Handled; la prima contiene la rappresentazione in formato stringa del carattere premuto, mentre l'altra consente di dire a Visual Basic che l'evento KeyPress gestito, cio che non si vuole visualizzare il carattere premuto nella TextBox perch sono state fatte altre elaborazioni: in pratica, equivale a porre KeyAscii = 0 nell'evento KeyPress delle precedenti versioni di Visual Basic. E' arrivato il momento di concretizzare quanto abbiamo detto finora con un esempio pratico. Realizziamo un'ipotetica finestra per il login di un'applicazione: per essere riconosciuto come valido, un utente deve digitare nome utente e password corretti (nel nostro esempio saranno rispettivamente utente e pass); vogliamo per prevedere anche un funzione di emergenza, in modo tale che sia possibile entrare anche se ci si dimentica la password. Nel nostro caso faremo una cosa molto semplice: la procedura di emergenza consiste nel digitare il nome pippo e premere la combinazione di tasti SHIFT+E. Iniziamo quindi a realizzare l'esempio, inserendo i controlli nella form in modo da ottenere una finestra simile a quella riprodotta a lato. Nella tabella qui sotto sono riportati i nomi dei controlli utilizzati con i valori delle propriet da modificare:

Nome controllo (tipo) Propriet Valore

Label1 (Label) AutoSize Text

True Nome utente:

TextBox1 (TextBox) Text

Label2 (TextBox) Autosize Text

True Password:

TextBox2 (TextBox) PasswordChar Text

* >

Button1 (Button) Enable Text

False OK

Form1 (Form) AcceptButton Button1


FormBorderStyle MaximizeBox MinimizeBox Text

FivedSingle False False Login

E' il momento di scrivere il codice. Innanzi tutto, vogliamo che il pulsante OK venga attivato solo quando sono stati immessi sia il nome utente sia la password. Questo comportamento si ottiene con il codice seguente: Private Sub TextBox1_TextChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles TextBox1.TextChanged 'La propriet "TextLength" usata per recuperare la lunghezza del testo digitato. If TextBox1.TextLength > 0 And TextBox2.TextLength > 0 Then Button1.Enabled = True Else Button1.Enabled = False End If End Sub Private Sub TextBox2_TextChanged(ByVal sender As Object, ByVal e As System.EventArgs) Handles TextBox2.TextChanged 'La propriet "TextLength" usata per recuperare la lunghezza del testo digitato. If TextBox1.TextLength > 0 And TextBox2.TextLength > 0 Then Button1.Enabled = True Else Button1.Enabled = False End If End Sub La propriet TextLength restituisce il numero di caratteri contenuti nella casella di testo su cui viene invocata, e corrisponde alla funzione Len(testo) delle versioni precedenti di Visual Basic. La funzione di controllo del login molto semplice: Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click If TextBox1.Text = "utente" AndAlso TextBox2.Text = "pass" Then Me.Close() Else MsgBox("La password digitata non valida.", MsgBoxStyle.Exclamation) TextBox1.Focus() End If End Sub Il significato del nuovo operatore AndAlso stato spiegato nella lezione 2. A questo punto l'esempio gi operativo: avendo impostato la propriet AcceptButton della form su Button1, possibile attivare la routine Button1_Click semplicemente premendo il pulsante Invio (naturalmente quando il pulsante attivo). Ma noi abbiamo deciso di prevedere anche una funzione di emergenza: Private Sub TextBox1_KeyDown(ByVal sender As Object, ByVal e As System.Windows.Forms.KeyEventArgs) Handles TextBox1.KeyDown If TextBox1.Text = "pippo" AndAlso e.Shift = True AndAlso e.KeyCode = Keys.E Then MsgBox("E' stata usata la procedura di emergenza.", MsgBoxStyle.Information) Me.Close() End If End Sub Questa routine semplicemente controlla se, quando il contenuto di TextBox1 pippo, viene premuta la combinazione SHIFT+E, nel qual caso visualizza un messaggio per informare l'utente che ha utilizzato la combinazione di emergenza. E' possibile scaricare il codice completo dell'esempio facendo clic qui. Nella prossima Lezione parleremo dei controlli PictureBox, Panel e GroupBox : il primo ha subito numerosi cambiamenti rispetto alle versioni precedenti, mentre il secondo una novit di Visual Basic. NET; il controllo GroupBox, infine, sostituisce il vecchio Frame.

I controlli PictureBox, Panel e GroupBox l controllo Image in Visual Basic .NET non esiste pi: ora per visualizzare un'immagine all'interno di una form possibile


utilizzare solo il controllo PictureBox . Anch'esso ha subito alcuni cambiamenti significativi. Innanzi tutto, la propriet Picture, utilizzata per impostare l'immagine da visualizzare nel controllo, stata rinominata in Image; per quanto riguarda i formati, stato aggiunto il supporto ai file PNG ed alle GIF animate. La propriet AutoSize stata sostituita da SizeMode , che rispetto alla prima offre alcune possibilit in pi: Normal l'impostazione predefinita; StretchImage adatta le dimensioni dell'immagine perch possa essere interamente visualizzata all'interno del controllo; AutoSize ridimensiona la PictureBox sulla base della grandezza dell'immagine; CenterImage visualizza l'immagine centrata nella PictureBox. Per impostare la propriet Image non pi disponibile il metodo LoadPicture; essa deve essere impostata su un oggetto di tipo System.Drawing.Bitmap: allo scopo possibile utilizzare il metodo FromFile della classe appena citata. Ad esempio, l'istruzione: PictureBox1.Image = System.Drawing.Bitmap.FromFile("C:\Immagini\Cascate.bmp") Visualizza nella PictureBox l'immagine C:\Immagini\Cascate.bmp. Per eliminare l'immagine, sufficiente porre la propriet Image uguale a Nothing . Il controllo Panel molto semplice da utilizzare. Si tratta di un controllo contenitore, cio consente di definire un'area al cui interno possibile inserire altri oggetti, che verranno logicamente considerati insieme, come facenti parte di un unico gruppo: ad esempio, nascondendo un controllo Panel, verranno automaticamente nascosti anche tutti i controlli in esso contenuti. Nelle precedenti versioni di Visual Basic, per raggruppare insieme alcuni oggetti era necessario inserirli all'interno di una PictureBox, che quindi aveva una doppia valenza (visualizzatore di immagini e contenitore). Per inserire oggetti in un controllo Panel sufficiente selezionarli e trascinarli all'interno del controllo stesso: non pi indispensabile crearli direttamente nel contenitore, come accadeva con la PictureBox; analogamente, se si vuole portare un oggetto all'esterno del Panel, basta selezionarlo e spostarlo al di fuori di esso. Se si elimina un controllo Panel, verranno automaticamente eliminati anche tutti gli oggetti al suo interno. Le considerazioni fatte fin qui relativamente al Panel si applicano anche al GroupBox, controllo che prende il posto del vecchio Frame. Anch'esso un controllo contenitore: la differenza rispetto al Panel che il GroupBox definisce un'area delimitata e visibile in fase di esecuzione, mentre i bordi del controllo Panel sono invisibili a runtime. Realizziamo ora un piccolo esempio per impratichirci con i controlli appena analizzati. Oltre a Panel e PictureBox, utilizzeremo anche la RadioButton (nuovo nome dell'OptionButton) e la CheckBox . L'applicazione che andremo a creare molto semplice: una PictureBox di cui si pu impostare la propriet SizeMode attraverso una serie di RadioButton; una CheckBox, inoltre, consente di stabilire se si vuole visualizzare o meno l'immagine. L'interfaccia che vogliamo realizzare visibile a lato. Le propriet da impostare sono le seguenti:

Nome controllo (tipo) Propriet Valore Panel1 (Label)

RadioButton 1 (RadioButton) Checked Tag Text

True 0 Normal

RadioButton 2 (RadioButton) Tag Text

1 StretchImage


2 Autosize


3 CenterImage

CheckBox 1 (CheckBox) Checked Text

True Visualizza

PictureBox 1 (PictureBox) SizeMode Normal Infine, impostiamo la propriet Image della PictureBox su un'immagine di dimensioni minori di quelle della casella, cosicch sia possibile notare gli effetti della modifica della propriet SizeMode . Cominciamo dalle cose pi facili, cio il codice associato al controllo CheckBox1 . Vogliamo che, attivando o disattivando la casella di controllo, la PictureBox venga visualizzata oppure nascosta: Private Sub CheckBox1_CheckedChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles CheckBox1.CheckedChanged 'Visualizza o nasconde la PictureBox.


PictureBox1.Visible = CheckBox1.Checked End Sub L'evento CheckedChanged viene generato quando si modifica la selezione di una CheckBox, sia direttamente, con un clic sul controllo, sia via codice, impostando la propriet Checked. Ora dobbiamo scrivere il codice per modificare la propriet SizeMode della PictureBox a seconda della RadioButton che viene premuta. Il modo pi semplice per farlo consiste nello scrivere quattro routine, una per controllo, ciascuna delle quali imposta SizeMode su un valore diverso. Vediamo qui, invece, una soluzione pi sofisticata ed efficiente, che sfrutta una sola routine e l'oggetto sender: Private Sub Selection(ByVal sender As Object, ByVal e As System.EventArgs) Handles RadioButton1.Click, RadioButton2.Click, RadioButton3.Click, RadioButton4.Click PictureBox1.SizeMode = CInt(CType(sender, RadioButton).Tag) End Sub Cerchiamo di spiegare bene il significato di queste righe di codice. Innanzi tutto, dopo la parola chiave Handles sono stati specificati quattro eventi, corrispondenti agli eventi Click di ciascuna RadioButton: in tal modo si dice a Visual Basic di eseguire la routine Selection ogni volta che si preme il pulsante del mouse su una RadioButton. All'interno della routine, l'oggetto sender usato per recuperare il particolare controllo che ha generato l'evento; sender di tipo Object, da cui sono derivati tutti i tipi di Visual Basic .NET. Noi per sappiamo che in questo caso l'oggetto passato alla funzione una RadioButton, quindi usiamo la funzione CType per convertirlo e poter utilizzare i metodi e le propriet tipiche di una RadioButton. In generale, la sintassi della funzione CType la seguente: CType(espressione, tipo) Dove espressione rappresenta quello che si vuole convertire (ad esempio un oggetto o una variabile), mentre tipo il tipo di dato che vogliamo ottenere con la conversione. Tornando la nostro esempio, dopo aver convertito l'oggetto sender in RadioButton ne leggiamo la propriet Tag, la trasformiamo in intero con CInt e la passiamo alla propriet SizeMode della PictureBox1. E' da notare che, se non avessimo utilizzato la funzione CType, il codice avrebbe funzionato ugualmente, poich VB avrebbe tentato una conversione implicita dell'oggetto sender. Utilizzando, invece, la funzione CType si forza una conversione esplicita: dove possibile, sempre preferibile usare le conversioni esplicite piuttosto che quelle implicite, innanzi tutto perch rendono pi chiaro il codice, poi perch consentono a Visual Basic di determinare univocamente il tipo di dati di un particolare oggetto. Il programma di esempio che abbiamo realizzato in questa Lezione pu essere scaricato facendo clic qui. La prossima Lezione sar dedicata ad una panoramica sui controlli ListBox, CheckedListBox e ComboBox: pur non essendo una novit, Visual Basic. NET ha introdotto numerosi cambiamenti relativamente al loro utilizzo.

I controlli ListBox, CheckedListBox e ComboBox controlli ListBox, CheckedListBox e ComboBox erano gi presenti in Visual Basic 6, anche se i primi due erano di fatto un unico oggetto: per visualizzare la caselle di spunta in una ListBox di VB 6 era necessario impostare la sua propriet Style su 1 - CheckBox. In VB .NET, invece, ListBox e CheckedListBox sono due controlli separati, pur se con molti elementi in comune. Cominciamo quindi ad analizzare le propriet che li accomu nano. La propriet Items (disponibile anche nella ComboBox) consente di aggiungere o rimuovere elementi alla lista in modo molto pi facile rispetto alle precedenti versioni di Visual Basic: premendo il pulsante con i tre puntini a destra di tale propriet, verr visualizzato l'Item Collection Editor in cui possibile digitare gli elementi, uno per riga. MultiColumn deve essere impostato su True se si vuole che gli elementi della ListBox o della CheckedListBox vengano visualizzati in colonne affiancate; in questo caso, la propriet ColumnWidth consente di definire la larghezza delle colonne. La propriet SelectionMode sostituisce ed estende la propriet MultiSelect. Per quanto riguarda le propriet della ComboBox, la propriet Style stata rinominata in DropDownStyle. DropDownWidth consente di definire la larghezza, in pixel, dell'elenco a discesa. E' possibile anche impostare il numero di elementi da visualizzare in tale elenco, agendo sulla propriet MaxDropDownItems . Passando ai metodi, interessante notare come questi controlli siano stati notevolmente potenziati, con l'aggiunta di funzionalit che prima erano disponibili solo utilizzando le API di Windows. Nel seguito faremo riferimento alla ListBox, ricordando per che le considerazioni che verranno fatte, salvo diversa indicazione, sono valide per tutti e tre i controlli oggetto di questa Lezione. Per lavorare con gli elementi di una ListBox necessario utilizzare i metodi della collezione Items del controllo. Ad esempio, per aggiungere un elemento ad una ListBox di nome ListBox1 necessario scrivere: ListBox1.Items.Add("Nuovo elemento") Per rimuovere una voce sono disponibili i metodi Remove e RemoveAt : il primo consente di rimuovere l'oggetto specificato,


in qualunque posizione si trovi, mentre il secondo cancella l'elemento nella posizione specificata. Ad esempio, ListBox1.Items.Remove ("Testing") rimuove l'elemento di nome Testing dalla ListBox, mentre ListBox1.Items.RemoveAt(5) elimina la sesta voce dell'elenco (ricordiamo che si inizia a contare da 0). E' da notare che se, nel primo caso, l'elemento Testing non esiste, non viene comunicato alcun messaggio, mentre se, nel secondo caso, la lista ha meno di sei elementi, si genera un errore. Altro metodo importante della collezione Items Contains, che restituisce True se l'elemento specificato come argomento presente nella lista, False altrimenti. Per recuperare l'elemento attualmente selezionato nella ListBox si pu usare la propriet SelectedItem; l'indice corrispondente conservato in SelectedIndex. Se si vogliono scorrere gli elementi selezionati possibile usare le collezioni che gli oggetti ListBox, CheckedListBox e ComboBox mettono a disposizione; il seguente esempio mostra come conoscere gli elementi attualmente selezionati in una CheckedListBox: Dim Elemento As String For Each Elemento In CheckedListBox1.CheckedItems MsgBox("Elemento selezionato: " & Elemento) Next Se, invece di conoscere gli elementi, fossimo stati interessati a recuperare gli indici selezionati, sarebbe stato sufficiente scorrere la collezione CheckedListBox1.CheckedIndices . Per quanto riguarda gli eventi, ricordiamo qui soltanto SelectedIndexChanged, comune a tutti e tre i controlli, che viene generato quando si seleziona un elemento nella lista, ovvero quando si modifica la propriet SelectedIndex del controllo. Passiamo alla consueta realizzazione di un esempio per chiarire i concetti fin qui esposti. Vogliamo creare un'applicazione che consenta di selezionare alcuni articoli da un elenco per inserirli, ad esempio, in un ordine da stampare o inviare via posta elettronica. L'interfaccia molto ricca di controlli, come si pu vedere dall'immagine a lato:

Nome controllo (tipo) Propriet Valore

Panel1 (Label) AutoSize Text

true Elementi disponibili:

ListBox 1 (ListBox)

Button 1 (Button) Text Aggiungi>>

Button 2 (Button) Text


visualizzi il nome dell'elemento stesso. Per fare questo usiamo il metodo IndexFromPoint e l'evento MouseMove: Private Sub ListBox1_MouseMove(ByVal sender As Object, ByVal e As System.Windows.Forms.MouseEventArgs) Handles ListBox1.MouseMove Dim Indice As Short = ListBox1.IndexFromPoint(e.X, e.Y) If Indice >= 0 Then Label3.Text = "Elemento corrente: " & ListBox1.Items(Indice) End If End Sub Il metodo IndexFromPoint restituisce l'indice dell'elemento che si trova nella posizione del mouse specificata; in questo caso usiamo due propriet dell'oggetto e, X e Y, per conoscere le coordinate del cursore. Se l'indice valido, cio un numero maggiore o uguale a 0, visualizziamo il valore dell'elemento corrispondente leggendo l'oggetto Items di posizione Indice. Per aggiungere o rimuovere elementi da una o dall'altra lista il codice da usare il seguente: Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click If ListBox1.SelectedIndex >= 0 Then 'Se stato selezionato un elemento, lo aggiunge alla CheckedListBox1. CheckedListBox1.Items.Add(ListBox1.SelectedItem, True) 'Rimuove l'elemento dalla ListBox1. ListBox1.Items.RemoveAt(ListBox1.SelectedIndex) End If End Sub Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click If CheckedListBox1.SelectedIndex >= 0 Then 'Se stato selezionato un elemento, lo rimette nella ListBox1. ListBox1.Items.Add(CheckedListBox1.SelectedItem) 'Rimuove l'elemento dalla CheckedListBox1. CheckedListBox1.Items.RemoveAt(CheckedListBox1.SelectedIndex) End If End Sub Come si vede, le due routine sono speculari. L'unica istruzione su cui spendere qualche parola CheckedListBox1.Items.Add(ListBox1.SelectedItem, True). Il metodo Items.Add della CheckedListBox polimorfico: se viene specificato il secondo parametro e lo si pone uguale a True, la casella di spunta corrispondente all'elemento appena inserito verr automaticamente selezionata. Sempre a riguardo dalla CheckedListBox, notiamo che, impostando la propriet CheckOnClick su True, la casella di spunta corrispondente all'elemento su cui si fa clic verr automaticamente selezionata o deselezionata. L'ultima cosa che dobbiamo fare scrivere il codice per fare in modo che, nella Label5, venga visualizzato il tipo di pagamento selezionato, utilizzando l'evento SelectedIndexChanged di cui abbiamo gi parlato: Private Sub ComboBox1_SelectedIndexChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles ComboBox1.SelectedIndexChanged Label5.Text = "Tipo di pagamento selezionato: " & ComboBox1.SelectedItem End Sub Il codice da eseguire alla pressione del pulsante Calcola, in quanto non direttamente collegato con l'esempio, lasciato come esercizio. L'esempio che abbiamo realizzato pu essere scaricato facendo clic qui. In questa Lezione abbiamo introdotto tre dei controlli pi utilizzati. La prossima Lezione sar incentrata sul menu, uno dei componenti fondamentali di un'applicazione Windows; come vedremo, la gestione dei menu in VB .NET radicalmente diversa rispetto a quella delle versioni precedenti.

Menu e Tooltip in VB .NET La gestione dei menu in Visual Basic .NET radicalmente diversa rispetto a quella delle versioni precedenti. L'amato-odiato Editor di menu ha fatto il suo tempo: ora per inserire un menu in un'applicazione VB .NET si deve utilizzare l'oggetto MainMenu , disponibile nella casella degli strumenti standard. Aggiungendo il controllo MainMenu in una form, comparir un'area nella parte bassa della finestra in cui verr inserita l'icona relativa. Si tratta di una novit di VB .NET: i controlli non visibili in fase di esecuzione, ad esempio il Timer, non vengono pi visualizzati nella form, ma in una zona separata, cos da evitare appesantimenti inutili. Dopo aver inserito il MainMenu, sotto la barra del titolo della form apparir la barra dei menu, come si pu vedere nell'immagine a lato. Ecco un'altro cambiamento rispetto alle versioni precedenti di Visual Basic: per definire i comandi dei


menu ora basta scriverli all'interno del menu stesso in fase di progettazione. Ad esempio, proviamo a fare clic sulla comando Type Here (scrivi qui) nella barra dei menu e a scrivere File: questo sufficiente per creare un menu di nome File. Appariranno ora nuove voci nella barra dei menu, tutte contrassegnate da Type Here: al posto di ognuna di esse possibile inserire un comando di menu. Come nelle versioni precedenti di Visual Basic, per inserire una barra di separazione nel menu basta creare una nuova voce e impostare la sua etichetta su - (segno meno); in alternativa, anche possibile fare clic con il tasto destro del mouse all'interno del menu e selezionare Insert Separator (Inserisci separatore). Per spostare un comando da una posizione ad un'altra basta trascinare l'elemento del menu nella posizione desiderata. Facendo clic su un comando, nella finestra delle Propriet compariranno le propriet della voce di menu. Checked consente di visualizzare un segno di spunta a sinistra del nome del menu; RadioCheck , novit di VB .NET, deve essere impostato su True se si vuole che al posto del segno di spunta venga visualizzato un radio button (pu essere usato, ad esempio, per indicare la scelta corrente in un insieme di opzioni). Shortcut consente di definire una scorciatoia da tastiera per il comando; possibile decidere se visualizzare o meno tale combinazione di tasti agendo sulla propriet ShowShortcut. Per scrivere il codice da eseguire quando si seleziona un comando dal menu, fare doppio clic sul comando stesso: si aprir l'editor del codice all'interno della routine che gestisce l'evento Click sulla voce di menu. Altro evento importante Select, che viene generato quando il puntatore del mouse di sposta su una voce del menu. L'altro tipo di menu disponibile in VB .NET il menu contestuale: nelle applicazioni per Windows esso viene visualizzato quando si fa clic con il tasto destro del mouse su di un controllo. Nelle precedenti versioni di Visual Basic, per mostrare questo tipo di menu era necessario aggiungerlo alla barra dei menu standard, quindi richiamarlo con il metodo PopupMenu ad esempio all'interno dell'evento MouseUp, in modo da intercettare la pressione del tasto destro del mouse. In VB .NET il metodo PopupMenu non esiste pi: per associare un menu contestuale ad un controllo necessario creare un oggetto di tipo ContextMenu. Anch'esso, al pari del MainMenu, una volta inserito nella form viene visualizzato nella parte bassa della

finestra di progettazione; anche la fase di creazione delle voci di menu e di impostazioni delle propriet la medesima. Se in una form sono presenti sia un MainMenu sia uno o pi ContextMenu, facendo clic sull'uno o sull'altro il corrispondente layout dei menu verr visualizzato sotto la barra del titolo, anche se, in fase di esecuzione, la barra dei menu sar quella impostata nel MainMenu. Dopo aver creato un menu contestuale, necessario associarlo ad uno o pi controlli. Per fare questo si deve selezionare il controllo a cui si vuole collegare il menu e impostare la

sua propriet ContextMenu sul nome del menu contestuale interessato. Fatto questo, ogni volta che si far clic con il tasto destro del mouse sul controllo verr visualizzato il menu contestuale; non pi necessario scrivere nemmeno una riga di codice per ottenere questo effetto. L'evento Popup del ContextMenu viene generato prima della visualizzazione del menu contestuale. Pu essere utilizzato, ad esempio, nel caso di un menu associato a pi controlli, per adattare i comandi in base all'oggetto su cui stato fatto il clic. Supponiamo di avere un ContextMenu associato ai controlli Button1 e Button2 con un unico comando, MenuItem1. Consideriamo il codice seguente: Private Sub ContextMenu1_Popup(ByVal sender As Object, ByVal e As System.EventArgs) Handles ContextMenu1.Popup If ContextMenu1.SourceControl Is Button1 Then MenuItem1.Text = "Nascondi pulsante" ElseIf ContextMenu1.SourceControl Is Button2 Then MenuItem1.Text = "Esci dal programma" End If End Sub Esso fa in modo che, premendo il pulsante destro del mouse su Button1, il comando del menu contestuale sia "Nascondi pulsante", mentre, facendo clic sul Button2 , diventi " Esci dal programma". Per fare questo si usata la propriet SourceControl dell'oggetto ContextMenu , che specifica il controllo su cui stato eseguito il clic destro. Anche gli elementi del ContextMenu dispongono dell'evento Click che viene generato quando l'utente seleziona un comando di menu con il tasto sinistro del mouse. Passiamo ora al controllo ToolTip, utilizzato per visualizzare un breve messaggio descrittivo quando si posiziona il mouse su un oggetto per alcuni istanti. Anch'esso una novit di Visual Basic .NET: nelle precedenti versioni di VB, infatti, per assegnare un tooltip era sufficiente impostare la propriet ToolTipText. In VB .NET, per definire un tooltip necessario inserire prima nella form un oggetto di tipo ToolTip; anch'esso, come il MainMenu e il ContextMenu, si posiziona nella parte bassa della finestra di progettazione. Inserito il ToolTip, tra le propriet dei controlli della form ne apparir una nuova, Tooltip on : il messaggio specificato in questa propriet verr utilizzato come tooltip. La decisione di aggiungere un controllo a parte per visualizzare i tooltip dovuta al fatto che, cos facendo, possibile impostarne alcune propriet, come il ritardo di visualizzazione, che prima non erano disponibili. In particolare, InitialDelay consente di specificare l'intervallo di


tempo, in millisecondi, che deve passare da quando il puntatore del mouse si sposta su un controllo alla visualizzazione del messaggio descrittivo; AutoPopDelay indica per quanti millisecondi deve essere visualizzato il tooltip. La propriet AutomaticDelay ha lo stesso scopo di InitialDelay, con la differenza che sulla base del valore in essa specificato, verranno automaticamente impostate anche le propriet AutoPopDelay, InitialDelay e ReshowDelay (quest'ultima propriet specifica quanti millisecondi devono passare prima di visualizzare il nuovo tooltip quando il puntatore del mouse si sposta da un controllo ad un altro). Per maggiori informazioni su come vengono impostate tali propriet sulla base di AutomaticDelay, si rimanda alla consultazione della Guida in linea. Dopo aver esaminato i controlli MainMenu, ContextMenu e ToolTip, novit assoluta per i programmatori Visual Basic, nella prossima Lezione realizzeremo un piccolo programma in cui troveranno posto tutti e tre questi oggetti.

Menu e Tooltip in VB .NET un esempio pratico Menu e Tooltip in VB .NET - un esempio pratico Nella precedente Lezione abbiamo introdotto la gestione dei menu e dei tooltip in VB .NET, evidenziandone gli aspetti chiave e le significative novit rispetto alle precedenti versioni di Visual Basic. Ora realizzeremo un piccolo programma per mostrare l'utilizzo di questi nuovi oggetti. Vogliamo creare un semplicissimo editor di testi, una versione super ridotta di Blocco note; per fare questo utilizzeremo menu, menu contestuali e tooltip, oltre a riprendere alcuni concetti che abbiamo trattato nelle precedenti Lezioni di questo corso. L'applicazione avr un MainMenu che conterr i menu File, Modifica e Formato; il testo verr visualizzato in una TextBox di cui ridefiniremo il menu contestuale creando un nostro ContextMenu. Un ToolTip, infine, sar utilizzato per visualizzare informazioni sul testo. Dato il numero di oggetti che creeremo, conveniente assegnare dei nomi significativi ai vari controlli, piuttosto che utilizzare quelli predefiniti; per fare questo si deve intervenire sulla propriet (Name) del controllo, che consente di impostare il nome con cui il controllo verr identificato all'interno del codice. Cominciamo col creare la struttura del menu. Per fare questo inseriamo un oggetto di tipo MainMenu nella form e impostiamo il suo nome su MenuPrincipale.. Per modificare i nomi degli elementi dei menu, dopo averne creato la struttura, possibile fare clic con il tasto destro del mouse su una voce e selezionare Edit Names (Modifica nomi): cos facendo, a sinistra del menu, tra parentesi quadre, comparir il nome del menu (vedi immagine a lato), che esattamente la propriet Name di quel comando. Togliendo il segno di spunto da Edit Names sar nuovamente possibile modificare le etichette dei menu. Per semplicit, invece che indicare come di consueto le propriet dei vari oggetti in una tabella, in questo caso ci limiteremo a mostrare la struttura del menu; a fianco di ogni voce, sono indicati l'eventuale shortcut e, tra parentesi, il nome:

&File (mnuFile)

&Modifica (mnuModifica) &Formato (mnuFormato)

&NuovoCTRLN (mnuFileNuovo)

&AnnullaCTRLZ (mnuModAnnulla)

Allinea a sinistra (mnuForSinistra)

&Apri...CTRLO (mnuFileApri) - (mnuModSep0)

Allinea al centro (mnuForCentro)

&Salva...CTRLS (mnuFileSalva)

&Taglia CTRLX (mnuModTaglia)

Allinea a destra (mnuForDestra)

- (mnuFileSep0) &Copia CTRLC (mnuModCopia)

- (mnuForSep0)

&Esci (mnuFileEsci) &Incolla CTRLV (mnuModIncolla)

&Tutto maiuscolo (mnuForMaiusc)

Ca&ncella Del (mnuModCancella)

T&utto minuscolo (mnuForMinusc)

- (mnuModSep1)

&Seleziona tutto (mnuModSelTutto)

I comandi Apri e Salva del menu File sono seguiti da tre puntini: con questa convenzione si fa capire all'utente che selezionando questi comandi si aprir una nuova finestra di dialogo (nel nostro caso, si dovranno aprire rispettivamente le finestre di dialogo Apri e Salva con nome ). Le voci di menu che non hanno i puntini, invece, corrispondono a comandi che vengono eseguiti senza necessit di ulteriore input. I comandi del menu Formato che gestiscono l'allineamento del testo sono esclusivi, ovvero possibile selezionarne solo uno alla volta. Per tale motivo impostiamo la loro propriet RadioCheck su True; inoltre mettiamo a True la propriet Checked di mnuForSinistra, perch l'allineamento a sinistra quello predefinito. Se non riuscite a riprodurre la struttura dei menu suggerita, potete scaricare la form che la contiene facendo clic qui.


Passiamo ora al ContextMenu. Innanzi tutto aggiungiamolo alla form e impostiamo il suo nome su MenuContestuale. Vogliamo che questo menu venga visualizzato quando si preme il tasto destro del mouse sulla TextBox, quindi deve includere comandi per operare rapidamente sul contenuto della casella di testo. Notiamo che una casella di testo include gi un menu contestuale, quello predefinito di Windows. Nelle precedenti versioni di Visual Basic, per visualizzare in una TextBox un menu contestuale diverso da quello standard era necessario ricorrere ad un trucco che consisteva nel disattivare e riattivare il controllo; in VB .NET, invece, impostando la propriet ContextMenu di una TextBox verr visualizzato solo il nuovo menu quando si preme il pulsante destro del mouse (in pratica il menu contestuale predefinito viene disattivato). Nel nostro esempio, per non complicare troppo il programma, nel ContextMenu ci limiteremo a riprodurre i comandi del menu Modifica. I nomi dei menu dovranno avere la forma mnuCont, come nel menu Modifica (ad esempio mnuContAnnulla, mnuContTaglia, ecc. ). La creazione del menu lasciata come esercizio. Se avete qualche problema nella realizzazione, potete scaricare l'applicazione con il menu contestuale facendo clic qui. La tabella seguente mostra i rimanenti oggetti da inserire nella form con le rispettive propriet:

Nome controllo (tipo) Propriet Valore AcceptsReturn True

AcceptsTab True

Anchor Top, Bottom, Left, Right

ContextMenu MenuContestuale

Location 0; 0

Multiline True

ScrollBars Vertical

txtTesto (TextBox)

Text

tltInfoTesto (ToolTip) AutomaticDelay 1000

MinimunSize 320; 240

StartPosition CenterScreen Form1 (Form)

Text Editor Possiamo finalmente cominciare a scrivere il codice. La prima cosa da fare modificare le dimensioni della TextBox in modo che, all'avvio, occupi l'intero form; sar poi la propriet Anchor a garantirci il ridimensionamento del controllo in accordo alle dimensioni della finestra. Questo risultato si ottiene con il codice seguente: Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load txtTesto.Height = Me.Height - 46 txtTesto.Width = Me.Width - 8 End Sub Cominciamo ora con lo scrivere il codice da eseguire in risposta ai clic sui vari comandi di menu. Bench si possa scrivere una routine per ogni comando di menu, mostreremo qui come sia possibile usare una sola Sub per ogni menu, quindi una per il menu File, una per Modifica e una per Formato, oltre a una per il menu contestuale. Il codice del menu File : Private Sub mnuFileCommand(ByVal sender As Object, ByVal e As System.EventArgs) Handles mnuFileNuovo.Click, mnuFileApri.Click, mnuFileSalva.Click, mnuFileEsci.Click Select Case CType(sender, MenuItem).Text Case "&Nuovo" txtTesto.Clear() Case "&Esci" Me.Close() End Select End Sub Questa routine intercetta gli eventi clic di tutti i comandi del menu File, quindi converte l'oggetto sender in MenuItem e ne controlla la propriet Text per sapere quale elemento stato effettivamente selezionato. Abbiamo parlato della funzione CType nella Lezione 11. Non abbiamo incluso il codice relativo ai comandi Apri e Salva, che discuteremo nella prossima Lezione, quando parleremo delle finestre di dialogo comuni. Per il menu Modifica, seguendo un ragionamento analogo, si ottiene: Private Sub mnuModificaCommand(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles mnuModAnnulla.Click, mnuModTaglia.Click, mnuModCopia.Click, mnuModIncolla.Click, mnuModCancella.Click, mnuModSelTutto.Click Select Case CType(sender, MenuItem).Text Case "&Annulla"


txtTesto.Undo() Case "&Taglia" txtTesto.Cut() Case "&Copia" ' ... End Select End Sub I rimanenti comandi del menu Modifica, il menu Formato e il menu contestuale, presentando una struttura del tutto analoga quella gi trattata, sono lasciati per esercizio. E' comunque possibile scaricare l'applicazione con tutto il codice dei menu. L'ultima cosa che dobbiamo fare aggiungere il codice relativo al tooltip. Poich il testo da visualizzare viene modificato durante la digitazione, necessario utilizzare il metodo SetToolTip dell'oggetto tltInfoTesto; esso prevede due argomenti, il primo il nome del controllo per cui si vuole impostare il tooltip, il secondo il testo del messaggio da mostrare: Private Sub txtTesto_TextChanged(ByVal sender As Object, ByVal e As System.EventArgs) Handles txtTesto.TextChanged tltInfoTesto.SetToolTip(txtTesto, "Lunghezza del testo: " & txtTesto.TextLength & " caratteri") End Sub Abbiamo utilizzato il metodo TextChanged, in modo che il tooltip venga aggiornato ogni volta che si modifica il contenuto della casella di testo. In VB .NET possibile creare tooltip multilinea: sufficiente inserire il carattere vbCrLf all'interno del messaggio per andare a capo. La finestre di dialogo comuni in VB .NET Le finestre di dialogo comuni sono quelle finestre che, come dice il nome stesso, sono standard in tutte le applicazioni per Windows. Provate ad esempio ad avviare Blocco note e a selezionare i comandi Apri e Salva con nome del menu File: quelle che appariranno sono due delle finestre di dialogo comuni offerte da Windows; le altre sono le finestre Stampa, Colore e Carattere. Visual Basic ha sempre offerto degli stramenti per utilizzare tali finestre nelle proprie applicazioni: fino alle versione 6 essi erano contenute in un controllo OCX aggiuntivo, che quindi doveva essere distribuito insieme ad ogni programma che ne faceva uso, mentre in VB .NET le finestre di dialogo comuni fanno parte del corredo di controlli standard e sono OpenFileDialog, SaveFileDialog, FontDialog, ColorDialog e PrintDialog . In questo corso ci occuperemo delle finestre di dialogo per la gestione dei file. I controlli OpenFileDialog e SaveFileDialog sono molto simili; cominceremo quindi ad analizzare le propriet comuni. La propriet pi importante Filter, che consente di stabilire quali tipi di file verranno visualizzati nella finestra di dialogo (in pratica va a modificare la ComboBox Tipo file nelle finestre Apri e Salva con nome). La sua sintassi la seguente: Descrizione tipo file|Tipo file|Descrizione tipo file|Tipo file|| Ad esempio: File di testo|*.txt|Tutti i file|*.* La propriet Filter formata da coppie in cui il primo elemento la descrizione del tipo di file, mentre la seconda il filtro corrispondente. E' possibile specificare pi filtri corrispondenti ad una stessa descrizione; in questo caso devono essere separati da un punto e virgola, senza spazi: File immagine|*.bmp;*.jpg;*.gif|Tutti i file|*.* Il carattere | (pipe) usato per separare sia le varie coppie, sia la descrizione dal filtro in una stessa coppia. Quando si specificano pi filtri per una finestra di dialogo, la propriet FilterIndex consente di specificare il filtro predefinito. Le propriet CheckFileExists e CheckPathExists , se impostate su True, visualizzano un messaggio di errore se, rispettivamente, il file o il percorso selezionato nella finestra non esiste; tali propriet sono utili, ad esempio, quando si vuole aprire un file. InitialDirectory imposta la cartella che deve essere visualizzata quando si apre la finestra di dialogo. Il controllo SaveFileDialog ha una propriet molto importante: OverwritePrompt, che, se impostata su True, visualizza un messaggio di conferma qualora l'utente specifichi il nome di un file esistente per il salvataggio. Per visualizzare la finestra di dialogo necessario richiamare il metodo ShowDialog. Tale metodo disponibile in tutti i controlli comuni. Esso restituisce un valore che pu essere utilizzato per sapere se l'utente ha effettivamente selezionato un file oppure ha premuto il pulsante Annulla, quindi ha interrotto l'operazione. Si consideri ad esempio il codice seguente: If OpenFileDialog1.ShowDialog = DialogResult.OK Then MsgBox("File selezionato " & OpenFileDialog1.FileName) Else MsgBox("L'utent

Date post:	30-Oct-2015
Category:	Documents
Upload:	marco-mancin
View:	44 times
Download:	0 times

vb_dot_net

Documents