Con la prima versione di VB.NET la Microsoft tentò di spezzare i legami con il passato recente: Visual Basic 6.0, uno dei linguaggi di programmazione più diffusi al mondo.
VB.NET era un linguaggio completamente Object Oriented ed aveva in comune con il suo 'presunto' predecessore unicamente la sintassi ed alcune proprietà lasciate per consentire una facile migrazione. Questo portò ad una sostanziale differenziazione tra i due linguaggi principe del Framework: C# e VB.NET. Con la versione 2005 di Visual Basic, che per l'occasione ha ripreso il suo nome per esteso, gli sviluppatori di casa Redmond hanno esteso VB.NET per andare incontro sia ai vecchi sviluppatori Visual Basic 6 sia ai nuovi. I vecchi chiedevano delle funzioni che permettessero una reale transizione indolore ed i nuovi scontenti per la mancanza di alcune funzioni presenti in C#.
Per i programmatori Visual Basic 6 è stato introdotto l'oggetto 'My'. 'My' è composto da due parti separate, la prima non è altro che un collegamento alle librerie .NET utilizzate con maggiore frequenza mentre la seconda contiene degli oggetti creati dinamicamente quando vengono aggiunti
dei particolari oggetti al progetto.
Grazie a 'My' gli sviluppatori non saranno costretti ad imparare tutte le classi del Framework necessarie per la loro applicazione prima di iniziare a lavorare ma solo una minima parte. L'inserimento di quest'ultima parte potrà essere scritta facendo uso degli Snippet, veri e propri mini wizard di codice.
'My' è adesso presente anche su C# grazie al porting effettuato da programmatori indipendenti.
Il restante lavoro è stato effettuato per equiparare il linguaggio Visual Basic a C# e per rendere il codice più facile da scrivere e da eseguire.
I commenti XML permettono di documentare il codice con una spiegazione del comando, gli eventuali parametri, il valore restituito facendo in modo che siano visibili in tempo reale grazie ad Intellisense.
Non solo, il compilatore creerà un file XML con tutta la documentazione presente nei file sorgenti, file che potrà in seguito essere trasformato in un file CHM per esempio.
Da notare che il compilatore è in grado di verificare che i nomi dati ai parametri siano corretti e segnalerà in caso contrario un errore impedendo così la generazione di documentazione fallace.
La sintassi da apporre sopra la porzione di codice che vogliamo documentare è semplice. Per differenziare le normali righe commentate dai commenti per la documentazione dovremo inserire tre apici invece di uno.
La prima riga è data dal sommario ovvero da quello che fa il codice:
'''<summary>Effettua un'addizione</summary>
Seguono i parametri:
'''<param name="PrimoAddendo">Primo è
un intero.</param>
'''<param name="SecondoAddendo">Anche
Secondo è un intero.</param>
La lista completa di tutti i comandi la trovate all'interno della guida del Framework.Net 2.0
A seguito del commento scriveremo la nostra funzione di Addizione:
Private Function Addizione(ByVal PrimoAddendo As
Integer, ByVal SecondoAddendo As Integer) As Long
Return
PrimoAddendo + SecondoAddendo
End Function
ed inizieremo a scrivere una subroutine Somma
Sub Somma()
Dim risultato As
Long
risultato = A
Premendo adesso CTRL + SBARRA accederemo all'Intellisense di Visual Studio, scorrendo fino alla voce Addizione otteremo come commento la scritta inserita alla voce 'Summary'. Proseguendo nell'inserimento avremo lo stesso sia per il primo che per il secondo addendo.
Per facilitare la scrittura e la rilettura del codice è stato introdotto l'operatore 'IsNot'. 'IsNot', come dice il nome stesso può essere usato per rendere più leggibili righe di codice di questo tipo:
If Not Oggetto1 is Oggetto2 Then
con
If Oggetto1 IsNot Oggetto2 Then
che rende immediatamente chiara l'espressione di confronto.
A proposito di operatori, adesso Visual Basic 2005 supporta sia l'overload degli operatori che degli operatori di conversione. In questo modo potremo usare per esempio il simbolo dell'addizione (+) per far fare quello che vogliamo ad un nostro oggetto rendendo sempre più facile lo sviluppo della nostra applicazione. Allo stesso modo potremo ridefinire gli operatori di conversione per venire incontro alle nostre esigenze. Un utilizzo classico è la ridefinizione di 'CType' per le operazioni di casting.
Proprio in termini di casting abbiamo adesso a nostra disposizione i comandi 'TryCast' e 'TryParse'. Il primo tenta la conversione di un tipo reference e restituisce 'Nothing' in caso di fallimento mentre il secondo è un'evoluzione del metodo 'Parse'. A differenza dei corrispettivi 'CType' e 'Parse' questi non causeranno delle eccezioni in caso di fallimento. Per esempio:
Dim NumeroIntero As Integer
Dim NumeroStringa As
String
Dim Risultato As Boolean
Risultato =
Integer.TryParse(NumeroStringa, NumeroIntero)
non causerà nessuna eccezione ma assegnerà a Risultato True o False a seconda se la conversione è andata a buon fine o meno e a NumeroIntero il valore convertito di stringa o il suo valore predefinito ovvero 0. Possiamo quindi dire addio ai blocchi Try - Catch - Finally necessari per effettuare una conversione a rischio e per essere sicuri che il nostro programma non si blocchi e/o che non liberi le risorse occupate. È presente anche un metodo 'TryParseExact' per le date.
Inoltre, chi ha già avuto modo di scrivere del codice con il Framework 1.0 o 1.1 si sarà trovato nella situazione di dovere controllare ad uno ad uno i campi di un datareader per controllare che non siamo né 'Nothing' né vuoti per ogni singolo valore. Per velocizzare questa fastidiosa e lenta fase possiamo usare il metodo 'IsNullOrEmpty':
Vecchio metodo:
If Not dr("valore") Is Nothing AndAlso dr("valore").ToString().Length() > 0 Then
Nuovo Metodo:
If String.IsNullOrEmpty(dr("valore")) Then
Scrivendo in Visual Web Developer (VWD) la dichiarazione di NumeroStringa noteremo che l'ambiente la sottolineerà in verde, questo perchè il compilatore tende a segnalare tutte le variabili che potrebbero causare delle eccezioni. Nel caso di una stringa viene suggerita la sua impostazione a '' o al valore equivalente String.Empty, a differenza di quanto si possa pensare questo non comporterà un aumento di memoria utilizzata poiché tutte queste stringhe puntano ad uno stesso indirizzo.
Se nello scrivere la nostra applicazione vogliamo un controllo del codice più serrato possiamo impostare a 'True' l'opzione 'Option Strict', dalla riga apposita presente nel Web.Config nel caso di progetti Web,
<compilation debug="true" strict="false" explicit="true"/>
che obbligherà il compilatore a segnalare tutti i casi in cui un'operazione potrebbe causare un'eccezione. In genere si tratta di operazioni di casting non effettuate o effettuate senza sufficiente controllo.
Chi si interfaccia con le API di Windows potrà di nuovo usare i tipi 'Unsigned', ovvero senza segno. I tipi a disposizione sono 'SByte', 'UShort', 'UInteger' e 'ULong'. Questi tipi di dato possono essere usati anche per risparmiare spazio in memoria, per esempio nella nostra funzione di Addizione potremo usare il tipo 'UInteger' per farci restituire la somma di due 'Integer' senza dover ricorrere ad una variabile di tipo 'Long'.
Altra funzione adesso presente anche in Visual Basic 2005 è il blocco 'Using'. Questo blocco definisce delle operazioni con un oggetto che è possibile gettare alla fine del blocco. Per esempio la semplice scrittura di una nota su di un file di log. Al termine del blocco l'oggetto verrà distrutto all'istante, è consigliabile l'utilizzo con sequenze di codice che occupino una gran quantità di memoria.
Using FileDiLog As New
System.IO.StreamWriter("c:FileDiLog.txt")
FileDiLog.WriteLine("Questo
è un file di log!")
End Using
Gli sviluppatori Visual Basic 6 che ancora non si sono abituati alle matrici con limite 0 posso dichiararle anche in modo esplicito, così facendo perlomeno ci verrà ricordato all'instante il nuovo modo.
Dim MyMatrix(0 To 100) As String
È stata anche posta una pezza ad un buco logico che portava a scrivere una gran quantità di codice, sto parlando dell'istruzione 'Continue' che abilita i cicli 'Do', 'For' e 'While' ad una rapida uscita senza dovere ricorrere al comando 'Goto' e/o innumerevoli variabili di stato con relative 'If'. Provate ad immaginare questo esempio della guida senza l'istruzione 'Continue'.
Dim row, col As Integer
Dim lastrow As Integer =6
Dim lastcol As Integer = 10
Dim a(,) As Double = New Double(lastrow, lastcol){}
Dim b(7) As Double
row = -1
While row < lastrowrow += 1
col = -1
While col < lastcol
col
+= 1
a(row,col) = 0
For i As Integer = 0 To b.GetUpperBound(0)
If b(i) = col Then
Continue While
Else
a(row, col) += (row + b(i)) / (col - b(i))
End If
Next i
End While
End While
Infine una delle novità, se non la novità in assoluto, è l'introduzione dei 'Generics' che vista l'importanza verranno trattati in un articolo a loro dedicato.
Per concludere abbiamo visto che le novità introdotte nell'ultima versione di Visual Basic sono tante e tutte molto interessanti al punto da fare affermare che sia stata la più importante versione mai rilasciata e, spot e campagna di marketing a parte, sembra proprio così.
Visual Basic 2005, con il Framework.Net 2.0, aumenta le sue potenzialità colmando allo stesso tempo il divario tra C# e Visual Basic 6.
