Convenzioni di codifica di Visual Basic

Articolo
06/08/2015

Microsoft sviluppa esempi e documentazione che si attengono alle linee guida di questo argomento. Se si seguono le stesse convenzioni di codifica, si possono ottenere i vantaggi seguenti:

Il codice deve avere un aspetto coerente, in modo che chi legge possa concentrarsi meglio sul contenuto, anziché sul layout.
I lettori comprendono il codice più rapidamente, grazie alla possibilità di formulare presupposti basati sulle esperienze precedenti.
È possibile copiare, modificare e gestire il codice più facilmente.
Si garantisce che il codice dimostra le "procedure consigliate" per Visual Basic.

Convenzioni di denominazione

Per informazioni sulle linee guida relative alla denominazione, vedere l'argomento Guidelines for Names.
Non utilizzare "My" o "my" come parte di un nome di variabile, Questa pratica crea confusione con gli oggetti My.
Non è necessario modificare i nomi degli oggetti con il codice generato automaticamente per adattarli alle linee guida.

Convenzioni di layout

Inserire le tabulazioni come spazi e utilizzare i rientri automatici con rientri a quattro spazi.
Utilizzare Riformattazione del listato di codice per riformattare il codice nell'editor di codice. Per ulteriori informazioni, vedere Opzioni, Editor di testo, Base (Visual Basic).
Utilizzare una sola istruzione per riga. Non utilizzare il carattere separatore di riga di Visual Basic (:).
Evitare di utilizzare il carattere esplicito "_" di continuazione di riga a favore della continuazione di riga implicita quando il linguaggio lo consente.
Utilizzare una sola dichiarazione per riga.
Se tramite l'opzione Riformatta il listato di codice le righe di continuazione non vengono formattate automaticamente, impostare manualmente il rientro delle righe di continuazione di un punto di tabulazione. Tuttavia, allineare sempre a sinistra gli elementi in un elenco.
```
a As Integer,
b As Integer
```
Aggiungere almeno una riga vuota tra le definizioni di metodi e di proprietà.

Convenzioni relative ai commenti

Inserire i commenti in una riga distinta, anziché alla fine di una riga di codice.
Iniziare il testo del commento con una lettera maiuscola e terminarlo con un punto.
Inserire uno spazio tra il delimitatore di commento (') e il testo del commento.
```
' Here is a comment.
```
Non racchiudere i commenti in blocchi formattati di asterischi.

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

Per concatenare le stringhe, utilizzare una e commerciale (&).
```
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

Delegati di tipo relaxed nei gestori eventi

Non qualificare esplicitamente gli argomenti (Object e EventArgs) nei gestori eventi. Se non si utilizzano gli argomenti dell'evento che vengano passati a un evento (ad esempio mittente come Object e come EventArgs), utilizzare i delegati di tipo relaxed e omettere gli argomenti dell'evento nel codice:

Public Sub Form1_Load() Handles Form1.Load
End Sub

Tipi di dati senza segno

Utilizzare Integer anziché tipi senza segno, ad eccezione dei casi in cui sono necessari.

Matrici

Utilizzare la sintassi breve quando si inizializzano matrici nella riga della dichiarazione. Ad esempio, utilizzare la seguente sintassi.
```
Dim letters1 As String() = {"a", "b", "c"}
```
Non utilizzare la seguente sintassi.
```
Dim letters2() As String = New String() {"a", "b", "c"}
```
Inserire l'identificatore di matrici nel tipo e non nella variabile: Ad esempio, utilizzare la seguente sintassi:
```
Dim letters4 As String() = {"a", "b", "c"}
```
Non utilizzare la seguente sintassi:
```
Dim letters3() As String = {"a", "b", "c"}
```
Utilizzare la sintassi { } quando si dichiarano e si inizializzano le matrici dei tipi di dati di base. Ad esempio, utilizzare la seguente sintassi:
```
Dim letters5() As String = {"a", "b", "c"}
```
Non utilizzare la seguente sintassi:
```
Dim letters6(2) As String
letters6(0) = "a"
letters6(1) = "b"
letters6(2) = "c"
```

Utilizzare la parola chiave With

Quando si effettua 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 delle istruzioni Try...Catch e Using quando si utilizza Gestione delle eccezioni

Non utilizzare la proprietà On Error Goto.

Utilizzo della parola chiave IsNot

Utilizzare la parola chiave IsNot anziché Not...Is Nothing.

Parola chiave New

Utilizzare la creazione di istanze breve. Ad esempio, utilizzare la seguente sintassi:
```
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 SampleEvent As EventHandler(Of SampleEventArgs)
' or 
Public Event SampleEvent(ByVal source As Object, 
                          ByVal e As SampleEventArgs)

Non verificare se un evento è Nothing (null) prima di chiamare il metodo 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 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"

Fornire nomi 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, sarà bene 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, in modo che le ultime clausole di query agiscano su un insieme di dati filtrato:

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

Utilizzare la clausola Join per definire un'operazione di join in modo esplicito anziché utilizzare la clausola Where per definire l'operazione di join in modo implicito:

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

Vedere anche

Altre risorse

Linee guida per la generazione di codice sicuro

Condividi tramite