Convenciones de código de Visual Basic

Artículo
06/08/2015

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

Su código tendrá un aspecto coherente, de modo que los lectores pueden centrar mejor su atención en el contenido y no en el diseño.
Los lectores entienden el código con más rapidez, ya que pueden hacer suposiciones en función de su experiencia anterior.
Puede copiar, cambiar y mantener el código con mayor facilidad.
Ayuda a garantiza que el código muestra “procedimientos recomendados” para Visual Basic.

Convenciones de nomenclatura

Para obtener información sobre las directrices de nomenclatura, vea el tema Guidelines for Names.
No utilice "Mi" o "mi" como parte de un nombre de variable. Esta práctica crea confusión con los objetos My.
No tiene que cambiar los nombres de objetos en código generado automáticamente para que se ajusten a las directrices.

Convenciones de diseño

Inserte tabulaciones como espacios y use la sangría inteligente con sangrías de cuatro espacios.
Utilice Lista descriptiva (nuevo formato) de código para volver a aplicar formato al código en el Editor de código. Para obtener más información, vea Opciones, editor de texto, básico (Visual Basic).
Utilice sólo una instrucción por línea. No utilice el carácter separador de línea de Visual Basic (:).
Evite utilizar el carácter de continuación de línea explícito "_" a favor de la continuación de línea implícita siempre que el lenguaje lo permita.
Utilice sólo 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, aplique manualmente una tabulación a las líneas de continuación para aplicar la sangría. Sin embargo, alinee siempre los elementos de una lista a la izquierda.
```
a As Integer,
b As Integer
```
Agregue al menos una línea en blanco entre el método y las definiciones de propiedad.

Convenciones de los comentarios

Ponga los comentarios en una línea independiente, no al final de una línea de código.
Comience el texto del comentario con una letra en 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 incluya bloques de asterisco con formato alrededor de los comentarios.

Estructura del programa

Al usar el método Main, utilice la construcción predeterminada para las nuevas aplicaciones de consola y utilice My para los argumentos de la 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)

Para concatenar cadenas, use una Y comercial (&).
```
MsgBox("hello" & vbCrLf & "goodbye")
```

Para anexar cadenas en bucles, utilice el objeto StringBuilder.

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

Delegados flexibles en controladores de eventos

No califique explícitamente los argumentos (Object y EventArgs) como controladores de eventos. Si no usa los argumentos de evento que se pasan a un evento (por ejemplo, el remitente como objeto como EventArgs), utilice los delegados flexibles y no incluya argumentos de evento en el código:

Public Sub Form1_Load() Handles Form1.Load
End Sub

Tipo de datos sin signo

Utilice Integer en lugar de tipos sin signo, excepto cuando sean necesarios.

Matrices

Conviene usar la sintaxis breve al inicializar matrices en la línea de declaración. Por ejemplo, puede usar la siguiente sintaxis.
```
Dim letters1 As String() = {"a", "b", "c"}
```
No use la sintaxis siguiente.
```
Dim letters2() As String = New String() {"a", "b", "c"}
```
Sitúe el designador en el tipo, no en la variable. Por ejemplo, puede usar la siguiente sintaxis:
```
Dim letters4 As String() = {"a", "b", "c"}
```
No use la sintaxis siguiente:
```
Dim letters3() As String = {"a", "b", "c"}
```
Utilice la sintaxis {} al declarar e inicializar matrices de tipos de datos básicos. Por ejemplo, puede usar la siguiente sintaxis:
```
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"
```

Utilice la palabra clave With

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

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

Use las instrucciones Try...Catch y Using cuando use el Control de excepciones

No utilice On Error Goto.

Utilizar la palabra clave IsNot

Use la palabra clave IsNot en lugar de Not...Is Nothing.

New (Palabra clave)

Usar la creación de instancias abreviadas. Por ejemplo, puede usar la siguiente sintaxis:
```
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)
```

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

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

Control de eventos

Utilice Handles en lugar de AddHandler.

Private Sub ToolStripMenuItem1_Click() Handles ToolStripMenuItem1.Click
End Sub

Utilice AddressOf y no cree instancias explícitas del delegado:

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

Cuando defina un evento, utilice la sintaxis corta y permita 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 Nothing antes de generar el evento.

Utilizar miembros compartidos

Llame a los miembros Shared utilizando el nombre de clase y no una variable de instancia.

Utilizar literales XML

Los literales XML simplifican las tareas más comunes con las que se encuentra al trabajar con XML (por ejemplo, cargar, consultar y transformar). Al desarrollar con XML, siga estas instrucciones:

Utilice literales XML para crear documentos y fragmentos XML en lugar de llamar directamente a API XML.
Importe espacios de nombres XML al archivo o nivel de proyecto para sacar partido de la optimización del rendimiento para los literales XML.
Utilice las propiedades de eje XML para tener acceso a elementos y atributos en un documento XML.

Utilice expresiones incrustadas para incluir valores y crear XML a partir de valores existentes en lugar de utilizar 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 elementos en una consulta para asegurarse de que los nombres de propiedad de tipos anónimos se escriben con las mayúsculas correctas mediante 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 los nombres de propiedad en el resultado puedan ser ambiguos. Por ejemplo, si la consulta devuelve un nombre de cliente y un Id. de pedido, cámbieles el nombre en lugar de dejarlos como Name e 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 intervalo:
```
Dim customerList = From cust In customers
```

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

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

Utilice las cláusulas Where antes de otras cláusulas de consulta de forma 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
```

Utilice la cláusula Join para definir explícitamente una operación de unión en lugar de utilizar la cláusula Where para definir implícitamente una operación de unión:

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

Vea también

Otros recursos

Instrucciones de codificación segura

Compartir a través de