Anweisungen in Visual Basic

Artikel
06/23/2023

Eine Anweisung ist in Visual Basic vollständig. Sie kann Schlüsselwörter, Operatoren, Variablen, Konstanten und Ausdrücke enthalten. Jede Anweisung gehört einer der folgenden Kategorien an:

Deklarationsanweisungen, die eine Variable, Konstante oder Prozedur benennen und auch einen Datentyp angeben können.
Ausführbare Anweisungen, die Aktionen initiieren. Diese Anweisungen können eine Methode oder Funktion aufrufen, und sie können Codeblöcke in Schleifen oder Verzweigungen durchlaufen. Ausführbare Anweisungen enthalten Zuweisungsanweisungen, die einer Variablen oder Konstanten einen Wert oder Ausdruck zuweisen.

In diesem Thema werden die einzelnen Kategorien beschrieben. Außerdem wird in diesem Thema beschrieben, wie Sie mehrere Anweisungen in einer einzelnen Zeile kombinieren und wie Sie eine Anweisung über mehrere Zeilen hinweg fortsetzen.

Deklarationsanweisungen

Sie verwenden Deklarationsanweisungen, um Prozeduren, Variablen, Eigenschaften, Arrays und Konstanten zu benennen und zu definieren. Beim Deklarieren eines Programmierelements können Sie auch dessen Datentyp, die Zugriffsebene und den Bereich definieren. Weitere Informationen finden Sie unter Merkmale deklarierter Elemente.

Das folgende Beispiel enthält drei Deklarationen.

Public Sub ApplyFormat()
    Const limit As Integer = 33
    Dim thisWidget As New widget
    ' Insert code to implement the procedure.
End Sub

Die erste Deklaration ist die Sub-Anweisung. Zusammen mit der zugehörigen End Sub-Anweisung deklariert sie eine Prozedur mit dem Namen applyFormat. Sie gibt auch an, dass applyFormatPublic ist. Dies bedeutet, dass jeder Code, der auf die Prozedur verweisen kann, sie aufrufen kann.

Die zweite Deklaration ist die Const-Anweisung, die die Konstante limit deklariert und dabei den Datentyp Integer sowie den Wert 33 angibt.

Die dritte Deklaration ist die Dim-Anweisung, die die Variable thisWidget deklariert. Der Datentyp ist ein bestimmtes Objekt, nämlich eines, das aus der Widget-Klasse erstellt wird. Sie können eine Variable so deklarieren, dass sie einen beliebigen elementaren Datentyp oder einen beliebigen Objekttyp aufweist, der in der verwendeten Anwendung verfügbar gemacht wird.

Anfängliche Werte

Wenn der Code mit einer Deklarationsanweisung ausgeführt wird, reserviert Visual Basic den für das deklarierte Element erforderlichen Arbeitsspeicher. Enthält das Element einen Wert, initialisiert Visual Basic es mit dem Standardwert für seinen Datentyp. Weitere Informationen finden Sie unter „Verhalten“ in Dim-Anweisung.

Sie können einer Variablen einen anfänglichen Wert als Teil ihrer Deklaration zuweisen, wie im folgenden Beispiel veranschaulicht.

Dim m As Integer = 45
' The preceding declaration creates m and assigns the value 45 to it.

Wenn es sich bei einer Variable um eine Objektvariable handelt, können Sie explizit bei der Deklaration eine Instanz ihrer Klasse erstellen, indem Sie das Schlüsselwort New Operator verwenden, wie im folgenden Beispiel veranschaulicht.

Dim f As New FileInfo("filename")

Beachten Sie, dass der in einer Deklarationsanweisung angegebene anfängliche Wert erst dann einer Variablen zugewiesen wird, wenn die Ausführung die Deklarationsanweisung erreicht. Bis zu diesem Zeitpunkt enthält die Variable den Standardwert für ihren Datentyp.

Ausführbare Anweisungen

Eine ausführbare Anweisung führt eine Aktion aus. Sie kann eine Prozedur aufrufen, an eine andere Stelle im Code verzweigen, mehrere Anweisungen in einer Schleife durchlaufen oder einen Ausdruck auswerten. Eine Zuweisungsanweisung ist ein Sonderfall einer ausführbaren Anweisung.

Im folgenden Beispiel wird eine If...Then...Else-Steuerstruktur verwendet, um verschiedene Codeblöcke basierend auf dem Wert einer Variablen auszuführen. In jedem Codeblock wird eine For...Next-Schleife eine bestimmte Anzahl von Malen ausgeführt.

