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

Artigo
03/05/2024

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 mais facilmente.
Você ajuda a garantir que seu código demonstre "práticas recomendadas" para Visual Basic.

Convenções de nomenclatura

Para obter informações sobre diretrizes de nomenclatura, consulte o tópico Diretrizes de nomenclatura.
Não use "Meu" ou "Meu" como parte de um nome de variável. Esta prática cria confusão com os My objetos.
Não é necessário alterar os nomes dos objetos no código gerado automaticamente para que eles se ajustem às diretrizes.

Convenções de Layout

Insira guias como espaços e use recuo inteligente com recuos de quatro espaços.
Use a listagem bonita (reformatação) de 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).
Use 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 "_" em favor da continuação de linha implícita sempre que a linguagem permitir.
Use apenas uma declaração por linha.
Se a listagem bonita (reformatação) do código não formatar linhas de continuação automaticamente, recue manualmente as linhas de continuação uma parada de tabulação. No entanto, sempre alinhe os 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 propriedade.

Convenções comentadoras

Coloque comentários em uma linha separada em vez de no final de uma linha de código.
Inicie o texto do comentário com uma letra maiúscula e termine o texto do comentário com um ponto.
Insira um espaço entre o delimitador de comentários (') e o texto do comentário.
```
' Here is a comment.
```
Não rodeie os comentários com blocos formatados de asteriscos.

Estrutura do Programa

Quando você usa o Main método, use a construção 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

Orientações linguísticas

Tipo de dados de cadeia de caracteres

Use a interpolação de cadeia de caracteres para concatenar cadeias curtas, conforme 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 estiver 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 não assinado

Use Integer em vez de tipos não assinados, exceto quando forem necessários.

Matrizes

Use a sintaxe curta ao inicializar matrizes na linha de 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"
```

Use a palavra-chave With

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... Capturar e usar instruções ao usar o Tratamento de Exceções

Não utilize On Error Goto.

Use a palavra-chave IsNot

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

Nova palavra-chave

Use uma instanciação curta. Por exemplo, use a seguinte sintaxe:
```
Dim employees As New List(Of String)
```
A linha anterior é equivalente a isto:
```
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 eventos

Utilizar 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 de gerar 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

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

Use literais XML para criar documentos e fragmentos XML em vez de chamar APIs XML diretamente.
Importe namespaces XML no nível de arquivo ou 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 incorporadas para incluir valores e criar XML a partir de valores existentes em vez de usar chamadas de 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 certificar-se de que os nomes de propriedade de tipos anônimos estejam corretamente capitalizados usando a caixa 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 propriedade no resultado forem ambíguos. Por exemplo, se sua consulta retornar um nome de cliente e um ID de pedido, renomeie-os em vez 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

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

Alinhe as cláusulas de consulta sob a From instrução:

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

Use Where cláusulas antes de outras cláusulas de consulta para que cláusulas de consulta posteriores operem no conjunto filtrado de dados:

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

Consulte também

Diretrizes de codificação segura

Partilhar via