Convenzioni di codifica di Visual Basic

Articolo
03/12/2013

Microsoft elabora gli esempi e la documentazione che seguono le istruzioni riportate in questo argomento.Se si seguono le stesse convenzioni di codifica, è possibile usufruire dei vantaggi seguenti:

Il codice avrà un aspetto coerente, in modo che chi legge possa aggiornare lo stato attivo sul contenuto, non layout.
I reader siano più rapidamente il codice quanto possono formulare ipotesi basate sulle esperienze precedenti.
È possibile copiare, modificare e gestire il codice più facilmente.
Assicura che il codice seguente viene illustrato "procedure consigliate" per Visual Basic.

Convenzioni di denominazione

Per informazioni sulla denominazione delle linee guida, vedere l'argomento di Guidelines for Names.
Non utilizzare "My" o "my" come parte di un nome di variabile,Questa procedura consente di creare confusione con gli oggetti di My.
Non è necessario modificare i nomi degli oggetti nel codice generato automaticamente per adattarli alle istruzioni.

Convenzioni di layout

Inserire le tabulazioni come spazi e rientri intelligenti con i rientri a quattro spazi.Per ulteriori informazioni, vedere Procedura: impostare le opzioni di tabulazione e rientro dell'editor.
Utilizzare Riformatta il 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 di separazione di Visual Basic (:).
Evitare di utilizzare il carattere esplicito "_" di continuazione di riga a favore di continuazione di riga implicita quando il linguaggio la consentita.
Utilizzare una sola dichiarazione per riga.
Se Riformatta il listato di codice non formattare le righe di continuazione automaticamente, manualmente impostare un rientro per le righe di continuazione una tabulazione.Tuttavia, a allineare sempre 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 commenti su una riga separata anziché alla fine di una riga di codice.
Iniziare il testo del commento con una lettera maiuscola e termini 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 utilizza il metodo di 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 stringhe, utilizzare una e commerciale (&).
```
MsgBox("hello" & vbCrLf & "goodbye")
```

Per aggiungere stringhe nei cicli, utilizzare l'oggetto di 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 esplicitamente qualificare gli argomenti (oggetto e EventArgs) ai gestori eventi.Se non si utilizzano gli argomenti che vengano passati a un evento, ad esempio mittente come oggetto, e come EventArgs), utilizzare i delegati di tipo relaxed e omettere gli argomenti nel codice:

Public Sub Form1_Load() Handles Form1.Load
End Sub

Tipi di dati senza segno

Utilizzare Integer anziché tipi senza segno, solo quando sono necessari.

Matrici

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

Utilizzare la parola chiave With

Quando si esegue una serie di chiamate a un oggetto, utilizzare la parola chiave di With :

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

Utilizzare il latch e le istruzioni try… quando si utilizza la gestione delle eccezioni

Non utilizzare la proprietà On Error Goto.

Utilizzo della parola chiave IsNot

Utilizzare la parola chiave di 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 compilatore definire il delegato:

Public Event SampleEvent As EventHandler(Of SampleEventArgs)
' or
Public Event SampleEvent(ByVal source As Object, 
                          ByVal e As SampleEventArgs)

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

Specificare i nomi degli elementi in una query per assicurarsi che i nomi di proprietà dei tipi anonimi correttamente è scritto in maiuscolo 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, rinominarli anziché 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

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 di Where prima di altre clausole di query in modo che le ultime clausole di query agiscano su un set di dati filtrato:

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

Utilizzare la clausola di Join per definire in modo esplicito un'operazione di join anziché utilizzare la clausola di Where in modo implicito per definire 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

Altre risorse

Linee guida per la generazione di codice sicuro

Condividi tramite