Dim-Anweisung (Visual Basic)

Deklariert Speicherplatz für eine oder mehrere Variablen und ordnet ihn zu.

Syntax

[ <attributelist> ] [ accessmodifier ] [[ Shared ] [ Shadows ] | [ Static ]] [ ReadOnly ]
Dim [ WithEvents ] variablelist

Bestandteile

• attributelist

  Optional. Siehe Attributliste.

• accessmodifier

  Optional. Dabei kann es sich um eine der folgenden Methoden handeln:

  • Public

  • Protected

  • Friend

  • Privat

  • Protected Friend

  • Private Protected

  Siehe Access levels in Visual Basic.

• Shared

  Optional. Siehe Shared.

• Shadows

  Optional. Siehe Shadows.

• Static

  Optional. Siehe Static.

• ReadOnly

  Optional. Siehe ReadOnly.

• WithEvents

  Optional. Gibt an, dass es sich um Objektvariablen handelt, die auf Instanzen einer Klasse verweisen, die Ereignisse auslösen können. Siehe WithEvents.

• variablelist

  Erforderlich. Liste der Variablen, die in dieser Anweisung deklariert werden.

  variable [ , variable ... ]

  Jede variable weist folgende Syntax und Bestandteile auf:

  variablename [ ( [ boundslist ] ) ] [ As [ New ] datatype [ With{[ .propertyname = propinitializer [ , ... ] ] } ] ] [ = initializer ]

  Teil	Beschreibung
  variablename	Erforderlich. Name der Variable. Siehe Declared Element Names.
  boundslist	Optional. Liste der Begrenzungen der einzelnen Dimensionen einer Arrayvariablen.
  New	Optional. Erstellt eine neue Instanz der Klasse, wenn die Dim-Anweisung ausgeführt wird.
  datatype	Optional. Datentyp der Variable.
  With	Optional. Führt die Objektinitialisiererliste ein.
  propertyname	Optional. Name einer Eigenschaft in der Klasse, von der Sie eine Instanz erstellen.
  propinitializer	Erforderlich nach propertyname =. Ausdruck, der ausgewertet und dem Eigenschaftennamen zugewiesen wird.
  initializer	Optional, wenn New nicht angegeben ist. Ausdruck, der ausgewertet und der Variablen zugewiesen wird, wenn sie erstellt wird.

Bemerkungen

Der Visual Basic-Compiler verwendet die Dim-Anweisung, um den Datentyp der Variablen und andere Informationen zu bestimmen (z. B. welcher Code auf die Variable zugreifen kann). Im folgenden Beispiel wird eine Variable zum Speichern eines Integer-Werts deklariert.

Dim numberOfStudents As Integer

Sie können einen beliebigen Datentyp oder den Namen einer Enumeration, Struktur, Klasse oder Schnittstelle angeben.

Dim finished As Boolean
Dim monitorBox As System.Windows.Forms.Form

Für einen Verweistyp verwenden Sie das Schlüsselwort New, um eine neue Instanz der vom Datentyp angegebenen Klasse oder Struktur zu erstellen. Bei der Verwendung von New verwenden Sie keinen Initialisiererausdruck. Stattdessen übergeben Sie (sofern erforderlich) Argumente an den Konstruktor der Klasse an, aus der Sie die Variable erstellen.

Dim bottomLabel As New System.Windows.Forms.Label

Sie können eine Variable in einer Prozedur, einem Block, einer Klasse, einer Struktur oder einem Modul deklarieren. Sie können eine Variable nicht in einer Quelldatei, einem Namespace oder einer Schnittstelle deklarieren. Weitere Informationen finden Sie unter Deklarationskontexte und Standardzugriffsebenen.

Eine Variable, die auf Modulebene außerhalb einer Prozedur deklariert wird, ist eine Membervariable oder ein Feld. Innerhalb ihrer Klasse, ihrer Struktur oder ihrem Modul befinden sich Membervariablen im Gültigkeitsbereich. Eine auf Prozedurebene deklarierte Variable ist eine lokale Variable. Lokale Variablen sind nur innerhalb ihrer Prozedur oder ihres Blocks im Gültigkeitsbereich.

Die folgenden Zugriffsmodifizierer werden verwendet, um Variablen außerhalb einer Prozedur zu deklarieren: Public, Protected, Friend, Protected Friend und Private. Weitere Informationen finden Sie unter Zugriffsebenen in Visual Basic.

Das Schlüsselwort Dim ist optional und wird in der Regel weggelassen, wenn Sie einen der folgenden Modifizierer angeben: Public, Protected, Friend, Protected Friend, Private, Shared, Shadows, Static, ReadOnly oder WithEvents.

