Convenciones de código de Visual Basic

Artículo
04/07/2023

Microsoft desarrolla ejemplos y documentación que siguen las instrucciones de este tema. Si sigue las mismas convenciones de codificación, puede obtener las siguientes ventajas:

El código tendrá un aspecto coherente para que los lectores puedan centrarse mejor en el contenido, no en el diseño.
Los lectores comprenden el código más rápidamente porque pueden realizar suposiciones en función de experiencias anteriores.
Puede copiar, cambiar y mantener el código más fácilmente.
Le ayudará a garantizar que el código muestra los "procedimientos recomendados" de Visual Basic.

Convenciones de nomenclatura

Para más información sobre las instrucciones de nomenclatura, consulte el tema Instrucciones de nomenclatura.
No use "My" o "my" como parte de un nombre de variable. Esta práctica crea confusión con los objetos My.
No es necesario cambiar los nombres de los objetos en el código generado automáticamente para que se ajusten a las instrucciones.

Convenciones de diseño

Inserte pestañas como espacios y use la sangría inteligente con sangrías de cuatro espacios.
Use Lista descriptiva (nuevo formato) de código para volver a formatear el código en el editor de código. Para más información, consulte Opciones, editor de texto, básico (Visual Basic).
Use solo una instrucción por línea. No use el carácter separador de líneas de Visual Basic (:).
Evite usar el carácter de continuación de línea explícito "_" en favor de la continuación de línea implícita siempre que el lenguaje lo permita.
Use solo una declaración por línea.
Si Lista descriptiva (nuevo formato) de código no da formato a las líneas de continuación automáticamente, inserte manualmente una sangría de una tabulación en las líneas de continuación. No obstante, alinee siempre los elementos a la izquierda en una lista.
```
a As Integer,  
b As Integer  
```
Agregue al menos una línea en blanco entre las definiciones de método y las de propiedad.

Convenciones de los comentarios

