.VB File Format – Types and variables

The primitive types

The names of the types are keywords and are not case-sensitive. Variant is still reserved but is not a type; Object replaces it.

Declaring variables

A local variable is declared with Dim (or Static, Const, and Using or For for loop-scoped ones). The type follows As; without it the type is inferred from the initialiser (Option Infer) or is Object. In a list, each name takes the type of the As that follows it, so Dim c, d As Long makes both Long. As New T(args) creates the object in the declaration. A local is in scope from its declaration to the end of its block, and a name cannot be declared again in a nested block.

Dim a As Integer = 1, b As Integer = 2
Dim c, d As Long                    ' both Long
Dim e = 10                          ' inferred Integer
Dim f As New List(Of String)        ' constructor call
Dim h? As Integer = Nothing         ' nullable
Dim i As Integer? = 5
Static calls As Integer             ' keeps its value between calls
calls += 1
Const Pi As Double = 3.14159        ' a constant (also allowed at module and class level)

At type level a variable is a field: Private, Public, Protected, Friend, Protected Friend or Private Protected (version 15.5), optionally Shared (one per type), ReadOnly (assigned in the declaration or a constructor), WithEvents (see events) or Const. Dim at type level means Private in a class or module and Public in a structure; a field has an initialiser that runs when the object or type is created.

Nullable types, arrays and tuples

• Nullable value types: Integer? (or Nullable(Of Integer)) is an Integer that can also be Nothing. Arithmetic on a nullable gives a nullable (null propagates), and If(x, default) takes a default for Nothing. The question mark may also follow the name: Dim h? As Integer.
• Arrays: Dim nums(9) As Integer declares an array with the upper bound 9, so ten elements, indexed from 0. Dim grid(2, 3) As Double is rectangular (3 by 4); Dim jagged()() As Integer is an array of arrays. New Integer() {1, 2} or the array literal {1, 2} creates one with values (the literal takes the dominant element type). ReDim changes the size (ReDim Preserve keeps the contents of the last dimension) and Erase clears.
• Tuples (version 15): Dim t As (Integer, String) = (1, "one"); elements can be named, (Id:=7, Label:="seven"), and read as t.Item1 or by name. The type is ValueTuple.

Dim nums(9) As Integer              ' ten elements, 0 to 9
Dim grid(2, 3) As Double            ' 3 by 4
Dim jagged()() As Integer = New Integer(1)() {}
Dim lit = {1, 2, 3}                 ' array literal: Integer()
Dim names As String() = {"a", "b"}
ReDim Preserve nums(19)
Dim t As (Integer, String) = (1, "one")
Dim named = (Id:=7, Label:="seven")

Enumerations and structures

Enum Colour As Byte                 ' the underlying type (default Integer)
    Red = 1
    Green                           ' 2
    Blue = 10
End Enum

<Flags>
Enum Access
    None = 0
    Read = 1
    Write = 2
    All = Read Or Write
End Enum

Structure Point
    Public X As Integer
    Public Y As Integer
    Public Sub New(x As Integer, y As Integer)
        Me.X = x
        Me.Y = y
    End Sub
End Structure

An enumeration has an integral underlying type, members with constant values (each is the previous plus one unless given) and no methods. A structure is a value type that can hold fields, properties, methods, events and constructors, implement interfaces, and cannot inherit (see classes).

Conversions

A widening conversion cannot lose information (Integer to Long, a class to its base class) and is implicit. A narrowing conversion can fail or lose data (Long to Integer, Object to anything, a base to a derived class); it is implicit only with Option Strict Off, and otherwise needs a conversion operator:

Dim n As Integer = CInt(3.7)        ' rounds to 4
Dim s As String = CStr(n)
Dim o As Object = n
Dim back = DirectCast(o, Integer)
Dim m = TryCast(o, String)          ' Nothing: o is not a String

Not described

Known, not yet covered

• Reference: the tables of which conversion is widening and which narrowing between each pair of primitive types, the dominant-type rules, the exact rounding of every C… operator and conversions through user-defined operators are in the conversions chapter of the specification and are not tabulated here.
• Reference: the CLS and size details of the types (Decimal layout, Date as ticks) are given only in outline.

See also

• Operators and expressions – arithmetic, comparison and conversion in expressions
• Generics, lambdas and delegates – type parameters and delegate types