Table Of ContentA1. Introduzione
Benvenuti, aspiranti programmatori! In questa guida dalla lunghezza chiolemtrica imparerete cosa significa e cosa
comporta programmare, e tutti i trucchi e gli espedienti per costruire solide e sicure applicazioni.
Una veloce panoramica sulla programmazione
La programmazione è quella disciplina dell'informatica che si occupa di ideare, costruire e mantenere il software.
Queste sono le tre principali divisioni che si possono operare all'interno di questa speciale e affascinante branca
dell'ingegneria. Infatti, un buon programmatore deve prima di tutto analizzare il problema, quindi pensare a una
possibile soluzione, se esiste, e costruire mentalmente un'ipotetica struttura del software che dovrà impegnarsi a
scrivere: questa parte della progettazione si chiama analisi. Successivamente, si viene alla fase più tecnica, e che
implica una conoscenza diretta del linguaggio di programmazione usato: in questa guida, mi occuperò di descrivere il
Visual Basic .NET. Una volta sviluppato il programma, lo si deve testare per trovare eventuali malfunzionamenti (bugs)
- che, per inciso, si manifestano solo quando non dovrebbero - e, come ultima operazione, bisogna attuare una
manutenzione periodica dello stesso, od organizzare un efficiente sistema di aggiornamento. Inutile dire che l'ultima
fase è necessaria solo nel caso di grandi applicazioni commerciali e non certamente nel contesto di piccoli programmi
amatoriali.
Prima di iniziare, una breve sintesi di alcuni dettagli tecnici: i termini da conoscere, e gli ambienti di sviluppo da
usare.
Alcuni termini da conoscere
Codice sorgente o sorgente: l'insieme di tutte le istruzioni che il programmatore scrive e fa eseguire al
programma. Il file testuale che contiene tali istruzioni viene esso stesso chiamato sorgente
Compilatore: il software utilizzato per creare il programma finito (un eseguibile *.exe) a partire dal solo codice
sorgente
Debugger: il software usato per l'analisi e la risoluzione degli errori (bugs) all'interno di un programma;
Parole riservate o keywords: di solito vengono evidenziate dai compilatori in un colore diverso e sono parole
predefinite intrinseche del linguaggio, che servono per scopi ben precisi.
Ambiente di sviluppo
L'ambiente di sviluppo che prenderò come riferimento per questa guida è Visual Basic Express 2008 (scaricabile dal
Sito Ufficiale della Microsoft; se si ha un profilo Passport.NET è possibile registrare il prodotto e ottenere una
versione completa). Potete comunque scaricare SharpDevelop da qui (vedi sezione downloads), un programma gratis e
molto buono (troverete una recensione nella sezione Sofwtare di PieroTofy.it redatta da me e HeDo qui). Dato che le
versioni precedenti della guida, dalle quali è ripresa la maggioranza dei sorgenti proposti, sono state redatte
prendendo come esempio Visual Basic Express 2005, potete scaricare anche quello da qui.
A2. Classi, Moduli e Namespace
Object Oriented Programming
I linguaggi .NET sono orientati agli oggetti e così lo è anche VB.NET. Questo approccio alla programmazione ha avuto
molto successo negli ultimi anni e si basa fondamentalmente sui concetti di astrazione, oggetto e interazione fra
oggetti. A loro volta, questi ultimi costituiscono un potente strumento per la modellizzazione e un nuovo modo di
avvicinarsi alla risoluzione dei problemi. La particolare mentalità che questa linea di sviluppo adotta è favorevole alla
rappresentazione dei dati in modo gerarchico, e per questo motivo il suo paradigma di programmazione - ossia
l'insieme degli strumenti concettuali messi a disposizione dal linguaggio e il modo in cui il programmatore concepisce
l'applicativo - è definito da tre concetti cardine: l'ereditarietà, il polimorfismo e l'incapsulamento. Molto presto
arriveremo ad osservare nel particolare le caratteristiche di ognuno di essi, ma prima vediamo di iniziare con
l'introdurre l'entità fondamentale che si pone alla base di tutti questi strumenti: la classe.
Le Classi
Come dicevo, una caratteristica particolare di questa categoria di linguaggi è che essi sono basati su un unico
importantissimo concetto fondamentale: gli oggetti, i quali vengono rappresentati da classi. Una classe non è altro che
la rappresentazione - ovviamente astratta - di qualcosa di concreto, mentre l'oggetto sarà una concretizzazione
di questa rappresentazione (per una discussione più approfondita sulla differenza tra classe e oggetto, vedere capitolo
A7). Ad esempio, in un programma che deve gestire una videoteca, ogni videocassetta o DVD è rappresentato da una
classe; in un programma per la fatturazione dei clienti, ogni cliente e ogni fattura vengono rappresentati da una
classe. Insomma, ogni cosa, ogni entità, ogni relazione - perfino ogni errore - trova la sua rappresentazione in una
classe.
Detto questo, viene spontaneo pensare che, se ogni cosa è astratta da una classe, questa classe dovrà anche contenere
dei dati su quella cosa. Ad esempio, la classe Utente dovrà contenere informazioni sul nome dell'utente, sulla sua
password, sulla sua data di nascita e su molto altro su cui si può sorvolare. Si dice che tutte queste informazioni sono
esposte dalla classe: ognuna di esse, inoltre, è rappresentata da quello che viene chiamato membro. I membri di una
classe sono tutti quei dati e quelle funzionalità che essa espone.
Per essere usabile, però, una classe deve venire prima dichiarata, mediante un preciso codice. L'atto di dichiarare una
qualsiasi entità le permette di iniziare ad "esistere": il programmatore deve infatti servirsi di qualcosa che è già stato
definito da qualche parte, e senza di quello non può costruire niente. Con la parola "entità" mi riferisco a qualsiasi cosa
si possa usare in programmazione: dato che le vostre conoscenze sono limitate, non posso che usare dei termini
generici e piuttosto vaghi, ma in breve il mio lessico si farà più preciso. Nella pratica, una classe si dichiara così:
1. Class [NomeClasse]
2. ...
3. End Class
dove [NomeClasse] è un qualsiasi nome che potete decidere arbitrariamente, a seconda di cosa debba essere
rappresentato. Tutto il codice compreso tra le parole sopra citate è interno alla classe e si chiama corpo; tutte le
entità esistenti nel corpo sono dei membri. Ad esempio, se si volesse idealizzare a livello di codice un triangolo, si
scriverebbe questo:
1. Class Triangolo
2. ...
3. End Class
Nel corpo di Triangolo si potranno poi definire tutte le informazioni che gli si possono attribuire, come la lunghezza
dei lati, la tipologia, l'ampiezza degli angoli, eccetera...
I Moduli
Nonostante il nome, i moduli non sono niente altro che dei tipi speciali di classi. La differenza sostanziale tra i due
termini verrà chiarita molto più avanti nella guida, poiché le vostre attuali competenze non sono sufficienti a un
completo apprendimento. Tuttavia, i moduli saranno la tipologia di classe più usata in tutta la sezione A.
I Namespace
Possiamo definire classi e moduli come unità funzionali: essi rappresentano qualcosa, possono essere usate,
manipolate, istanziate, dichiarate, eccetera... Sono quindi strumenti attivi di programmazione, che servono a
realizzare concretamente azioni e a produrre risultati. I namespace, invece, appartengono a tutt'altro genere di
categoria: essi sono solo dei raggruppamenti "passivi" di classi o di moduli. Possiamo pensare a un namespace come ad
una cartella, entro la quale possono stare files, ma anche altre cartelle, ognuna delle quali raggruppa un particolare
tipo di informazione. Ad esempio, volendo scrivere un programma che aiuti nel calcolo geometrico di alcune figure, si
potrebbe usare un codice strutturate come segue:
01. Namespace Triangoli
02. Class Scaleno
03. '...
04. End Class
05.
06. Class Isoscele
07. '...
08. End Class
09.
10. Class Equilatero
11. '...
12. End Class
13. End Namespace
14.
15. Namespace Quadrilateri
16. Namespace Parallelogrammi
17. Class Parallelogramma
18. '...
19. End Class
20.
21. Namespace Rombi
22. Class Rombo
23. '...
24. End Class
25.
26. Class Quadrato
27. '...
28. End Class
29. End Namespace
30. End Namespace
31. End Namespace
Come si vede, tutte le classi che rappresentano tipologie di triangoli (Scaleno, Isoscele, Equilatero) sono all'interno del
namespace Triangoli; allo stesso modo esiste anche il namespace Quadrilateri, che contiene al suo interno un altro
namespace Parallelogrammi, poiché tutti i parallelogrammi sono quadrilateri, per definizione. In quest'ultimo esiste la
classe Parallelogramma che rappresenta una generica figura di questo tipo, ma esiste ancora un altro namespace
Rombi: come noto, infatti, tutti i rombi sono anche parallelogrammi.
Dall'esempio si osserva che i namespace categorizzano le unità funzionali, dividendole in insiemi di pertinenza. Quando
un namespace si trova all'interno di un altro namespace, lo si definisce nidificato: in questo caso, Paralleloogrammi e
Rombi sono namespace nidificati. Altra cosa: al contrario della classi, gli spazi di nomi (italianizzazione dell'inglese
name-space) non possiedono un "corpo", poiché questo termine si può usare solo quando si parla di qualcosa di attivo;
per lo stesso motivo, non si può neanche parlare di membri di un namespace.
A3. Panoramica sul Framework .NET
Come ho spiegato nel precedente capitolo, il concetto più importante della programmazione ad oggetti è la classe.
Quindi, per scrivere i nostri programmi, utilizzeremo sempre, bene o male, queste entità. Ma non è possibile pensare
che si debba scrivere tutto da zero: per i programmatori .NET, esiste un vastissimo inventario di classi già pronte,
raggruppate sotto una trentina di namespace fondamentali. L'insieme di tutti questi strumenti di programmazione è il
Framework .NET, l'ossatura principale su cui si reggono tutti i linguaggi basati sulla tecnologia .NET (di cui Vb.NET è
solo un esponente, accanto al più usato C# e agli altri meno noti, come J#, F#, Delphi per .NET, eccetera...). Sarebbe
tuttavia riduttivo descrivere tale piattaforma come un semplice agglomerato di librerie (vedi oltre), quando essa
contempla meccanismi assai più complessi, che sovrintendono alla generale esecuzione di tutte le applicazioni .NET.
L'intera struttura del Framework si presente come stratificata in diversi livelli:
1. Sistema operativo
Il Framework .NET presenta una struttura stratificata, alla base della quale risiede il sistema operativo, Windows. Più
precisamente, si considera il sistema operativo e l'API (Application Programming Interface) di Windows, che espone
tutti i metodi resi disponibili al programmatore per svolgere un dato compito.
2. Common Language Runtime
Un gradino più in su c'è il Common Language Runtime (CLR), responsabile dei servizi basilari del Framework, quali la
gestione della memoria e la sua liberazione tramite il meccanismo di Garbage Collection (vedi capitolo relativo), la
gestione strutturata delle eccezioni (errori) e il multithreading. Nessuna applicazione interagisce mai direttamente
con il CLR, ma tutte sono allo stesso modo controllate da esso, come se fosse il loro supervisore. Proprio per questo si
definisce il codice .NET Managed o Safe ("Gestito" o "Sicuro"), poichè questo strato del Framework garantisce che non
vengano mai eseguite istruzioni dannose che possano mandare in crash il programma o il sistema operativo stesso. Al
contrario, il codice Unmanaged o Unsafe può eseguire operazioni rischiose per il computer: sorgenti prodotti in Vb6 o
C++ possono produrre tale tipo di codice.
3. Base Class Library
Lo strato successivo è denominato Base Class Library (BCL): questa parte contiene tutti i tipi e le classi disponibili nel
Framework (il che corrisponde in numero a diverse migliaia di elementi), raggruppati in una trentina di file principali
(assembly). In questi ultimi è compresa la definizione della classe System.Object, dalla quale deriva pressochè ogni altra
classe. I dati contenuti nella BCL permettono di svolgere ogni operazione possibile sulla macchina.
4. XML
Successivamente troviamo i dati, le risorse. Per salvare i dati viene usato quasi sempre il formato XML (eXtensible
Markup Language), che utilizza dei tag spesso nidificati per contenere i campi necessari. La struttura di questo tipo di
file, inoltre, è adatta alla rappresentazione gerarchica, un metodo che nell'ambiente .net è importantissimo. I file di
configurazione e quelli delle opzioni impostate dell'utente, ad esempio, vengono salvati in formato XML. Anche la nuova
tecnologia denominata Windows Presentation Foundation (WPF), introdotta nella versione 3.5 del Framework, che
permette di creare controlli dalla grafica accattivante e stravagante, si basa su un linguaggio di contrassegno (di
markup) surrogato dell'XML.
5. Windows Forms e ASP.NET
Al livello superiore troviamo ASP.NET e Windows Forms, ossia le interfacce grafiche che ricoprono il codice
dell'applicazione vera e propria. La prima è una tecnologia pensata per lo sviluppo sul Web, mentre la seconda fornisce
sostanzialmente la possibilità di creare una interfaccia grafica (Graphical User Interface, GUI) in tutto e per tutto
uguale a quella classica, a finestre, dei sistemi operativi Windows. La costruzione di una Windows Form (ossia una
singola finestra) è semplice e avviene come nel Vb classico, e chi sta leggendo questa guida per passare dal VB6 al
VB.NET lo saprà bene: si prendono uno o più controlli e li si trascinano sulla superficie della finestra, dopodichè si scrive
il codice associato ad ognuno dei loro eventi.
6. Common Language Specifications
Il penultimo stadio della stratificazione del Framework coincide con le Common Language Specifications (CLS), ossia un
insieme di specifiche che definiscono i requisiti minimi richiesti a un linguaggio di programmazione per essere
qualificato come .NET. Un esempio di tali direttive: il linguaggio deve sapere gestire tipi base come stringhe e numeri
interi, vettori e collezioni a base zero e deve saper processare un'eccezione scatenata dal Framework.
7. Linguaggi .NET
In cima alla struttura ci sono tutti i linguaggi .net: Vb, C#, J#, eccetera.
Versioni del Framework
Con il passare degli anni, a partire dal 2002, Microsoft ha rilasciato versioni successive del Framework .NET e ognuna
di queste release ha introdotto nuovi concetti di programmazione e nuove possibilità per lo sviluppatore.
Parallelamente all'uscita di queste nuove versioni, sono state create anche edizioni successive del linguaggio VB.NET,
ognuna delle quali è stata naturalmente accostata alla versione del Framework su cui si reggeva. Ecco una rapida
panoramica dell'evoluzione del linguaggio:
VB2002: si basa sulla versione 1.0 del Framework
VB2003: si basa sulla versione 1.1 del Framework
VB2005: si basa sulla versione 2.0 del Framework. Questa è la versione maggiormente utilizzata in questa
guida, sebbene certi capitoli si concentreranno sull'introduzione di alcuni nuovi aspetti portati da VB2008
VB2008: si basa sulla versione 3.5 del Framework. La versione 3.0 si fondava ancora sulla 2.0 del CLR e perciò le
modifiche consistevano sostanzialmente nell'aggiunta di alcuni componenti e nell'apporto di diverse migliorie e
correzioni
VB2010: si basa sulla versione 4.0 del Framework
A4. Utilizzo base dell'IDE
IDE? Me lo sono dimenticato a casa...
Non vi preoccupate: se avete seguito tutti i capitoli fino a questo punto, siete già un possesso di un IDE: Visual Basic
2005 (o 2008) Express. L'acronimo IDE significa Integrated Development Environment ("ambiente di sviluppo integrato")
ed indica un software che aiuta il programmatore nella stesura del codice. Il software che vi ho consigliato fornisce,
sebbene sia la versione free, un numero molto alto di strumenti e tools. In primis, contiene, ovviamente, un editor di
codice sorgente, progettato in modo da evidenziare in modo differente le keywords e da supportare molte funzioni di
ricerca e raggruppamento che vedremo in seguito. Accanto a questo, i principali componenti che non possono mancare
in un IDE sono il compilatore ed il debugger, di cui ho dato una veloce definizione nel capitolo introduttivo. Il primo ha
lo scopo di leggere il sorgente scritto dal programmatore e produrre da questo un eseguibile: i passi che vengono
portati a termine durante un processo di compilazione sono in realtà più di uno (di solito compilazione e linking), ma
molto spesso si semplifica il tutto parlando semplicemente di compilazione. Il secondo, invece, è il programma che vi
darà più filo da torcere, anche se in realtà sarà il vostro migliore aiutante (diciamo che vi sfinirà a fin di bene): il
debugger ha la funzione di analizzare e segnalare i bugs (bachi, errori) che si verificano durante l'esecuzione; assieme
ad un rapporto dettagliato del tipo di errore verificatosi, segnala parallelamente anche il punto del codice che ha dato
problemi, in modo da rendere molto più semplice individuare e correggere la falla.
Funzionamento del compilatore .NET
Il compilatore è, come già detto, quel software necessario a "trasformare" il codice sorgente scritto in un determinato
linguaggio in un programma eseguibile. Normalmente, un compilatore produrrebbe un applicativo traducendo le
istruzioni testuali introdotte dal programmatore in linguaggio macchina, ossia una serie di bit univocamente
interpretabile dal processore. I compilatori .NET, invece, hanno un comportamento differente, in quanto il loro output
non è un "normale programma" scritto in linguaggio macchina, ma si tratta di una serie di istruzioni codificate in un
altro linguaggio speciale, chiamato IL (Intermediate Language). Come suggerisce il nome, esso si trova ad un livello
intermedio tra la macchina e l'astrazione: è superiore rispetto al puro codice binario, ma allo stesso tempo è un
gradino più sotto rispetto ai linguaggi .NET. Venendo a conoscenza di queste informazioni, dovrebbe sorgere
spontaneamente una domanda: come fa allora un programma .NET ad essere eseguito? La risposta è semplice: è lo
stesso Framework che si occupa di interpretarne le istruzioni e di eseguirle, sempre sotto la supervisione del CLR. Per
questo motivo, si hanno tre importanti conseguenze:
Non è possibile far correre un'applicazione .NET su una macchina sprovvista del Framework;
Il codice .NET è sempre sicuro;
Un programma .NET è sempre disassemblabile: su questo punto mi soffermerò in seguito.
Creare una Console Application
Nei prossimi capitoli inizerò ad introdurre la sintassi del linguaggio, ossia le regole da rispettare quando si scrive un
codice. Per tutti gli esempi della sezione A, farò uso di applicazioni console (avete presente la finestrella con lo sfondo
nero?), che lavorano in DOS. Per creare una Applicazione Console bisogna selezionare dal menù File del compilatore, la
voce New Project, e quindi scegliere il tipo di applicazione desiderata. Dopodichè, il compilatore scriverà
aumaticamente alcune righe di codice preimpostate, che possono essere simili a queste:
Module Module1
Sub Main()
End Sub
End Module
Nello screenshot proposto qui sopra si possono vedere le tre aree in cui è solitamente divisa l'interfaccia del
compilatore: non vi preoccupate se la vostra appare differente, poiché, essendo modificabile a piacimento, la mia
potrebbe essere diversa dal layout preimpostato del compilatore. Per ora, le finestre importanti sono due: quella del
codice, dove andremo a scrivere le istruzioni, e quella degli errori, dove potrete tenere costantemente sott'occhio se
avete commesso degli errori di sintassi. Nello screenshot la seconda di queste non è visibile, ma la si può portare in
primo piano tenendo premuto Ctrl e digitando in successione "\" ed "E".
Per quanto riguarda il codice che appare, ho già specificato in precedenza che i moduli sono dei tipi speciali di classe, e
fin qui vi basterà sapere questo. Quello che potreste non conoscere è la parte di sorgente in cui appaiono le parole Sub
ed End Sub: anche in questo caso, la trattazione particolare di queste keywords sarà rimandata più in là. Per ora
possiamo considerare la Sub Main() come il programma intero: ogni cosa che viene scritta tra "Sub Main()" ed "End Sub"
verrà eseguita quando si premerà il pulsante Start (il triangolino verde in alto sulla barra degli strumenti), o in
alternativa F5.
Compilazione del programma finito
Una volta finito di scrivere il codice e di testarlo usando le funzioni dell'IDE (ivi compresa l'esecuzione in modalità debug
premendo F5), sarà necessario creare il programma finito. Quello che avete eseguito fin'ora non era altro che una
versione più lenta e meno ottimizzata del software scritto, poiché c'era bisogno di controllare tutti gli errori e i bugs,
impiegando tempo e spazio per memorizzare le informazioni relative al debug, appunto. Per creare l'applicazione
reale finita, è necessario compilare il codice in modalità release. Aprite la scheda delle proprietà di progetto, dal menù
principale Project > [NomeProgetto] Properties (l'ultima voce del sottomenù); selezionate la scheda Compile e cambiate
il campo Configuration su Release, quindi premete Build > Build Project (Build è sempre una voce del menù principale).
Troverete l'eseguibile compilato nella cartella Documenti\Visual Studio 2008\Projects\[Nome progetto]\bin\Release.
