Visual Basic-coderingsconventies

Microsoft ontwikkelt voorbeelden en documentatie die voldoen aan de richtlijnen in dit onderwerp. Als u dezelfde coderingsconventies volgt, profiteert u mogelijk van de volgende voordelen:

Uw code heeft een consistent uiterlijk, zodat lezers zich beter kunnen richten op inhoud, niet op lay-out.
Lezers begrijpen uw code sneller omdat ze veronderstellingen kunnen maken op basis van eerdere ervaringen.
U kunt de code eenvoudiger kopiëren, wijzigen en onderhouden.
U zorgt ervoor dat uw code 'best practices' laat zien voor Visual Basic.

Naamgevingsconventies

Zie het onderwerp Naamgevingsrichtlijnen voor meer informatie over naamgevingsrichtlijnen.
Gebruik 'Mijn' of 'mijn' niet als onderdeel van een variabelenaam. In deze praktijk ontstaat verwarring met de My objecten.
U hoeft de namen van objecten in automatisch gegenereerde code niet te wijzigen om ze aan de richtlijnen te laten voldoen.

Layoutconventies

Voeg tabbladen in als spaties en gebruik slimme inspringing met vier spaties.
Gebruik Een mooie vermelding (opnieuw opmaken) van code om uw code opnieuw op te maken in de code-editor. Zie Opties, Teksteditor, Basic (Visual Basic) voor meer informatie.
Gebruik slechts één instructie per regel. Gebruik het scheidingsteken van de Visual Basic-regel (:) niet.
Vermijd het gebruik van het expliciete regelvervolgteken '_' ten gunste van impliciete regelvervolging waar de taal dit toestaat.
Gebruik slechts één declaratie per regel.
Als een behoorlijk overzicht (opnieuw opmaken) van code niet automatisch vervolgregels opmaken, laat u vervolglijnen handmatig inspringen met één tabstop. Items in een lijst worden echter altijd links uitgelijnd.
```
a As Integer,  
b As Integer  
```
Voeg ten minste één lege regel toe tussen methode- en eigenschapsdefinities.

Commentaarrichtlijnen

