Nouveautés de Visual BasicWhat's new for Visual Basic

Cette rubrique liste les noms des principales fonctionnalités de chaque version de Visual Basic et décrit en détail les fonctionnalités nouvelles et améliorées de la dernière version du langage.This topic lists key feature names for each version of Visual Basic, with detailed descriptions of the new and enhanced features in the lastest version of the language.

Version actuelleCurrent Version

Visual Basic / Visual Studio .NET 2017Visual Basic / Visual Studio .NET 2017
Pour connaître les nouvelles fonctionnalités, consultez Visual Basic 2017For new features, see Visual Basic 2017

Versions antérieuresPrevious versions

Visual Basic / Visual Studio .NET 2015Visual Basic / Visual Studio .NET 2015
Pour connaître les nouvelles fonctionnalités, consultez Visual Basic 14For new features, see Visual Basic 14

Visual Basic / Visual Studio .NET 2013Visual Basic / Visual Studio .NET 2013
Aperçus des technologies de la plateforme des compilateurs .NET (« Roslyn »)Technology previews of the .NET Compiler Platform (“Roslyn”)

Visual Basic / Visual Studio .NET 2012Visual Basic / Visual Studio .NET 2012
Mots clés Async et await, itérateurs, attributs des informations de l’appelantAsync and await keywords, iterators, caller info attributes

Visual Basic, Visual Studio .NET 2010Visual Basic, Visual Studio .NET 2010
Propriétés implémentées automatiquement, initialiseurs de collection, continuation de ligne implicite, variance co/contra générique, dynamique, accès de l’espace de noms globalAuto-implemented properties, collection initializers, implicit line continuation, dynamic, generic co/contra variance, global namespace access

Visual Basic / Visual Studio .NET 2008Visual Basic / Visual Studio .NET 2008
LINQ (Language Integrated Query), littéraux XML, inférence de type local, initialiseurs d’objet, types anonymes, méthodes d’extension, inférence de type var local, expressions lambda, opérateur if, méthodes partielles, types de valeur nullableLanguage Integrated Query (LINQ), XML literals, local type inference, object initializers, anonymous types, extension methods, local var type inference, lambda expressions, if operator, partial methods, nullable value types

Visual Basic / Visual Studio .NET 2005Visual Basic / Visual Studio .NET 2005
Type My et types d’assistance (accès à l’application, ordinateur, système de fichiers, réseau)The My type and helper types (access to app, computer, files system, network)

Visual Basic / Visual Studio .NET 2003Visual Basic / Visual Studio .NET 2003
Opérateurs de décalage de bits, déclaration de variable de boucleBit-shift operators, loop variable declaration

Visual Basic / Visual Studio .NET 2002Visual Basic / Visual Studio .NET 2002
Première version de Visual Basic .NETThe first release of Visual Basic .NET

Visual Basic 2017Visual Basic 2017

TuplesTuples

Les tuples sont une structure de données légère qui est le plus souvent utilisée pour retourner plusieurs valeurs à partir d’un seul appel de méthode.Tuples are a lightweight data structure that most commonly is used to return multiple values from a single method call. En règle générale, pour retourner plusieurs valeurs à partir d’une méthode, vous devez effectuer l’une des opérations suivantes :Ordinarily, to return multiple values from a method, you have to do one of the following:

  • Définir un type personnalisé (Class ou Structure).Define a custom type (a Class or a Structure). Il s’agit d’une solution lourde.This is a heavyweight solution.

  • Définir un ou plusieurs paramètres ByRef, en plus de retourner une valeur à partir de la méthode.Define one or more ByRef parameters, in addition to returning a value from the method.

La prise en charge des tuples par Visual Basic vous permet de définir rapidement un tuple, d’affecter éventuellement des noms de sémantique à ses valeurs et de récupérer rapidement ses valeurs.Visual Basic's support for tuples lets you quickly define a tuple, optionally assign semantic names to its values, and quickly retrieve its values. L’exemple suivant encapsule un appel à la méthode TryParse et retourne un tuple.The following example wraps a call to the TryParse method and returns a tuple.

Imports System.Globalization