Public Sub StartWidget(ByVal aWidget As widget,
    ByVal clockwise As Boolean, ByVal revolutions As Integer)
    Dim counter As Integer
    If clockwise = True Then
        For counter = 1 To revolutions
            aWidget.SpinClockwise()
        Next counter
    Else
        For counter = 1 To revolutions
            aWidget.SpinCounterClockwise()
        Next counter
    End If
End Sub

Die If-Anweisung im vorherigen Beispiel überprüft den Wert des Parameters clockwise. Wenn der Wert True ist, wird die spinClockwise-Methode von aWidget aufgerufen. Wenn der Wert False ist, wird die spinCounterClockwise-Methode von aWidget aufgerufen. Die If...Then...Else-Steuerstruktur endet mit End If.

Die For...Next-Schleife in jedem Block ruft die entsprechende Methode so oft auf, wie der Wert des Parameters revolutions lautet.

Zuweisungsanweisungen

Zuordnungsanweisungen führen Zuweisungsvorgänge aus. Diese übernehmen den Wert auf der rechten Seite des Zuweisungsoperators (=) und speichern ihn im Element auf der linken Seite, wie im folgenden Beispiel gezeigt.

v = 42

Im vorhergehenden Beispiel speichert die Zuweisungsanweisung den Literalwert 42 in der Variablen v.

Geeignete Programmierelemente

Das Programmierelement auf der linken Seite des Zuweisungsoperators muss in der Lage sein, einen Wert zu akzeptieren und zu speichern. Dies bedeutet, dass es sich um eine Variable oder Eigenschaft handelt, die nicht ReadOnly ist, oder um ein Arrayelement. Im Kontext einer Zuweisungsanweisung wird ein solches Element manchmal als lvalue für „left value“ (linker Wert) bezeichnet.

Der Wert auf der rechten Seite des Zuweisungsoperators wird von einem Ausdruck generiert, der aus einer beliebigen Kombination von Literalen, Konstanten, Variablen, Eigenschaften, Arrayelementen, anderen Ausdrücken und Funktionsaufrufen bestehen kann. Dies wird anhand des folgenden Beispiels veranschaulicht.

x = y + z + FindResult(3)

Im vorherigen Beispiel wird der in der Variablen y gespeicherte Wert, zu dem Wert in der Variablen z addiert, und dann wird der Wert addiert, der durch den Aufruf der findResult-Funktion zurückgegeben wird. Der Gesamtwert dieses Ausdrucks wird dann in der Variablen x gespeichert.

Datentypen in Zuweisungsanweisungen

Neben numerischen Werten kann der Zuweisungsoperator auch String-Werte zuweisen, wie im folgenden Beispiel veranschaulicht.

Dim a, b As String
a = "String variable assignment"
b = "Con" & "cat" & "enation"
' The preceding statement assigns the value "Concatenation" to b.

Sie können auch Boolean-Werte mit einem Boolean-Literal oder einem Boolean-Ausdruck zuweisen, wie im folgenden Beispiel veranschaulicht.

Dim r, s, t As Boolean
r = True
s = 45 > 1003
t = 45 > 1003 Or 45 > 17
' The preceding statements assign False to s and True to t.

Ebenso können Sie Programmierelementen der Datentypen Char, Date oder Object geeignete Werte zuweisen. Sie können auch eine Objektinstanz einem Element zuweisen, das als Klasse deklariert ist, aus der diese Instanz erstellt wurde.

Verbundzuweisungsanweisungen

Verbundzuweisungsanweisungen führen zunächst einen Vorgang für einen Ausdruck aus, bevor sie einem Programmierelement zugewiesen werden. Im folgenden Beispiel wird einer dieser Operatoren, +=, veranschaulicht. Er erhöht den Wert der Variablen auf der linken Seite des Operators um den Wert des Ausdrucks auf der rechten Seite.

n += 1

Im vorherigen Beispiel wird 1 zum Wert von n addiert und dann dieser neue Wert in n gespeichert. Es handelt sich um eine Kurzform der folgenden Anweisung:

n = n + 1

Eine Vielzahl von zusammengesetzten Zuweisungsvorgängen kann mithilfe von Operatoren dieses Typs ausgeführt werden. Eine Liste dieser Operatoren und weitere Informationen zu diesen finden Sie unter Zuweisungsoperatoren.

Der Verkettungszuweisungsoperator (&=) ist nützlich, um eine Zeichenfolge am Ende bereits vorhandener Zeichenfolgen hinzuzufügen, wie im folgenden Beispiel veranschaulicht.

Dim q As String = "Sample "
q &= "String"
' q now contains "Sample String".

Typkonvertierungen in Zuordnungsanweisungen

