Condividi tramite

Modifiche importanti in Visual Basic 2010

  • Articolo

Nella tabella seguente vengono elencate tutte le modifiche che potrebbero impedire la compilazione in Visual Basic 2010 di un'applicazione creata in Visual Basic 2008 o che potrebbero modificare il comportamento in fase di esecuzione.

Categoria

Problema

Descrizione

Inferenza del tipo di matrice

Le regole di inferenza per gli inizializzatori di matrice sono state modificate.

Tramite l'inferenza Dim x() = {1, 2, 3} deduce ad esempio come tipo Integer.

Dim x() = {1, 2.2, "3"} causa un errore del compilatore quando Option Strict è impostato su On.

In Visual Basic 2008 quando si dichiara una variabile di matrice, ma si omette il tipo di elemento, il compilatore presuppone che il tipo di elemento sia Object. In Visual Basic 2010 è stata introdotta l'inferenza per i tipi di elementi matrice e viene dedotto che il tipo di elemento sia il tipo dominante del valore letterale della matrice.

Se non è presente un tipo dominante, si presuppone il tipo Object. In questo caso, se Option Strict viene impostato su On, si verifica un errore del compilatore.

Per ulteriori informazioni, vedere Arrays in Visual Basic.

Conflitti di denominazione

I tipi negli spazi dei nomi importati a livello di file hanno priorità sui tipi negli spazi dei nomi importati a livello di progetto.

Quando due spazi dei nomi contengono ciascuno un tipo con lo stesso nome, se un tipo si trova in uno spazio dei nomi importato a livello di progetto e l'altro in uno spazio dei nomi importato a livello di file, in Visual Basic 2010 viene stabilita l'associazione al tipo nello spazio dei nomi importato a livello di file. Nelle versioni precedenti viene stabilita l'associazione al tipo nello spazio dei nomi importato a livello di progetto. Per ulteriori informazioni, vedere Istruzione Imports (tipo e spazio dei nomi .NET).

Parole chiave di query come identificatori

L'utilizzo di una parola chiave di query come identificatore può produrre risultati imprevisti.

Il compilatore Visual Basic accetta le parole chiave come nomi di identificatori in vari contesti. A causa delle nuove regole di continuazione di riga implicita introdotte in Visual Basic 2010, è possibile che si verifichino errori se si utilizza una parola chiave come nome dell'elemento in una query LINQ che omette i caratteri di continuazione di riga.

Nell'esempio seguente viene utilizzata la parola chiave Aggregate come nome di identificatore. Se l'identificatore aggregate è immediatamente successivo a una query, viene considerato parte di tale query a causa delle regole di continuazione di riga implicita per le clausole di query. In questo esempio, viene generato un errore del compilatore.

Dim aggregate = 0
Dim numbers = {1, 2, 3, 4, 5}
Dim query As IEnumerable(Of Integer)

While aggregate < 5

    query = From i In numbers
            Skip aggregate
            Take 1
            Select i
    aggregate += 1

End While

Per assicurarsi che una riga non venga inclusa in modo implicito nella riga di codice precedente, inserire un'interruzione di riga aggiuntiva prima della riga di codice, come illustrato nell'esempio seguente.

    query = From i In numbers
            Skip aggregate
            Take 1
            Select i

    aggregate += 1

Per ulteriori informazioni sulla continuazione di riga implicita, vedere Istruzioni in Visual Basic.

Moduli

I moduli vengono compilati come MustInherit.

I moduli vengono ora compilati come MustInherit. Ciò non influisce sul comportamento dei moduli, ma può avere effetto sul codice che utilizza la reflection per esaminare i tipi creati dall'istruzione Module di Visual Basic. Per ulteriori informazioni, vedere Istruzione Module.

Espressioni lambda

Le espressioni lambda anonime generano tipi univoci.

I tipi delegati anonimi generati per le espressioni lambda sono sicuramente univoci. Ciò può influire sul codice che valuta l'uguaglianza dei tipi di delegati anonimi, come il codice nell'esempio seguente.

Dim x = Function(a As Integer) a + 1
Dim y = Function(b As Integer) b + 1

' Returns True in Visual Basic 2008. Returns False in Visual Basic 2010.
Dim t = x.GetType().Equals(y.GetType())

Per ulteriori informazioni, vedere Lambda Expressions.

Varianza nelle interfacce generiche

Le interfacce generiche possono essere causa di ambiguità.

Visual Basic 2010 supporta la varianza (covarianza e controvarianza) nelle interfacce generiche. È possibile che venga generato un avviso che segnala interfacce ambigue quando si implementano più interfacce, una delle quali deriva da un'altra.

