Nouveautés de Visual Basic

Cet article répertorie les noms de fonctionnalités clés pour chaque version de Visual Basic. Pour obtenir des descriptions détaillées des fonctionnalités nouvelles et améliorées dans les dernières versions de la langue, consultez les sections liées.

Version actuelle

Visual Basic 17.13 / Visual Studio 2026
Pour connaître les nouvelles fonctionnalités, consultez Visual Basic 17.13.

Vous pouvez télécharger le dernier SDK .NET à partir de la page de téléchargements .NET.

Versions précédentes

Visual Basic 17.0 / Visual Studio 2022
Pour connaître les nouvelles fonctionnalités, consultez Visual Basic 17.0.

Visual Basic 16.9 / Visual Studio 2019 version 16.9
Pour connaître les nouvelles fonctionnalités, consultez Visual Basic 16.9.

Visual Basic 16.0 / Visual Studio 2019 version 16.0
Pour les nouvelles fonctionnalités, consultez Visual Basic 16.0.

Visual Basic 15.5 / Visual Studio 2017 version 15.5
Pour connaître les nouvelles fonctionnalités, consultez Visual Basic 15.5.

Visual Basic 15.3 / Visual Studio 2017 version 15.3
Pour connaître les nouvelles fonctionnalités, consultez Visual Basic 15.3.

Visual Basic 15 / Visual Studio 2017
Pour les nouvelles fonctionnalités, consultez Visual Basic 2017.

Visual Basic / Visual Studio 2015
Pour connaître les nouvelles fonctionnalités, consultez Visual Basic 14.

Visual Basic / Visual Studio 2013
Aperçus technologiques de la plateforme du compilateur .NET (« Roslyn »)

Visual Basic / Visual Studio 2012
Async et await mots clés, itérateurs, attributs d’informations de l’appelant

Visual Basic, Visual Studio 2010
Propriétés implémentées automatiquement, initialiseurs de collection, continuation de ligne implicite, dynamique, variance co/contra générique, accès à l’espace de noms global

Visual Basic / Visual Studio 2008
Language Integrated Query (LINQ), littéraux XML, inférence de type local, initialiseurs d’objet, types anonymes, méthodes d’extension, inférence de type local var , expressions lambda, if opérateur, méthodes partielles, types valeur nullable

Visual Basic / Visual Studio 2005
Types My et types d’assistance (accès à l’application, à l’ordinateur, au système de fichiers, au réseau)

Visual Basic / Visual Studio .NET 2003
Opérateurs de décalage de bits, déclaration de variable de boucle

Visual Basic / Visual Studio .NET 2002
La première version de Visual Basic .NET

Visual Basic 17.13

Visual Basic 17.13 reconnaît la unmanaged contrainte générique. Visual Basic 17.13 reconnaît la System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute pour la résolution de la méthode.

Visual Basic 17.0

Visual Basic 17.0 active le System.Runtime.CompilerServices.CallerArgumentExpressionAttribute.

Visual Basic 16.9

Visual Basic 16.9 permet de consommer des propriétés init uniquement.

Visual Basic 16.0

Visual Basic 16.0 se concentre sur l’approvisionnement de davantage de fonctionnalités du runtime Visual Basic (microsoft.visualbasic.dll) à .NET Core. Il s’agit de la première version de Visual Basic axée sur .NET Core. .NET Core 3.0 ajoute les parties du Runtime Visual Basic qui dépendent de Windows Forms.

Commentaires autorisés dans d’autres emplacements dans les instructions

Dans Visual Basic 15.5 et versions antérieures, vous pouvez uniquement ajouter des commentaires sur des lignes vides, à la fin d’une instruction ou à des emplacements spécifiques dans une instruction où une continuation de ligne implicite est autorisée. À compter de Visual Basic 16.0, vous pouvez également ajouter des commentaires après des continuations de ligne explicites et dans une instruction sur une ligne commençant par un espace suivi d’un trait de soulignement.

