Conventions de codage Visual Basic

Article
03/12/2013

Microsoft développe des exemples et de la documentation qui suivent les règles dans cette rubrique.Si vous suivez les mêmes conventions de codage, vous pouvez comprendre les avantages suivants :

Votre code ira voir homogène, afin que les lecteurs puissent mettre le focus sur le contenu, et non pas sur la disposition.
Les lecteurs incluent votre code plus rapide car ils peuvent faire des hypothèses selon leur expérience précédente.
Vous pouvez copier, modifier, et mettre à jour le code plus facilement.
Vous contribuez garantissez que votre code montre des « meilleures pratiques » pour Visual Basic.

Conventions d'affectation de noms

Pour plus d'informations sur l'attribution des instructions, consultez la rubrique de Guidelines for Names .
N'utilisez pas "My" ou "my" dans un nom de variable,Cette pratique crée une confusion avec les objets d' My .
Vous ne devez pas 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 les retraits de quatre espaces.Pour plus d'informations, consultez Comment : définir les options de tabulation et d'indentation de l'éditeur.
Utilisez Mise en forme automatique avec tabulation du code pour reformater 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 (:).
Évitez d'utiliser le caractère de continuation de ligne implicite « _ » en faveur de continuation de ligne implicite partout où le langage le permet.
Mettez une seule déclaration par ligne.
Si Mise en forme automatique avec tabulation du code ne pas met en forme des lignes continuation automatiquement, mettez en retrait manuellement les lignes continuation un taquet de tabulation.Toutefois, toujours éléments d'inscription à gauche d'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.
Commencez le texte du commentaire par une lettre majuscule, et le texte de commentaire de fin avec un point.
Insérez un espace entre le délimiteur de commentaire (') et le texte de commentaire.
```
' Here is a comment.
```
Entourez ne pas les commentaires avec les blocs d'astérisques mis en forme.

Structure du programme

Lorsque vous utilisez la méthode d' Main, utilisez l'élément par défaut pour les nouvelles applications console, et utiliser 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 un et commercial (&).
```
MsgBox("hello" & vbCrLf & "goodbye")
```

Pour ajouter des chaînes dans des boucles, utilisez l'objet d' 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

Qualifiez ne pas explicitement les arguments (l'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 comme l'objet, e comme EventArgs), utilisez les délégués simplifiés, et omettre 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, mais où 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, 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 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 effectuez une série d'appels à un objet, envisagez d'utiliser le mot clé d' With :

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

Utilisez le Catch et les instructions try… lorsque vous utilisez la gestion des exceptions

N'utilisez pas On Error Goto.

Utilisation du mot clé IsNot

Utilisez le mot clé d' IsNot au lieu d' 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 courte, et laisser 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 d' 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"

Fournissez les noms des éléments dans une requête afin de vous 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 une référence 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 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 d' Where avant les autres clauses de requête afin que les clauses de requête ultérieures s'appliquent correctement au groupe de données filtré :
```
Dim newyorkCustomers2 = From cust In customers 
                        Where cust.City = "New York" 
                        Order By cust.LastName
```

Utilisez la clause d' Join pour définir explicitement une opération de jointure au lieu d'utiliser la clause d' 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

Autres ressources

Instructions de codage sécurisé

Partager via