Declaring variables

Declaring and assigning a variable using a primitive type

Variables in Visual Basic are declared using the Dim keyword. For example, this declares a new variable called counter with the data type Integer:

Dim counter As Integer

A variable declaration can also include an access modifier, such as Public, Protected, Friend, or Private. This works in conjunction with the variable’s scope to determine its accessibility.

|Access Modifier|Meaning |---|---|---|---|---|---|---|---|---|--- |Public|All types which can access the enclosing type |Protected|Only the enclosing class and those that inherit from it |Friend|All types in the same assembly that can access the enclosing type |Protected Friend|The enclosing class and its inheritors, or the types in the same assembly that can access the enclosing class |Private|Only the enclosing type |Static|Only on local variables and only initializes once.

As a shorthand, the Dim keyword can be replaced with the access modifier in the variable’s declaration:

Public TotalItems As Integer
Private counter As Integer

The supported data types are outlined in the table below:

|Type|Alias|Memory allocation|Example |---|---|---|---|---|---|---|---|---|--- |SByte|N/A|1 byte|Dim example As SByte = 10 |Int16|Short|2 bytes|Dim example As Short = 10 |Int32|Integer|4 bytes|Dim example As Integer = 10 |Int64|Long|8 bytes|Dim example As Long = 10 |Single|N/A|4 bytes|Dim example As Single = 10.95 |Double|N/A|8 bytes|Dim example As Double = 10.95 |Decimal|N/A|16 bytes|Dim example As Decimal = 10.95 |Boolean|N/A|Dictated by implementing platform|Dim example As Boolean = True |Char|N/A|2 Bytes|Dim example As Char = "A"C |String|N/A|source|Dim example As String = "Stack Overflow" |DateTime|Date|8 Bytes|Dim example As Date = Date.Now |Byte|N/A|1 byte|Dim example As Byte = 10 |UInt16|UShort|2 bytes|Dim example As UShort = 10 |UInt32|UInteger|4 bytes|Dim example As UInteger = 10 |UInt64|ULong|8 bytes|Dim example As ULong = 10 |Object|N/A|4 bytes 32 bit architecture, 8 bytes 64 bit architecture|Dim example As Object = Nothing

There also exist data identifier and literal type characters usable in replacement for the textual type and or to force literal type:

|Type (or Alias)|Identifier type character|Literal type character |---|---|---|---|---|---|---|---|---|--- |Short|N/A|example = 10S |Integer|Dim example%|example = 10% or example = 10I |Long|Dim example&|example = 10& or example = 10L |Single|Dim example!|example = 10! or example = 10F |Double|Dim example#|example = 10# or example = 10R |Decimal|Dim example@|example = 10@ or example = 10D |Char|N/A|example = "A"C |String|Dim example$|N/A |UShort|N/A|example = 10US |UInteger|N/A|example = 10UI |ULong|N/A|example = 10UL

The integral suffixes are also usable with hexadecimal (&H) or octal (&O) prefixes:
example = &H8000S or example = &O77&

Date(Time) objects can also be defined using literal syntax:
Dim example As Date = #7/26/2016 12:8 PM#

Once a variable is declared it will exist within the Scope of the containing type, Sub or Function declared, as an example:

Public Function IncrementCounter() As Integer
    Dim counter As Integer = 0
    counter += 1

    Return counter
End Function

The counter variable will only exist until the End Function and then will be out of scope. If this counter variable is needed outside of the function you will have to define it at class/structure or module level.

Public Class ExampleClass

    Private _counter As Integer

    Public Function IncrementCounter() As Integer
       _counter += 1
       Return _counter
    End Function

End Class

Alternatively, you can use the Static (not to be confused with Shared) modifier to allow a local variable to retain it’s value between calls of its enclosing method:

Function IncrementCounter() As Integer
    Static counter As Integer = 0
    counter += 1

    Return counter
End Function

Levels of declaration – Local and Member variables

Local variables - Those declared within a procedure (subroutine or function) of a class (or other structure). In this example, exampleLocalVariable is a local variable declared within ExampleFunction():

Public Class ExampleClass1

    Public Function ExampleFunction() As Integer
        Dim exampleLocalVariable As Integer = 3
        Return exampleLocalVariable
    End Function

End Class

The Static keyword allows a local variable to be retained and keep its value after termination (where usually, local variables cease to exist when the containing procedure terminates).

In this example, the console is 024. On each call to ExampleSub() from Main() the static variable retains the value it had at the end of the previous call:

Module Module1

    Sub Main()
        ExampleSub()
        ExampleSub()
        ExampleSub()
    End Sub

    Public Sub ExampleSub()
        Static exampleStaticLocalVariable As Integer = 0
        Console.Write(exampleStaticLocalVariable.ToString)
        exampleStaticLocalVariable += 2
    End Sub

End Module

Member variables - Declared outside of any procedure, at the class (or other structure) level. They may be instance variables, in which each instance of the containing class has its own distinct copy of that variable, or Shared variables, which exist as a single variable associated with the class itself, independent of any instance.

Here, ExampleClass2 contains two member variables. Each instance of the ExampleClass2 has an individual ExampleInstanceVariable which can be accessed via the class reference. The shared variable ExampleSharedVariable however is accessed using the class name:

Module Module1

    Sub Main()

        Dim instance1 As ExampleClass4 = New ExampleClass4
        instance1.ExampleInstanceVariable = "Foo"

        Dim instance2 As ExampleClass4 = New ExampleClass4
        instance2.ExampleInstanceVariable = "Bar"

        Console.WriteLine(instance1.ExampleInstanceVariable)
        Console.WriteLine(instance2.ExampleInstanceVariable)
        Console.WriteLine(ExampleClass4.ExampleSharedVariable)

    End Sub

    Public Class ExampleClass4

        Public ExampleInstanceVariable As String
        Public Shared ExampleSharedVariable As String = "FizzBuzz"

    End Class

End Module

Example of Access Modifiers

In the following example consider you have a solution hosting two projects: ConsoleApplication1 and SampleClassLibrary. The first project will have the classes SampleClass1 and SampleClass2. The second one will have SampleClass3 and SampleClass4. In other words we have two assemblies with two classes each. ConsoleApplication1 has a reference to SampleClassLibrary.

See how SampleClass1.MethodA interacts with other classes and methods.

SampleClass1.vb:

SampleClass2.vb:

SampleClass3.vb:

SampleClass4.vb:

Syntax

• Public counter As Integer
• Private _counter As Integer
• Dim counter As Integer