Visual Basic .NET Language
Funzionalità di Visual Basic 14.0

introduzione

Operatore condizionale nullo

Per evitare il controllo null dettagliato, il ?. operatore è stato introdotto nella lingua.

La vecchia sintassi verbosa:

If myObject IsNot Nothing AndAlso myObject.Value >= 10 Then

Può essere ora sostituito dal conciso:

If myObject?.Value >= 10 Then

Il ? l'operatore è particolarmente potente quando si ha una catena di proprietà. Considera quanto segue:

Dim fooInstance As Foo = Nothing
Dim s As String

Normalmente dovresti scrivere qualcosa come questo:

If fooInstance IsNot Nothing AndAlso fooInstance.BarInstance IsNot Nothing Then
    s = fooInstance.BarInstance.Baz
Else
    s = Nothing
End If

Ma con il ? l'operatore può essere sostituito solo con:

s = fooInstance?.BarInstance?.Baz

Nome dell'operatore

L'operatore NameOf risolve spazio dei nomi, tipi, variabili e nomi dei membri in fase di compilazione e li sostituisce con l'equivalente della stringa.

Uno dei casi d'uso:

Sub MySub(variable As String)
    If variable Is Nothing Then Throw New ArgumentNullException("variable")
End Sub

La vecchia sintassi espone il rischio di rinominare la variabile e lasciare la stringa hardcoded al valore errato.

Sub MySub(variable As String)
    If variable Is Nothing Then Throw New ArgumentNullException(NameOf(variable))
End Sub

Con NameOf , la sola rinomina della variabile solleverà un errore del compilatore. Ciò consentirà inoltre allo strumento di ridenominazione di rinominare entrambi con un solo sforzo.

L'operatore NameOf utilizza solo l'ultimo componente del riferimento tra parentesi. Questo è importante quando si gestisce qualcosa come namespace nell'operatore NameOf .

Imports System

Module Module1
    Sub WriteIO()
        Console.WriteLine(NameOf(IO)) 'displays "IO"
        Console.WriteLine(NameOf(System.IO)) 'displays "IO"
    End Sub
End Module

L'operatore usa anche il nome del riferimento che viene digitato senza risolvere alcun cambiamento di nome nelle importazioni. Per esempio:

Imports OldList = System.Collections.ArrayList

Module Module1
    Sub WriteList()
        Console.WriteLine(NameOf(OldList)) 'displays "OldList"
        Console.WriteLine(NameOf(System.Collections.ArrayList)) 'displays "ArrayList"
    End Sub
End Module

Interpolazione a stringa

Questa nuova funzione rende più leggibile la concatenazione di stringhe. Questa sintassi verrà compilata alla sua chiamata String.Format equivalente.

Senza interpolazione delle stringhe:

String.Format("Hello, {0}", name)

Con interpolazione delle stringhe:

$"Hello, {name}"

Le due righe sono equivalenti e vengono entrambi compilati in una chiamata a String.Format .

Come in String.Format , le parentesi possono contenere qualsiasi singola espressione (chiamata a un metodo, proprietà, un operatore coalescente null eccetera).

String Interpolation è il metodo preferito su String.Format perché impedisce che si verifichino alcuni errori di runtime. Si consideri la seguente riga String.Format :

String.Format("The number of people is {0}/{1}", numPeople)

Questo verrà compilato, ma causerà un errore di runtime in quanto il compilatore non controlla che il numero di argomenti corrisponda ai segnaposto.

Auto-Proprietà di sola lettura

Le proprietà di sola lettura erano sempre possibili in VB.NET in questo formato:

Public Class Foo

  Private _MyProperty As String = "Bar"

  Public ReadOnly Property MyProperty As String
    Get
      Return _MyProperty
    End Get
  End Property

End Class

La nuova versione di Visual Basic consente una breve mano per la dichiarazione delle proprietà in questo modo:

Public Class Foo

  Public ReadOnly Property MyProperty As String = "Bar"

End Class

L'effettiva implementazione generata dal compilatore è esattamente la stessa per entrambi gli esempi. Il nuovo metodo per scriverlo è solo una mano breve. Il compilatore genererà comunque un campo privato con il formato: _<PropertyName> per supportare la proprietà di sola lettura.

Moduli e interfacce parziali

Simile alle classi parziali, la nuova versione di Visual Basic ora è in grado di gestire moduli parziali e interfacce parziali. La sintassi e il comportamento sono esattamente gli stessi di quelli per le classi parziali.

Un esempio di modulo parziale:

