Conventions de codage Visual Basic

Article
06/08/2015

Microsoft développe les exemples et la documentation qui suivent les instructions de cette rubrique. Si vous suivez les mêmes conventions de codage, vous pouvez bénéficier des avantages suivants :

Votre code aura un aspect homogène afin que les lecteurs puissent mieux se concentrer sur le contenu et non pas sur la disposition.
Les lecteurs comprennent votre code plus rapidement, parce qu'ils peuvent faire des hypothèses fondées sur leur expérience précédente.
Vous pouvez copier, modifier et gérer le code plus facilement.
Vous aidez à garantir que votre code illustre les « meilleures pratiques » pour Visual Basic.

Conventions d'affectation de noms

Pour plus d'informations sur les instructions d'attribution d'un nom, consultez la rubrique Guidelines for Names.
N'utilisez pas "My" ou "my" dans un nom de variable, Cette pratique peut créer une confusion avec les objets My.
Il n'est pas nécessaire de modifier les noms des objets dans le code généré automatiquement pour les rendre conformes aux indications.

Conventions de disposition

Insérez les tabulations en tant qu'espaces et la mise en retrait intelligente d'utilisation avec des retraits de quatre espaces.
Utilisez Mise en forme automatique avec tabulation du code pour mettre en forme votre code dans l'éditeur de code. Pour plus d'informations, consultez Options, Éditeur de texte, De base (Visual Basic).
Mettez une seule instruction par ligne. N'utilisez pas le caractère de séparation de ligne Visual Basic (:).
Préférez au caractère de continuation de ligne explicite « _ » la continuation de ligne implicite partout où le langage le permet.
Mettez une seule déclaration par ligne.
Si la mise en forme automatique du code (reformatage) ne met pas les lignes de continuation en forme automatiquement, mettez manuellement les lignes de continuation en retrait d'un taquet de tabulation. Toutefois, alignez toujours les éléments à gauche dans une liste.
```
a As Integer,
b As Integer
```
Laissez au moins une ligne vide entre les définitions de méthode et de propriété.

Conventions de commentaires