Public maximumAllowed As Double
Protected Friend currentUserName As String
Private salary As Decimal
Static runningTotal As Integer

Wenn Option Explicit aktiviert ist (Standardeinstellung), erfordert der Compiler eine Deklaration für jede von Ihnen verwendete Variable. Weitere Informationen finden Sie unter Option Explicit-Anweisung.

Angeben eines Anfangswerts

Sie können einer Variablen bei ihrer Erstellung einen Wert zuweisen. Für einen Werttyp verwenden Sie einen Initialisierer, um einen Ausdruck anzugeben, der der Variablen zugewiesen werden soll. Der Ausdruck muss zu einer Konstanten ausgewertet werden, die zur Kompilierzeit berechnet werden kann.

Dim quantity As Integer = 10
Dim message As String = "Just started"

Wenn ein Initialisierer, aber kein Datentyp in einer As-Klausel angegeben ist, wird der Typrückschluss verwendet, um den Datentyp aus dem Initialisierer abzuleiten. Im folgenden Beispiel sind sowohl num1 als auch num2 stark typisiert als „integer“ (ganze Zahl). In der zweiten Deklaration leitet der Typrückschluss den Typ vom Wert 3 ab.

' Use explicit typing.
Dim num1 As Integer = 3

' Use local type inference.
Dim num2 = 3

Der Typrückschluss wird auf der Prozedurebene angewendet. Er findet nicht außerhalb einer Prozedur in einer Klasse, einer Struktur, einem Modul oder einer Schnittstelle statt. Weitere Informationen zum Typrückschluss finden Sie unter Option Infer-Anweisung und Lokaler Typrückschluss.

Informationen dazu, was passiert, wenn kein Datentyp oder Initialisierer angegeben wird, finden Sie weiter unten in diesem Thema unter Standarddatentypen und -werte.

Sie können einen Objektinitialisierer verwenden, um Instanzen von benannten und anonymen Typen zu deklarieren. Der folgende Code erstellt eine Instanz einer Student-Klasse und verwendet einen Objektinitialisierer, um Eigenschaften zu initialisieren.

Dim student1 As New Student With {.First = "Michael",
                                  .Last = "Tucker"}

Weitere Informationen zu Objektinitialisierern finden Sie unter Gewusst wie: Deklarieren eines Objekts mithilfe eines Objektinitialisierers, Objektinitialisierer: Benannte und anonyme Typen und Anonyme Typen.

Deklarieren mehrerer Variablen

Sie können mehrere Variablen in einer Deklarationsanweisung deklarieren, indem Sie den Variablennamen für jede Variable und nach jedem Arraynamen Klammern angeben. Mehrere Variablen werden durch Kommas voneinander getrennt.

Dim lastTime, nextTime, allTimes() As Date

Wenn Sie mehr als eine Variable mit einer As-Klausel deklarieren, können Sie keinen Initialisierer für diese Gruppe von Variablen angeben.

Sie können unterschiedliche Datentypen für verschiedene Variablen angeben, indem Sie eine separate As-Klausel für jede deklarierte Variable verwenden. Jede Variable verwendet den Datentyp, der in der ersten As-Klausel nach dem zugehörigen Teil variablename angegeben ist.

Dim a, b, c As Single, x, y As Double, i As Integer
' a, b, and c are all Single; x and y are both Double

Arrays

Sie können eine Variable zum Speichern eines Arrays deklarieren, das mehrere Werte enthalten kann. Um anzugeben, dass eine Variable ein Array enthält, fügen Sie direkt nach dem variablename Klammern hinzu. Weitere Informationen zu Arrays finden Sie unter Arrays.

Sie können die Unter- und Obergrenze jeder Dimension eines Arrays angeben. Dazu fügen Sie in den Klammern eine boundslist hinzu. Die boundslist gibt für jede Dimension die Obergrenze und optional die Untergrenze an. Die Untergrenze ist immer Null, unabhängig davon, ob Sie sie angeben oder nicht. Jeder Index kann zwischen Null und der jeweiligen Obergrenze variieren.

Die folgenden beiden Anweisungen sind gleichwertig. Jede Anweisung deklariert ein Array von 21 Integer-Elementen. Wenn Sie auf das Array zugreifen, kann der Index von 0 bis 20 variieren.

Dim totals(20) As Integer
Dim totals(0 To 20) As Integer

Die folgende Anweisung deklariert ein zweidimensionales Array vom Typ Double. Das Array verfügt über vier Zeilen (3 + 1) mit jeweils sechs Spalten (5 + 1). Beachten Sie, dass eine Obergrenze den höchsten möglichen Wert für den Index darstellt, nicht die Länge der Dimension. Die Länge der Dimension ist die Obergrenze plus 1.

