1.1. Visual Basic.NET: un nuovo linguaggio di programmazione Una breve introduzione a Visual Basic.NET, per iniziare a prendere confidenza con il nuovo ambiente di sviluppo. 1. 2. I cambiamenti nei tipi di dato e nelle dichiarazioni I tipo di dato e le dichiarazioni in VB.NET presentano delle differenze in alcuni casi anche significative rispetto alle versioni precedenti 2. 3. Utilizzo di classi in VB.NET Vediamo come si definisce una classe in VB.NET e quali sono le sue caratteristiche essenziali. 3. 4. Ereditarietà Vediamo come VB.NET consente di utilizzare l'ereditarietà, una delle caratteristiche fondamentali di ogni linguaggio di programmazione orientato agli oggetti. 4. 5. Polimorfismo Il polimorfismo e il suo uso in VB.NET. Come definire all'interno delle classi metodi e proprietà con lo stesso nome. 5. 6. Overloading L'overloading è la terza caratteristica basilare di un linguaggio orientato gli oggetti. Vediamo i meccanismi che Visual Basic.NET offre per implementarlo. 6. 7. Il nuovo ambiente di sviluppo Una rapida panoramica sulle caratteristiche del nuovo ambiente di sviluppo. 7. 8. La Windows form Cominciamo ad esaminare la Windows form, il componente fondamentale di un'applicazione VB.NET. 8. 9. La Windows form - parte seconda Continuamo la nostra analisi delle caratteristiche principali della Windows form. I controlli di Visual Basic.NET e la programmazione pratica 1. 10. La TextBox Cominciamo l'analisi dei controlli di Visual Basic.NET con uno dei più utilizzati: la TextBox 2. 11. I controlli PictureBox, Panel e GroupBox Continuiamo il nostro esame dei controlli standard di VB.NET: in questa lezione ci occupiamo dei controlli PictureBox, Panel e GroupBox. 3. 12. I controlli ListBox, CheckedListBox e ComboBox Tre controlli molto usati in Visual Basic.NET, utili per integrare nei programmi una lista di opzioni selezionabili dall'utente. 4. 13. Menu e Tooltip in VB.NET La gestione de menu e dei Tooltip in VB.NET presenta cambiamenti significativi rispetto alle versioni precedenti. Vediamo quali sono le novità principali. 5. 14. Menu e Tooltip in VB.NET - un esempio pratico Iniziamo la realizzazione di una piccola applicazione di esempio per mettere in pratica quanto abbiamo detto nella lezione precedente. 6. 15. La finestre di dialogo comuni in VB.NET Le finestre di dialogo comuni sono presenti praticamente in tutte le applicazioni per Windows. Esaminiamo gli strumenti che VB.NET offre per utilizzarle.
7. 16. La gestione degli errori in VB.NET VB.NET introduce delle novità anche per quanto riguarda la gestione degli errori. La Class Library: un nuovo tipo di progetto 1. 17. Il controllo NotifyIcon e le applicazioni senza interfaccia utente Il controllo NotifyIcon permette di inserire con facilità un'icona nella barra delle applicazioni, a fianco dell'orologio. Vediamo come utilizzarlo, realizzando un'applicazione senza interfaccia utente, che rimane costantemente in background. 2. 18. La Class Library La Class Library è un nuovo tipo di progetto che può essere realizzato con VB.NET. In questa lezione esaminiamo le sue caratteristiche basilari attraverso un piccolo esempio pratico. 3. 19. Utilizzare una Class Library in un progetto Completiamo il discorso iniziato nella lezione precedente discutendo di come sia possibile utilizzare una Class Library all'interno di un altro progetto. Considerazioni finali 1. 20. Compilare e distribuire un'applicazione Concludiamo il corso su Visual Basic.NET con alcune considerazioni relative alla compilazione ed alla distribuzione di unâ applicazione. 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. Al momento della stesura di questa Guida non era ancora disponibile Visual Basic.NET in italiano, quindi si è fatto riferimento ai nomi dei menu e delle finestre della versione inglese; dove possibile, è stata fornita una traduzione, che però in alcuni casi potrebbe non corrispondere con l'effettiva localizzazione in italiano. 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 Dim I As Integer Visual Basic.NET 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 fissa 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 Public Type IMPIEGATO Nome As String Matricola As String End Type Visual Basic.NET 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 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 Private Sub DoSomething(frm As Form, Optional I As Integer)... Visual Basic.NET Private Sub DoSomething(ByVal frm As Form, Optional ByVal I As Short = -1)... 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 <nome funzione> = 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 Dopo questa panoramica sui principali cambiamenti nei tipi di dato e nelle dichiarazioni, nella prossima lezione ci occuperemo del concetto di classe, già presente nelle versioni precedenti di Visual Basic, ma che in VB.NET assume un'importanza centrale, essendo alla base della programmazione orientata agli oggetti. 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 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
Public Sub VisualizzaNome() '... 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() '... 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 commentiamo 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 Il termine polimorfismo indica la possibilità di implementare in modo speciale metodi e proprietà eredidati dalla classe base mantenendone il 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'overloading, altra importante caratteristica dei linguaggi di programmazione orientati agli oggetti, che sarà discussa nella prossima Lezione. 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 & ".") Public Sub Prova(ByVal Numero As Integer) MsgBox("Il numero specificato è: " & Numero & ".") 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), Visual 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. 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" Sub New(ByVal snome As String) NomeGiocatore = snome '... 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 Options (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 esempio, 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. Dopo questa breve panoramica sulle nuove caratteristiche di Visual Studio.NET, siamo finalmente pronti ad entrare nel vivo della programmazione. Cominceremo con l'analizzare la Windows form, che sarà l'argomento della prossima Lezione. La Windows form Visual Basic.NET introduce un nuovo oggetto, la Windows form, che prende il posto della 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 nella precedente lezione. 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 nella lezione "Utilizzo di classi in VB.NET" 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 (per una breve descrizione dei namespace, si rimanda alla lezione 3. 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 informazioni 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!") 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 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 Supponiamo di voler stampare un messaggio diverso a seconda che si digiti una consonante o una vocale. Il codice da scrivere è: 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 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. 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() 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. Potete scaricare un esempio che mostra l'uso di ShowDialog e Show facendo clic qui. 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 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() 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. Opacity consente di impostare 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. 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. 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 nella precedente Lezione 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 (vedi "Utilizzo di classi in VB.NET"), 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() 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. Potete scaricare un esempio che mostra l'uso di ShowDialog e Show facendo clic qui. 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 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() 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 nelle Lezioni successive. Opacity consente di impostare 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. 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. La 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