Ponga los comentarios en una línea aparte en lugar de al final de una línea de código.
Inicie el texto del comentario con una letra mayúscula y termine con un punto.
Inserte un espacio entre el delimitador de comentarios (') y el texto del comentario.
```
' Here is a comment.
```
No rodee los comentarios con bloques con formato de asteriscos.

Estructura del programa

Cuando use el método Main, use la construcción predeterminada para las nuevas aplicaciones de consola y use My para argumentos de línea de comandos.
```
Sub Main()
  For Each argument As String In My.Application.CommandLineArgs
    ' Add code here to use the string variable.
  Next
End Sub
```

Convenciones de lenguaje

String (Tipo de datos)

Use interpolación de cadenas para concatenar cadenas cortas, como se muestra en el código siguiente.
```
MsgBox($"hello{vbCrLf}goodbye")
```

Para anexar cadenas en bucles, use el objeto StringBuilder.

Dim longString As New System.Text.StringBuilder
For count As Integer = 1 To 1000
  longString.Append(count)
Next

Delegados relajados en controladores de eventos

No califique explícitamente los argumentos (Object y EventArgs) en los controladores de eventos. Si no usa los argumentos de evento que se pasan a un evento (por ejemplo, sender As Object y e As EventArgs), use delegados relajados y deje los argumentos de evento en el código:

Public Sub Form1_Load() Handles Form1.Load
End Sub

Tipo de datos sin signo

Use Integer en lugar de tipos sin firmar, excepto cuando sean necesarios.

Matrices

Utilice sintaxis corta para inicializar las matrices en la línea de declaración. Por ejemplo, use la sintaxis siguiente.
```
Dim letters1 As String() = {"a", "b", "c"}
```
No use la sintaxis siguiente.
```
Dim letters2() As String = New String() {"a", "b", "c"}
```
Coloque el designador de matriz en el tipo, no en la variable. Por ejemplo, use la sintaxis siguiente:
```
Dim letters4 As String() = {"a", "b", "c"}
```
No use la sintaxis siguiente:
```
Dim letters3() As String = {"a", "b", "c"}
```
Use la sintaxis { } al declarar e inicializar matrices de tipos de datos básicos. Por ejemplo, use la sintaxis siguiente:
```
Dim letters5 As String() = {"a", "b", "c"}
```
No use la sintaxis siguiente:
```
Dim letters6(2) As String
letters6(0) = "a"
letters6(1) = "b"
letters6(2) = "c"
```

Uso de la palabra clave With

Cuando realice una serie de llamadas a un objeto, considere la posibilidad de usar la palabra clave With:

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

Uso de las instrucciones Try...Catch y Using cuando utilice el control de excepciones

No use On Error Goto.

Uso de la palabra clave IsNot

Use ... IsNot Nothing en lugar de Not ... Is Nothing.

Nueva palabra clave

Use la creación de instancias cortas. Por ejemplo, use la sintaxis siguiente:
```
Dim employees As New List(Of String)
```
La línea anterior equivale a lo siguiente:
```
Dim employees2 As List(Of String) = New List(Of String)
```

Use inicializadores de objeto para objetos nuevos en lugar del constructor sin parámetros:

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

Control de eventos

Use Handles en lugar de AddHandler:

Private Sub ToolStripMenuItem1_Click() Handles ToolStripMenuItem1.Click
End Sub

Use AddressOf y no cree instancias del delegado explícitamente:

Dim closeItem As New ToolStripMenuItem( 
    "Close", Nothing, AddressOf ToolStripMenuItem1_Click)
Me.MainMenuStrip.Items.Add(closeItem)

Al definir un evento, use la sintaxis corta y deje que el compilador defina el delegado:

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

No compruebe si un evento es Nothing (null) antes de llamar al método RaiseEvent. RaiseEvent comprueba si aparece Nothing antes de generar el evento.

Uso de miembros compartidos

Llame a los miembros Shared mediante el nombre de clase, no desde una variable de instancia.

Uso de literales XML

Los literales XML simplifican las tareas más comunes que se encuentran al trabajar con XML (por ejemplo, la carga, consulta y transformación). Cuando desarrolle con XML, siga estas instrucciones:

Use literales XML para crear documentos y fragmentos XML en lugar de llamar directamente a las API de XML.
Importe espacios de nombres XML en el nivel de archivo o proyecto para aprovechar las optimizaciones de rendimiento de los literales XML.
Use las propiedades del eje XML para acceder a los elementos y atributos de un documento XML.

Use expresiones insertadas para incluir valores y para crear XML a partir de los valores existentes en lugar de usar llamadas API como el método 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

Consultas LINQ

Utilice nombres descriptivos para las variables de consulta:

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

Proporcione nombres para los elementos de una consulta para asegurarse de que los nombres de propiedad de tipos anónimos se escriben correctamente con mayúscula o minúscula, usando para ello la grafía Pascal:

Dim customerOrders = From customer In customers 
                     Join order In orders 
                       On customer.CustomerID Equals order.CustomerID 
                     Select Customer = customer, Order = order

Cambie el nombre de las propiedades cuando puedan ser ambiguos en el resultado. Por ejemplo, si su consulta devuelve un nombre de cliente y un identificador de pedido, reasígneles un nombre en lugar de dejarlos como Name y ID en el resultado:

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

Utilice la inferencia de tipos en la declaración de variables de consulta y variables de rango:
```
Dim customerList = From cust In customers
```

Alinee las cláusulas de consulta en la instrucción From:

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

Use cláusulas Where antes de otras cláusulas de consulta para que las cláusulas de consulta posteriores operen en el conjunto de datos filtrado:

Dim newyorkCustomers2 = From cust In customers 
                        Where cust.City = "New York" 
                        Order By cust.LastName

Use la cláusula Join para definir explícitamente una operación de combinación en lugar de usar la cláusula Where para definir implícitamente una operación de combinación:

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

Consulte también

Instrucciones de codificación segura

Compartir a través de