Public Module NumericLibrary
    Public Function ParseInteger(value As String) As (Success As Boolean, Number As Int32)
        Dim number As Integer
        Return (Int32.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 celui-ci.You can then call the method and handle the returned tuple with code like the following.

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

Littéraux binaires et séparateurs numériquesBinary literals and digit separators

Vous pouvez définir un littéral binaire à l’aide du préfixe &B ou &b.You can define a binary literal by using the prefix &B or &b. Vous pouvez aussi utiliser le trait de soulignement, _, comme séparateur numérique pour améliorer la lisibilité.In addition, you can use the underscore character, _, as a digit separator to enhance readability. L’exemple suivant utilise les deux fonctionnalités pour affecter une valeur Byte et l’afficher sous la forme d’un nombre décimal, hexadécimal et binaire.The following example uses both features to assign a Byte value and to display it as a decimal, hexadecimal, and binary number.

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 de littéraux » des types de données Byte, Integer, Long, Short, SByte, UInteger, ULong et UShort.For more information, see the "Literal assignments" section of the Byte, Integer, Long, Short, SByte, UInteger, ULong, and UShort data types.

Prise en charge des valeurs de retour de référence C#Support for C# reference return values

Depuis C# 7, C# prend en charge les valeurs de retour de référence.Starting with C# 7, C# supports reference return values. Autrement dit, quand la méthode d’appel reçoit une valeur retournée par référence, elle peut modifier la valeur de la référence.That is, when the calling method receives a value returned by reference, it can change the value of the reference. Visual Basic ne vous autorise pas à créer des méthodes avec des valeurs de retour de référence, mais vous permet d’utiliser et de modifier ces valeurs.Visual Basic does not allow you to author methods with reference return values, but it does allow you to consume and modify the reference return values.

Par exemple, la classe Sentence suivante écrite en C# inclut une méthode FindNext qui recherche le mot suivant dans une phrase qui commence par une sous-chaîne spécifiée.For example, the following Sentence class written in C# includes a FindNext method that finds the next word in a sentence that begins with a specified substring. La chaîne est retournée comme valeur de retour de référence et une variable Boolean passée par référence à la méthode indique si la recherche a réussi.The string is returned as a reference return value, and a Boolean variable passed by reference to the method indicates whether the search was successful. Cela signifie que l’appelant peut non seulement lire la valeur retournée, mais il peut également la modifier et cette modification est répercutée dans la classe Sentence.This means that the caller can not only read the returned value; he or she can also modify it, and that modification is reflected in the Sentence class.

 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();    
   }
}

Sous sa forme la plus simple, vous pouvez modifier le mot trouvé dans la phrase à l’aide de code semblable au suivant.In its simplest form, you can modify the word found in the sentence by using code like the following. 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.Note that you are not assigning a value to the method, but rather to the expression that the method returns, which is the reference return value.

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.

Ce code pose cependant un problème : si aucune correspondance n’est trouvée, la méthode retourne le premier mot.A problem with this code, though, is that if a match is not found, the method returns the first word. Comme l’exemple n’examine pas la valeur de l’argument Boolean pour déterminer si une correspondance est trouvée, il modifie le premier mot en l’absence de correspondance.Since the example does not examine the value of the Boolean argument to determine whether a match is found, it modifies the first word if there is no match. L’exemple suivant corrige ce comportement en remplaçant le premier mot par lui-même en l’absence de correspondance.The following example corrects this by replacing the first word with itself if there is no match.

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.A better solution is to use a helper method to which the reference return value is passed by reference. La méthode d’assistance peut ensuite modifier l’argument qui lui est passé par référence.The helper method can then modify the argument passed to it by reference. L’exemple suivant effectue cette opération.The following example does that.

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 Valeurs de retour de référence.For more information, see Reference Return Values.

Visual Basic 14Visual Basic 14

NameofNameof
Vous pouvez obtenir le nom de chaîne non qualifié d’un type ou membre et l’utiliser dans un message d’erreur sans effectuer de codage irréversible de chaîne.You can get the unqualified string name of a type or member for use in an error message without hard coding a string. Votre code reste alors correct lors de la refactorisation.This allows your code to remain correct when refactoring. Cette fonctionnalité est également utile pour placer des liens MVC modèle-vue-contrôleur et activer des événements de modification de propriété.This feature is also useful for hooking up model-view-controller MVC links and firing property changed events.

Interpolation de chaîneString Interpolation
Vous pouvez utiliser des expressions d’interpolation de chaîne pour construire des chaînes.You can use string interpolation expressions to construct strings. Une expression de chaîne interpolée s’apparente à une chaîne de modèle contenant des expressions.An interpolated string expression looks like a template string that contains expressions. Les arguments d’une chaîne interpolée sont plus compréhensibles que dans une Mise en forme composite.An interpolated string is easier to understand with respect to arguments than Composite Formatting.

Indexation et accès aux membres conditionnels NullNull-conditional Member Access and Indexing
Vous pouvez rechercher les valeurs Null à l’aide d’une syntaxe très légère avant d’effectuer une opération d’accès aux membres (?.) ou d’indexation (?[]).You can test for null in a very light syntactic way before performing a member access (?.) or index (?[]) operation. Ces opérateurs permettent d’écrire moins de code pour gérer les vérifications Null, notamment pour l’exploration des structures de données.These operators help you write less code to handle null checks, especially for descending into data structures. Si la référence objet ou l’opérande gauche est Null, l’opération retourne la valeur Null.If the left operand or object reference is null, the operations returns null.

Littéraux de chaîne multiligneMulti-line String Literals
Les littéraux de chaîne peuvent contenir des séquences de saut de ligne.String literals can contain newline sequences. Il n’est plus nécessaire de passer par la méthode <xml><![CDATA[...text with newlines...]]></xml>.Value.You no longer need the old work around of using <xml><![CDATA[...text with newlines...]]></xml>.Value

