Convenzioni di codifica di Visual Basic

Articolo
08/11/2011

Queste istruzioni vengono utilizzate da Microsoft per sviluppare gli esempi e la documentazione. La specifica di linguaggio Visual Basic non definisce uno standard di codifica.

Le convenzioni di codifica conferiscono al codice un aspetto coerente, in modo che chi legge possa concentrarsi sul contenuto e non sul layout.
Le convenzioni consentono a chi legge di comprendere il codice più rapidamente, in quanto ha la possibilità di formulare ipotesi basate sulle esperienze precedenti.
Le convenzioni semplificano la copia, la modifica e la gestione del codice.
Le convenzioni illustrano i "suggerimenti" di Visual Basic.

Descrizione

Convenzioni di denominazione

Le indicazioni per la denominazione sono illustrate in Linee guida di progettazione per lo sviluppo di librerie di classi.
Non è necessario modificare il nome degli oggetti creati dagli strumenti di progettazione di Visual Studio per adattarli alle istruzioni.
Utilizzare le qualificazioni degli spazi dei nomi invece di aggiungere istruzioni Imports. Se uno spazio dei nomi viene importato in un progetto per impostazione predefinita, non è necessario specificare il nome completo del codice perché questo verrà eseguito come non qualificato con IntelliSense quando verrà copiato e incollato. Quando si interrompono lunghe righe di codice per agevolarne la lettura, è possibile interrompere i nomi completi dopo il "." Di seguito è riportato un esempio:
```
Dim collection As System.Diagnostics. 
       InstanceDataCollectionCollection
```
Non utilizzare "My" o "my" come parte di un nome di variabile, in quanto crea confusione con gli oggetti My.

Convenzioni di layout

Il layout appropriato utilizza la formattazione per mettere in evidenza la struttura del codice e agevolarne la lettura.

Utilizzare la funzionalità di riformattazione del listato per formattare il codice con le impostazioni predefinite (rientri intelligenti, rientri di 4 caratteri, tabulazioni salvate come spazi). Per ulteriori informazioni, vedere Specifiche di VB, Di base, Editor di testo, finestra di dialogo Opzioni.
Utilizzare una sola istruzione per riga. Non utilizzare il carattere di continuazione di riga di Visual Basic (:).
Utilizzare una sola dichiarazione per riga.
Se nella riformattazione del listato non viene eseguita la formattazione di righe di continuazione, impostare il rientro delle righe di continuazione di un punto di tabulazione.
Aggiungere almeno una riga vuota tra le definizioni di metodi e di proprietà.

Convenzioni relative ai commenti