Public Sub Main()
    cmd.CommandText = ' Comment is allowed here without _
        "SELECT * FROM Titles JOIN Publishers " _ ' This is a comment
        & "ON Publishers.PubId = Titles.PubID " _
 _ ' This is a comment on a line without code
        & "WHERE Publishers.State = 'CA'"
End Sub

Conversion à virgule flottante optimisée en entier

Dans les versions précédentes de Visual Basic, la conversion de valeurs doubles et uniques en entiers offre des performances relativement médiocres. Visual Basic 16.0 améliore considérablement les performances des conversions à virgule flottante en entiers lorsque vous passez la valeur retournée par l’une des méthodes suivantes à l’une des fonctions de conversion d’entiers Visual Basic intrinsèques (CByte, CShort, CInt, CLng, CSByte, CUShort, CUInt et CULng), ou lorsque la valeur retournée par l’une des méthodes suivantes est implicitement convertie en type intégral et Option Strict est définie sur Off:

Cette optimisation permet au code de s’exécuter plus rapidement , jusqu’à deux fois plus rapide pour le code qui effectue un grand nombre de conversions en types entiers. L’exemple suivant illustre quelques appels de méthode simples que l’optimisation affecte :

Dim s As Single = 173.7619
Dim d As Double = s

Dim i1 As Integer = CInt(Fix(s))               ' Result: 173
Dim b1 As Byte = CByte(Int(d))                 ' Result: 173
Dim s1 AS Short = CShort(Math.Truncate(s))     ' Result: 173
Dim i2 As Integer = CInt(Math.Ceiling(d))      ' Result: 174
Dim i3 As Integer = CInt(Math.Round(s))        ' Result: 174

Cette optimisation tronque au lieu d’arrondir les valeurs à virgule flottante.

Visual Basic 15.5

Arguments nommés sans fin

Dans Visual Basic 15.3 et versions antérieures, lorsqu’un appel de méthode incluait des arguments à la fois par position et par nom, vous deviez placer les arguments positionnels avant les arguments nommés. À partir de Visual Basic 15.5, vous pouvez combiner des arguments positionnels et nommés dans n’importe quel ordre, tant que tous les arguments jusqu’au dernier argument positionnel sont à la bonne position. Cette flexibilité est particulièrement utile lorsque les arguments nommés rendent votre code plus lisible.

Par exemple, l’appel de méthode suivant comporte deux arguments positionnels entre un argument nommé. L’argument nommé indique clairement que la valeur 19 représente un âge.

