Convenzioni di codifica di Visual Basic

Articolo
04/02/2024

Microsoft sviluppa esempi e documentazione che seguono le linee guida riportate 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 chi legge possa concentrarsi sul contenuto, non sul layout.
I lettori comprenderanno più rapidamente il codice perché potranno fare ipotesi basate sull'esperienza precedente.
È possibile copiare, modificare e gestire più facilmente il codice.
È possibile assicurarsi che il codice dimostri le "procedure consigliate" 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, in quanto questa procedura crea confusione con gli oggetti My.
Non è necessario modificare i nomi degli oggetti nel codice generato automaticamente per renderli adatti alle linee guida.

Convenzioni di layout

Inserire tabulazioni come spazi e usare il rientro intelligente con rientri a quattro spazi.
Usare la 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 la Riformattazione del codice non formatta automaticamente le righe di continuazione, impostare manualmente il rientro delle righe di continuazione a una tabulazione. Tuttavia, allineare sempre gli elementi a sinistra in un elenco.
```
a As Integer,  
b As Integer  
```
Aggiungere almeno una riga vuota tra le definizioni di metodo e proprietà.

Convenzioni relative ai commenti

Posizionare il commento su una riga separata, non alla fine di una riga di codice.
Inizia il testo del commento con una lettera maiuscola e terminarlo con un punto.
Inserire uno spazio tra i delimitatori 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 metodo Main, 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 della lingua

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 rilassati nei gestori eventi

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

Public Sub Form1_Load() Handles Form1.Load
End Sub

Tipi di dati non firmati

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

Matrici

Usare la sintassi breve quando si inizializzano le matrici nella riga della dichiarazione. Usare ad esempio 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 l'elemento di progettazione della matrice sul tipo, non sulla variabile. Usare ad esempio 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. Usare ad esempio 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 parola chiave With:

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

Usare le istruzioni Try...Catch e Using quando si usa la gestione delle eccezioni

Non usare On Error Goto.

Usare la parola chiave IsNot

Usare ... IsNot Nothing invece di Not ... Is Nothing.

Parola chiave New

Usare la creazione di un'istanza breve. Usare ad esempio 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 al posto di 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 metodo RaiseEvent. RaiseEvent verifica la presenza di Nothing prima di generare l'evento.

Uso di membri condivisi

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

Usare valori letterali XML

I valori letterali XML semplificano le attività più comuni che si verificano quando si lavora con XML (ad esempio caricare, eseguire query 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 spazi dei nomi XML a livello di file o progetto per sfruttare le ottimizzazioni delle prestazioni per i valori 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 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

Usare nomi significativi per le variabili di query:

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

Specificare nomi per gli elementi in una query per assicurarsi che i nomi delle proprietà dei tipi anonimi abbiano maiuscole o minuscole corrette tramite il metodo 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 clausole Where prima di altre clausole di query in modo che le clausole di query successive funzionino sul set filtrato di dati:

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

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

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

Vedi anche

Linee guida per la generazione di codice sicuro

Condividi tramite