Dim matrix2(3, 5) As Double

Ein Array kann zwischen 1 und 32 Dimensionen aufweisen.

Sie können alle Begrenzungen in einer Arraydeklaration leer lassen. In diesem Fall verfügt das Array über die von Ihnen angegebene Anzahl von Dimensionen, wird jedoch nicht initialisiert. Es hat den Wert Nothing, bis Sie mindestens einige der Elemente initialisieren. Die Dim-Anweisung muss entweder für alle oder für keine Dimensionen Grenzwerte angeben.

' Declare an array with blank array bounds.
Dim messages() As String
' Initialize the array.
ReDim messages(4)

Wenn das Array mehr als eine Dimension aufweist, müssen Sie Kommas zwischen den Klammern einfügen, um die Anzahl von Dimensionen anzugeben.

Dim oneDimension(), twoDimensions(,), threeDimensions(,,) As Byte

Sie können ein Array der Länge 0 (Null) deklarieren, indem Sie eine der Dimensionen des Arrays als -1 deklarieren. Eine Variable mit einem Array der Länge 0 weist nicht den Wert Nothing auf. Arrays mit der Länge 0 sind für bestimmte Funktionen der Common Language Runtime (CLR) erforderlich. Wenn Sie versuchen, auf ein solches Array zuzugreifen, tritt eine Laufzeitausnahme auf. Weitere Informationen finden Sie unter Arrays.

Sie können die Werte eines Arrays initialisieren, indem Sie ein Arrayliteral verwenden. Umschließen Sie dazu die Initialisierungswerte mit geschweiften Klammern ({}).

Dim longArray() As Long = {0, 1, 2, 3}

Bei mehrdimensionalen Arrays wird die Initialisierung für die einzelnen separaten Dimensionen in geschweiften Klammern in der äußeren Dimension eingeschlossen. Die Elemente werden in zeilengerichteter Reihenfolge angegeben.

Dim twoDimensions(,) As Integer = {{0, 1, 2}, {10, 11, 12}}

Weitere Informationen zu Arrayliteralen finden Sie unter Arrays.

Standarddatentypen und -werte

Die folgende Tabelle beschreibt die Ergebnisse der verschiedenen Kombinationen der Spezifizierung von Datentyp und Initialisierung in einer Dim-Anweisung.

Wenn Sie einen Datentyp, aber keinen Initialisierer angeben, initialisiert Visual Basic die Variable mit dem Standardwert für den jeweiligen Datentyp. In der folgenden Tabelle sind die Standardinitialisierungswerte aufgeführt.

Jedes Element einer Struktur wird wie eine separate Variable initialisiert. Wenn Sie die Länge eines Arrays deklarieren, seine Elemente aber nicht initialisieren, wird jedes Element wie eine separate Variable initialisiert.

Lebensdauer von statischen lokalen Variablen

Eine lokale Static-Variable hat eine längere Lebensdauer als die Prozedur, in der sie deklariert wird. Die Begrenzungen der Lebensdauer der Variablen hängen davon ab, wo die Prozedur deklariert wird und ob sie freigegeben (Shared) ist.

Attribute und Modifizierer

Attribute können nur auf Membervariablen angewendet werden, nicht auf lokale Variablen. Ein Attribut enthält ergänzende Informationen zu den Metadaten der Assembly, was für temporären Speicher wie lokale Variablen nicht sinnvoll ist.

Auf Modulebene können Sie den Static-Modifizierer nicht verwenden, um Membervariablen zu deklarieren. Auf Prozedurebene können Sie Shared, Shadows, ReadOnly, WithEvents oder Zugriffsmodifizierer nicht verwenden, um lokale Variablen zu deklarieren.

Sie können festlegen, welcher Code auf eine Variable zugreifen kann, indem Sie einen accessmodifier angeben. Klassen- und Modulmembervariablen (außerhalb einer Prozedur) sind standardmäßig auf privaten Zugriff festgelegt und Strukturmembervariablen standardmäßig auf öffentlichen Zugriff. Sie können ihre Zugriffsebenen mit den Zugriffsmodifizierern anpassen. Sie können keine Zugriffsmodifizierer für lokale Variablen (innerhalb einer Prozedur) verwenden.

Sie können WithEvents nur für Membervariablen angeben, nicht für lokale Variablen innerhalb einer Prozedur. Wenn Sie WithEvents angeben, muss der Datentyp der Variablen ein bestimmter Klassentyp sein, nicht Object. Sie können ein Array nicht mit WithEvents deklarieren. Weitere Informationen zu Ereignissen finden Sie unter Ereignisse.

Freigeben von verwalteten Ressourcen