StudentInfo.Display("Mary", age:=19, #9/21/1998#)

Private Protected modificateur d’accès membre

Cette nouvelle combinaison de mots clés définit un membre auquel tous les membres de sa classe conteneur peuvent accéder, ainsi que les types dérivés de la classe conteneur, mais uniquement s’ils sont également trouvés dans l’assembly conteneur. Étant donné que les structures ne peuvent pas être héritées, vous ne pouvez s’appliquer Private Protected qu’aux membres d’une classe.

Séparateur hexadécimal/binaire/octal de début

Visual Basic 2017 a ajouté la prise en charge du caractère de soulignement (_) comme séparateur de chiffres. À compter de Visual Basic 15.5, vous pouvez utiliser le caractère de soulignement comme séparateur de début entre le préfixe et les chiffres hexadécimaux, binaires ou octal. L’exemple suivant utilise un séparateur de chiffres de début pour définir 3 271 948 384 comme nombre hexadécimal :

Dim number As Integer = &H_C305_F860

Pour utiliser le caractère de soulignement comme séparateur de début, vous devez ajouter l’élément suivant à votre fichier de projet Visual Basic (*.vbproj) :

<PropertyGroup>
  <LangVersion>15.5</LangVersion>
</PropertyGroup>

Visual Basic 15.3

Inférence tuple nommée

Lorsque vous attribuez la valeur des éléments tuple à partir de variables, Visual Basic déduit le nom des éléments tuple des noms de variables correspondants. Vous n’avez pas besoin de nommer explicitement un élément tuple. L’exemple suivant utilise l’inférence pour créer un tuple avec deux éléments nommés : state et stateName.

Const state As String = "MI"
Const stateName As String = "Michigan"
Const capital As String = "Lansing"
Dim stateInfo = (state, stateName, capital)
Console.WriteLine($"{stateInfo.stateName}: 2-letter code: {stateInfo.State}, Capital {stateInfo.capital}")
' The example displays the following output:
'      Michigan: 2-letter code: MI, Capital Lansing

Commutateurs de compilateur supplémentaires

Le compilateur de ligne de commande Visual Basic prend désormais en charge les options du compilateur -refout et -refonly pour contrôler la sortie des assemblys de référence. Utilisez -refout pour définir le répertoire de sortie de l’assembly de référence. Utilisez -refonly pour spécifier que la compilation génère uniquement un assembly de référence.

Visual Basic 15

Tuples

Les tuples sont une structure de données légère que vous utilisez le plus souvent pour retourner plusieurs valeurs à partir d’un seul appel de méthode. En règle générale, pour retourner plusieurs valeurs d’une méthode, vous devez effectuer l’une des options suivantes :

Définir un type personnalisé (a Class ou a Structure). Cette option est une solution de grande envergure.
Définissez un ou plusieurs ByRef paramètres, en plus de retourner une valeur de la méthode.

La prise en charge de Visual Basic pour les tuples vous permet de définir rapidement un tuple, d’attribuer éventuellement des noms sémantiques à ses valeurs et de récupérer rapidement ses valeurs. L’exemple suivant encapsule un appel à la TryParse méthode et retourne un tuple.

Imports System.Globalization

Public Module NumericLibrary
    Public Function ParseInteger(value As String) As (Success As Boolean, Number As Integer)
        Dim number As Integer
        Return (Integer.TryParse(value, NumberStyles.Any, CultureInfo.InvariantCulture, number), number)
    End Function
End Module

Vous pouvez ensuite appeler la méthode et gérer le tuple retourné avec du code comme dans l’exemple suivant.

Dim numericString As String = "123,456"
Dim result = ParseInteger(numericString)
Console.WriteLine($"{If(result.Success, $"Success: {result.Number:N0}", "Failure")}")
Console.ReadLine()
'      Output: Success: 123,456

Littéraux binaires et séparateurs de chiffres

Vous pouvez définir un littéral binaire à l’aide du préfixe &B ou &b. En outre, vous pouvez utiliser le caractère de soulignement, _en tant que séparateur de chiffres pour améliorer la lisibilité. L’exemple suivant utilise les deux fonctionnalités pour affecter une Byte valeur et l’afficher sous la forme d’un nombre décimal, hexadécimal et binaire.

Dim value As Byte = &B0110_1110
Console.WriteLine($"{NameOf(value)}  = {value} (hex: 0x{value:X2}) " +
                  $"(binary: {Convert.ToString(value, 2)})")
' The example displays the following output:
'      value  = 110 (hex: 0x6E) (binary: 1101110)

Pour plus d’informations, consultez la section « Affectations littérales » des types de données Byte, Integer, Long, Short, SByte, UInteger, ULong et UShort.

Prise en charge des valeurs de retour de référence C#

C# prend en charge les valeurs de retour de référence. Autrement dit, lorsque la méthode appelante reçoit une valeur retournée par référence, elle peut modifier la valeur de la référence. Visual Basic ne vous permet pas de créer des méthodes avec des valeurs de retour de référence, mais elle vous permet de consommer et de modifier les valeurs de retour de référence.

Par exemple, la classe suivante Sentence écrite en C# inclut une FindNext méthode qui recherche le mot suivant dans une phrase commençant par une sous-chaîne spécifiée. La chaîne est retournée en tant que valeur de retour de référence et une Boolean variable transmise par référence à la méthode indique si la recherche a réussi. Cela signifie qu’en plus de lire la valeur retournée, l’appelant peut également le modifier et cette modification est reflétée dans la Sentence classe.

using System;

public class Sentence
{
    private string[] words;
    private int currentSearchPointer;

    public Sentence(string sentence)
    {
        words = sentence.Split(' ');
        currentSearchPointer = -1;
    }

    public ref string FindNext(string startWithString, ref bool found)
    {
        for (int count = currentSearchPointer + 1; count < words.Length; count++)
        {
            if (words[count].StartsWith(startWithString))
            {
                currentSearchPointer = count;
                found = true;
                return ref words[currentSearchPointer];
            }
        }
        currentSearchPointer = -1;
        found = false;
        return ref words[0];
    }

    public string GetSentence()
    {
        string stringToReturn = null;
        foreach (var word in words)
            stringToReturn += $"{word} ";

        return stringToReturn.Trim();
    }
}

Dans sa forme la plus simple, vous pouvez modifier le mot trouvé dans la phrase à l’aide de code comme dans l’exemple suivant. Notez que vous n’affectez pas de valeur à la méthode, mais plutôt à l’expression retournée par la méthode, qui est la valeur de retour de référence.

Dim sentence As New Sentence("A time to see the world is now.")
Dim found = False
sentence.FindNext("A", found) = "A good" 
Console.WriteLine(sentence.GetSentence()) 
' The example displays the following output:
'      A good time to see the world is now.

Un problème avec ce code, cependant, est que si une correspondance n’est pas trouvée, la méthode retourne le premier mot. Étant donné que l’exemple n’examine pas la valeur de l’argument Boolean pour déterminer si une correspondance est trouvée, elle modifie le premier mot s’il n’y a pas de correspondance. L’exemple suivant corrige ce problème en remplaçant le premier mot par le même mot s’il n’y a pas de correspondance.

Dim sentence As New Sentence("A time to see the world is now.")
Dim found = False
sentence.FindNext("A", found) = IIf(found, "A good", sentence.FindNext("B", found)) 
Console.WriteLine(sentence.GetSentence()) 
' The example displays the following output:
'      A good time to see the world is now.

Une meilleure solution consiste à utiliser une méthode d’assistance à laquelle la valeur de retour de référence est passée par référence. La méthode d’assistance peut ensuite modifier l’argument passé à celui-ci par référence. L’exemple suivant le fait.

Module Example
   Public Sub Main()
      Dim sentence As New Sentence("A time to see the world is now.")
      Dim found = False
      Dim returns = RefHelper(sentence.FindNext("A", found), "A good", found) 
      Console.WriteLine(sentence.GetSentence()) 
   End Sub
   
   Private Function RefHelper(ByRef stringFound As String, replacement As String, success As Boolean) _ 
                    As (originalString As String, found As Boolean) 
      Dim originalString = stringFound
      If found Then stringFound = replacement
      Return (originalString, found)   
   End Function
End Module
' The example displays the following output:
'      A good time to see the world is now.

Pour plus d’informations, consultez Référence des valeurs de retour.

Visual Basic 14

NameOf

Vous pouvez obtenir le nom de chaîne non qualifié d’un type ou d’un membre à utiliser dans un message d’erreur sans coder en dur une chaîne. Cette approche permet de corriger votre code lors de la refactorisation. Cette fonctionnalité est également utile pour raccorder les liens MVC du contrôleur de vue de modèle et déclencher des événements modifiés de propriété.

Interpolation de chaîne

Utilisez des expressions d’interpolation de chaîne pour construire des chaînes. Une expression de chaîne interpolée ressemble à une chaîne de modèle qui contient des expressions. Une chaîne interpolée est plus facile à comprendre en ce qui concerne les arguments que la mise en forme composite.

Accès et indexation de membres conditionnels Null

Vous pouvez tester la valeur Null de manière syntactique très légère avant d’effectuer une opération d’accès membre (?.) ou d’index (?[]). Ces opérateurs vous aident à écrire moins de code pour gérer les vérifications Null, en particulier pour descendre dans des structures de données. Si l’opérande gauche ou la référence d’objet est null, les opérations retournent null.

Littéraux de chaîne à plusieurs lignes

Les littéraux de chaîne peuvent contenir des séquences de saut de ligne. Vous n’avez plus besoin de l’ancienne méthode de contournement de l’utilisation de <xml><![CDATA[...text with newlines...]]></xml>.Value.

Commentaires

Vous pouvez placer des commentaires après les continuations de ligne implicites, à l’intérieur des expressions d’initialiseur et entre les termes d’expression LINQ.

Résolution de noms complète plus intelligente

Étant donné le code tel que Threading.Thread.Sleep(1000), Visual Basic utilisait pour rechercher l’espace de noms « Threading », découvrait qu’il était ambigu entre System.Threading et System.Windows.Threading, puis signalait une erreur. Visual Basic considère désormais les deux espaces de noms possibles ensemble. Si vous affichez la liste de saisie semi-automatique, l’éditeur Visual Studio répertorie les membres des deux types de la liste de saisie semi-automatique.

Littéraux de date pour la première année

Vous pouvez avoir des littéraux de date au format aaaa-mm-dd, #2015-03-17 16:10 PM#.

Propriétés de l’interface en lecture seule

Vous pouvez implémenter des propriétés d’interface en lecture seule à l’aide d’une propriété readwrite. L’interface garantit une fonctionnalité minimale et n’empêche pas une classe d’implémentation d’autoriser la définition de la propriété.

TypeOf <expr> IsNot <type>

Pour plus de lisibilité de votre code, vous pouvez désormais l’utiliser TypeOf avec IsNot.

ID d’avertissement <#Disable et ID d’avertissement >#Enable<>

Vous pouvez désactiver et activer des avertissements spécifiques pour les régions au sein d’un fichier source.

Améliorations apportées aux commentaires de document XML

Lorsque vous écrivez des commentaires de document, vous obtenez une prise en charge intelligente de l’éditeur et de la génération pour valider les noms de paramètres, la gestion appropriée des crefs paramètres (par exemple, les génériques et les opérateurs), le redimensionnement et la refactorisation.

Définitions de module et d’interface partielles

En plus des classes et des structs, vous pouvez déclarer des modules et interfaces partiels.

directives #Region à l’intérieur des organismes de méthode

Vous pouvez placer #Region...#End délimiteurs de région n’importe où dans un fichier, à l’intérieur des fonctions et même s’étendent sur les corps de fonction.

Les définitions de remplacements sont implicitement des surcharges

Si vous ajoutez le Overrides modificateur à une définition, le compilateur ajoute Overloads implicitement afin de pouvoir taper moins de code dans les cas courants.

CObj autorisé dans les arguments d’attributs

Vous pouvez désormais utiliser CObj(...) dans les arguments d’attribut. Auparavant, le compilateur a retourné une erreur indiquant que ce n'était pas une constante.

Déclaration et consommation de méthodes ambiguës à partir de différentes interfaces

Auparavant, le code suivant retournait des erreurs qui vous empêchaient de déclarer IMock ou d’appeler GetDetails (si ces méthodes ont été déclarées en C#) :

Interface ICustomer
  Sub GetDetails(x As Integer)
End Interface

Interface ITime
  Sub GetDetails(x As String)
End Interface

Interface IMock : Inherits ICustomer, ITime
  Overloads Sub GetDetails(x As Char)
End Interface

Interface IMock2 : Inherits ICustomer, ITime
End Interface

À présent, le compilateur utilise des règles de résolution de surcharge normales pour choisir la méthode la plus appropriée GetDetails à appeler. Vous pouvez déclarer des relations d’interface dans Visual Basic comme celles affichées dans l’exemple.

Voir aussi

Rétroaction

Cette page a-t-elle été utile ?

Last updated on 2025-12-16