Conventions de codage Visual BasicVisual Basic Coding Conventions

Microsoft développe des exemples et la documentation qui suivent les instructions de cette rubrique.Microsoft develops samples and documentation that follow the guidelines in this topic. Si vous suivez les mêmes conventions de codage, vous pouvez profiter des avantages suivants :If you follow the same coding conventions, you may gain the following benefits:

  • Votre code aura une apparence cohérente, afin que les lecteurs peuvent mieux se concentrer sur le contenu, pas de disposition.Your code will have a consistent look, so that readers can better focus on content, not layout.

  • Lecteurs de comprennent votre code plus rapidement, car ils peuvent émettre des hypothèses selon leur expérience précédente.Readers understand your code more quickly because they can make assumptions based on previous experience.

  • Vous pouvez copier, modifier et gérer le code plus facilement.You can copy, change, and maintain the code more easily.

  • Vous permettent de garantir que votre code illustre les « meilleures pratiques » pour Visual Basic.You help ensure that your code demonstrates "best practices" for Visual Basic.

Conventions d'affectation de nomsNaming Conventions

  • Pour plus d’informations sur les règles d’affectation de noms, consultez les instructions d’affectation de noms rubrique.For information about naming guidelines, see Naming Guidelines topic.

  • N’utilisez pas « Mon » ou « my » en tant que partie d’un nom de variable.Do not use "My" or "my" as part of a variable name. Cette pratique peut créer une confusion avec les My objets.This practice creates confusion with the My objects.

  • Il est inutile de modifier les noms des objets dans le code généré automatiquement pour les rendre conformes aux indications.You do not have to change the names of objects in auto-generated code to make them fit the guidelines.

Conventions de dispositionLayout Conventions

  • Insérer des tabulations en espaces et utiliser la mise en retrait intelligente avec tirets de quatre espaces.Insert tabs as spaces, and use smart indenting with four-space indents.

  • Utilisez (Reformatage) d’un code de liste automatique à remettre en forme votre code dans l’éditeur de code.Use Pretty listing (reformatting) of code to reformat your code in the code editor. Pour plus d’informations, consultez Options, éditeur de texte, base (Visual Basic).For more information, see Options, Text Editor, Basic (Visual Basic).

  • Utilisez une seule instruction par ligne.Use only one statement per line. N’utilisez pas le caractère de séparation de ligne Visual Basic ( :).Don't use the Visual Basic line separator character (:).

  • Évitez d’utiliser le caractère de continuation de ligne explicite « » en faveur de la continuation de ligne implicite, partout où il permet à la langue.Avoid using the explicit line continuation character "" in favor of implicit line continuation wherever the language allows it.

  • Utiliser une seule déclaration par ligne.Use only one declaration per line.

  • Si (Reformatage) d’un code de liste automatique ne format des lignes de continuation automatiquement, manuellement mettre en retrait continuation lignes un taquet de tabulation.If Pretty listing (reformatting) of code doesn't format continuation lines automatically, manually indent continuation lines one tab stop. Toutefois, toujours aligner à gauche des éléments dans une liste.However, always left-align items in a list.

    a As Integer,  
    b As Integer  
    
  • Ajoutez au moins une ligne vide entre les définitions de méthode et la propriété.Add at least one blank line between method and property definitions.

Conventions de commentairesCommenting Conventions

  • Placer des commentaires sur une ligne distincte et non à la fin d’une ligne de code.Put comments on a separate line instead of at the end of a line of code.

  • Démarrez le texte de commentaire par une lettre majuscule et texte de commentaire de fin avec une période.Start comment text with an uppercase letter, and end comment text with a period.

  • Insérer un espace entre le délimiteur de commentaire (') et le texte du commentaire.Insert one space between the comment delimiter (') and the comment text.

    ' Here is a comment.
    
  • N’encadrez pas de commentaires avec les blocs d’astérisques mis en forme.Do not surround comments with formatted blocks of asterisks.

Structure du programmeProgram Structure

  • Lorsque vous utilisez la Main (méthode), utilisez la construction par défaut pour les nouvelles applications de console et My pour les arguments de ligne de commande.When you use the Main method, use the default construct for new console applications, and use My for command-line arguments.

    Sub Main()
      For Each argument As String In My.Application.CommandLineArgs
        ' Add code here to use the string variable.
      Next
    End Sub
    

Directives du langageLanguage Guidelines

String, type de donnéesString Data Type

  • Pour concaténer des chaînes, utilisez une esperluette (&).To concatenate strings, use an ampersand (&).

    MsgBox("hello" & vbCrLf & "goodbye")
    
  • Pour ajouter des chaînes dans des boucles, utilisez le StringBuilder objet.To append strings in loops, use the StringBuilder object.

    Dim longString As New System.Text.StringBuilder
    For count As Integer = 1 To 1000
      longString.Append(count)
    Next
    