CommentairesComments
Vous pouvez placer des commentaires après les continuations de ligne implicite, dans les expressions d’initialiseur et dans les termes d’expression LINQ.You can put comments after implicit line continuations, inside initializer expressions, and amongst LINQ expression terms.

Résolution de nom qualifié complet plus intelligenteSmarter Fully-qualified Name Resolution
En présence de code tel que Threading.Thread.Sleep(1000), Visual Basic recherchait l’espace de noms « Threading », détectait l’ambiguïté entre System.Threading et System.Windows.Threading, et signalait une erreur.Given code such as Threading.Thread.Sleep(1000), Visual Basic used to look up the namespace "Threading", discover it was ambiguous between System.Threading and System.Windows.Threading, and then report an error. Visual Basic prend désormais en compte les deux espaces de noms possibles.Visual Basic now considers both possible namespaces together. Lorsque vous affichez la liste de saisie semi-automatique, les membres de ces deux types y sont recensés par l’éditeur Visual Studio.If you show the completion list, the Visual Studio editor lists members from both types in the completion list.

Littéraux de date avec année en premierYear-first Date Literals
Vous pouvez avoir des littéraux de date au format aaaa-mm-jj, #2015-03-17 16:10 PM#.You can have date literals in yyyy-mm-dd format, #2015-03-17 16:10 PM#.

Propriétés d’interface en lecture seuleReadonly Interface Properties
Vous pouvez implémenter des propriétés d’interface en lecture seule à l’aide d’une propriété readwrite.You can implement readonly interface properties using a readwrite property. L’interface garantit les fonctionnalités minimales et n’empêche pas une classe d’implémentation d’autoriser la définition de la propriété.The interface guarantees minimum functionality, and it does not stop an implementing class from allowing the property to be set.

TypeOf <expr> IsNot <type>TypeOf <expr> IsNot <type>
Pour une meilleure lisibilité du code, vous pouvez maintenant utiliser TypeOf avec IsNot.For more readability of your code, you can now use TypeOf with IsNot.

#Disable Warning <ID> et #Enable Warning <ID>#Disable Warning <ID> and #Enable Warning <ID>
Vous pouvez désactiver et activer des avertissements spécifiques pour les zones d’un fichier source.You can disable and enable specific warnings for regions within a source file.

Améliorations de la fonctionnalité de commentaires de document XMLXML Doc-comment Improvements
Lorsque vous écrivez des commentaires de document, vous bénéficiez d’un éditeur intelligent et de la prise en charge de version pour la validation des noms de paramètres, le gestion appropriée des crefs (génériques, opérateurs, etc.), la colorisation et la refactorisation.When writing doc comments, you get smart editor and build support for validating parameter names, proper handling of crefs (generics, operators, etc.), colorizing, and refactoring.

Définitions d’interface et de module partiellesPartial Module and Interface Definitions
En plus des classes et structures, vous pouvez déclarer des interfaces et des modules partiels.In addition to classes and structs, you can declare partial modules and interfaces.

Directives #Region dans le corps de la méthode#Region Directives inside Method Bodies
Vous pouvez placer des délimiteurs #Region…#End Region n’importe où dans un fichier, dans des fonctions, ou encore répartis à différents endroits du corps d’une fonction.You can put #Region…#End Region delimiters anywhere in a file, inside functions, and even spanning across function bodies.

Les définitions de substitutions sont implicitement des surchargesOverrides Definitions are Implicitly Overloads
Si vous ajoutez le modificateur Overrides à une définition, le compilateur ajoute Overloads de manière implicite, de sorte que vous pouvez taper moins de code dans les situations courantes.If you add the Overrides modifier to a definition, the compiler implicitly adds Overloads so that you can type less code in common cases.

CObj autorisé dans les arguments d’attributsCObj Allowed in Attributes Arguments
Le compilateur signalait l’erreur indiquant que CObj(...) n’est pas une constante lorsqu’il est utilisé dans les constructions d’attribut.The compiler used to give an error that CObj(…) was not a constant when used in attribute constructions.

Déclaration et utilisation de méthodes ambiguës issues d’interfaces différentesDeclaring and Consuming Ambiguous Methods from Different Interfaces
Auparavant, le code suivant générait des erreurs qui vous empêchaient de déclarer IMock ou d’appeler GetDetails (s’ils avaient été déclarés en C#) :Previously the following code yielded errors that prevented you from declaring IMock or from calling GetDetails (if these had been declared in 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 les règles de résolution de surcharge normales pour choisir le GetDetails à appeler le plus approprié, et vous pouvez déclarer des relations d’interface dans Visual Basic comme indiqué dans l’exemple.Now the compiler will use normal overload resolution rules to choose the most appropriate GetDetails to call, and you can declare interface relationships in Visual Basic like those shown in the sample.

Voir aussiSee also

Nouveautés de Visual Studio 2017What's New in Visual Studio 2017