Partilhar via

Convenções codificação Visual Basic

  • Artigo

Essas diretrizes são usadas pela Microsoft para desenvolver amostras e documentação. A especificação de linguagem Visual Basic não define um padrão de codificação.

  • Codificação convenções criar uma aparência consistente para o código, para que os leitores possam se concentrar no conteúdo, não o layout.

  • Convenções permitem os leitores de compreender o código mais rapidamente, pois permite que eles façam suposições com base em experiências anteriores.

  • Convenções de tornam a copiar, alterar e manter o código mais fácil.

  • Convenções demonstram Visual Basic "best practices".

Discussão

Naming Conventions

  • Diretrizes de nomeação são abordadas em Diretrizes de Design para desenvolvimento bibliotecas de classe.

  • Não é necessário alterar o nome de objetos criados pelas ferramentas dedesigner de Visual Studiopara fazer com que ajuste as diretrizes.

  • Use as qualificações de namespace em vez de adicionar instruções de importações. Se um namespace foi importado por padrão em um projeto, você precisa qualificar totalmente o código, pois ele será executado não qualificado com IntelliSense quando copiado e colado. Quando você estiver dividindo longas linhas de código para torná-los mais fáceis de ler, os nomes qualificados podem ser interrompidos após o "." For example:

    Dim collection As System.Diagnostics. 
       InstanceDataCollectionCollection

  • Não use "Meu" ou "Meu" como parte de um nome de variável . Isso cria uma confusão com o My objetos.

Convenções de layout

Um bom layout usa formatação para enfatizar a estrutura do código e facilita a leitura do código.

  • Use o recurso de listagem bonita para formatar o código com as configurações padrão (inteligente recuos, recuos de 4 caracteres, tabulações como espaços de salvamento). For more information, see Específico do VB, Basic, o Editor de texto, caixa de diálogo Opções.

  • Use apenas uma demonstrativo por linha. Não use o caractere de continuação de linha de Visual Basic (:).

  • Use apenas uma declaração por linha.

  • Se a listagem bastante não não o formato continuação linhas, recuar continuação linhas uma parada de tabulação.

  • Adicionar pelo menos um em branco a linha entre as definições de método e propriedade .

