Le novità di Visual Basic 2010 - Il linguaggio, prima parte
a cura di Alessandro Del Sole (requisiti: conoscenza intermedia del linguaggio Visual Basic 2008 )Introduzione
Nel precedente articolo abbiamo introdotto le novità della Beta 1 di Microsoft Visual Studio 2010 a livello di ambiente integrato di sviluppo, osservando diverse nuove caratteristiche di pertinenza, in modo particolare, dell'editor di codice che, oltre ad essere ora basato su Windows Presentation Foundation, offre diversi strumenti per migliorare e semplificare la scrittura di codice.In questo secondo articolo della mini-serie dedicata a Visual Basic 2010, inizieremo ad illustrare le novità dal punto di vista del linguaggio. In particolare, ci occuperemo di introdurre le novità un pochino più semplici (ma non per questo meno interessanti), mentre nel prossimo articolo parleremo di quelle un po' più complesse. Inizieremo così a capire come cambierà il modo di scrivere il nostro codice nella prossima versione del linguaggio e osserveremo come questa versione abbia raggiunto un elevato livello qualitativo.
Anche in questo caso è bene ricordare che, essendo allo stato attuale Microsoft Visual Studio 2010 offerto in Beta 1, potrebbe essere soggetto a modifiche prima del rilascio della sua versione definitiva, anche se le novità sintattiche non dovrebbero subire particolari modifiche, dal momento che sono state introdotte (e rimaste pressoché invariate) fin dalla prima CTP pubblica di ottobre 2008.
Inoltre, a corredo del prossimo articolo verrà fornito tutto il codice sorgente, scaricabile dall'area download.
Cosa occorre
Per poter proseguire nella lettura dell'articolo è necessario scaricare e installare Visual Studio 2010 Beta 1, disponibile nelle seguenti edizioni:Una volta installato il tutto (altre indicazioni sono fornite nel primo articolo), possiamo iniziare a vedere qualche novità.
Il progetto per le prove
E' sufficiente creare un nuovo progetto per la Console (adatto per questo tipo di dimostrazione) in Visual Basic 2010, utilizzando il comando File|New project e selezionando il modello di progetto apposito nella finestra New project:
Assicuratevi che sia selezionata la versione 4.0 di .NET Framework e fate clic su OK, attendendo la generazione del nuovo progetto. Una volta che abbiamo il cursore pronto all'interno del modulo principale del progetto, possiamo iniziare con le novità.
Auto-implemented properties
Una delle novità più importanti del linguaggio è costituita dalle auto-implemented properties, ossia dalla nuova modalità di dichiarazione delle proprietà. Analogamente a quanto avviene in Visual C# già a partire dalla versione 2008, ora si può dichiarare una proprietà in una sola riga di codice:Public Property MiaProprieta As String
Questo equivale a scrivere il seguente codice Visual Basic 2008:
Private _miaProprieta As String
Public Property MiaProprieta() As String
Get
Return _miaProprieta
End Get
Set(ByVal Value As String)
_miaProprieta = Value
End Set
End Property
E' quindi un modo molto più immediato e intuitivo di dichiarare proprietà. E' anche possibile eseguire l'assegnazione già in fase di dichiarazione:
Public Property MiaProprieta As String = "Qualcosa"
Saremo poi in grado di utilizzare le proprietà nel modo consueto, non cambia assolutamente nulla, se non il fatto che ci risparmiamo di scrivere ogni volta blocchi di codice come quello sopra riportato. Ci sono essenzialmente due eccezioni a questa regola. La prima riguarda le proprietà a sola lettura, che funzionano ancora nel vecchio modo:
Private _counter As Integer
Public ReadOnly Property Counter() As Integer
Get
Return _counter + 1
End Get
End Property
La seconda eccezione riguarda l'operazione di ridefinizione, nell'ambito di una classe derivata. A esempio, quando ereditiamo da una classe e vogliamo ridefinirne una proprietà, Visual Studio 2010 offrirà la seguente definizione:
Public Overrides Property MiaProprieta() As String
Get
Return MyBase.MiaProprieta
End Get
Set(ByVal value As String)
MyBase.MiaProprieta = value
End Set
End Property
Questo ha un senso poiché potremmo voler modificare il comportamento della proprietà. Cosa, comunque, non sempre necessaria.
Implicit line continuation
La implicit line continuation, tradotto in continuazione implicita di linea, è una novità senza dubbio storica per Visual Basic. Infatti, ci consente di andare a capo all'interno delle linee di codice senza dover utilizzare il carattere underscore (_).
Questa novità, però, non influenza ogni ambito sintattico, ma solo alcuni specifici scenari. E' infatti possibile omettere di digitare il carattere undescore andando a capo tranquillamente nelle situazioni che ora illustriamo.
All'interno di una query LINQ:
Dim query = From proc In Process.GetProcesses.AsEnumerable
Where (proc.ProcessName.StartsWith("A"))
Select proc
All'interno di una espressione incorporata in LINQ to Xml:
Dim doc = <?xml version="1.0"?>
<Processes>
<%= From proc In query
Select <Process>
<Name <%= proc.ProcessName %>/>
</Process>
%>
</Processes>
Dopo le virgole e le parentesi graffe:
Dim p As New List(Of Integer) From {
1,
2,
3,
4}
Dopo il punto:
Dim appDataDir As String = My.Computer.FileSystem.
SpecialDirectories.AllUsersApplicationData()
Nel decorare oggetti con attributi:
<CLSCompliant(True)>
Class Test End Class
Al di fuori di questi casi, la continuazione implicita di linea non è consentita. A esempio, l'istruzione Handles vuole la continuazione esplicita nel vecchio stile:
Private Sub AnEventHandler(ByVal sender As Object, ByVal e As EventArgs) _
Handles anObject.Disposed End Sub
Optional nullable parameters
Visual Basic 2010 offre il supporto ad argomenti di tipo Nullable(Of T) per i parametri opzionali all'interno dei metodi. A esempio, la firma del seguente metodo è ora valida:
Private Sub DoSomething(ByVal someText As String,
Optional ByVal someNumber As Integer? = Nothing)
If someNumber Is Nothing Then
Console.WriteLine("Parameter is null")
End If
Console.ReadLine()
End Sub
È anche possibile inizializzare l'argomento direttamente nella firma.
Collection initializers
Dopo gli Object Initializers, introdotti con .NET Framework 3.5, che permettevano l'inizializzazione in-line dei membri di una classe direttamente in fase di istanza, con .NET Framework 4.0 vengono introdotti i Collection Initializers, una caratteristica che offre la stessa opportunità con le istanze delle collezioni.
Facciamo un esempio per capire meglio. Ipotizzando di voler istanziare una List(Of String) e popolarla con alcuni elementi, in Visual Basic 2008 dovremmo scrivere il seguente codice:
Dim customList As New List(Of String)
With customList
.Add("One")
.Add("Two")
.Add("Three")
End With
In Visual Basic 2010, invece, possiamo scrivere:
Dim customList As New List(Of String) From {"One", "Two", "Three"}
In sostanza, la parola chiave From seguita da una coppia di parentesi graffe contenenti i valori iniziali ci consente di istanziare e popolare una collection contestualmente alla sua istanza. Questo approccio vale per tutte le collezioni .NET, come ad esempio per i Dictionary(Of T, T):
Dim customDictionary As New Dictionary(Of String, Integer) From
{{"One", 1}, {"Two", 2}, {"Three", 3}}
Chiaramente, questo tipo di tecnica può essere utilizzato non solo nei confronti di tipi primitivi, ma anche di classi proprie. Ipotizzando di avere una classe Customer, che rappresenta un cliente, così definita:
Class Customer
Property CustomerID() As String
Property CompanyName As String
Property ContactName As String
End Class
E supponendo di avere alcune istanze della predetta classe, esemplificate in questo modo:
Dim alessandro As New Customer With {.CustomerID = "DELSO",
.CompanyName = "Del Sole S.p.A",
.ContactName = "Alessandro Del Sole"}
Dim diego As New Customer With {.CustomerID = "CATTA",
.CompanyName = "Cattaruzza S.r.l.",
.ContactName = "Diego Cattaruzza"}
Dim antonio As New Customer With {.CustomerID = "CATUC",
.CompanyName = "Catucci S.a.s.",
.ContactName = "Antonio Catucci"}
Dim renato As New Customer With {.CustomerID = "MARZA",
.CompanyName = "Marzaro S.n.c.",
.ContactName = "Renato Marzaro"}
Potremmo istanziare una collezione di qualunque tipo, purché generica nei confronti della classe Customer, popolandola direttamente in fase di istanza:
Dim customerFriends As New ObservableCollection(Of Customer) From {antonio,
alessandro,
renato,
diego}
I più attenti avranno anche notato che nel codice sopra evidenziato si fa utilizzo di alcune novità di VB 2010, come le auto-implemented properties e la implicit line continuation.
Array Literals, array multidimensionali e jagged arrays
Visual Basic 2010 offre importanti novità anche dal punto di vista della manipolazione di array.
La prima novità, propedeutica alle altre, è quella degli Array Literals ossia l'inferenza del tipo degli elementi degli array. Consideriamo la seguente riga di codice Visual Basic 2008, che dichiara un array di interi:
Dim intArray() As Integer = {1, 2, 3, 4}
In Visual Basic 2010, la stessa cosa si può fare in questo modo:
Dim intArray() = {1, 2, 3, 4}
Il compilatore inferisce il tipo Integer
La seguente riga, dichiara un array di stringhe utilizzando la nuova modalità:
Dim strArray = {"One", "Two", "Three", "Four"}
Il compilatore inferisce il tipo String.
Un'eccezione ovvia a questo particolare contesto si presenta nel momento in cui dichiariamo array misti. Considerate la seguente riga di codice:
Dim varArray = {"One", 1}
Non funziona con Option Strict On, viene visualizzato un messaggio di errore circa l'impossibilità di inferire il tipo. Con Option Strict Off il compilatore inferisce Object.
L'introduzione degli array literals permette di dichiarare allo stesso modo due particolari tipologie di array: gli array multidimensionali e i cosiddetti jagged arrays. Dei primi facciamo il seguente esempio:
Dim multiArray = {{1, 2}, {3, 4}}
Come vedete, la 'multidimensionalità' è data dal racchiudere coppie di parentesi graffe (contenenti i valori di interesse) all'interno di una coppia di altrettante graffe. Se vogliamo capire come Visual Basic interpreta la dichiarazione dell'array, ci basta passare col puntatore del mouse sopra la dichiarazione stessa per ottenere un tooltip descrittivo:
I jagged arrays, invece, sono array di array, ognuno dei quali può essere di tipo e dimensione diversi. L'inferenza del tipo serve proprio a rendere più facile la loro dichiarazione, come nel seguente esempio in cui si dichiara un array di array di interi:
Dim jaggedArray = {({1, 2}), ({3, 4})}
Anche in questo caso, passando col puntatore del mouse sulla dichiarazione, si ottiene qualche informazione utile su come il compilatore interpreta la dichiarazione stessa:
Per accedere al contenuto di un jagged array utilizziamo le modalità a noi già note:
Dim arr = jaggedArray(0)
La variabile arr è un array di interi che contiene i valori 1 e 2.
Conclusioni
Con i jagged arrays concludiamo il nostro primo contatto con le novità di Visual Basic 2010, di modo che possiate tirare il fiato e memorizzarle con calma. Nel prossimo articolo tratteremo molte cose interessanti, come la varianza generica, la distribuzione di applicazioni che sfruttano classi di Office senza assembly per l'interoperabilità, le espressioni lambda multi linea e la possibilità di sfruttare da codice VB altri linguaggi dinamici come IronPython.
Uno degli obiettivi che il Team di Visual Studio si è proposto è quello del miglioramento della coding experience. Le novità di Visual Basic, quindi, hanno proprio questa finalità oltre a rendere ancor più potente il linguaggio. Potete come di consueto contattarmi al mio indirizzo di posta elettronica o visitare il mio blog.
Risorse utili
Riporto, anche in questo caso, un elenco di link a risorse utili che vi serviranno per iniziare a prendere confidenza con Visual Studio 2010 Beta 1, partendo dai download fino alle risorse di apprendimento:
- Visual Studio 2010 and the .NET Framework 4.0 Beta 1
- Visual Studio 2010 and the .NET Framework 4.0 Beta 1 Walkthroughs
(non perdetevi, tra questi, l'intervista che ho fatto a Milind Lele di Microsoft Corp. durante l'MVP Global Summit inerente il databinding drag'n'drop per applicazioni WPF)
- MSDN Library - Visual Studio 2010
- Visual Basic 2010 Code Samples
- I miei screencast nell'apposita area di Visual Basic Tips & Tricks.
Nessun commento:
Posta un commento