Der .NET Framework-Garbage Collector (GC) gibt verwaltete Ressourcen ohne zusätzliche Codierung Ihrerseits frei. Sie können jedoch die Freigabe bzw. das Verwerfen einer verwalteten Ressource erzwingen, anstatt auf die Ausführung des Garbage Collectors zu warten.

Wenn eine Klasse eine besonders wertvolle und knappe Ressource (z. B. eine Datenbankverbindung oder ein Dateihandle) hält, möchten Sie mit der Bereinigung einer nicht mehr verwendeten Klasseninstanz möglicherweise nicht bis zur nächsten Ausführung der Garbage Collection warten. Eine Klasse kann die IDisposable-Schnittstelle implementieren, um eine Möglichkeit zum Freigeben von Ressourcen vor einer Garbage Collection bereitzustellen. Eine Klasse, die diese Schnittstelle implementiert, macht eine Dispose-Methode verfügbar, die aufgerufen werden kann, um die sofortige Freigabe wertvoller Ressourcen zu erzwingen.

Die Using-Anweisung automatisiert den Prozess des Abrufens einer Ressource, der Ausführung einer Reihe von Anweisungen und der anschließenden Freigabe der Ressource. Die Ressource muss jedoch die IDisposable-Schnittstelle implementieren. Weitere Informationen finden Sie unter using-Anweisung.

Beispiel 1

Im folgenden Beispiel werden Variablen mithilfe der Dim-Anweisung mit verschiedenen Optionen deklariert.

' Declare and initialize a Long variable.
Dim startingAmount As Long = 500

' Declare a local variable that always retains its value,
' even after its procedure returns to the calling code.
Static totalSales As Double

' Declare a variable that refers to an array.
Dim highTemperature(31) As Integer

' Declare and initialize an array variable that
' holds four Boolean check values.
Dim checkValues() As Boolean = {False, False, True, False}

Beispiel 2

Das folgende Beispiel listet die Primzahlen zwischen 1 und 30 auf. Der Bereich der lokalen Variablen wird in Codekommentaren beschrieben.

Public Sub ListPrimes()
    ' The sb variable can be accessed only
    ' within the ListPrimes procedure.
    Dim sb As New System.Text.StringBuilder()

    ' The number variable can be accessed only
    ' within the For...Next block.  A different
    ' variable with the same name could be declared
    ' outside of the For...Next block.
    For number As Integer = 1 To 30
        If CheckIfPrime(number) = True Then
            sb.Append(number.ToString & " ")
        End If
    Next

    Debug.WriteLine(sb.ToString)
    ' Output: 2 3 5 7 11 13 17 19 23 29
End Sub

Private Function CheckIfPrime(ByVal number As Integer) As Boolean
    If number < 2 Then
        Return False
    Else
        ' The root and highCheck variables can be accessed
        ' only within the Else block.  Different variables
        ' with the same names could be declared outside of
        ' the Else block.
        Dim root As Double = Math.Sqrt(number)
        Dim highCheck As Integer = Convert.ToInt32(Math.Truncate(root))

        ' The div variable can be accessed only within
        ' the For...Next block.
        For div As Integer = 2 To highCheck
            If number Mod div = 0 Then
                Return False
            End If
        Next

        Return True
    End If
End Function

Beispiel 3

Im folgenden Beispiel wird die speedValue-Variable auf der Klassenebene deklariert. Das Schlüsselwort Private wird verwendet, um die Variable zu deklarieren. Auf die Variable kann von jeder Prozedur in der Car-Klasse zugegriffen werden.

' Create a new instance of a Car.
Dim theCar As New Car()
theCar.Accelerate(30)
theCar.Accelerate(20)
theCar.Accelerate(-5)

Debug.WriteLine(theCar.Speed.ToString)
' Output: 45

Public Class Car
    ' The speedValue variable can be accessed by
    ' any procedure in the Car class.
    Private speedValue As Integer = 0

    Public ReadOnly Property Speed() As Integer
        Get
            Return speedValue
        End Get
    End Property

    Public Sub Accelerate(ByVal speedIncrease As Integer)
        speedValue += speedIncrease
    End Sub
End Class

Weitere Informationen

• Const-Anweisung
• ReDim-Anweisung
• Option Explicit-Anweisung
• Option Infer-Anweisung
• Option Strict-Anweisung
• Seite „Kompilieren“, Projekt-Designer (Visual Basic)
• Variablendeklaration
• Arrays
• Objektinitialisierer: benannte und anonyme Typen
• Anonyme Typen
• Objektinitialisierer: benannte und anonyme Typen
• Vorgehensweise: Deklarieren eines Objekts mithilfe eines Objektinitialisierers
• Lokaler Typrückschluss