Conventions de codage Visual Basic

2025-06-22

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 disposition.
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 pouvez vous assurer que votre code illustre les « bonnes pratiques » pour Visual Basic.

Conventions d'affectation de noms

Pour plus d’informations sur les instructions d’affectation de noms, 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 My objets.
Vous n’avez pas besoin de modifier les noms d’objets dans le code généré automatiquement pour qu’ils correspondent aux instructions.

Conventions de disposition

Insérez des onglets en tant qu’espaces et utilisez le retrait intelligent avec des retraits à quatre espaces.
Utilisez la description jolie (reformatage) du code pour reformater votre code dans l’éditeur de code. Pour plus d’informations, consultez Options, Éditeur de texte, Basic (Visual Basic).
Utilisez une seule instruction par ligne. N’utilisez pas le caractère de 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ù la langue l’autorise.
Utilisez une seule déclaration par ligne.
Si la description jolie (reformatage) du code ne met pas automatiquement en forme les lignes de continuation, mettez manuellement en retrait les lignes de continuation d’un taquet de tabulation. Toutefois, alignez toujours les éléments de gauche dans une liste.
```
a As Integer,  
b As Integer  
```
Ajoutez au moins une ligne vide entre les définitions de méthode et de propriété.

Conventions de commentaire

Placez des commentaires sur une ligne distincte au lieu de la fin d’une ligne de code.
Démarrez le texte du commentaire avec une lettre majuscule et terminez le texte du commentaire avec un point.
Insérez un espace entre le délimiteur de commentaire (') et le texte du commentaire.
```
' Here is a comment.
```
N’entourez pas les commentaires avec des blocs mis en forme d’astérisques.

Structure du programme

Lorsque vous utilisez la Main méthode, utilisez la construction par défaut pour les nouvelles applications console et utilisez-la 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
```

Recommandations en matière de langue

Type de données de chaîne

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 courte 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 l’indicateur 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 With mot clé :

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

Utilisez l’essai... Instructions Catch et Using 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.

Nouveau mot clé

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

Utilisation de membres partagés

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

Utiliser des littéraux XML

Les littéraux XML simplifient les tâches les plus courantes que vous rencontrez lorsque vous travaillez avec XML (par exemple, charger, interroger et transformer). Lorsque vous développez avec 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 pour les littéraux XML.
Utilisez les propriétés de l’axe XML pour accéder aux éléments et 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 Add méthode :

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"

Fournissez des noms pour les éléments d’une requête pour vous assurer que les noms de propriétés 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é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 plage :
```
Dim customerList = From cust In customers
```

Aligner 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 Where des clauses avant d’autres clauses de requête afin que les clauses de requête ultérieures opèrent sur le jeu de données 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 Where clause 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