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

Artigo
03/12/2013

Microsoft desenvolver os exemplos e documentação que seguem as diretrizes contidas neste tópico.Se você segue as mesmas convenções de codificação, você pode obter os seguintes benefícios:

O código terá uma aparência consistente, de modo que leitores podem melhorar o foco no conteúdo, não layout.
Os leitores compõem seu código mais rápido porque podem fazer as suposições com base na experiência anterior.
Você pode copiar, modificar, e manter o código mais facilmente.
Você ajuda a garantir que seu código demonstra “práticas recomendadas” para Visual Basic.

Convenções de nomenclatura

Para obter informações sobre como nomear diretrizes, consulte o tópico de Guidelines for Names .
Não use “meu” ou “meu” como parte de um nome de variável.Esta prática cria a confusão com objetos de My .
Você não tem que alterar os nomes dos objetos no código gerado automaticamente para torná-los ajustar as diretrizes.

Convenções de layout

Inserir guias como espaços, e o recuo inteligente de uso com recortes de quatro espaço.Para obter mais informações, consulte Como: definir opções de recuo e guia Editor.
Use Reformatação automática de código para reformatar o código no editor de códigos.Para obter mais informações, consulte Opções, o Editor de texto, Basic (Visual Basic).
Use apenas uma declaração linha por linha.Não use a linha de caractere separador do Visual Basic (:).
Evite usar a linha explícita “_” caractere de continuação de linha em favor de continuação de linha implícita onde quer que o permite a linguagem.
Use apenas uma declaração linha por linha.
Se Reformatação automática de código não formata linhas de continuação automaticamente, recuar manualmente linhas de continuação uma parada de tabulação.No entanto, um alinhar sempre itens em uma lista.
```
a As Integer,
b As Integer
```
Adicione pelo menos uma linha em branco entre o método e as definições de propriedade.

Convenções de comentário

Colocar comentários em uma linha separada em vez no final de uma linha de código.
Inicie o texto de comentário com uma letra maiúscula, e o texto do comentário de fim com um ponto.
O inserir um espaço entre o comentário delimitador (') e o texto de comentário.
```
' Here is a comment.
```
Não coloque comentários com blocos formatado de asteriscos.

Programar a estrutura

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

Diretrizes de linguagem

Tipo de dados de cadeia de caracteres

Para concatenar as cadeias de caracteres, use um E comercial (&).
```
MsgBox("hello" & vbCrLf & "goodbye")
```

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

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

Delegados relaxado nos manipuladores de eventos

Não qualifique explicitamente os argumentos (objeto 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, remetente como o objeto, e como EventArgs), use representantes relaxado, e deixe para fora os argumentos de evento no seu código:

Public Sub Form1_Load() Handles Form1.Load
End Sub

Tipo de dados sem sinal

Use Integer em vez dos tipos sem sinal, exceto onde são necessários.

Matrizes

Use a sintaxe abreviada quando você inicializa matrizes na linha da declaração.Por exemplo, use a seguinte sintaxe.
```
Dim letters1 As String() = {"a", "b", "c"}
```
Não use a seguinte sintaxe.
```
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 {} quando você declara e inicializa arrays 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

Quando você faz uma série de chamadas para um objeto, considere usar a palavra-chave de With :

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

Use a try… catch e instruções de uso quando você usa a manipulação de exceção

Não use On Error Goto.

Use não são palavras-chave

Use a palavra-chave de IsNot em vez de Not...Is Nothing.

Palavra-chave new

Use a instanciação curta.Por exemplo, use a seguinte sintaxe:
```
Dim employees As New List(Of String)
```
A linha anterior é equivalente a esta:
```
Dim employees2 As List(Of String) = New List(Of String)
```

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

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

Tratamento de eventos

Use Handles em vez de AddHandler:

Private Sub ToolStripMenuItem1_Click() Handles ToolStripMenuItem1.Click
End Sub

Use AddressOf, e não criar uma instância do representante explicitamente:

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

Quando você define um evento, use a sintaxe abreviada, 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 verificar se um evento é Nothing (zero) antes de chamar o método de RaiseEvent .RaiseEvent verifica Nothing antes que gera o evento.

Usando membros compartilhados

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

Usar literais XML

Os literais XML (as tarefas mais comuns que você encontrar quando você trabalha com XML (por exemplo, o carregamento, consulta, e as transformações).Quando você desenvolve com XML, siga estas diretrizes:

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

Usar expressões inseridas para incluir valores e para criar XML dos valores existentes em vez de usar chamadas à API como o método de 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

Use nomes significativos para variáveis de consulta:

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

Fornecer nomes de elementos em uma consulta para certificar-se que os nomes de propriedade de tipos anônimos são colocar a primeira letra da palavra em maiúscula corretamente usando a caixa de Pascal:

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

Renomear propriedades quando os nomes de propriedade no resultado é ambíguo.Por exemplo, se sua consulta retorna um nome de cliente e uma identificação do pedido, renomeá-los 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ável de consulta e das variáveis de intervalo:
```
Dim customerList = From cust In customers
```

Alinhar cláusulas de consulta sob a declaração de From :

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

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

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

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

Consulte também

Outros recursos

Diretrizes para codificação segura

Compartilhar via