Convenciones de codificación de Visual Basic

2025-06-20

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 entienden el código más rápidamente porque pueden realizar suposiciones en función de la experiencia anterior.
Puede copiar, cambiar y mantener el código más fácilmente.
Ayudas a asegurar que tu código demuestre "mejores prácticas" para Visual Basic.

Convenciones de nomenclatura

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

Convenciones de maquetación

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 obtener más información, vea Opciones, Editor de texto, Basic (Visual Basic) .
Use solo una instrucción por línea. No use el carácter separador de línea 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 propiedad.

Convenciones de los comentarios

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

Estructura del programa

Cuando se usa el Main método , 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
```

Directrices de idioma

Tipo de datos de cadena

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 StringBuilder objeto .

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) a los controladores de eventos. Si no usa los argumentos de evento que se pasan a un evento (por ejemplo, sender As Object, e As EventArgs), use delegados flexibles y omita los argumentos de evento en el código.

Public Sub Form1_Load() Handles Form1.Load
End Sub

Tipo de datos sin firmar

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

Matrices

Use la sintaxis corta al inicializar 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

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

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 es equivalente a esto:
```
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 RaiseEvent método . RaiseEvent verifica la presencia de 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, carga, consulta y transformación). Al desarrollar con XML, siga estas instrucciones:

Use literales XML para crear documentos y fragmentos XML en lugar de llamar directamente a las API 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 tener acceso a elementos y atributos en un documento XML.

Use expresiones incrustadas para incluir valores y crear XML a partir de valores existentes en lugar de usar llamadas API como el Add método :

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

Use nombres significativos 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 la consulta devuelve un nombre de cliente y un identificador de pedido, cámbielos 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

Use la inferencia de tipos en la declaración de variables de consulta y variables de intervalo:
```
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 Join cláusula para definir explícitamente una operación de combinación en lugar de usar la Where cláusula 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

Directrices de codificación segura

Compartir a través de