Visual Basic-kodningskonventioner

Artikel
04/07/2023

Microsoft utvecklar exempel och dokumentation som följer riktlinjerna i det här avsnittet. Om du följer samma kodningskonventioner kan du få följande fördelar:

Koden kommer att ha ett konsekvent utseende, så att läsarna bättre kan fokusera på innehåll, inte layout.
Läsarna förstår koden snabbare eftersom de kan göra antaganden baserat på tidigare erfarenheter.
Du kan kopiera, ändra och underhålla koden enklare.
Du hjälper till att se till att koden visar "metodtips" för Visual Basic.

Namngivning

Information om namngivningsriktlinjer finns i avsnittet Namngivningsriktlinjer .
Använd inte "My" eller "my" som en del av ett variabelnamn. Den här metoden skapar förvirring med objekten My .
Du behöver inte ändra namnen på objekt i automatiskt genererad kod för att få dem att passa riktlinjerna.

Layoutkonventioner

Infoga flikar som blanksteg och använd smart indrag med indrag med fyra blanksteg.
Använd Pretty listing (formatera om) kod för att formatera om koden i kodredigeraren. Mer information finns i Alternativ, Textredigerare, Grundläggande (Visual Basic).
Använd endast en instruktion per rad. Använd inte linjeavgränsartecknet Visual Basic (:).
Undvik att använda det explicita radfortsättningstecknet "_" till förmån för implicit radfortsättning där språket tillåter det.
Använd endast en deklaration per rad.
Om ganska lista (omformatering) av kod inte formaterar fortsättningsrader automatiskt, drar du in fortsättningsrader manuellt ett tabbstopp. Men alltid vänsterjustera objekt i en lista.
```
a As Integer,  
b As Integer  
```
Lägg till minst en tom rad mellan metod- och egenskapsdefinitioner.

Kommentera konventioner

Placera kommentarer på en separat rad i stället för i slutet av en kodrad.
Starta kommentarstexten med en versal bokstav och avsluta kommentarstexten med en punkt.
Infoga ett blanksteg mellan kommentars avgränsare (') och kommentarstexten.
```
' Here is a comment.
```
Omge inte kommentarer med formaterade block av asterisker.

Programstruktur

När du använder Main metoden använder du standardkonstruktionen för nya konsolprogram och använder My för kommandoradsargument.

Sub Main()
  For Each argument As String In My.Application.CommandLineArgs
    ' Add code here to use the string variable.
  Next
End Sub

Språkriktlinjer

Strängdatatyp

Använd stränginterpolation för att sammanfoga korta strängar, enligt följande kod.
```
MsgBox($"hello{vbCrLf}goodbye")
```

Om du vill lägga till strängar i loopar använder du objektet StringBuilder .

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

Avslappnade ombud i händelsehanterare

Kvalificera inte uttryckligen argumenten (Object och EventArgs) till händelsehanterare. Om du inte använder de händelseargument som skickas till en händelse (till exempel sender As Object, e As EventArgs), använder du avslappnade ombud och utelämnar händelseargumenten i koden:

Public Sub Form1_Load() Handles Form1.Load
End Sub

Osignerad datatyp

Använd Integer i stället för osignerade typer, förutom där de är nödvändiga.

Matriser

Använd den korta syntaxen när du initierar matriser på deklarationsraden. Använd till exempel följande syntax.
```
Dim letters1 As String() = {"a", "b", "c"}
```
Använd inte följande syntax.
```
Dim letters2() As String = New String() {"a", "b", "c"}
```
Placera matrisdesignatorn på typen, inte på variabeln. Använd till exempel följande syntax:
```
Dim letters4 As String() = {"a", "b", "c"}
```
Använd inte följande syntax:
```
Dim letters3() As String = {"a", "b", "c"}
```
Använd syntaxen { } när du deklarerar och initierar matriser med grundläggande datatyper. Använd till exempel följande syntax:
```
Dim letters5 As String() = {"a", "b", "c"}
```
Använd inte följande syntax:
```
Dim letters6(2) As String
letters6(0) = "a"
letters6(1) = "b"
letters6(2) = "c"
```

Använda nyckelordet Med

När du gör en serie anrop till ett objekt bör du överväga att använda nyckelordet With :

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

Använd prova... Catch and Using-instruktioner när du använder undantagshantering

Använd inte On Error Goto.

Använd nyckelordet IsNot

Använd ... IsNot Nothing i stället för Not ... Is Nothing.

Nytt nyckelord

Använd kort instansiering. Använd till exempel följande syntax:
```
Dim employees As New List(Of String)
```
Föregående rad motsvarar följande:
```
Dim employees2 As List(Of String) = New List(Of String)
```

Använd objektinitierare för nya objekt i stället för den parameterlösa konstruktorn:

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

Händelsehantering

Använd Handles i stället AddHandlerför :

Private Sub ToolStripMenuItem1_Click() Handles ToolStripMenuItem1.Click
End Sub

Använd AddressOfoch instansiera inte ombudet explicit:

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

När du definierar en händelse använder du den korta syntaxen och låter kompilatorn definiera ombudet:

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

Kontrollera inte om en händelse är Nothing (null) innan du anropar RaiseEvent metoden. RaiseEvent söker Nothing efter innan händelsen aktiveras.

Använda delade medlemmar

Anropa Shared medlemmar med hjälp av klassnamnet, inte från en instansvariabel.

Använda XML-literaler

XML-literaler förenklar de vanligaste uppgifterna som du stöter på när du arbetar med XML (till exempel belastning, fråga och transformering). När du utvecklar med XML följer du dessa riktlinjer:

Använd XML-literaler för att skapa XML-dokument och fragment i stället för att anropa XML-API:er direkt.
Importera XML-namnområden på fil- eller projektnivå för att dra nytta av prestandaoptimeringarna för XML-literaler.
Använd XML-axelns egenskaper för att komma åt element och attribut i ett XML-dokument.

Använd inbäddade uttryck för att inkludera värden och för att skapa XML från befintliga värden i stället för att använda API-anrop, till exempel Add metoden:

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

LINQ-frågor

Använd meningsfulla namn för frågevariabler:

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

Ange namn på element i en fråga för att se till att egenskapsnamnen för anonyma typer är korrekt versaler med Pascal-hölje:

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

Byt namn på egenskaper när egenskapsnamnen i resultatet skulle vara tvetydiga. Om din fråga till exempel returnerar ett kundnamn och ett order-ID byter du namn på dem i stället för att lämna dem som Name och ID i resultatet:

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

Använd typinferens i deklarationen av frågevariabler och intervallvariabler:
```
Dim customerList = From cust In customers
```

Justera frågesatser under instruktionen From :

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

Använd Where satser före andra frågesatser så att senare frågesatser fungerar på den filtrerade datauppsättningen:

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

Join Använd -satsen för att explicit definiera en kopplingsåtgärd i stället för att använda Where -satsen för att implicit definiera en kopplingsåtgärd:

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

Se även

Riktlinjer för säker kodning

Dela via