Délégués souples dans les gestionnaires d’événementsRelaxed Delegates in Event Handlers

Ne relèvent pas explicitement les arguments (objet et EventArgs) aux gestionnaires d’événements.Do not explicitly qualify the arguments (Object and EventArgs) to event handlers. Si vous n’utilisez pas les arguments d’événement sont passés à un événement (par exemple, l’expéditeur en tant qu’objet, e en tant que EventArgs), utilisez des délégués souples et omettre les arguments d’événement dans votre code :If you are not using the event arguments that are passed to an event (for example, sender as Object, e as EventArgs), use relaxed delegates, and leave out the event arguments in your code:

Public Sub Form1_Load() Handles Form1.Load
End Sub

Type de données non signéUnsigned Data Type

  • Utilisez Integer plutôt que des types non signés, sauf s’ils sont nécessaires.Use Integer rather than unsigned types, except where they are necessary.

TableauxArrays

  • Utilisez la syntaxe courte lorsque vous initialisez des tableaux sur la ligne de déclaration.Use the short syntax when you initialize arrays on the declaration line. Par exemple, utilisez la syntaxe suivante.For example, use the following syntax.

    Dim letters1 As String() = {"a", "b", "c"}
    

    N’utilisez pas la syntaxe suivante.Do not use the following syntax.

    Dim letters2() As String = New String() {"a", "b", "c"}
    
  • Placez l’indicateur de tableau sur le type, et non sur la variable.Put the array designator on the type, not on the variable. Par exemple, utilisez la syntaxe suivante :For example, use the following syntax:

    Dim letters4 As String() = {"a", "b", "c"}
    

    N’utilisez pas la syntaxe suivante :Do not use the following syntax:

    Dim letters3() As String = {"a", "b", "c"}
    
  • Utilisez la syntaxe {} lorsque vous déclarez et initialisez des tableaux de types de base de données.Use the { } syntax when you declare and initialize arrays of basic data types. Par exemple, utilisez la syntaxe suivante :For example, use the following syntax:

    Dim letters5 As String() = {"a", "b", "c"}
    

    N’utilisez pas la syntaxe suivante :Do not use the following syntax:

    Dim letters6(2) As String
    letters6(0) = "a"
    letters6(1) = "b"
    letters6(2) = "c"
    

Utilisez le mot cléUse the With Keyword

Lorsque vous effectuez une série d’appels à un objet, envisagez d’utiliser le With (mot clé) :When you make a series of calls to one object, consider using the With keyword:

With orderLog
  .Log = "Application"
  .Source = "Application Name"
  .MachineName = "Computer Name"
End With

Utilisez les instructions Try... Capture et à l’aide des instructions lorsque vous utilisez la gestion des exceptionsUse the Try...Catch and Using Statements when you use Exception Handling

N’utilisez pas On Error Goto.Do not use On Error Goto.

Utilisez le mot clé IsNotUse the IsNot Keyword

Utilisez le IsNot (mot clé) au lieu de Not...Is Nothing.Use the IsNot keyword instead of Not...Is Nothing.

Nouveau mot cléNew Keyword

  • Utilisez l’instanciation courte.Use short instantiation. Par exemple, utilisez la syntaxe suivante :For example, use the following syntax:

    Dim employees As New List(Of String)
    

    La ligne précédente est équivalente à ceci :The preceding line is equivalent to this:

    Dim employees2 As List(Of String) = New List(Of String)
    
  • Utiliser des initialiseurs d’objets pour les nouveaux objets au lieu du constructeur sans paramètre :Use object initializers for new objects instead of the parameterless constructor:

    Dim orderLog As New EventLog With { 
        .Log = "Application", 
        .Source = "Application Name", 
        .MachineName = "Computer Name"}
    

Gestion des événementsEvent Handling

  • Utilisez Handles plutôt que AddHandler:Use Handles rather than AddHandler:

    Private Sub ToolStripMenuItem1_Click() Handles ToolStripMenuItem1.Click
    End Sub
    
  • Utilisez AddressOfet n’instanciez pas le délégué explicitement :Use AddressOf, and do not instantiate the delegate explicitly:

    Dim closeItem As New ToolStripMenuItem( 
        "Close", Nothing, AddressOf ToolStripMenuItem1_Click)
    Me.MainMenuStrip.Items.Add(closeItem)
    
  • Lorsque vous définissez un événement, utilisez la syntaxe courte et laissez le compilateur définir le délégué :When you define an event, use the short syntax, and let the compiler define the delegate:

    Public Event SampleEvent As EventHandler(Of SampleEventArgs)
    ' or
    Public Event SampleEvent(ByVal source As Object, 
                              ByVal e As SampleEventArgs)
    
  • Ne vérifient pas si un événement est Nothing (null) avant d’appeler le RaiseEvent (méthode).Do not verify whether an event is Nothing (null) before you call the RaiseEvent method. RaiseEventvérifie les Nothing avant de déclencher l’événement.RaiseEvent checks for Nothing before it raises the event.