Non utilizzare commenti alla fine di una riga di codice. Inserire i commenti in una riga separata.
Iniziare il testo del commento con una lettera maiuscola.
Terminare il commento con un punto.
Inserire uno spazio tra il delimitatore di commento (') e il testo del commento.
```
' Here is a comment.
```
Non creare blocchi formattati di asterischi che racchiudono il commento.

Struttura del programma

Quando si utilizza il metodo Main, utilizzare il costrutto predefinito per le nuove applicazioni console e utilizzare My per gli argomenti della riga di comando.
```
Sub Main()
  For Each argument As String In My.Application.CommandLineArgs
    ' Add code here to use the string variable.
  Next
End Sub
```

Istruzioni relative al linguaggio

Tipo di dati String

Utilizzare & per concatenare le stringhe:
```
MsgBox("hello" & vbCrLf & "goodbye")
```

Per accodare stringhe nei cicli, utilizzare l'oggetto StringBuilder:

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

Inferenza di tipi

Utilizzare l'inferenza dei tipi per le variabili locali:

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

Delegati di tipo relaxed nei gestori eventi

Se non si utilizzano argomenti degli eventi nel codice, utilizzare i delegati di tipo relaxed ed escludere gli argomenti degli eventi:

Public Sub Form1_Load() Handles Form1.Load
End Sub

Tipi di dati senza segno

Utilizzare Integer invece dei tipi senza segno a meno che non si disponga di poca memoria.

Matrici

Utilizzare la sintassi breve quando si inizializzano le matrici nella riga della dichiarazione:
```
Dim letters1() As String = {"a", "b", "c"}
```
Invece di:
```
Dim letters2() As String = New String() {"a", "b", "c"}
```

Inserire l'identificatore di matrici nella variabile e non nel tipo:

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

Invece di:

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

Utilizzare la sintassi { } quando si dichiarano e si inizializzano le matrici dei tipi di dati di base:

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

Invece di:

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

Utilizzare la parola chiave With

Per la gestione di una serie di chiamate a un oggetto, è consigliabile utilizzare la parola chiave With.

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

Utilizzo dell'inferenza dei tipi per le variabili di ciclo nelle istruzioni For o For Each

È possibile utilizzare l'inferenza dei tipi per determinare il tipo della variabile di intervallo di ciclo.

Nell'esempio riportato di seguito viene illustrato l'utilizzo dell'inferenza dei tipi in un'istruzione For:

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

Nell'esempio riportato di seguito viene illustrato l'utilizzo dell'inferenza dei tipi in un'istruzione For Each:

For Each name In names
  MsgBox(name)
Next

Utilizzo delle istruzioni Try...Catch e Using per la gestione delle eccezioni

Non utilizzare la proprietà On Error Goto.

Per gestire le eccezioni, utilizzare un'istruzione Try...Catch:

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

Finally
  Conn.Close()
End Try

L'istruzione Using combina un'istruzione Try...Catch con una chiamata al metodo Dispose e consente di semplificare il codice. Se si utilizza un'istruzione Try...Catch e il solo codice nel blocco Finally è costituito da una chiamata al metodo Dispose, utilizzare invece l'istruzione Using.
```
Using redPen As New Pen(color.Red)
  ' Insert code here.
End Using
```

Utilizzo della parola chiave IsNot

Preferire la parola chiave IsNot a Not...Is Nothing.

Utilizzo delle parole chiave AndAlso e OrElse

Per evitare che vengano generate eccezioni e migliorare le prestazioni ignorando il codice non necessario, nell'esecuzione di confronti utilizzare AndAlso anziché And e OrElse anziché Or:

' 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

Istanze predefinite dei form

Utilizzare Form1.ShowDialog invece di My.Forms.Form1.ShowDialog.

Parola chiave New

Utilizzare la creazione di istanze breve:

Dim employees As New List(Of String)

La riga precedente è equivalente a:

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

Per i nuovi oggetti, utilizzare inizializzatori di oggetti anziché il costruttore senza parametri:

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

Gestione di eventi

Utilizzare Handles invece di AddHandler:

Private Sub ToolStripMenuItem1_Click() Handles ToolStripMenuItem1.Click
End Sub

Utilizzare AddressOf e non creare l'istanza del delegato in modo esplicito:

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

Quando si definisce un evento, utilizzare la sintassi breve e lasciare che il delegato venga definito dal compilatore:
```
Public Event WhatHappened(ByVal source As Object, 
                          ByVal e As WhatHappenedEventArgs)
```
Non è necessario verificare se un evento è Nothing (null) prima di effettuare la chiamata a RaiseEvent. Il metodo RaiseEvent esegue una ricerca per Nothing prima di generare l'evento.

Utilizzo di membri condivisi

Per la chiamata a membri Shared, utilizzare il nome della classe anziché una variabile di istanza.

Utilizzo della funzione MsgBox

Utilizzare MsgBox invece di MessageBox.Show o di Console.WriteLine. In ambienti che non supportano la funzione MsgBox, ad esempio Silverlight, utilizzare un'alternativa appropriata.

Utilizzare lo spazio dei nomi My

Preferire le funzionalità di My alla libreria di classi di .NET Framework e alla libreria di runtime di Visual Basic. Per ulteriori informazioni, vedere la classe Oggetti (Visual Basic).

Utilizzo di valori letterali XML

I valori letterali XML semplificano le attività più comuni nell'utilizzo di XML (caricamento, query, trasformazione e così via). Quando si utilizza XML a fini di sviluppo, attenersi alle seguenti linee guida:

Utilizzare i valori letterali XML per creare documenti e frammenti XML anziché chiamare direttamente API XML.
Importare spazi dei nomi XML a livello di file o di progetto per sfruttare le ottimizzazioni delle prestazioni per i valori letterali XML.
Utilizzare le proprietà axis XML per accedere a elementi e attributi in un documento XML.

Utilizzare le espressioni incorporate per includere valori e creare XML da valori esistenti anziché utilizzare le chiamate API, ad esempio il metodo 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

Query LINQ

Utilizzare nomi significativi per le variabili di query:

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

Utilizzare alias per gli elementi delle query, in modo che i nomi di proprietà dei tipi anonimi vengano convertiti in maiuscole in modo corretto utilizzando la convenzione Pascal:

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

Rinominare le proprietà quando i nomi potrebbero risultare ambigui nel risultato. Ad esempio, se la query restituisce il nome di un cliente e l'ID di un ordine, anziché lasciarli come Name e ID nei risultati, rinominarli come indicato di seguito:

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

Utilizzare l'inferenza dei tipi nella dichiarazione di variabili di query e variabili di intervallo:
```
Dim customerList = From cust In customers
```

Allineare le clausole di query sotto l'istruzione From:

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

Utilizzare le clausole Where prima di altre clausole di query per fare in modo che le ultime clausole di query agiscano su un insieme di dati ridotto e filtrato:
```
Dim newyorkCustomers2 = From cust In customers 
                        Where cust.City = "New York" 
                        Order By cust.LastName
```

Utilizzare la clausola Join per definire un join in modo esplicito anziché utilizzare la clausola Where per definirlo in modo implicito:

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

Utilizzare i membri delle librerie di runtime di Visual Basic

Preferire la libreria di runtime di Visual Basic alla libreria di classi di .NET Framework.

Condividi tramite