Convenções de comentários

  • Não use os comentários no final de uma linha de código. Coloque os comentários em uma linhade separada.

  • Começa com uma letra maiúsculas o texto do comentário.

  • participante do comentário com um ponto.

  • Inserir um espaço entre os delimitadores de comentários (') e o texto do comentário.

    ' Here is a comment.

  • Fazer-se de não criar formatado blocos de asteriscos que cercam os comentários.

Estrutura de programa

  • Ao usar o Main método, use a construção do padrão para novos aplicativos de console e My para o comando -linha argumentos.

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

Directrizes do idioma

String Data Type

  • Usar & para concatenar seqüências:

    MsgBox("hello" & vbCrLf & "goodbye")

  • Para acrescentar seqüências de caracteres em loops, use o StringBuilderdeobjeto:

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

Type Inference

Aproveite inferência de tipo para variáveis de locais:

Public Sub GetQuery()
  Dim filterValue = "London"
  Dim query = From customer In customers 
              Where customer.Country = filterValue
End Sub

Delegados relaxados nos manipuladores de eventos

Usar delegados relaxados e deixar os argumentos de evento se você não estiver usando 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 unsigned tipos, a menos que a memória é premium.

Arrays

  • Use a sintaxe abreviada durante a inicialização de arrays nalinhade declaração:

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

    Em vez disso:

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

  • Coloca o designador de matriz de variável, não no tipo:

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

    Em vez disso:

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

  • Use a sintaxe {} quando declarar e inicializar matrizes de tipos de dados básicos:

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

    Em vez disso:

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

Use o com a palavra-chave

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

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

Use a Tipo para variáveis de Loop em para ou para cada instruções

Permitir digite inferência para determinar o tipo davariável de intervalode loop.

A seguir está um exemplo do uso de inferência de tipo em um For demonstrativo:

For count = 0 To 2
  MsgBox(names(count))
Next

A seguir está um exemplo do uso de inferência de tipo em um For Each demonstrativo:

For Each name In names
  MsgBox(name)
Next

Usar a instrução Try...Catch e usando as instruções para manipulação de exceção

  • Do not use On Error Goto.

  • Para manipular exceções, use um Try...Catchdedemonstrativo:

    Dim conn As New SqlConnection("connection string")
Try
  Conn.Open()
Catch ex As SqlException

Finally
  Conn.Close()
End Try

  • O Usingdemonstrativo combina um Try...Catchademonstrativo com uma chamada para o Disposemétodo e simplifica o código. Se você estiver usando um Try...Catch demonstrativo e somente o código no Finally bloco é uma chamada para o Dispose método, use o Using demonstrativo em vez disso:

    Using redPen As New Pen(color.Red)
  ' Insert code here.
End Using

Use a palavra-chave de IsNot

Use o IsNotapalavra-chave em preferência a Not...Is Nothing.

Use o AndAlso e OrElse as de palavras-chave

Para evitar exceções e aumentar o desempenho ignorando desnecessário código, use AndAlso em vez de And e OrElse em vez de Or ao realizar comparações:

' Avoid a null reference exception. If the left side of the AndAlso 
' operator is False, the right side is not evaluated and a null 
' exception is not thrown.
If nullableObject IsNot Nothing AndAlso nullableObject = testValue Then

End If

' Avoid an unnecessary resource-intensive operation. If the left side
' of the OrElse operator is True, the right side is not evaluated and 
' a resource-intensive operation is not called.
If testCondition OrElse ResourceIntensiveOperation() Then

End If

Padrão Instâncias de formulários

Use Form1.ShowDialog em vez de My.Forms.Form1.ShowDialog.

New Keyword

  • Use a instanciação curta:

    Dim employees As New List(Of String)

    A linha precedente é equivalente a isso:

    Dim employees2 As List(Of String) = New List(Of String)

  • Use os inicializadores de objeto para novos objetos em vez do construtorsem parâmetros:

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

Manipulação de eventos

  • Use Handles em vez de AddHandler:

    Private Sub ToolStripMenuItem1_Click() Handles ToolStripMenuItem1.Click
End Sub

  • Use AddressOfe não criar uma instância do delegado 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 permitem que o compilador definem o delegado:

    Public Event WhatHappened(ByVal source As Object, 
                          ByVal e As WhatHappenedEventArgs)

  • Não verificar se um evento é Nothing (null) antes de chamar o RaiseEvent método. RaiseEventverifica a existência de Nothing antes que ele gera o evento.

Usando membros compartilhados

Chame Shared membros usando o nome de classe , não a partir de uma variávelde instância.

Utilize a função MsgBox

Use MsgBox instead of MessageBox.Show or Console.WriteLine. Em ambientes que não oferecem suporte a MsgBox função, como o Silverlight, use uma alternativa apropriada.

Use o Namespace My

Use My recursos em preferência à.NET Framework classe biblioteca ou o Visual Basic-run-time biblioteca. For more information, see Objetos (Visual Basic).

Usar literais XML

LiteraisXML simplificam as tarefas mais comuns encontrados ao trabalhar com XML (por exemplo, carga, consultae transformação). Quando você desenvolve com XML, siga estas diretrizes:

  • Use literais XML para criardocumentos e fragmentosXML em vez de chamar diretamente o XML APIs.

  • Importe os namespaces XML no nível de arquivo ou projeto para aproveitar as otimizações de desempenho para os literais XML .

  • Use as propriedades de eixo XML para acessar os elementos e atributos em um documento XML .

  • Use expressões incorporadas para incluir valores e para criaroXML de valores existentes em vez de usar a API como chama o Addmé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

LINQ Queries

  • Use nomes descritivos para variáveis de consulta :

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

  • Elementos de alias em uma consulta para certificar-se de que os nomes de propriedade de tipos anônimos corretamente forem capitalizados usando Pascal casing:

    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 seria ambíguos. Por exemplo, se sua consulta retorna o nome do cliente e uma identificação de ordem, em vez de deixá-los como Name e ID no resultado, renomeá-los:

    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 intervalo:

    Dim customerList = From cust In customers

  • Alinhar as cláusulas de consulta sob o From demonstrativo:

    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 certificar-se de que as cláusulas de consulta posteriores operam reduzido, filtrado o conjunto de dados:

    Dim newyorkCustomers2 = From cust In customers 
                        Where cust.City = "New York" 
                        Order By cust.LastName

  • Use o Join cláusula definir explicitamente uma unir em vez de usar o Where cláusula implicitamente definir uma unir:

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

Use os membros da biblioteca deHora de Executar-Visual Basic

Use o Visual Basic-run-time biblioteca em preferência à.NET Framework classe biblioteca.

Consulte também

Conceitos

Diretrizes para Codificação Segura

Outros recursos

Diretrizes de Design para desenvolvimento bibliotecas de classe