Per ulteriori informazioni, vedere Varianza nelle interfacce generiche (C# e Visual Basic).

Metodi di estensione

I metodi locali vengono preferiti rispetto ai metodi di estensione.

Se un metodo di estensione viene definito con lo stesso nome e gli stessi parametri di un metodo definito per un tipo, il compilatore stabilisce l'associazione al metodo locale anziché al metodo di estensione. Questo comportamento corregge l'errore del comportamento di associazione di Visual Basic 2008. Per ulteriori informazioni, vedere Metodi di estensione (Visual Basic).

Tipi di valori nullable

Il test di un tipo di valore nullable per Nothing eseguito tramite l'operatore =, come illustrato nel codice seguente, genera un errore del compilatore.

Dim i? As Integer
If i = Nothing Then
  ' ...
End If

Se si esegue il test di un tipo di valore nullable per Nothing tramite l'operatore =, anche se il tipo di valore nullable è Nothing, il risultato sarà False, molto probabilmente non il risultato previsto. Utilizzare invece l'operatore Is, come illustrato nell'esempio seguente.

Dim i? As Integer
If i Is Nothing Then
  ' ...
End If

Chiamata implicita di proprietà o funzioni senza parametri

Se una funzione o una proprietà restituisce un valore indicizzabile, ad esempio una stringa o una matrice, è possibile utilizzare la sintassi abbreviata per fare riferimento a un elemento del valore restituito dall'indice solo se non sono presenti overload per la funzione o la proprietà.

Si consideri una proprietà o una funzione senza parametri che restituisce un valore indicizzabile, come illustrato nell'esempio seguente.

Class Sample

    Public Function GetValue() As String
        Return "Default Value"
    End Function

End Class

È possibile utilizzare la sintassi abbreviata per fare riferimento a un elemento del valore restituito dall'indice come illustrato nell'esempio seguente.

Dim o As Object = New Sample()
' Returns "D" if no overloads exist for the GetValue function.
Dim val = o.GetValue(0)

Visual Basic 2008 consente l'utilizzo della sintassi abbreviata per le chiamate ad associazione tardiva anche se esistono overload per la funzione o la proprietà. In Visual Basic 2010, è possibile utilizzare la sintassi abbreviata per fare riferimento a un elemento del valore restituito dall'indice solo se non sono presenti overload per la funzione o la proprietà.

Vincoli di Class

Il vincolo Class non viene più presupposto.

In Visual Basic 2008 il vincolo Class viene dedotto per un parametro generico se questo è vincolato da un secondo parametro generico vincolato a sua volta dal vincolo Class. In Visual Basic 2010 non viene più dedotto che un parametro generico erediti il vincolo Class, perché potrebbe essere stata creata un'istanza del primo parametro generico con un tipo che implementa un'interfaccia, ma non è una classe. Le interfacce soddisfano il vincolo Class.

Per assicurarsi che un parametro generico sia vincolato come classe, aggiungere il vincolo Class come illustrato nell'esempio seguente.

    ' The following code causes a compiler error.
    ' Function RefEquals(Of T1 As T2, T2 As Class)(ByVal x As T1, ByVal y As T2) As Boolean
    '     Return y Is x
    ' End Function

    ' The following code is valid in Visual Basic 2010.
    Function RefEquals(Of T1 As {T2, Class}, T2 As Class)(ByVal x As T1, ByVal y As T2) As Boolean
        Return y Is x
    End Function

Per ulteriori informazioni, vedere Generic Types in Visual Basic.

Metodi di classi parziali

Se un metodo che ha vincolato parametri generici viene dichiarato in più classi parziali, tutte le dichiarazioni del metodo devono avere vincoli identici.

È possibile dichiarare un metodo con parametri generici in più classi parziali. In Visual Basic 2008 il compilatore non richiede sempre la corrispondenza dei vincoli dei parametri generici per tutte le dichiarazioni del metodo. In Visual Basic 2010 è necessario che tutte le dichiarazioni del metodo abbiano vincoli identici.

Per ulteriori informazioni, vedere Generic Types in Visual Basic.

Strutture ad albero delle espressioni lambda

Rimozione del boxing non necessario delle istanze di tipi di parametri generici

In Visual Basic 2008, all'interno di una struttura ad albero di un'espressione lambda, se un tipo di parametro generico è vincolato a un'interfaccia, la chiamata di un metodo in un'istanza di questo tipo comporta sempre il boxing di tale istanza. In Visual Basic 2010 il boxing dell'istanza viene eseguito solo quando è necessario.

Per ulteriori informazioni sulle conversioni boxing e unboxing, vedere Visual Basic Language Specification.

Espressioni lambda e strutture ad albero dell'espressione

Una struttura ad albero di un'espressione lambda può essere restituita da una struttura ad albero di un'espressione lambda.

In Visual Basic 2008 se un'espressione lambda esegue il cast di un'espressione lambda in una struttura ad albero dell'espressione, in alcuni casi non viene eseguito il cast. Mediante il compilatore di Visual Basic 2010 viene eseguito correttamente il cast delle espressioni lambda come strutture ad albero dell'espressione se il cast ha luogo all'interno di un'espressione lambda.

Vedere anche

Concetti

Novità di Visual Basic 2010

Altre risorse

Guida introduttiva a Visual Basic