Der Wert, den Sie einer Variablen, einer Eigenschaft oder einem Arrayelement zuweisen, muss einen für dieses Zielelement geeigneten Datentyp aufweisen. Im Allgemeinen sollten Sie versuchen, einen Wert desselben Datentyps wie im Zielelement zu generieren. Einige Typen können jedoch bei der Zuweisung in andere Typen konvertiert werden.

Informationen zum Konvertieren zwischen Datentypen finden Sie unter Typkonvertierung in Visual Basic. Kurz gesagt konvertiert Visual Basic Werte eines bestimmten Typs automatisch in einen anderen Typ, in den sie erweitert werden. Eine Erweiterungskonvertierung ist zur Laufzeit immer erfolgreich ist und nicht mit Datenverlusten verbunden. Beispielsweise konvertiert Visual Basic einen Integer-Wert bei Bedarf in Double, da Integer in Double erweitert werden kann. Weitere Informationen finden Sie unter Widening and Narrowing Conversions.

Eingrenzungskonvertierungen (die nicht erweitert werden) bergen das Risiko eines Fehlers zur Laufzeit oder eines Datenverlusts. Sie können eine Eingrenzungskonvertierung explizit mithilfe einer Typkonvertierungsfunktion ausführen, oder Sie können den Compiler anweisen, alle Konvertierungen implizit auszuführen, indem Sie Option Strict Off festlegen. Weitere Informationen finden Sie unter Implizite und explizite Konvertierungen.

Platzieren mehrerer Anweisungen in einer Zeile

Sie können mehrere Anweisungen in eine einzelne Zeile aufnehmen, indem Sie sie durch das Doppelpunktzeichen (:) trennen. Dies wird anhand des folgenden Beispiels veranschaulicht.

Dim sampleString As String = "Hello World" : MsgBox(sampleString)

Obwohl diese Syntax gelegentlich praktisch ist, ist mit ihr der Code schwierig zu lesen und zu verwalten. Daher empfiehlt es sich, eine Anweisung pro Zeile beizubehalten.

Fortsetzen einer Anweisung über mehrere Zeilen

Eine Anweisung passt normalerweise in eine Zeile, aber wenn sie zu lang ist, können Sie sie in der nächsten Zeile fortsetzen. Dazu verwenden Sie eine Zeilenfortsetzungssequenz, die aus einem Leerzeichen gefolgt von einem Unterstrich (_) gefolgt von einem Wagenrücklauf besteht. Im folgenden Beispiel wird die ausführbare MsgBox-Anweisung über zwei Zeilen fortgesetzt.

Public Sub DemoBox()
    Dim nameVar As String
    nameVar = "John"
    MsgBox("Hello " & nameVar _
        & ". How are you?")
End Sub

Implizite Zeilenfortsetzung

In vielen Fällen können Sie eine Anweisung in der nächsten aufeinanderfolgenden Zeile fortsetzen, ohne den Unterstrich (_) zu verwenden. Bei den folgenden Syntaxelementen wird die Anweisung implizit in der nächsten Codezeile fortgesetzt.

Nach einem Komma (,). Zum Beispiel:

Public Function GetUsername(ByVal username As String,
                            ByVal delimiter As Char,
                            ByVal position As Integer) As String

    Return username.Split(delimiter)(position)
End Function

Nach einer öffnenden Klammer (() oder vor einer schließenden Klammer ()). Zum Beispiel:

