Codierungskonventionen in Visual Basic

Artikel
06/26/2023

Microsoft entwickelt Beispiele und Dokumentation, die den Richtlinien in diesem Thema folgen. Wenn Sie dieselben Codierungskonventionen beachten, erhalten Sie möglicherweise folgende Vorteile:

Der Code erhält eine konsistente Gestaltung, damit sich die Leser mehr auf den Inhalt und nicht auf das Layout konzentrieren.
Leser verstehen den Code schneller, da sie Rückschlüsse aus früheren Erfahrungen ziehen können.
Sie können den Code kopieren, ändern und leichter pflegen.
Sie können sicherstellen, dass der Code die "empfohlenen Vorgehensweisen" für Visual Basic berücksichtigt.

Namenskonventionen

Informationen zu den Benennungsrichtlinien finden Sie im Thema Benennungsrichtlinien.
Verwenden Sie nicht "My" oder "my" als Teil eines Variablennamens. Diese Vorgehensweise führt zu Verwechslungen mit den My-Objekten.
Sie müssen die Namen von Objekten in automatisch generiertem Code nicht ändern, um sie an die Richtlinien anzupassen.

Layoutkonventionen

Fügen Sie Registerkarten als Leerzeichen ein, und verwenden Sie intelligenten Einzug mit vier Leerzeichen.
Verwenden Sie Automatische Strukturierung und Einrückung des Programmcodes, um den Code im Code-Editor neu zu formatieren. Weitere Informationen finden Sie unter Optionen, Text-Editor, Basic (Visual Basic).
Verwenden Sie pro Zeile nur eine Anweisung. Verwenden Sie nicht das Visual Basic-Zeilentrennzeichen (:).
Vermeiden Sie, das explizite Zeilenfortsetzungszeichen „_“ zugunsten der impliziten Zeilenfortsetzung, wenn die Sprache dies ermöglicht.
Verwenden Sie pro Zeile nur eine Deklaration.
Mit Automatische Strukturierung und Einrückung des Programmcodes werden Fortsetzungszeilen nicht automatisch formatiert. Sie müssen zum Einrücken manuell auf einen Tabstopp gezogen werden. In einer Liste werden jedoch die Elemente immer links ausgerichtet.
```
a As Integer,  
b As Integer  
```
Fügen Sie zwischen Methoden- und Eigenschaftendefinitionen mindestens eine Leerzeile ein.

Konventionen für Kommentare

