Variable Declaration in VB.Net

The Dim statement is used for variable declaration and storage allocation for one or more variables. The Dim statement is used at module, class, structure, procedure or block level.

Syntax for variable declaration in VB.Net is:

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


  • attributelist is a list of attributes that apply to the variable. Optional.

  • accessmodifier defines the access levels of the variables, it has values as - Public, Protected, Friend, Protected Friend and Private. Optional.

  • Shared declares a shared variable, which is not associated with any specific instance of a class or structure, rather available to all the instances of the class or structure. Optional.

  • Shadows indicate that the variable re-declares and hides an identically named element, or set of overloaded elements, in a base class. Optional.

  • Static indicates that the variable will retain its value, even when the after termination of the procedure in which it is declared. Optional.

  • ReadOnly means the variable can be read, but not written. Optional.

  • WithEvents specifies that the variable is used to respond to events raised by the instance assigned to the variable. Optional.

  • Variablelist provides the list of variables declared.

Each variable in the variable list has the following syntax and parts:

variablename[ ( [ boundslist ] ) ] [ As [ New ] datatype ] [ = initializer ]


  • variablename: is the name of the variable

  • boundslist: optional. It provides list of bounds of each dimension of an array variable.

  • New: optional. It creates a new instance of the class when the Dim statement runs.

  • datatype: Required if Option Strict is On. It specifies the data type of the variable.

  • initializer: Optional if New is not specified. Expression that is evaluated and assigned to the variable when it is created.

Some valid variable declarations along with their definition are shown here:

Dim StudentID As Integer
Dim StudentName As String
Dim Salary As Double
Dim count1, count2 As Integer
Dim status As Boolean
Dim exitButton As New System.Windows.Forms.Button
Dim lastTime, nextTime As Date

Variable Initialization in VB.Net

Variables are initialized (assigned a value) with an equal sign followed by a constant expression. The general form of initialization is:

variable_name = value;

for example,

Dim pi As Double
pi = 3.14159

You can initialize a variable at the time of declaration as follows:

Dim StudentID As Integer = 100
Dim StudentName As String = "Bill Smith"


Try the following example which makes use of various types of variables:

Module variablesNdataypes
   Sub Main()
      Dim a As Short
      Dim b As Integer
      Dim c As Double
      a = 10
      b = 20
      c = a + b
      Console.WriteLine("a = {0}, b = {1}, c = {2}", a, b, c)
   End Sub
End Module

When the above code is compiled and executed, it produces the following result:

a = 10, b = 20, c = 30

Accepting Values from User

The Console class in the System namespace provides a function ReadLine for accepting input from the user and store it into a variable. For example,

Dim message As String
message = Console.ReadLine

The following example demonstrates it:

Module variablesNdataypes
   Sub Main()
      Dim message As String
      Console.Write("Enter message: ")
      message = Console.ReadLine
      Console.WriteLine("Your Message: {0}", message)
   End Sub
End Module

When the above code is compiled and executed, it produces the following result (assume the user inputs Hello World):

Enter message: Hello World   
Your Message: Hello World

Lvalues and Rvalues

There are two kinds of expressions:

  1. lvalue : An expression that is an lvalue may appear as either the left-hand or right-hand side of an assignment.

  2. rvalue : An expression that is an rvalue may appear on the right- but not left-hand side of an assignment.

Variables are lvalues and so may appear on the left-hand side of an assignment. Numeric literals are rvalues and so may not be assigned and can not appear on the left-hand side. Following is a valid statement:

Dim g As Integer = 20

But following is not a valid statement and would generate compile-time error:

20 = g

The constants refer to fixed values that the program may not alter during its execution. These fixed values are also called literals.

Constants can be of any of the basic data types like an integer constant, a floating constant, a character constant, or a string literal. There are also enumeration constants as well.

The constants are treated just like regular variables except that their values cannot be modified after their definition.

An enumeration is a set of named integer constants.

Declaring Constants

In VB.Net, constants are declared using the Const statement. The Const statement is used at module, class, structure, procedure, or block level for use in place of literal values.

The syntax for the Const statement is:

[ < attributelist> ] [ accessmodifier ] [ Shadows ] 
Const constantlist


  • attributelist: specifies the list of attributes applied to the constants; you can provide multiple attributes separated by commas. Optional.

  • accessmodifier: specifies which code can access these constants. Optional. Values can be either of the: Public, Protected, Friend, Protected Friend, or Private.

  • Shadows: this makes the constant hide a programming element of identical name in a base class. Optional.

  • Constantlist: gives the list of names of constants declared. Required.

Where, each constant name has the following syntax and parts:

constantname [ As datatype ] = initializer
  • constantname: specifies the name of the constant