Conventions de codage Visual Basic

Article
06/23/2023

Microsoft développe des exemples et de 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 une apparence cohérente, afin que les lecteurs puissent mieux se concentrer sur le contenu, et non sur la mise en page.
Les lecteurs comprennent votre code plus rapidement, car ils peuvent faire des hypothèses basées sur l’expérience précédente.
Vous pouvez copier, modifier et gérer le code plus facilement.
Vous veillez à ce que votre code illustre les « bonnes pratiques » pour Visual Basic.

Conventions d'affectation de noms

Pour plus d’informations sur les instructions de nommage, consultez la rubrique Instructions d’affectation de noms.
N’utilisez pas « My » ou « my » dans le cadre d’un nom de variable. Cette pratique crée une confusion avec les objets My.
Vous n’avez pas besoin de modifier les noms des objets dans le code généré automatiquement pour qu’ils correspondent aux instructions.

Conventions de disposition

Insérez des tabulations sous forme d’espaces et utilisez la mise en retrait intelligente avec des retraits à quatre espaces.
Utilisez pretty listing (reformatage) du code pour reformater votre code dans l’éditeur de code. Pour plus d’informations, consultez Options, Éditeur de texte, Basic (Visual Basic).
Écrivez une seule instruction par ligne. N’utilisez pas le caractère séparateur de ligne Visual Basic (:).
Évitez d’utiliser le caractère de continuation de ligne explicite « _ » en faveur de la continuation de ligne implicite partout où le langage le permet.
Écrivez une seule déclaration par ligne.
Si pretty listing (reformatage) du code ne met pas automatiquement en forme les lignes de continuation, mettez en retrait manuellement les lignes de continuation d’un taquet de tabulation. Toutefois, alignez toujours les éléments à gauche dans une liste.
```
a As Integer,  
b As Integer  
```
Ajoutez au moins une ligne blanche entre les définitions des méthodes et les définitions des propriétés.

Conventions de commentaires

Placez le commentaire sur une ligne séparée, pas à la fin d'une ligne de code.
Commencez le texte de commentaire avec une lettre majuscule et terminez le texte de commentaire par un point.
Insérez un espace entre le délimiteur de commentaire (') et le texte du commentaire, comme illustré dans l'exemple suivant.
```
' Here is a comment.
```
N’entourez pas les commentaires de blocs mis en forme d’astérisques.

Structure du programme

Lorsque vous utilisez 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
```

Directives du langage

String, type de données

Utilisez une interpolation de chaîne pour concaténer les chaînes courtes, comme illustré dans le code suivant.
```
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 détendus dans les gestionnaires d’événements

Ne qualifiez pas explicitement les arguments (Object et EventArgs) aux gestionnaires d’événements. Si vous n’utilisez pas les arguments d’événement passés à un événement (par exemple, sender As Object, e As EventArgs), utilisez des délégués détendus et laissez 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 plutôt que 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"}
```
Placez le désignateur de tableau sur le type, et non 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 de 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"
```

Utiliser le mot clé With

Lorsque vous effectuez une série d’appels à un objet, envisagez d’utiliser le mot clé With :

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

Utilisez l’option Essayer... et les instructions catch lorsque vous utilisez la gestion des exceptions

N’utilisez pas On Error Goto.

Utiliser le mot clé IsNot

Utilisez ... IsNot Nothing 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 équivaut à ceci :
```
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 AddressOfet n’instanciez pas explicitement le délégué :

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

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 vérifie Nothing avant de déclencher l’événement.

Utilisation des membres partagés

Appelez les membres Shared en utilisant le nom de la classe, et non à partir d’une variable instance.

Utilisation des littéraux XML

Les littéraux XML simplifient les tâches les plus courantes que vous rencontrez lorsque vous utilisez du code XML (par exemple, charger, interroger et transformer). Lorsque vous développez avec le langage XML, suivez ces instructions :

Utilisez des littéraux XML pour créer des documents et des fragments 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 de l’axe XML pour accéder aux éléments et aux attributs d’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"

Utilisez des alias pour vous assurer que les noms de propriétés des types anonymes sont correctement écrits en majuscules à 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és 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 comme 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 des variables 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 pour garantir que les clauses de requête ultérieures opèrent sur l’ensemble de données réduit et filtré :
```
Dim newyorkCustomers2 = From cust In customers 
                        Where cust.City = "New York" 
                        Order By cust.LastName
```

Utilisez la Join clause pour définir explicitement une opération de jointure au lieu d’utiliser la clause Where pour définir implicitement une opération de jointure :

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

Voir aussi

Instructions de codage sécurisé

Partager via