Partial Module Module1
  Sub Main()
    Console.Write("Ping -> ")
    TestFunktion()
  End Sub
End Module

Partial Module Module1
  Private Sub TestFunktion()
    Console.WriteLine("Pong")
  End Sub
End Module

E un'interfaccia parziale:

Partial Interface Interface1
  Sub Methode1()
End Interface

Partial Interface Interface1
  Sub Methode2()
End Interface

Public Class Class1
  Implements Interface1
  Public Sub Methode1() Implements Interface1.Methode1
    Throw New NotImplementedException()
  End Sub

  Public Sub Methode2() Implements Interface1.Methode2
    Throw New NotImplementedException()
  End Sub
End Class

Proprio come per le classi parziali, le definizioni per i moduli e le interfacce parziali devono trovarsi nello stesso spazio dei nomi e nello stesso assembly. Questo perché le parti parziali dei moduli e delle interfacce vengono unite durante la compilazione e l'assembly compilato non contiene alcuna indicazione che la definizione originale del modulo o dell'interfaccia sia stata divisa.

Letterali stringa multilinea

VB ora consente di ottenere stringhe letterali suddivise su più righe.

Vecchia sintassi:

Dim text As String = "Line1" & Environment.NewLine & "Line2"

Nuova sintassi:

Dim text As String = "Line 1
Line 2"

#Region miglioramenti alla direttiva

La direttiva #Region può ora essere collocata all'interno di metodi e può estendersi su metodi, classi e moduli.

#Region "A Region Spanning A Class and Ending Inside Of A Method In A Module"
   Public Class FakeClass
    'Nothing to see here, just a fake class.
   End Class

   Module Extensions

    ''' <summary>
    ''' Checks the path of files or directories and returns [TRUE] if it exists.
    ''' </summary>
    ''' <param name="Path">[Sting] Path of file or directory to check.</param>
    ''' <returns>[Boolean]</returns>
    <Extension>
    Public Function PathExists(ByVal Path As String) As Boolean
        If My.Computer.FileSystem.FileExists(Path) Then Return True
        If My.Computer.FileSystem.DirectoryExists(Path) Then Return True
        Return False
    End Function

    ''' <summary>
    ''' Returns the version number from the specified assembly using the assembly's strong name.
    ''' </summary>
    ''' <param name="Assy">[Assembly] Assembly to get the version info from.</param>
    ''' <returns>[String]</returns>
    <Extension>
    Friend Function GetVersionFromAssembly(ByVal Assy As Assembly) As String
#End Region
        Return Split(Split(Assy.FullName, ",")(1), "=")(1)
    End Function
End Module

Commenti dopo la continuazione della linea implicita

VB 14.0 introduce la possibilità di aggiungere commenti dopo la continuazione della linea implicita.

Dim number =
    From c As Char 'Comment
    In "dj58kwd92n4" 'Comment
    Where Char.IsNumber(c) 'Comment
    Select c 'Comment

La gestione delle eccezioni

Durante la codifica, gli errori imprevisti si verificano abbastanza frequentemente, il che richiede il debug e il test. Ma a volte gli errori sono effettivamente previsti e per aggirarlo, c'è il blocco Try..Catch..Throw..Finally..End Try .

Per gestire correttamente un errore, il codice viene inserito in un blocco Try..Catch , in cui il Catch , come afferma il nome, catturerà tutte le eccezioni che si presentano in questo blocco.

E in caso di eccezione, abbiamo la possibilità di Throw l'errore, cioè restituirlo per avvisare l'utente o gestirlo internamente nel codice stesso.

La Finally parte è il codice finale che, qualunque sia il risultato sia, se v'è o meno un'eccezione, il codice verrà eseguito prima di uscire del blocco.

Nel caso in cui sia necessario uscire dall'orologio, è possibile utilizzare l'istruzione Exit Try . Ma anche qui, il codice nella sezione Finally verrà eseguito prima di terminare.

La sintassi è semplice;

Try
    [ tryStatements ]
    [ Exit Try ]
[ Catch [ exception [ As type ] ] [ When expression ]
    [ catchStatements ]
    [ Exit Try ] ]
[ Catch ... ]
[ Finally
    [ finallyStatements ] ]
End Try

dove solo la Try e End Try è obbligatoria. Il resto può essere ignorato, ma come una buona pratica, non comprendono la Finally parte, anche se sarebbe essere lasciato vuoto.

Venendo all'eccezione, ci sono diversi tipi di eccezioni che possono essere scoperti. Sono disponibili eccezioni pronte disponibili da .Net Framework, come di seguito;