Conventions de codage Visual Basic

Article
08/10/2011

Ces conventions sont utilisées par Microsoft pour développer des exemples et de la documentation. La spécification du langage Visual Basic ne définit aucune norme de codage.

Les conventions de codage donnent au code un aspect homogène, afin que les lecteurs puissent se concentrer sur le contenu et non pas sur la disposition.
Les conventions permettent aux lecteurs de comprendre le code plus rapidement, parce qu'ils peuvent faire des hypothèses selon leur expérience précédente.
Les conventions facilitent la copie, la modification et la gestion du code.
Les conventions décrivent les meilleures pratiques applicables à Visual Basic.

Discussion

Conventions d'affectation de noms

Les indications concernant l'attribution d'un nom sont décrites dans Instructions de conception pour le développement de bibliothèques de classes.
Vous ne devez pas modifier le nom des objets créés avec les outils du Concepteur de Visual Studio pour les rendre conformes aux indications.
Utilisez les qualifications d'espace de noms au lieu d'ajouter des instructions Imports. Si un espace de noms est importé par défaut dans un projet, vous ne devez pas qualifier pleinement le code parce qu'il s'exécutera de façon non qualifiée avec IntelliSense lors du copier-coller. Lorsque vous coupez de longues lignes de code pour en simplifier la lecture, les noms qualifiés risquent d'être coupés après le "." Par exemple :
```
Dim collection As System.Diagnostics. 
       InstanceDataCollectionCollection
```
N'utilisez pas "My" ou "my" dans un nom de variable, car cela peut créer une confusion avec les objets My.

Conventions de disposition

Une bonne disposition utilise la mise en forme pour souligner la structure du code et simplifier la lecture du code.

Utilisez la fonctionnalité Mise en forme automatique avec tabulation du code pour mettre le code en forme avec les paramètres par défaut (mise en retrait intelligente, mise en retrait de 4 caractères, enregistrement des tabulations en tant qu'espaces). Pour plus d'informations, consultez Spécifique à VB, Basic, Éditeur de texte, boîte de dialogue Options.
Mettez une seule instruction par ligne. N'utilisez pas le caractère de continuation de ligne Visual Basic (:).
Mettez une seule déclaration par ligne.
Si la fonctionnalité Mise en forme automatique avec tabulation du code ne met pas en forme les lignes de continuation, mettez en retrait ces lignes d'un taquet de tabulation.
Laissez au moins une ligne vide entre les définitions de méthode et de propriété.

Conventions de commentaires

Ne mettez pas de commentaires à la fin d'une ligne de code, mais plutôt sur une ligne séparée.
Commencez le texte du commentaire par une lettre majuscule.
Ajoutez un point à la fin du commentaire.
Insérez un espace entre le délimiteur de commentaire (') et le texte de commentaire.
```
' Here is a comment.
```
Ne créez pas de blocs d'astérisques mis en forme autour des commentaires.

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

Utilisez le signe & pour concaténer des chaînes :
```
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

Inférence de type

Tirez parti de l'inférence de type pour les variables locales :

Public Sub GetQuery()
  Dim filterValue = "London"
  Dim query = From customer In customers 
              Where customer.Country = filterValue
End Sub

Délégués souples dans les gestionnaires d'événements

Utilisez des délégués souples et laissez les arguments d'événements de côté si vous ne les utilisez pas 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 si vous donnez plus d'importance à la mémoire.

Tableaux

Utilisez une syntaxe courte lorsque vous initialisez des tableaux sur la ligne de déclaration :
```
Dim letters1() As String = {"a", "b", "c"}
```
Au lieu de :
```
Dim letters2() As String = New String() {"a", "b", "c"}
```

Mettez l'indicateur de tableau sur la variable, pas sur le type :

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

Au lieu de :

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

Utilisez la syntaxe {} lorsque vous déclarez et initialisez des tableaux comportant des types de données de base :
```
Dim letters5() As String = {"a", "b", "c"}
```
Au lieu de :
```
Dim letters6(2) As String
letters6(0) = "a"
letters6(1) = "b"
letters6(2) = "c"
```

Utilisation du mot clé "With"

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

Utilisation de l'inférence de type pour les variables de boucle dans les instructions For ou For Each

Permettez à l'inférence de type de déterminer le type d'une variable de portée de boucle.

L'exemple suivant illustre l'utilisation de l'inférence de type dans une instruction For :

For count = 0 To 2
  MsgBox(names(count))
Next

L'exemple suivant illustre l'utilisation de l'inférence de type dans une instruction For Each :

For Each name In names
  MsgBox(name)
Next

Utilisation des instructions Try...Catch et Using pour la gestion des exceptions

N'utilisez pas On Error Goto.

Pour gérer les exceptions, utilisez une instruction Try...Catch.

Dim conn As New SqlConnection("connection string")
Try
  Conn.Open()
Catch ex As SqlException

Finally
  Conn.Close()
End Try

L'instruction Using associe une instruction Try...Catch avec un appel à la méthode Dispose et simplifie le code. Si vous utilisez une instruction Try...Catch et si le seul code dans le bloc Finally est un appel à la méthode Dispose, utilisez plutôt l'instruction Using.
```
Using redPen As New Pen(color.Red)
  ' Insert code here.
End Using
```

Utilisation du mot clé IsNot

Utilisez le mot clé IsNot plutôt que Not...Is Nothing.

Utilisation des mots clés AndAlso et OrElse

Pour éviter les exceptions et améliorer les performances en ignorant le code superflu, utilisez AndAlso au lieu de And et OrElse au lieu de Or lorsque vous effectuez des comparaisons :

' Avoid a null reference exception. If the left side of the AndAlso 
' operator is False, the right side is not evaluated and a null 
' exception is not thrown.
If nullableObject IsNot Nothing AndAlso nullableObject = testValue Then

End If

' Avoid an unnecessary resource-intensive operation. If the left side
' of the OrElse operator is True, the right side is not evaluated and 
' a resource-intensive operation is not called.
If testCondition OrElse ResourceIntensiveOperation() Then

End If

Instances de formulaires par défaut

Utilisez Form1.ShowDialog plutôt que My.Forms.Form1.ShowDialog.

Mot clé New

Utilisez l'instanciation courte :

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 courte et laissez le compilateur définir le délégué :
```
Public Event WhatHappened(ByVal source As Object, 
                          ByVal e As WhatHappenedEventArgs)
```
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 de la fonction MsgBox

Utilisez MsgBox au lieu de MessageBox.Show ou Console.WriteLine. Dans les environnements qui ne prennent pas en charge la fonction MsgBox, comme Silverlight, utilisez une alternative appropriée.

Utilisation de l'espace de noms My

Utilisez les fonctionnalités My plutôt que la bibliothèque de classes .NET Framework ou la bibliothèque runtime Visual Basic. Pour plus d'informations, consultez Objets (Visual Basic).

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"

Eléments d'alias dans 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 d'ordre, au lieu de les laisser au format Name et ID dans le résultat, renommez-les comme suit :

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'appliquent correctement 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

Utilisation des membres de la bibliothèque runtime Visual Basic

Utilisez la bibliothèque runtime Visual Basic plutôt que la bibliothèque de classes .NET Framework.

Partager via