Visual Basic .NET Language
Fonctionnalités de Visual Basic 14.0

Introduction

Opérateur conditionnel nul

Pour éviter la vérification nulle verbeuse, le ?. l'opérateur a été introduit dans la langue.

L'ancienne syntaxe verbeuse:

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

Peut être maintenant remplacé par le concis:

If myObject?.Value >= 10 Then

Le ? l'opérateur est particulièrement puissant lorsque vous avez une chaîne de propriétés. Considérer ce qui suit:

Dim fooInstance As Foo = Nothing
Dim s As String

Normalement, vous devriez écrire quelque chose comme ceci:

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

Mais avec le ? l'opérateur cela peut être remplacé par seulement:

s = fooInstance?.BarInstance?.Baz

Opérateur NameOf

L'opérateur NameOf résout les espaces de noms, les types, les variables et les noms de membres au moment de la compilation et les remplace par l'équivalent de chaîne.

Un des cas d'utilisation:

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

L'ancienne syntaxe exposera le risque de renommer la variable et de laisser la chaîne codée en dur à la mauvaise valeur.

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

Avec NameOf , renommer la variable uniquement provoquera une erreur de compilation. Cela permettra également à l’outil de renommage de renommer les deux en un seul effort.

L'opérateur NameOf n'utilise que le dernier composant de la référence entre crochets. Ceci est important lorsque vous manipulez quelque chose comme des espaces de noms dans l'opérateur 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'opérateur utilise également le nom de la référence saisie sans résoudre aucun changement de nom. Par exemple:

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

Interpolation de chaîne

Cette nouvelle fonctionnalité rend la concaténation de chaîne plus lisible. Cette syntaxe sera compilée à son appel String.Format équivalent.

Sans interpolation de chaîne:

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

Avec interpolation de chaîne:

$"Hello, {name}"

Les deux lignes sont équivalentes et les deux sont compilées en un appel à String.Format .

Comme dans String.Format , les parenthèses peuvent contenir n'importe quelle expression unique (appel à une méthode, propriété, opérateur de coalescence nul et ainsi de suite).

L'interpolation de chaîne est la méthode préférée par rapport à String.Format car elle empêche certaines erreurs d'exécution de se produire. Considérons la ligne String.Format suivante:

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

Cela compilera, mais provoquera une erreur d'exécution car le compilateur ne vérifie pas que le nombre d'arguments correspond aux espaces réservés.

Propriétés automatiques en lecture seule

Les propriétés en lecture seule étaient toujours possibles dans VB.NET dans ce format:

Public Class Foo

  Private _MyProperty As String = "Bar"

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

End Class

La nouvelle version de Visual Basic permet une courte main pour la déclaration de propriété comme suit:

Public Class Foo

  Public ReadOnly Property MyProperty As String = "Bar"

End Class

L'implémentation réelle générée par le compilateur est exactement la même pour les deux exemples. La nouvelle méthode pour l'écrire n'est qu'une main courte. Le compilateur générera toujours un champ privé au format: _<PropertyName> pour sauvegarder la propriété en lecture seule.

Modules partiels et interfaces

Semblable à des classes partielles, la nouvelle version de Visual Basic est désormais capable de gérer des modules partiels et des interfaces partielles. La syntaxe et le comportement sont exactement les mêmes que pour les classes partielles.

Un exemple de module partiel:

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

Et une interface partielle:

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

Tout comme pour les classes partielles, les définitions des modules partiels et des interfaces doivent être situées dans le même espace de noms et le même assemblage. Cela est dû au fait que les parties partielles des modules et des interfaces sont fusionnées pendant la compilation et que l'assembly compilé ne contient aucune indication indiquant que la définition d'origine du module ou de l'interface était fractionnée.

Littéraux multilignes

VB autorise désormais les littéraux de chaîne répartis sur plusieurs lignes.

Ancienne syntaxe:

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

Nouvelle syntaxe:

Dim text As String = "Line 1
Line 2"

Amélioration de la directive #Region

La directive #Region peut maintenant être placée dans des méthodes et peut même couvrir des méthodes, des classes et des modules.

#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

Commentaires après suite de ligne implicite

VB 14.0 introduit la possibilité d'ajouter des commentaires après la continuation implicite des lignes.

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

Gestion des exceptions

Pendant le codage, des erreurs inattendues surviennent assez fréquemment, ce qui nécessite un débogage et des tests. Mais parfois les erreurs sont effectivement attendues et pour le contourner, il y a le bloc Try..Catch..Throw..Finally..End Try .

Pour gérer correctement une erreur, le code est placé dans un bloc Try..Catch , dans lequel le Catch , comme le nom l'indique, intercepte toutes les exceptions qui surviennent dans ce bloc.

Et en cas d'exception, nous avons la possibilité de Throw l'erreur, c'est-à-dire de la renvoyer pour avertir l'utilisateur ou la gérer en interne dans le code lui-même.

La partie Finally est le code final qui, quel que soit le résultat, s'il y a une exception ou non, le code s'exécutera avant de sortir du bloc.

Si vous avez besoin de sortir de l'horloge, vous pouvez utiliser l'instruction Exit Try . Mais ici aussi, le code de la section Finally sera exécuté avant de se terminer.

La syntaxe est simple

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

où seul le Try et End Try est obligatoire. Le reste peut être ignoré mais, en tant que bonne pratique, incluez la partie Finally , même si elle reste vide.

À l’exception, il existe différents types d’exceptions pouvant être interceptées. Ce sont des exceptions prêtes à l'emploi disponibles dans le cadre .Net, comme ci-dessous;