Plaats opmerkingen op een afzonderlijke regel in plaats van aan het einde van een coderegel.
Begin de tekst van de opmerking met een hoofdletter en beëindig de tekst van de opmerking met een punt.
Voeg één spatie tussen het scheidingsteken voor opmerkingen (') en de tekst van de opmerking in.
```
' Here is a comment.
```
Omgeef opmerkingen niet met opgemaakte blokken van sterretjes.

Programmastructuur

Wanneer u de Main methode gebruikt, gebruikt u de standaardconstructie voor nieuwe consoletoepassingen en gebruikt My u deze voor opdrachtregelargumenten.
```
Sub Main()
  For Each argument As String In My.Application.CommandLineArgs
    ' Add code here to use the string variable.
  Next
End Sub
```

Taalrichtlijnen

Tekenreeks gegevenstype

Gebruik tekenreeksinterpolatie om korte tekenreeksen samen te voegen, zoals wordt weergegeven in de volgende code.
```
MsgBox($"hello{vbCrLf}goodbye")
```

Als u tekenreeksen in lussen wilt toevoegen, gebruikt u het StringBuilder object.

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

Ontspannen delegaten in gebeurtenishandlers

De argumenten (Object en EventArgs) niet expliciet kwalificeren voor event handlers. Als u de argumenten die aan een gebeurtenis worden doorgegeven niet gebruikt (bijvoorbeeldsender As Objecte As EventArgs), gebruik dan vereenvoudigde gedelegeerden en laat de gebeurtenisargumenten in uw code weg.

Public Sub Form1_Load() Handles Form1.Load
End Sub

Niet-ondertekend gegevenstype

Gebruik Integer in plaats van niet-ondertekende typen, behalve waar ze nodig zijn.

Reeksen

Gebruik de korte syntaxis wanneer u matrices initialiseert op de declaratieregel. Gebruik bijvoorbeeld de volgende syntaxis.
```
Dim letters1 As String() = {"a", "b", "c"}
```
Gebruik de volgende syntaxis niet.
```
Dim letters2() As String = New String() {"a", "b", "c"}
```
Plaats de matrixontwerper op het type, niet op de variabele. Gebruik bijvoorbeeld de volgende syntaxis:
```
Dim letters4 As String() = {"a", "b", "c"}
```
Gebruik niet de volgende syntaxis:
```
Dim letters3() As String = {"a", "b", "c"}
```
Gebruik de syntaxis { } wanneer u matrices van basisgegevenstypen declareert en initialiseert. Gebruik bijvoorbeeld de volgende syntaxis:
```
Dim letters5 As String() = {"a", "b", "c"}
```
Gebruik niet de volgende syntaxis:
```
Dim letters6(2) As String
letters6(0) = "a"
letters6(1) = "b"
letters6(2) = "c"
```

Gebruik het trefwoord ‘met’

Wanneer u een reeks aanroepen naar één object uitvoert, kunt u overwegen het With trefwoord te gebruiken:

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

Gebruik Try...Catch en Using-instructies wanneer u gebruikmaakt van uitzonderingsafhandeling

Maak geen gebruik van On Error Goto.

Het trefwoord IsNot gebruiken

Gebruik ... IsNot Nothing in plaats van Not ... Is Nothing.

Nieuw trefwoord

Gebruik korte instantiëring. Gebruik bijvoorbeeld de volgende syntaxis:
```
Dim employees As New List(Of String)
```
De voorgaande regel is gelijk aan deze:
```
Dim employees2 As List(Of String) = New List(Of String)
```

Gebruik object-initialisatiefuncties voor nieuwe objecten in plaats van de parameterloze constructor:

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

Gebeurtenisafhandeling

Gebruik Handles in plaats AddHandlervan:

Private Sub ToolStripMenuItem1_Click() Handles ToolStripMenuItem1.Click
End Sub

Gebruik AddressOfen instantieer de gemachtigde niet expliciet:

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

Wanneer u een gebeurtenis definieert, gebruikt u de korte syntaxis en laat u de compiler de gedelegeerde definiëren:

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

Controleer niet of een gebeurtenis Nothing (null) is voordat u de RaiseEvent-methode aanroept. RaiseEvent controleert op Nothing voordat de gebeurtenis wordt gegenereerd.

Gedeelde leden gebruiken

Roep Shared leden aan met behulp van de klassenaam, niet vanuit een exemplaarvariabele.

XML-Literals gebruiken

XML-letterlijke gegevens vereenvoudigen de meest voorkomende taken die u tegenkomt wanneer u met XML werkt (bijvoorbeeld laden, query's uitvoeren en transformeren). Wanneer u ontwikkelt met XML, volgt u deze richtlijnen:

Gebruik LETTERLIJKE XML-bestanden om XML-documenten en -fragmenten te maken in plaats van XML-API's rechtstreeks aan te roepen.
Importeer XML-naamruimten op bestand- of projectniveau om te profiteren van de prestatieoptimalisaties voor letterlijke XML-gegevens.
Gebruik de eigenschappen van de XML-as voor toegang tot elementen en kenmerken in een XML-document.

Gebruik ingesloten expressies om waarden op te nemen en XML te maken op basis van bestaande waarden in plaats van API-aanroepen te gebruiken, zoals de Add methode:

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-queries

Gebruik betekenisvolle namen voor queryvariabelen:

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

Geef namen op voor elementen in een query om ervoor te zorgen dat eigenschapsnamen van anonieme typen correct zijn voorzien van hoofdletters met Pascal-case.

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

Wijzig de naam van eigenschappen wanneer de eigenschapsnamen in het resultaat dubbelzinnig zouden zijn. Als uw query bijvoorbeeld een klantnaam en een order-id retourneert, wijzigt u de naam ervan in plaats van ze te verlaten als Name en ID in het resultaat:

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

Gebruik typedeductie in de declaratie van queryvariabelen en bereikvariabelen:
```
Dim customerList = From cust In customers
```

Clausules van de query uitlijnen onder de From instructie:

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

Gebruik Where componenten vóór andere queryclausules, zodat latere queryclausules worden uitgevoerd op de gefilterde set gegevens:

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

Gebruik de Join component om expliciet een join-bewerking te definiëren in plaats van de Where component te gebruiken om impliciet een join-bewerking te definiëren:

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

Zie ook

richtlijnen voor veilige codering

Feedback

Is deze pagina nuttig?

Last updated on 2024-03-05