Convenções de codificação do Visual Basic

Artigo
04/07/2023

A Microsoft desenvolve exemplos e documentação que seguem as diretrizes neste tópico. Se você seguir as mesmas convenções de codificação, poderá obter os seguintes benefícios:

Seu código terá uma aparência consistente, para que os leitores possam se concentrar melhor no conteúdo, não no layout.
Os leitores entendem seu código mais rapidamente porque podem fazer suposições com base na experiência anterior.
Você pode copiar, alterar e manter o código com mais facilidade.
Você ajuda a garantir que seu código demonstre "práticas recomendadas" para o Visual Basic.

Convenções de nomenclatura

Para obter informações sobre diretrizes de nomenclatura, consulte o tópico Diretrizes de Nomenclatura.
Não use "My" ou "my" como parte de um nome de variável. Essa prática cria confusão com os My objetos.
Você não precisa alterar os nomes dos objetos no código gerado automaticamente para torná-los adequados às diretrizes.

Convenções de Layout

Insira guias como espaços e use recuos inteligentes com recuos de quatro espaços.
Use a listagem Bonita (reformatação) do código para reformatar seu código no editor de código. Para obter mais informações, consulte Opções, Editor de Texto, Básico (Visual Basic).
Gravar apenas uma instrução por linha. Não use o caractere separador de linha do Visual Basic (:).
Evite usar o caractere de continuação de linha explícita "_" a favor da continuação de linha implícita onde quer que o idioma o permita.
Gravar apenas uma declaração por linha.
Se a listagem bonita (reformatação) do código não formatar linhas de continuação automaticamente, recuo manual das linhas de continuação uma parada de tabulação. No entanto, sempre alinhe itens à esquerda em uma lista.
```
a As Integer,  
b As Integer  
```
Adicione pelo menos uma linha em branco entre as definições de método e de propriedade.

Comentando Convenções

Coloque comentários em uma linha separada, ao invés do final de uma linha de código.
Inicie o texto de comentário com uma letra maiúscula e encerre o texto do comentário com um período.
Insira um espaço entre o delimitador de comentário (') e o texto do comentário.
```
' Here is a comment.
```
Não envolva comentários com blocos formatados de asteriscos.

Estrutura do programa

Ao usar o Main método, use o constructo padrão para novos aplicativos de console e use My para argumentos de linha de comando.

Sub Main()
  For Each argument As String In My.Application.CommandLineArgs
    ' Add code here to use the string variable.
  Next
End Sub

Diretrizes de Linguagem

Tipo de dados da cadeia de caracteres

Use a interpolação de cadeia de caracteres para concatenar cadeias de caracteres curtas, como é mostrado no código a seguir.
```
MsgBox($"hello{vbCrLf}goodbye")
```

Para acrescentar cadeias de caracteres em loops, use o StringBuilder objeto.

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

Delegados relaxados em manipuladores de eventos

Não qualifique explicitamente os argumentos (Object e EventArgs) para manipuladores de eventos. Se você não está usando os argumentos de evento que são passados para um evento (por exemplo, sender As Object, e As EventArgs), use delegados relaxados e deixe de fora os argumentos de evento em seu código:

Public Sub Form1_Load() Handles Form1.Load
End Sub

Tipo de Dados Sem Sinal

Use Integer em vez de tipos não assinados, exceto onde eles são necessários.

Matrizes

Use a sintaxe concisa ao inicializar matrizes na linha da declaração. Por exemplo, use a sintaxe a seguir.
```
Dim letters1 As String() = {"a", "b", "c"}
```
Não use a sintaxe a seguir.
```
Dim letters2() As String = New String() {"a", "b", "c"}
```
Coloque o designador de matriz no tipo, não na variável. Por exemplo, use a seguinte sintaxe:
```
Dim letters4 As String() = {"a", "b", "c"}
```
Não use a seguinte sintaxe:
```
Dim letters3() As String = {"a", "b", "c"}
```
Use a sintaxe { } ao declarar e inicializar matrizes de tipos de dados básicos. Por exemplo, use a seguinte sintaxe:
```
Dim letters5 As String() = {"a", "b", "c"}
```
Não use a seguinte sintaxe:
```
Dim letters6(2) As String
letters6(0) = "a"
letters6(1) = "b"
letters6(2) = "c"
```

Usar a palavra-chave Com

Ao fazer uma série de chamadas para um objeto, considere usar a With palavra-chave:

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

Use o Try... Capturar e usar instruções ao usar o Tratamento de Exceções

Não use On Error Goto.

Usar a palavra-chave IsNot

Use ... IsNot Nothing em vez de Not ... Is Nothing.

Nova palavra-chave

Use uma instância curta. Por exemplo, use a seguinte sintaxe:
```
Dim employees As New List(Of String)
```
A linha precedente é equivalente a isso:
```
Dim employees2 As List(Of String) = New List(Of String)
```

Use inicializadores de objeto para novos objetos em vez do construtor sem parâmetros:

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

Tratamento de Evento

Use Handles em vez de AddHandler:

Private Sub ToolStripMenuItem1_Click() Handles ToolStripMenuItem1.Click
End Sub

Use AddressOfe não instancie o delegado explicitamente:

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

Ao definir um evento, use a sintaxe curta e deixe o compilador definir o delegado:

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

Não verifique se um evento é Nothing (nulo) antes de chamar o RaiseEvent método. RaiseEvent verifica antes Nothing que ele acione o evento.

Usando membros compartilhados

Chame Shared os membros usando o nome da classe, não de uma variável de instância.

Usar literais XML

Literais XML simplificam as tarefas mais comuns encontradas quando você trabalha com XML (por exemplo, carregar, consultar e transformar). Ao desenvolver com XML, siga estas diretrizes:

Use literais XML para criar documentos XML e fragmentos em vez de chamar APIs XML diretamente.
Importe namespaces XML no nível do arquivo ou do projeto para aproveitar as otimizações de desempenho para literais XML.
Use as propriedades do eixo XML para acessar elementos e atributos em um documento XML.

Use expressões inseridas para incluir valores e criar XML com base em valores existentes em vez de usar chamadas à API, como o 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 nomes significativos para variáveis de consulta:

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

Forneça nomes para elementos em uma consulta para garantir que os nomes de propriedades de tipos anônimos sejam maiúsculas corretamente usando o uso de maiúsculas e minúsculas pascal:

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

Renomeie propriedades quando os nomes de propriedades no resultado forem ambíguos. Por exemplo, se a sua consulta retornar um nome de cliente e um ID de ordem, renome-os ao invés de deixá-los como Name e ID no resultado:

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

Usa a inferência de tipos na declaração de variáveis de consulta e de intervalo:
```
Dim customerList = From cust In customers
```

Alinhar cláusulas de consulta na instrução From :

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

Use as cláusulas Where antes de outras cláusulas de consulta, para garantir que as cláusulas de consulta posteriores operem no conjunto de dados filtrado:
```
Dim newyorkCustomers2 = From cust In customers 
                        Where cust.City = "New York" 
                        Order By cust.LastName
```

Use a Join cláusula para definir explicitamente uma operação de junção em vez de usar a Where cláusula para definir implicitamente uma operação de junção:

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

Confira também

Diretrizes de codificação segura