Il passaggio evolutivo del .NET Framework che l'ha portato dalla versione 1.0, uscita più di dieci fa, alla versione 4.0 attuale, è stata costellata da importanti novità che hanno portato molteplici benefici al programmatore che sfrutta questa tecnologia. Senza entrare nei dettagli, le più importanti evoluzioni che ha vissuto il .NET Framework si possono riassumere nell'introduzione dei Generics, Iterator pattern, anonymous method e nullable type con la versione 2.0 del .NET Framework e degli anonymous type, extension methods, lambda expression e LINQ con la versione 3.0 e 3.5. Il .NET Framework 4.0 aggiunge ulteriormente altre novità, introducendo i Dynamic, gli optional parameter (in C#), la collection initializer (per VB), un maggiore falicilità nell'accesso degli oggetti COM, la covariance e contravariance più altre piccole novità che facilitano il lavoro del programmatore. Ma un'evoluzione importante è stata finalmente decisa riguardante i linguaggi di programmazione principali del .NET Framework: C# e VB.

Fin dall'inizio della loro storia all'interno del .NET Framework, questi due linguaggi hanno continuato la loro evoluzione attraverso due team separati all'interno di Microsoft, e si era giunti alla versione 3.5 con feature presenti nel primo linguaggio e non presenti nel secondo, e viceversa. Per esempio, in C#, ma non in VB, sono presenti l'auto implemented property che permette con una sola riga di codice la creazione di proprietà, oppure la collection initializer, che permette, in fase di dichiarazione di una collection, di specificare anche gli elementi al loro interno. Viceversa in VB sono presenti i parametri opzionali nei metodi e funzioni, che in C# non sono presenti. Per questo motivo nella nuova versione 4.0, Microsoft ha deciso che i due team dovevano cooperare per colmare il gap esistente tra i due linguaggi.

Nelle sezioni successive vedremo innanzitutto le novità introdotte in VB, visto che sono le più numerose, e di seguito le novità del C# e per entrambi i linguaggi.

Visual Basic 10

Una novità che farà piacere agli sviluppatori di VB è l'implicit line continuation. Anche se non è una novità del .NET Framework in sé e non introduce nessuna eclatante funzionalità, finalmente gli sviluppatori Microsoft hanno capito che lo sviluppo su più linee di codice non dev'essere sempre espressamente dichiarato come avviene fino alla versione 3.5. Per esempio, per scrivere su più righe una select con LINQ su una collection, dovevamo scrivere:

Dim collection = From c In mycollection _
  Where c.Id=1 _
  Select <Name>
           <%= c.Name %>
         </Name>

Dalla versione 10, implicitamente Visual Basic sa che le precedenti righe di codice fanno tutte riferimento alla prima riga e possiamo ora scrivere così:

Dim collection = From c In mycollection
  Where c.Id=1
  Select <Name>
           <%= c.Name %>
         </Name>

Ma in quali casi VB implicitamente sa che due o più righe sono parte dello stesso comando? Il tutto si può riassumere nella due liste successive. Ecco i token che implicitamente non necessitano dell'underscore prima di essere usati:

• * ), }, , (virgola), ]
• Linq keywords: Aggregate, Distinct, From, Group By, Group Join, Join, Let, Order By, Select, Skip, Skip While, Take, Take While, Where, In, Into, On, Ascending, Descending

E i token che implicitamente possono seguire sulla riga successiva senza underscore:

• , (virgola), . (punto), > (attributo), ( { (apertura parentesi)
• Linq keywords: Aggregate, Distinct, From, Group By, Group Join, Join, Let, Order By, Select, Skip, Skip While, Take, Take While, Where, In, Into, On, Ascending, Descending
• Operatori: + , - , * , / , \ , ^ , >> , << , Mod, & , += , -= , *= , /= , \= , ^= , >>= , <<= , &= , < , <= , > , >= , <> , Is, IsNot, Like, And, Or, Xor, AndAlso, OrElse
• With, nuova espressione nella dichiarazione delle collection che vedremo successivamente.

Finalmente è possibile inserire un attributo ad una classe od un metodo senza l'underscore dopo la sua dichiarazione, o inserire la dichiarazione di un metodo/funzione su più righe:

<Extension()>
Sub Insert(ByVal name As String,
           ByVal age As Integer,
           ByVal city As String)
  ' ...
End Sub

Notare l'assenza di underscore per concatenare le righe. Un altro gap che è stato recuperato in VB è nella dichiarazione delle lambda expression e per capire andiamo con ordine. Dalla versione 2005 di Visual Studio in VB dovevamo scrivere:

Function OnlyOneChar(ByVal s As String) As Boolean
  Return s.Length=1
End Function

Dim words() as string...
Dim query = Array.FindAll(words, AddressOf OnlyOneChar)

Dalla versione 2008 potevamo usare lambda expression:

Array.FindAll(words, Function(s) s.Length=1)

Fino alla versione precedente era obbligatorio inserire nelle lambda expression solo funzioni e non era possibile inserire metodi che non avessero il return di un qualsiasi valore/oggetto. Ora possiamo scrivere:

Array.ForEach(Words, Sub(s) Response.Write(s))

Ma possiamo dichiarare anche più istruzioni su più righe sfruttando l'implicit line continuation visto prima:

Array.ForEach(Words, Sub(s)
Response.Write(s)
Response.Write("<br />")
End Sub)

Questa sintassi risulta comoda anche per inserire codice per eventi:

AddHandler Button1.Click, Sub(sender as Object, e as EventArgs)
  Label1.Text="Clicked!"
End Sub

Ad inizio di questo articolo avevo parlato dell'auto implemented properties. In C# è possibile scrivere:

public string Name { get; set; }

Prima della nuova versione, in VB dovevamo scrivere:

Private _Name As String

Property Name As String
  Get
    Return _Name
  End Get
  Set (ByVal value As String)
    _Name = value
  End Set
End Property

Ora possiamo scrivere:

Property Name as String

Automaticamente il compilatore creerà la sezione get e set e una variabile privata per la property; normalmente inserisce l'underscore al nome inserito. Nell'esempio qui sopra è _Name.

Ultima novità riguardante VB per chiudere il gap con il C# è la collection initializer. Ora è possibile inserire in una collection gli elementi al momento della dichiarazione:

Dim numbers As New List(Of Integer) From { 0,1,2,3,4,5}
' Invece di:
Dim numbers As New List(Of Integer)
numbers.Add(0)
numbers.Add(1)
numbers.Add(2)

E' possibile anche con oggetti come il dictionary:

Dim collections As New Dictionary(Of String, Integer) From
{
  { "A", 1 },
  { "B", 2 },
  { "C", 3 }
}