Convenções de codificação Visual Basic

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

  • O seu código terá um aspeto consistente, para que os leitores possam focar-se melhor no conteúdo, não no layout.

  • Os leitores entendem o seu código mais rapidamente porque podem fazer suposições com base em experiências anteriores.

  • Pode copiar, alterar e manter o código mais facilmente.

  • Ajuda a garantir que o seu código demonstra "boas práticas" para Visual Basic.

Convenções de Nomeação

  • Para obter informações sobre as diretrizes de nomeação, consulte o tópico Naming Guidelines .

  • Não use "My" ou "My" como parte de um nome variável. Esta prática cria confusão com os My objetos.

  • Não é preciso alterar os nomes dos objetos em código gerado automaticamente para que se encaixem nas diretrizes.

Convenções de Layout

  • Insira os separadores como espaços e use o entalhe inteligente com os travões de quatro espaços.

  • Utilize uma listagem bonita (reformatting) de código para reformar o seu código no editor de código. Para mais informações, consulte Opções, Editor de Texto, Básico (Visual Basic).

  • Use apenas uma declaração por linha. Não utilize o Visual Basic caracteres separadores de linha (:).

  • Evite usar o caracteres de continuação da linha explícita "_" em favor da continuação implícita da linha onde quer que a língua o permita.

  • Utilize apenas uma declaração por linha.

  • Se a listagem Bonita (reformatting) do código não formar as linhas de continuação automaticamente, as linhas de continuação do travessão manualmente uma paragem de separador. No entanto, sempre alinhar itens à esquerda numa lista.

    a As Integer,  
    b As Integer  
    
  • Adicione pelo menos uma linha em branco entre o método e as definições de propriedade.

Comentando Convenções

  • Coloque comentários numa linha separada em vez de no final de uma linha de código.

  • Comece a comentar texto com uma letra maiúscula e termine o texto de comentário com um período.

  • Insira um espaço entre o delimiter de comentários (') e o texto de comentário.

    ' Here is a comment.
    
  • Não rode os comentários com blocos formatados de asteriscos.

Estrutura do Programa

  • Quando utilizar o Main método, utilize a construção padrão para novas aplicações de consola 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 linguísticas

Tipo de dados de cadeia

  • Utilize a interpolação de cordas para concatenar cordas curtas, como mostra o código seguinte.

    MsgBox($"hello{vbCrLf}goodbye")
    
  • Para apar as cordas 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 and EventArgs) para os manipuladores de eventos. Se não estiver a utilizar os argumentos do evento que são transmitidos a um evento (por exemplo, remetente como Objeto, e como EventArgs), use delegados descontraídos e deixe de fora os argumentos do evento no seu código:

Public Sub Form1_Load() Handles Form1.Load
End Sub

Tipo de dados não assinado

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

Matrizes

  • Utilize a sintaxe curta quando rubricar as matrizes na linha de declaração. Por exemplo, utilize a seguinte sintaxe.

    Dim letters1 As String() = {"a", "b", "c"}
    

    Não utilize a seguinte sintaxe.

    Dim letters2() As String = New String() {"a", "b", "c"}
    
  • Coloque o designor de matriz no tipo, não na variável. Por exemplo, utilize a seguinte sintaxe:

    Dim letters4 As String() = {"a", "b", "c"}
    

    Não utilize a seguinte sintaxe:

    Dim letters3() As String = {"a", "b", "c"}
    
  • Utilize a sintaxe { } quando declarar e rubricar matrizes de tipos básicos de dados. Por exemplo, utilize a seguinte sintaxe:

    Dim letters5 As String() = {"a", "b", "c"}
    

    Não utilize a seguinte sintaxe:

    Dim letters6(2) As String
    letters6(0) = "a"
    letters6(1) = "b"
    letters6(2) = "c"
    

Use o Com Palavra-Chave

Quando fizer 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 a Tentativa... Captura e utilização de declarações quando utiliza o Tratamento de Exceções

Não utilize On Error Goto.

Use a palavra-chave IsNot

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

Nova palavra-chave

  • Use uma instantânea curta. Por exemplo, utilize 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)
    
  • Utilize inicializadores de objetos novos 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

  • Utilização Handles em vez de AddHandler:

    Private Sub ToolStripMenuItem1_Click() Handles ToolStripMenuItem1.Click
    End Sub
    
  • Utilizar AddressOf, e não instantanear o delegado explicitamente:

    Dim closeItem As New ToolStripMenuItem( 
        "Close", Nothing, AddressOf ToolStripMenuItem1_Click)
    Me.MainMenuStrip.Items.Add(closeItem)
    
  • Quando 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 ligar para o RaiseEvent método. RaiseEvent verifica antes Nothing de levantar o evento.

Usando membros compartilhados

Ligue para Shared os membros usando o nome da classe, não a partir de uma variável de exemplo.

Use XML Literais

Os literais XML simplificam as tarefas mais comuns que encontra quando se trabalha com XML (por exemplo, carga, consulta e transformação). Quando se desenvolver com XML, siga estas orientações:

  • Utilize literais XML para criar documentos e fragmentos XML em vez de chamar apis XML diretamente.

  • Importe espaços de nomes XML ao nível do arquivo ou do projeto para tirar partido das otimizações de desempenho para os literais XML.

  • Utilize as propriedades do eixo XML para aceder a elementos e atributos num documento XML.

  • Utilize expressões incorporadas para incluir valores e criar XML a partir de valores existentes em vez de utilizar 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

  • Utilizar nomes significativos para variáveis de consulta:

    Dim seattleCustomers = From cust In customers 
                           Where cust.City = "Seattle"
    
  • Fornecer nomes para elementos numa consulta para garantir que os nomes de propriedade de tipos anónimos são corretamente capitalizados usando o invólucro Pascal:

    Dim customerOrders = From customer In customers 
                         Join order In orders 
                           On customer.CustomerID Equals order.CustomerID 
                         Select Customer = customer, Order = order
    
  • Mudar de nome de propriedades quando os nomes da propriedade no resultado seriam ambíguos. Por exemplo, se a sua consulta devolver um nome de cliente e um ID de encomenda, mude-os para o nome em vez de os deixar 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
    
  • Utilização da inferência do tipo na declaração de variáveis de consulta e variáveis de gama:

    Dim customerList = From cust In customers
    
  • Alinhar cláusulas de consulta nos termos da From declaração:

    Dim newyorkCustomers = From cust In customers 
                           Where cust.City = "New York" 
                           Select cust.LastName, cust.CompanyName
    
  • Utilize Where cláusulas antes de outras cláusulas de consulta para que as 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
    

Ver também