Convenções codificação Visual Basic

  • Artigo

Essas diretrizes são usadas pela Microsoft para desenvolver Exemplos e documentação.Especificação da linguagem Visual Basic não define um padrão de codificação.

  • Convenções de codificação criar uma aparência consistente para o código, para que leitores podem 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 fazem suposições com base na experiência anterior.

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

  • Convenções demostram o uso do Visual Basic "práticas recomendadas".

Discussão

Convenções de nomenclatura

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

  • Não é necessário alterar o nome de objetos criados por ferramentas de designer do Visual Studio para torná-los a atender as diretrizes.

  • Use namespace qualificações em vez de adicionar instruções Imports.Se um espaço para nome for importado por padrão em um projeto, não é necessário que qualificar totalmente o código porque ele será executado não qualificado com o IntelliSense quando copiado e colado.Quando a quebra de longas linhas de código para torná-los mais fáceis de ler, nomes qualificados podem ser interrompidos após o "." Por exemplo:

    Dim collection As System.Diagnostics. _
       InstanceDataCollectionCollection

  • Não use "Meu" ou "Meu" sistema autônomo parte de um nome de variável.Isso cria confusão com o My objetos.

Convenções de layout

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

  • Use o recurso de listagem bonita ao código de formato com sistema autônomo configurações padrão (SMART recuando 4 recuos de caractere, gravação guias sistema autônomo espaços).Para obter mais informações, consulte Específico do VB, Basic, editor de texto, caixa de diálogo Options.

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

  • Use somente uma declaração por linha.

  • Se bem a listagem não formata linhas de continuação, recue linhas de continuação de uma parada de tabulação.

  • Adicione pelo menos uma linha em branco entre definições de método e propriedade.

Convenções de comentários

  • Não use os comentários no participante de uma linha de código.Colocar comentários em uma linha separada.

  • Iniciar o texto do comentário com uma letra maiúscula.

  • Finalize 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.

  • Não crie blocos formatados de asteriscos ao redor de 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 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 sequência de caracteres

  • Usar & concatenar seqüências:

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

  • Para acrescentar seqüências 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

Inferência de Tipo

Aproveite as vantagens de inferência de tipos de variáveis locais:

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

Delegados relaxados em manipuladores de eventos

Usar delegados relaxados e deixar os argumentos de evento se você não estiver usando os argumentos do 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 é precioso.

Matrizes

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

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

    Em vez de isso:

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

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

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

    Em vez de isso:

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

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

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

    Em vez de isso:

    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 a With palavra-chave:

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

Usar inferência de tipos de variáveis de loop em para ou para cada instruções

Permita inferência de tipos de tipos determinar o tipo da variável de intervalo de loop.

Veja a seguir um exemplo de uso de inferência de tipos de tipos em um For demonstrativo:

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

Veja a seguir um exemplo de uso de inferência de tipos de tipos em um For Each demonstrativo:

For Each name In names
  MsgBox(name)
Next

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

  • Não use On Error Goto.

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

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

Finally
  Conn.Close()
End Try

  • The Using demonstrativo combina um Try...Catch demonstrativo com uma telefonar para o Dispose método e simplifica o código. Se você estiver usando um Try...Catch demonstrativo e o código apenas no Finally bloco é uma telefonar 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 IsNot

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

Use o AndAlso e OrElse Keywords

Para evitar exceções e aumentar o desempenho ignorando código desnecessário, 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

Instâncias padrão de formulários

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

Keyword NEW

  • Use instanciação curta:

    Dim employees As New List(Of String)

    A linha precedente é equivalente a esta:

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

  • Use os 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"}

Manipulação de eventos

  • Use Handles em vez de AddHandler:

    Private Sub ToolStripMenuItem1_Click() Handles ToolStripMenuItem1.Click
End Sub

  • Use AddressOfe não instanciar o 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 define o delegado:

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

  • Não verificar se um evento é Nothing (nulo) antes de ligar o RaiseEvent método. RaiseEvent procura Nothing antes que ele gera o evento.

