Convenzioni di codifica di Visual Basic

2025-06-17

Microsoft sviluppa esempi e documentazione che seguono le linee guida contenute in questo argomento. Se si seguono le stesse convenzioni di codifica, è possibile ottenere i vantaggi seguenti:

Il codice avrà un aspetto coerente, in modo che i lettori possano concentrarsi meglio sul contenuto, non sul layout.
I lettori capiscono più rapidamente il codice perché possono fare ipotesi basate sull'esperienza precedente.
È possibile copiare, modificare e gestire più facilmente il codice.
Puoi contribuire a garantire che il tuo codice dimostri le "migliori pratiche" per Visual Basic.

Convenzioni di denominazione

Per informazioni sulle linee guida per la denominazione, vedere l'argomento Linee guida per la denominazione .
Non usare "My" o "my" come parte di un nome di variabile. Questa procedura crea confusione con gli My oggetti .
Non è necessario modificare i nomi degli oggetti nel codice generato automaticamente per renderli adatti alle linee guida.

Convenzioni di layout

Convertire le tabulazioni in spazi e utilizzare l'indentazione intelligente con indentazioni di quattro spazi.
Usare pretty listing (riformattazione) del codice per riformattare il codice nell'editor di codice. Per altre informazioni, vedere Opzioni, Editor di testo, Basic (Visual Basic).
Usare una sola istruzione per riga. Non usare il carattere separatore di riga di Visual Basic (:).
Evitare di usare il carattere di continuazione di riga esplicito "_" a favore della continuazione di riga implicita ovunque il linguaggio lo consenta.
Usare una sola dichiarazione per riga.
Se l'elenco ordinato (riformattazione) del codice non formatta automaticamente le righe di continuazione, rientrare manualmente le righe di continuazione di uno spazio di tabulazione. Tuttavia, allineare sempre a sinistra gli elementi di un elenco.
```
a As Integer,  
b As Integer  
```
Aggiungere almeno una riga vuota tra le definizioni di metodo e proprietà.

Convenzioni di commento

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

Struttura del programma

Quando si usa il Main metodo , usare il costrutto predefinito per le nuove applicazioni console e usare 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
```

Linee guida per il linguaggio

Tipo di dati String

Usare l'interpolazione di stringhe per concatenare stringhe brevi, come illustrato nel codice seguente.
```
MsgBox($"hello{vbCrLf}goodbye")
```

Per accodare stringhe in cicli, utilizzare l'oggetto StringBuilder .

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

Delegati semplificati nei gestori di eventi

Non qualificare in modo esplicito gli argomenti (Object e EventArgs) ai gestori eventi. Se non si usano gli argomenti passati a un evento (ad esempio, sender As Object, e As EventArgs), utilizzare delegati rilassati ed escludere gli argomenti dell'evento nel codice:

Public Sub Form1_Load() Handles Form1.Load
End Sub

Tipo di dati senza segno

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

Matrici

Usare la sintassi breve quando si inizializzano matrici nella riga di dichiarazione. Ad esempio, usare la sintassi seguente.
```
Dim letters1 As String() = {"a", "b", "c"}
```
Non usare la sintassi seguente.
```
Dim letters2() As String = New String() {"a", "b", "c"}
```
Inserire il designatore dell'array sul tipo, non sulla variabile. Ad esempio, usare la sintassi seguente:
```
Dim letters4 As String() = {"a", "b", "c"}
```
Non usare la sintassi seguente:
```
Dim letters3() As String = {"a", "b", "c"}
```
Usare la sintassi { } quando si dichiarano e inizializzano matrici di tipi di dati di base. Ad esempio, usare la sintassi seguente:
```
Dim letters5 As String() = {"a", "b", "c"}
```
Non usare la sintassi seguente:
```
Dim letters6(2) As String
letters6(0) = "a"
letters6(1) = "b"
letters6(2) = "c"
```

Usare la parola chiave With

Quando si effettua una serie di chiamate a un oggetto, è consigliabile usare la With parola chiave :

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

Usa le istruzioni Try...Catch e Using quando gestisci le eccezioni.

Non usare On Error Goto.

Usare la parola chiave IsNot

Usare ... IsNot Nothing anziché Not ... Is Nothing.

Nuova Parola Chiave

Usa l'istanza breve. Ad esempio, usare la sintassi seguente:
```
Dim employees As New List(Of String)
```
La riga precedente equivale a questa:
```
Dim employees2 As List(Of String) = New List(Of String)
```

Usare gli inizializzatori di oggetti per i nuovi oggetti anziché il costruttore senza parametri:

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

Gestione di eventi

Usare Handles anziché AddHandler:

Private Sub ToolStripMenuItem1_Click() Handles ToolStripMenuItem1.Click
End Sub

Usare AddressOf, e non creare un'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, usare la sintassi breve e consentire al compilatore di definire il delegato:

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 RaiseEvent metodo . RaiseEvent verifica Nothing prima che generi l'evento.

Uso di membri condivisi

Chiamare Shared i membri usando il nome della classe, non da una variabile di istanza.

Usare valori letterali XML

I valori letterali XML semplificano le attività più comuni quando si lavora con XML, ad esempio caricare, interrogare e trasformare. Quando si sviluppa con XML, seguire queste linee guida:

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

Usare espressioni incorporate per includere valori e per creare codice XML da valori esistenti anziché usare chiamate API come il Add metodo :

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

Usare nomi significativi per le variabili di query:

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

Fornire nomi agli elementi di una query per assicurarsi che i nomi delle proprietà dei tipi anonimi siano correttamente capitalizzati usando il formattaggio 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 delle proprietà nel risultato potrebbero risultare ambigui. Ad esempio, se la query restituisce un nome cliente e un ID ordine, rinominarli invece di lasciarli come Name e ID nel risultato:

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

Usare l'inferenza del tipo nella dichiarazione di variabili di query e variabili di intervallo:
```
Dim customerList = From cust In customers
```

Allineare le clausole di query nell'istruzione From :

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

Usare Where clausole prima di altre clausole di query in modo che le clausole di query seguenti funzionino sull'insieme di dati filtrato.

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

Usare la Join clausola per definire in modo esplicito un'operazione di join anziché usare la Where clausola per definire in modo implicito un'operazione di join:

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

Vedere anche

linee guida per la codifica sicura

Condividi tramite