Convenções de codificação Visual Basic

  • Artigo
  • 6 minutos para ler

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