Usando membros compartilhados

De telefonarShared membros usando o nome de classe, não a partir de uma variável da ocorrência.

Use a função CaixaDeMensagem

Use MsgBox em vez de MessageBox.Show ou Console.WriteLine. Em ambientes que não oferecem suporte a MsgBox função, sistema autônomo o Silverlight, use uma alternativa apropriada.

Uso do Namespace My

Use My recursos em preferência a biblioteca de classes do .NET estrutura ou do Visual Basic em time de execução biblioteca. Para obter mais informações, consulte Objetos (Visual Basic).

Use literais XML

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

  • Use literais XML para criar documentos XML e fragmentos em vez de chamar XML APIs diretamente.

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

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

  • Use expressões incorporadas para incluir valores e criar o XML de valores existentes em vez de usar a API chama, sistema autônomo a 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"

  • Alias de elementos em uma consulta para certificar-se de que os nomes de propriedades de tipos anônimo 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 poderiam ser ambíguos.Por exemplo, se sua consulta retorna um cliente, nome e uma ID de ordem, em vez de deixá-los sistema autônomo Name e ID no resultado, renomeá-las:

    Dim customerOrders2 = From cust In customers _
                      Join ord In orders _
                        On cust.CustomerID Equals ord.CustomerID _
                      Select CustomerName = cust.Name, _
                             OrderID = ord.ID

  • Use inferência de tipos de tipos na declaração de variáveis de consulta e variáveis de alcance:

    Dim customerList = From cust In customers

  • Alinhar 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 posterior cláusulas de consulta operam em reduzido, filtrado o conjunto de dados:

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

  • 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 Visual Basic em tempo de execução biblioteca Members

Use a biblioteca de time de execução do Visual Basic em preferência a biblioteca de classes do .NET estrutura.

Diretrizes para Exemplos

Geral

  • Siga as diretrizes de design em Diretrizes de design para desenvolvedores de biblioteca de classes.

  • Especifique o aviso e o título de MsgBox chamadas.

  • Use arquivos de recurso quando apropriado.

  • Use Option Strict On, em cada arquivo ou sistema autônomo uma configuração de projeto.

  • compilar com todos os avisos em.

  • Definir somente um Class, Structure, ou Interface em um arquivo.

  • Use o padrão de codificação para salvar arquivos.

Localização

  • Use o AutoSize propriedade onde for possível.

  • Não ocultar ou controles de sobreposição.

  • Não alinhe controles para criar uma frase.

  • Não crie seqüências de caracteres pela colocação de caracteres de outra seqüência de caracteres.

  • Use gráficos de cultura neutra.

  • Use apenas fontes Tahoma ou MS Sans Serif.

Acessibilidade

  • Usar cores do Sistema guia da caixa de diálogo Seletor de cores.

  • Use aceleradores para todos os menus, rótulos, botões e assim por diante.

  • conjunto controlar propriedades conforme descrito na tabela a seguir.

Propriedade

Configuração

AccessibleDescription

Uma descrição do controle.

AccessibleName

Um nome para o controle.

AccessibleRole

Padrão ou reiniciar esta propriedade se um controle tem outra função.

TabIndex

conjunto em uma ordem lógica.

Texto

Todos os controles clicáveis devem ter uma tecla de acesso do teclado (atalho).

Tamanho da Fonte

Padrão ou definido como 10 pontos ou maior

Forecolor

Padrão

Backcolor

Padrão

BackgroundImage

Padrão

Segurança

Siga as orientações da Diretrizes para Codificação Segura.

Consulte também

Outros recursos

Diretrizes de Design para desenvolvimento bibliotecas de classe

Diretrizes para Codificação Segura

Date

History

Motivo

Julho de 2008

Diretrizes atualizadas para incluir novos recursos de linguagem, incluindo o LINQ, literais XML, inicializadores de objeto, inferência de tipos e delegados relaxados.

Correção de bug do conteúdo.