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 (opens new window), such as Public, Protected, Friend, or Private. This works in conjunction with the variable's scope (opens new window) to determine its accessibility.

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 (opens new window)	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:

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 (opens new window) 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

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

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