Placez les commentaires sur une ligne séparée, et non à la fin d'une ligne de code.
Démarrez le texte de commentaire par une majuscule et terminez le texte de commentaire par un point.
Insérez un espace entre le délimiteur de commentaire (') et le texte de commentaire.
```
' Here is a comment.
```
N'entourez pas les commentaires avec des blocs d'astérisques mis en forme.

Structure du programme

Avec la méthode Main, utilisez la construction par défaut pour les nouvelles applications console et utilisez My pour les arguments de ligne de commande.
```
Sub Main()
  For Each argument As String In My.Application.CommandLineArgs
    ' Add code here to use the string variable. 
  Next 
End Sub
```

Indications concernant le langage

Type de données String

Pour concaténer des chaînes, utilisez une perluète (&).
```
MsgBox("hello" & vbCrLf & "goodbye")
```

Pour ajouter des chaînes dans des boucles, utilisez l'objet StringBuilder.

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énements

N'appliquez pas explicitement les arguments (Objet et EventArgs) aux gestionnaires d'événements. Si vous n'utilisez pas les arguments d'événement passés à un événement (par exemple, expéditeur pour Objet, e pour EventArgs), utilisez les délégués simplifiés et omettez les arguments d'événement dans votre code :

Public Sub Form1_Load() Handles Form1.Load
End Sub

Type de données non signé

Utilisez Integer au lieu des types non signés, sauf s'ils sont nécessaires.

Tableaux

Utilisez la syntaxe concise lorsque vous initialisez des tableaux sur la ligne de déclaration. Par exemple, utilisez la syntaxe suivante.
```
Dim letters1 As String() = {"a", "b", "c"}
```
N'utilisez pas la syntaxe suivante.
```
Dim letters2() As String = New String() {"a", "b", "c"}
```
Mettez l'indicateur de tableau sur le type, pas sur la variable. Par exemple, utilisez la syntaxe suivante :
```
Dim letters4 As String() = {"a", "b", "c"}
```
N'utilisez pas la syntaxe suivante :
```
Dim letters3() As String = {"a", "b", "c"}
```
Utilisez la syntaxe { } lorsque vous déclarez et initialisez des tableaux comportant des types de données de base. Par exemple, utilisez la syntaxe suivante :
```
Dim letters5() As String = {"a", "b", "c"}
```
N'utilisez pas la syntaxe suivante :
```
Dim letters6(2) As String
letters6(0) = "a"
letters6(1) = "b"
letters6(2) = "c"
```

Utilisation du mot clé "With"

Lorsque vous créez une série d'appels à un objet, envisagez l'utilisation du mot clé With :

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

Utilisez les instructions Try...Catch et Using pour la gestion des exceptions

N'utilisez pas On Error Goto.

Utilisation du mot clé IsNot

Utilisez le mot clé IsNot au lieu de Not...Is Nothing.

Mot clé New

Utilisez l'instanciation courte. Par exemple, utilisez la syntaxe suivante :
```
Dim employees As New List(Of String)
```
La ligne précédente est équivalente à ce qui suit :
```
Dim employees2 As List(Of String) = New List(Of String)
```

Utilisez des initialiseurs d'objets pour les nouveaux objets au lieu du constructeur sans paramètre :

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

Gestion des événements

Utilisez Handles plutôt que AddHandler :

Private Sub ToolStripMenuItem1_Click() Handles ToolStripMenuItem1.Click
End Sub

Utilisez AddressOf et n'instanciez pas le délégué explicitement :

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 concise et laissez le compilateur définir le délégué :

Public Event SampleEvent As EventHandler(Of SampleEventArgs)
' or 
Public Event SampleEvent(ByVal source As Object, 
                          ByVal e As SampleEventArgs)

Ne vérifiez pas si un événement est Nothing (null) avant d'appeler la méthode RaiseEvent. RaiseEvent recherche la valeur Nothing avant de déclencher l'événement.

Utilisation des membres partagés

Appelez des membres Shared à l'aide du nom de la classe et non à partir d'une variable d'instance.

Utilisation des littéraux XML

Les littéraux XML simplifient les tâches les plus courantes que vous rencontrez lorsque vous utilisez XML (par exemple, chargement, interrogation et transformation). Lorsque vous utilisez XML pour un développement, suivez ces consignes :

Utilisez des littéraux XML pour créer des fragments et des documents XML au lieu d'appeler directement des API XML.
Importez des espaces de noms XML au niveau du fichier ou du projet pour tirer parti des optimisations des performances des littéraux XML.
Utilisez les propriétés d'axe XML pour accéder aux éléments et aux attributs dans un document XML.

Utilisez 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 la méthode Add :

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 LINQ

Utilisez des noms explicites pour les variables de requête :

Dim seattleCustomers = From cust In customers 
                       Where cust.City = "Seattle"

Fournit des noms pour les éléments d'une requête qui permettent de s'assurer que les noms de propriété des types anonymes sont correctement capitalisés à l'aide de la casse Pascal :

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é dans le résultat sont ambigus. Par exemple, si votre requête retourne un nom de client et un ID de commande, renommez-les au lieu de les laisser au format Name et ID dans le résultat :

Dim customerOrders2 = From cust In customers 
                      Join ord In orders
                        On cust.CustomerID Equals ord.CustomerID 
                      Select CustomerName = cust.Name, 
                             OrderID = ord.ID

Utilisez l'inférence de type dans la déclaration des variables de requête et de portée :
```
Dim customerList = From cust In customers
```

Alignez les clauses de requête sous l'instruction From :

Dim newyorkCustomers = From cust In customers 
                       Where cust.City = "New York"  
                       Select cust.LastName, cust.CompanyName

Utilisez les clauses Where avant les autres clauses de requête afin de vous assurer que les clauses de requête ultérieures s'appliqueront au groupe de données réduit et filtré :
```
Dim newyorkCustomers2 = From cust In customers 
                        Where cust.City = "New York" 
                        Order By cust.LastName
```

Utilisez la clause Join pour définir explicitement une jointure au lieu de la définir implicitement à l'aide de la clause Where:

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

Voir aussi

Autres ressources

Instructions de codage sécurisé

Partager via