À l’aide de membres partagésUsing Shared Members

Appelez Shared membres en utilisant le nom de classe, pas à partir d’une variable d’instance.Call Shared members by using the class name, not from an instance variable.

Utiliser des littéraux XMLUse XML Literals

Les littéraux XML simplifient les tâches les plus courantes que vous rencontrez lorsque vous travaillez avec XML (par exemple, chargement, requête et transformation).XML literals simplify the most common tasks that you encounter when you work with XML (for example, load, query, and transform). Lorsque vous développez avec XML, suivez ces instructions :When you develop with XML, follow these guidelines:

  • Utiliser des littéraux XML pour créer des documents XML et des fragments au lieu d’appeler directement des API XML.Use XML literals to create XML documents and fragments instead of calling XML APIs directly.

  • Importez les espaces de noms XML au niveau du fichier ou du projet pour tirer parti des optimisations des performances des littéraux XML.Import XML namespaces at the file or project level to take advantage of the performance optimizations for XML literals.

  • Utilisez les propriétés d’axe XML pour accéder aux éléments et attributs dans un document XML.Use the XML axis properties to access elements and attributes in an XML document.

  • Utiliser des expressions incorporées pour inclure des valeurs et créer du code XML à partir de valeurs existantes au lieu d’utiliser des appels d’API tels que le Add méthode :Use embedded expressions to include values and to create XML from existing values instead of using API calls such as the Add method:

    Private Function GetHtmlDocument( 
        ByVal items As IEnumerable(Of XElement)) As String
    
      Dim htmlDoc = <html>
                      <body>
                        <table border="0" cellspacing="2">
                          <%= 
                            From item In items 
                            Select <tr>
                                     <td style="width:480">
                                       <%= item.<title>.Value %>
                                     </td>
                                     <td><%= item.<pubDate>.Value %></td>
                                   </tr> 
                          %>
                        </table>
                      </body>
                    </html>
    
      Return htmlDoc.ToString()
    End Function
    

Requêtes LINQLINQ Queries

  • Utilisez des noms explicites pour les variables de requête :Use meaningful names for query variables:

    Dim seattleCustomers = From cust In customers 
                           Where cust.City = "Seattle"
    
  • Fournir des noms pour les éléments d’une requête pour vous assurer que les noms de propriété des types anonymes sont correctement écrits en majuscules à l’aide de la casse Pascal casse :Provide names for elements in a query to make sure that property names of anonymous types are correctly capitalized using Pascal casing:

    Dim customerOrders = From customer In customers 
                         Join order In orders 
                           On customer.CustomerID Equals order.CustomerID 
                         Select Customer = customer, Order = order
    
  • Renommez les propriétés lorsque les noms de propriétés dans le résultat sont ambigus.Rename properties when the property names in the result would be ambiguous. Par exemple, si votre requête retourne un client, nom et un ID de commande, les renommer au lieu de les laisser en tant que Name et ID dans le résultat :For example, if your query returns a customer name and an order ID, rename them instead of leaving them as Name and ID in the result:

    Dim customerOrders2 = From cust In customers 
                          Join ord In orders
                            On cust.CustomerID Equals ord.CustomerID 
                          Select CustomerName = cust.Name, 
                                 OrderID = ord.ID
    
  • Utiliser l’inférence de type dans la déclaration de variables de requête et les variables de portée :Use type inference in the declaration of query variables and range variables:

    Dim customerList = From cust In customers
    
  • Alignez les clauses de requête sous la From instruction :Align query clauses under the From statement:

    Dim newyorkCustomers = From cust In customers 
                           Where cust.City = "New York" 
                           Select cust.LastName, cust.CompanyName
    
  • Utilisez Where clauses avant les autres clauses de requête afin que les clauses de requête ultérieures opèrent sur l’ensemble filtré de données :Use Where clauses before other query clauses so that later query clauses operate on the filtered set of data:

    Dim newyorkCustomers2 = From cust In customers 
                            Where cust.City = "New York" 
                            Order By cust.LastName
    
  • Utilisez le Join clause pour définir explicitement une opération de jointure au lieu d’utiliser le Where clause définir implicitement une opération de jointure :Use the Join clause to explicitly define a join operation instead of using the Where clause to implicitly define a join operation:

    Dim customerList2 = From cust In customers 
                        Join order In orders 
                          On cust.CustomerID Equals order.CustomerID 
                        Select cust, order
    

Voir aussiSee Also

Instructions de codage sécuriséSecure Coding Guidelines