Fügen Sie den Kommentar in einer eigenen Zeile und nicht am Ende einer Codezeile ein.
Beginnen Sie den Kommentartext mit einem Großbuchstaben, und beenden Sie ihn mit einem Punkt.
Fügen Sie ein Leerzeichen zwischen dem Kommentartrennzeichen (') und dem Kommentartext ein.
```
' Here is a comment.
```
Erstellen Sie keine formatierten Blöcke von Sternchen, die die Kommentare umgeben.

Programmstruktur

Wenn Sie die Main-Methode verwenden, verwenden Sie das Standardkonstrukt für neue Konsolenanwendungen, und verwenden Sie My für Befehlszeilenargumente.
```
Sub Main()
  For Each argument As String In My.Application.CommandLineArgs
    ' Add code here to use the string variable.
  Next
End Sub
```

Sprachrichtlinien

String-Datentyp

Verwenden Sie die Zeichenfolgeninterpolation, um wie im folgenden Code gezeigt kurze Zeichenfolgen zu verketten.
```
MsgBox($"hello{vbCrLf}goodbye")
```

Verwenden Sie das StringBuilder-Objekt, um Zeichenfolgen in Schleifen anzuhängen.

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

Weniger strenge Delegaten in Ereignishandlern

Qualifizieren Sie die Argumente (Object und EventArgs) nicht explizit für Ereignishandler. Wenn Sie nicht die Ereignisargumente verwenden, die an ein Ereignis übergeben werden (z. B. sender As Object, e As EventArgs), verwenden Sie weniger strenge Delegaten, und lassen Sie die Ereignisargumente im Code aus:

Public Sub Form1_Load() Handles Form1.Load
End Sub

Datentyp ohne Vorzeichen

Verwenden Sie Integer anstelle von Typen ohne Vorzeichen, wenn sie nicht notwendig sind.

Arrays

Verwenden Sie die kurze Syntax, wenn Sie Arrays in der Deklarationszeile initialisieren. Sie können z. B. folgende Syntax verwenden.
```
Dim letters1 As String() = {"a", "b", "c"}
```
Verwenden Sie nicht die folgende Syntax.
```
Dim letters2() As String = New String() {"a", "b", "c"}
```
Legen Sie den Arraybezeichner im Typ und nicht in der Variablen ab. Sie können z. B. folgende Syntax verwenden:
```
Dim letters4 As String() = {"a", "b", "c"}
```
Verwenden Sie nicht die folgende Syntax:
```
Dim letters3() As String = {"a", "b", "c"}
```
Verwenden Sie die { }-Syntax, wenn Sie Arrays aus grundlegenden Datentypen deklarieren und initialisieren. Sie können z. B. folgende Syntax verwenden:
```
Dim letters5 As String() = {"a", "b", "c"}
```
Verwenden Sie nicht die folgende Syntax:
```
Dim letters6(2) As String
letters6(0) = "a"
letters6(1) = "b"
letters6(2) = "c"
```

Verwenden des with-Schlüsselworts

Wenn Sie eine Reihe von Aufrufen eines Objekts ausführen, sollten Sie erwägen, das With-Schlüsselwort zu verwenden:

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

Verwenden Sie try-catch-Anweisungen zur Ausnahmebehandlung.

Verwenden Sie nicht On Error Goto.

Verwenden des IsNot-Schlüsselworts

Verwenden Sie ... IsNot Nothing anstelle von Not ... Is Nothing.

New-Schlüsselwort

Verwenden Sie die kurze Instanziierung. Sie können z. B. folgende Syntax verwenden:
```
Dim employees As New List(Of String)
```
Die vorangehende Zeile entspricht der Folgenden:
```
Dim employees2 As List(Of String) = New List(Of String)
```

Verwenden Sie für neue Objekte Objektinitialisierer anstelle des parameterlosen Konstruktors:

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

Ereignisbehandlung

Verwenden Sie eher Handles als AddHandler:

Private Sub ToolStripMenuItem1_Click() Handles ToolStripMenuItem1.Click
End Sub

Verwenden Sie AddressOf, und instanziieren Sie den Delegaten nicht explizit:

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

Wenn Sie ein Ereignis definieren, verwenden Sie die kurze Syntax, und lassen Sie den Delegaten vom Compiler definieren:

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

Überprüfen Sie nicht, ob ein Ereignis Nothing (NULL) ist, bevor Sie die RaiseEvent-Methode aufrufen. Die RaiseEvent-Methode führt vor dem Auslösen des Ereignisses eine Überprüfung auf den Wert Nothing durch.

Verwenden von Shared-Membern

Rufen Sie Shared-Member über den Klassennamen auf, nicht von einer Instanzvariablen aus.

Verwenden von XML-Literalen

XML-Literale vereinfachen allgemeine Aufgaben bei der Arbeit mit XML (z. B. Laden, Abfragen und Transformieren). Beachten Sie bei der Entwicklung mit XML die folgenden Richtlinien:

Verwenden Sie zum Erstellen von XML-Dokumenten und –Fragmenten XML-Literale, anstatt die XML-APIs direkt aufzurufen.
Importieren Sie XML-Namespaces auf Datei- oder Projektebene, um die Leistungsoptimierung für XML-Literale zu verwenden.
Verwenden Sie die XML-Achseneigenschaften, um auf Elemente und Attribute in einem XML-Dokument zuzugreifen.

Verwenden Sie eingebettete Ausdrücke, um Werte einzuschließen und XML aus vorhandenen Werten zu erstellen, anstatt API-Aufrufe wie die Add-Methode zu nutzen:

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

Verwenden Sie aussagekräftige Namen für Abfragevariablen:

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

Geben Sie Aliasnamen für Elemente in einer Abfrage an, um eine korrekte Großschreibung von Eigenschaftennamen anonymer Typen in Pascal-Schreibweise sicherzustellen:

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

Benennen Sie Eigenschaften um, wenn die Eigenschaftennamen im Ergebnis nicht eindeutig sind. Wenn die Abfrage beispielsweise einen Kundennamen und eine Auftrags-ID zurückgibt, sollten Sie diese im Ergebnis umbenennen, anstatt Name und ID zu übernehmen:

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

Verwenden Sie den Typrückschluss in der Deklaration von Abfragevariablen und Bereichsvariablen:
```
Dim customerList = From cust In customers
```

Richten Sie Abfrageklauseln unter der From-Anweisung aus:

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

Verwenden Sie vor anderen Abfrageklauseln Where-Klauseln, sodass die nachfolgenden Abfrageklauseln für den reduzierten, gefilterten Datensatz ausgeführt werden:
```
Dim newyorkCustomers2 = From cust In customers 
                        Where cust.City = "New York" 
                        Order By cust.LastName
```

Verwenden Sie zum expliziten Definieren eines Verbindungsvorgangs die Join-Klausel anstelle der Where-Klausel, bei der ein Verbindungsvorgang implizit definiert wird:

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

Siehe auch

Richtlinien für das Schreiben von sicherem Code