Visual Basic Coding-Konventionen

2025-06-19

Microsoft entwickelt Beispiele und Dokumentationen, die den Richtlinien in diesem Thema entsprechen. Wenn Sie die gleichen Codierungskonventionen befolgen, können Sie die folgenden Vorteile erzielen:

Ihr Code hat ein einheitliches Aussehen, sodass Leser sich besser auf Inhalte konzentrieren können, nicht auf das Layout.
Leser verstehen Ihren Code schneller, da sie Annahmen basierend auf früheren Erfahrungen treffen können.
Sie können den Code einfacher kopieren, ändern und verwalten.
Sie stellen sicher, dass Ihr Code bewährte Methoden für Visual Basic veranschaulicht.

Namenskonventionen

Informationen zu Benennungsrichtlinien finden Sie im Thema "Benennungsrichtlinien ".
Verwenden Sie nicht "My" oder "my" als Teil eines Variablennamens. Diese Übung erzeugt Verwirrung mit den My Objekten.
Sie müssen die Namen von Objekten im automatisch generierten Code nicht ändern, damit sie den Richtlinien entsprechen.

Layoutkonventionen

Fügen Sie Registerkarten als Leerzeichen ein, und verwenden Sie intelligenten Einzug mit vier Leerzeichen.
Verwenden Sie Übersichtliche Auflistung (Neuformatierung) von Code zur Neuformatierung Ihres Codes im Code-Editor. 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 die Verwendung des expliziten Zeilenfortsetzungszeichens "_" zugunsten der impliziten Zeilenfortsetzung, wenn die Sprache dies zulässt.
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. Jedoch sollten Sie Elemente in einer Liste immer linksbündig ausrichten.
```
a As Integer,  
b As Integer  
```
Fügen Sie mindestens eine leere Zeile zwischen Methoden- und Eigenschaftsdefinitionen hinzu.

Konventionen für Kommentare

Platzieren Sie Kommentare in einer separaten Zeile statt am Ende einer Codezeile.
Beginnen Sie Kommentartext mit einem Großbuchstaben, und beenden Sie Kommentartext mit einem Punkt.
Fügen Sie ein Leerzeichen zwischen dem Kommentartrennzeichen (') und dem Kommentartext ein.
```
' Here is a comment.
```
Umschließen Sie Kommentare nicht mit formatierten Sternchenblöcken.

Programmstruktur

Wenn Sie die Main Methode verwenden, verwenden Sie das Standardkonstrukt für neue Konsolenanwendungen, und verwenden Sie My sie 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 anzufügen.

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

Nicht signierter Datentyp

Verwenden Sie Integer anstelle nicht signierter Typen, es sei denn, sie sind erforderlich.

Felder

Verwenden Sie die kurze Syntax, wenn Sie Arrays in der Deklarationszeile initialisieren. Verwenden Sie beispielsweise die folgende Syntax.
```
Dim letters1 As String() = {"a", "b", "c"}
```
Verwenden Sie nicht die folgende Syntax.
```
Dim letters2() As String = New String() {"a", "b", "c"}
```
Platzieren Sie den Array-Deklarator beim Typ, nicht bei der Variablen. Verwenden Sie beispielsweise die folgende Syntax:
```
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 grundlegender Datentypen deklarieren und initialisieren. Verwenden Sie beispielsweise die folgende Syntax:
```
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 an ein Objekt durchführen, sollten Sie das With Schlüsselwort 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.

Neues Schlüsselwort

Verwenden Sie die kurze Instanziierung. Verwenden Sie beispielsweise die folgende Syntax:
```
Dim employees As New List(Of String)
```
Die vorangehende Zeile entspricht folgendem:
```
Dim employees2 As List(Of String) = New List(Of String)
```

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

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

Ereignisbehandlung

Anstelle Handles von 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 Compiler den Delegaten 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. RaiseEvent überprüft Nothing, bevor es das Ereignis auslöst.

Verwenden von Shared-Membern

Rufen Sie Shared-Member über den Klassennamen und nicht über eine Instanzvariable auf.

Verwenden von XML-Literalen

XML-Literale vereinfachen die am häufigsten auftretenden Aufgaben, wenn Sie mit XML arbeiten (z. B. Laden, Abfragen und Transformieren). Befolgen Sie beim Entwickeln mit XML die folgenden Richtlinien:

Verwenden Sie XML-Literale, um XML-Dokumente und -Fragmente zu erstellen, anstatt XML-APIs direkt aufzurufen.
Importieren Sie XML-Namespaces auf Datei- oder Projektebene, um die Leistungsoptimierungen für XML-Literale zu nutzen.
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 verwenden:

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"

Stellen Sie Namen für Elemente in einer Abfrage bereit, um sicherzustellen, dass Eigenschaftennamen anonymer Typen mit Pascal-Großschreibung richtig groß geschrieben werden:

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 Ihre Abfrage z. B. einen Kundennamen und eine Auftrags-ID zurückgibt, benennen Sie sie um, anstatt sie wie Name und ID im Ergebnis zu verlassen:

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 typinferenz 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 Where Klauseln vor anderen Abfrageklauseln, damit spätere Abfrageklauseln für den gefilterten Satz von Daten funktionieren:

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

Verwenden Sie die Join Klausel, um einen Verknüpfungsvorgang explizit zu definieren, anstatt die Where Klausel zum impliziten Definieren eines Verknüpfungsvorgangs zu verwenden:

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

Siehe auch

Richtlinien für sicheres Codieren

Freigeben über