Dim username = GetUsername(
    Security.Principal.WindowsIdentity.GetCurrent().Name,
    CChar("\"),
    1
  )

Nach einer öffnenden geschweiften Klammer ({) oder vor einer schließenden geschweiften Klammer (}). Zum Beispiel:
```
Dim customer = New Customer With {
  .Name = "Terry Adams",
  .Company = "Adventure Works",
  .Email = "terry@www.adventure-works.com"
}
```
Weitere Informationen finden Sie unter Objektinitialisierer: Benannte und anonyme Typen und Auflistungsinitialisierer.

Nach einem geöffneten eingebetteten Ausdruck (<%=) oder vor dem Schließen eines eingebetteten Ausdrucks (%>) in einem XML-Literal. Zum Beispiel:

Dim customerXml = <Customer>
                      <Name>
                          <%=
                              customer.Name
                          %>
                      </Name>
                      <Email>
                          <%=
                              customer.Email
                          %>
                      </Email>
                  </Customer>

Weitere Informationen finden Sie unter Eingebettete Ausdrücke in XML (Visual Basic).

Nach dem Verkettungsoperator (&). Zum Beispiel:

cmd.CommandText = 
    "SELECT * FROM Titles JOIN Publishers " &
    "ON Publishers.PubId = Titles.PubID " &
    "WHERE Publishers.State = 'CA'"

Weitere Informationen finden Sie unter Operatoren sortiert nach Funktionalität.

Nach Zuweisungsoperatoren (=, &=, :=, +=, -=, *=, /=, \=, ^=, <<=, >>=). Zum Beispiel:
```
Dim fileStream =
  My.Computer.FileSystem.
    OpenTextFileReader(filePath)
```
Weitere Informationen finden Sie unter Operatoren sortiert nach Funktionalität.
Nach Binäroperatoren (+, -, /, *, Mod, <>, <, >, <=, >=, ^, >>, <<, And, AndAlso, Or, OrElse, Like, Xor) innerhalb eines Ausdrucks. Zum Beispiel:
```
Dim memoryInUse =
  My.Computer.Info.TotalPhysicalMemory +
  My.Computer.Info.TotalVirtualMemory -
  My.Computer.Info.AvailablePhysicalMemory -
  My.Computer.Info.AvailableVirtualMemory
```
Weitere Informationen finden Sie unter Operatoren sortiert nach Funktionalität.
Nach den Operatoren Is und IsNot. Zum Beispiel:
```
If TypeOf inStream Is 
  IO.FileStream AndAlso
  inStream IsNot
  Nothing Then

    ReadFile(inStream)

End If
```
Weitere Informationen finden Sie unter Operatoren sortiert nach Funktionalität.
Nach einem Memberqualifiziererzeichen (.) und vor dem Membernamen. Zum Beispiel:
```
Dim fileStream =
  My.Computer.FileSystem.
    OpenTextFileReader(filePath)
```
Sie müssen jedoch nach einem Memberqualifiziererzeichen ein Zeilenfortsetzungszeichen (_) einschließen, wenn Sie die With-Anweisung verwenden oder Werte in der Initialisierungsliste für einen Typ angeben. Ziehen Sie in Erwägung, die Zeile nach dem Zuweisungsoperator (z. B. =) umzubrechen, wenn Sie With-Anweisungen oder Objektinitialisierungslisten verwenden. Zum Beispiel:
```
' Not allowed:
' Dim aType = New With { .
'    PropertyName = "Value"

' Allowed:
Dim aType = New With {.PropertyName =
    "Value"}



Dim log As New EventLog()

' Not allowed:
' With log
'    .
'      Source = "Application"
' End With

' Allowed:
With log
    .Source =
      "Application"
End With
```
Weitere Informationen finden Sie unter With...End With-Anweisung und Objektinitialisierer: Benannte und anonyme Typen.
Nach einem XML-Achseneigenschaftsqualifizierer (., .@ oder ...). Sie müssen jedoch ein Zeilenfortsetzungszeichen (_) einschließen, wenn Sie bei Verwendung des Schlüsselworts With einen Memberqualifizierer angeben. Zum Beispiel:
```
Dim customerName = customerXml.
  <Name>.Value

Dim customerEmail = customerXml...
  <Email>.Value
```
Weitere Informationen finden Sie unter XML-Achseneigenschaften.
Nach einem Kleiner-als-Zeichen (<) oder vor einem Größer-als-Zeichen (>), wenn Sie ein Attribut angeben. Auch nach einem Größer-als-Zeichen (>), wenn Sie ein Attribut angeben. Sie müssen jedoch ein Zeilenfortsetzungszeichen (_) einschließen, wenn Sie Attribute auf Assembly- oder Modulebene angeben. Zum Beispiel:
```
<
Serializable()
>
Public Class Customer
    Public Property Name As String
    Public Property Company As String
    Public Property Email As String
End Class
```
Weitere Informationen finden Sie in der Übersicht über Attribute.
Vor und nach Abfrageoperatoren (Aggregate, Distinct, From, Group By, Group Join, Join, Let, Order By, Select, Skip, Skip While, Take, Take While, Where, In, Into, On, Ascending, Descending). Sie können die Zeile nicht zwischen den Schlüsselwörtern von Abfrageoperatoren umbrechen, die aus mehreren Schlüsselwörtern bestehen (Order By, Group Join, Take While und Skip While). Zum Beispiel:
```
Dim vsProcesses = From proc In
                    Process.GetProcesses
                  Where proc.MainWindowTitle.Contains("Visual Studio")
                  Select proc.ProcessName, proc.Id,
                         proc.MainWindowTitle
```
Weitere Informationen finden Sie unter Abfragen.

Nach dem Schlüsselwort In in einer For Each-Anweisung. Zum Beispiel:

For Each p In
  vsProcesses

    Console.WriteLine("{0}" & vbTab & "{1}" & vbTab & "{2}",
      p.ProcessName,
      p.Id,
      p.MainWindowTitle)
Next

Weitere Informationen finden Sie unter For Each...Next-Anweisung.

Nach dem Schlüsselwort From in einem Auflistungsinitialisierer. Zum Beispiel:
```
Dim days = New List(Of String) From
  {
   "Mo", "Tu", "We", "Th", "F", "Sa", "Su"
  }
```
Weitere Informationen finden Sie unter Auflistungsinitialisierer.

Hinzufügen von Kommentaren

Der Quellcode ist nicht immer selbsterklärend, selbst für den/die Programmierer*in, der bzw. die ihn geschrieben hat. Um den Code zu dokumentieren, verwenden die meisten Programmierer*innen daher eingebettete Kommentare. Kommentare im Code können eine Prozedur oder eine bestimmte Anweisung für Personen erläutern, die sie später lesen oder damit arbeiten. Visual Basic ignoriert Kommentare während der Kompilierung, und sie haben keinen Einfluss auf den kompilierten Code.

Kommentarzeilen beginnen mit einem Apostroph (') oder REM gefolgt von einem Leerzeichen. Sie können an einer beliebigen Stelle im Code hinzugefügt werden, außer innerhalb einer Zeichenfolge. Um einen Kommentar an eine Anweisung anzufügen, fügen Sie einen Apostroph oder REM nach der Anweisung ein, gefolgt von dem Kommentar. Kommentare können auch in einer eigenen separaten Zeile geschrieben werden. Diese Möglichkeiten werden im folgenden Beispiel dargestellt.

' This is a comment on a separate code line.
REM This is another comment on a separate code line.
x += a(i) * b(i) ' Add this amount to total.
MsgBox(statusMessage) REM Inform operator of status.

Überprüfen von Kompilierungsfehlern

Wenn die Zeile nach der Eingabe einer Codezeile mit einer wellenförmigen blauen Unterstreichung angezeigt wird (möglicherweise wird auch eine Fehlermeldung angezeigt), liegt ein Syntaxfehler in der Anweisung vor. Sie müssen herausfinden, welches Problem mit der Anweisung aufgetreten ist (indem Sie in der Aufgabenliste nachsehen oder mit dem Mauszeiger auf den Fehler zeigen und die Fehlermeldung lesen), und es korrigieren. Bis Sie alle Syntaxfehler im Code behoben haben, kann das Programm nicht ordnungsgemäß kompiliert werden.

Begriff	Definition
Zuweisungsoperatoren	Stellt Links zu Sprachreferenzseiten bereit, die Zuweisungsoperatoren wie `=`, `*=` und `&=` behandeln.
Operatoren und Ausdrücke	Zeigt, wie Elemente mit Operatoren kombiniert werden, um neue Werte zu erhalten.
Vorgehensweise: Umbrechen und Zusammenfassen von Anweisungen in Code	Zeigt, wie eine einzelne Anweisung in mehrere Zeilen aufgeteilt wird und wie mehrere Anweisungen in derselben Zeile platziert werden.
Vorgehensweise: Label-Anweisungen	Zeigt, wie eine Codezeile beschriftet wird.

Freigeben über

Anweisungen in Visual Basic

Deklarationsanweisungen

Anfängliche Werte

Ausführbare Anweisungen

Zuweisungsanweisungen

Geeignete Programmierelemente

Datentypen in Zuweisungsanweisungen

Verbundzuweisungsanweisungen

Typkonvertierungen in Zuordnungsanweisungen

Platzieren mehrerer Anweisungen in einer Zeile

Fortsetzen einer Anweisung über mehrere Zeilen

Implizite Zeilenfortsetzung

Hinzufügen von Kommentaren

Überprüfen von Kompilierungsfehlern

Zusätzliche Ressourcen

Freigeben über

Anweisungen in Visual Basic

Deklarationsanweisungen

Anfängliche Werte

Ausführbare Anweisungen

Zuweisungsanweisungen

Geeignete Programmierelemente

Datentypen in Zuweisungsanweisungen

Verbundzuweisungsanweisungen

Typkonvertierungen in Zuordnungsanweisungen

Platzieren mehrerer Anweisungen in einer Zeile

Fortsetzen einer Anweisung über mehrere Zeilen

Implizite Zeilenfortsetzung

Hinzufügen von Kommentaren

Überprüfen von Kompilierungsfehlern

Verwandte Abschnitte

Zusätzliche Ressourcen