Codierungskonventionen in Visual Basic

Artikel
03/12/2013

Microsoft entwickelt Beispiele und Dokumentation, die den Richtlinien in diesem Thema folgen.Wenn Sie den gleichen Codierungskonventionen ausführen, erhalten Sie möglicherweise die folgenden Vorteile:

Der Code hat ein einheitliches Aussehen, damit Leser Fokus auf Inhalt verbessern können, nicht auf das Layout.
Leser verstehen den Code schneller, da sie Rückschlüsse aus früheren Erfahrungen ausführen können.
Sie können den Code kopieren, ändern und einfach beibehalten.
Sie helfen, sicherzustellen, dass der Code "bewährten Methoden" für Visual Basic wird.

Namenskonventionen

Informationen zum Benennungsrichtlinien, finden Sie unter Guidelines for Names Thema.
Verwenden Sie nicht "My" oder "my" als Teil eines Variablennamens.Diese Praxis 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 und intelligenten Einzug der Verwendung mit VierLeerzeicheneinzügen ein.Weitere Informationen finden Sie unter Gewusst wie: Festlegen von Tabstopp- und Einzugsoptionen für den Editor.
Verwenden Sie Automatische Strukturierung und Einrückung des Programmcodes, um den Code im Code-Editor umzuformatieren.Weitere Informationen finden Sie unter Optionen, Text-Editor, Standard (Visual Basic).
Verwenden Sie pro Zeile nur eine Anweisung.Verwenden Sie nicht das Visual Basic-Zeilentrennzeichen (:).
Vermeiden Sie es, das explizite Zeilenfortsetzungszeichen "_" zugunsten der impliziten Zeilenfortsetzung zu verwenden, auf dem die Sprache sie zulässig.
Verwenden Sie pro Zeile nur eine Deklaration.
Wenn Automatische Strukturierung und Einrückung des Programmcodes Fortsetzungszeilen nicht automatisch formatiert, ziehen Sie manuell Fortsetzungszeilen ein Tabstopp einrücken.belassene-richten jedoch immer Sie Elemente in einer Liste aus.
```
a As Integer,
b As Integer
```
Fügen Sie zwischen Methoden- und Eigenschaftendefinitionen mindestens eine Leerzeile ein.

Konventionen für Kommentare

Schreiben Sie Kommentare in eine eigene Zeile anstelle des Stapelrahmens an einer Codezeile.
Starten Sie den Kommentartext mit einem Großbuchstaben und, beenden Sie den Kommentartext mit einem Punkt.
Fügen Sie ein Leerzeichen zwischen dem Kommentartrennzeichen (') und dem Kommentartext ein.
```
' Here is a comment.
```
Schließen Sie keine Kommentare mit formatierten Blöcke Sternchen.

Programmstruktur

Wenn Sie die - Methode Main 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

Um Zeichenfolgen verketten, verwenden Sie ein kaufmännisches Und-Zeichen (&).
```
MsgBox("hello" & vbCrLf & "goodbye")
```

Um Zeichenfolgen in Schleifen anzufügen, verwenden Sie das StringBuilder-Objekt.

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

Weniger strenge Delegaten in Ereignishandlern

Nicht explizit qualifizieren Sie die Argumente und EventArgs (- Objekt) für Ereignishandler.Wenn Sie nicht die Ereignisargumente verwenden, die mit einem Ereignis übergeben werden (beispielsweise, sender, wie Objekt, e als 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 statt Typen ohne Vorzeichen, wenn sie benötigt werden.

Arrays

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"}
```
Legen Sie den Arraybezeichner auf den Typ, nicht auf die Variable.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 der grundlegenden 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 von einem Objekt 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 die Try... Catch-Blocks und die using-Anweisungen, wenn Sie Ausnahmebehandlung verwenden

Verwenden Sie nicht On Error Goto.

Verwenden des IsNot-Schlüsselworts

Verwenden Sie das - Schlüsselwort anstelle IsNotNot...Is Nothing.

New-Schlüsselwort

Verwenden Sie die kurze Instanziierung.Verwenden Sie beispielsweise die folgende Syntax:
```
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, ob ein Ereignis nicht Nothing (NULL) ist RaiseEvent bevor Sie die 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 Umwandeln).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 Namen für Elemente in einer Abfrage an, um sicherzustellen, dass Eigenschaftennamen anonymer Typen ordnungsgemäß mit Pascal-Umkleidens 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 die Abfrage beispielsweise einen Kundennamen und eine Auftrags-ID zurückgibt, benennen Sie sie um, anstatt sie werden als Name und ID im Ergebnis:

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 - Klauseln Where, sodass die nachfolgenden Abfrageklauseln für den gefilterten Datensatz ausgeführt werden:
```
Dim newyorkCustomers2 = From cust In customers 
                        Where cust.City = "New York" 
                        Order By cust.LastName
```

Verwenden Sie die Join-Klausel, um eine Joinoperation explizit zu definieren, Where, anstatt die - Klausel zu verwenden, um eine Joinoperation implizit zu definieren:

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

Siehe auch

Weitere Ressourcen

Richtlinien für das Schreiben von sicherem Code

Freigeben über