MSDN Documentation

Variables in Visual Basic .NET

Variables are fundamental building blocks in any programming language, and Visual Basic .NET is no exception. They are symbolic names given to memory locations that store values. These values can be changed during program execution, hence the term 'variable'. Understanding how to declare, initialize, and use variables is crucial for writing effective VB.NET code.

Declaring Variables

Before you can use a variable, you must declare it. Variable declaration tells the compiler the variable's name and the type of data it will hold. The basic syntax for declaring a variable is:

Dim variableName As DataType

• Dim: This keyword is used to declare a variable.
• variableName: This is the name you give to your variable. It must follow naming conventions (e.g., start with a letter, contain letters, numbers, and underscores, not be a reserved keyword).
• As: This keyword separates the variable name from its data type.
• DataType: This specifies the type of data the variable can store, such as Integer, String, Boolean, Double, etc.

Data Types

Choosing the correct data type is important for memory efficiency and preventing errors. Common VB.NET data types include:

• Numeric Types:
  • Byte: 8-bit unsigned integer (0 to 255).
  • Short: 16-bit signed integer (-32,768 to 32,767).
  • Integer: 32-bit signed integer (-2,147,483,648 to 2,147,483,647).
  • Long: 64-bit signed integer.
  • Single: 32-bit floating-point number.
  • Double: 64-bit floating-point number.
  • Decimal: 128-bit decimal number, suitable for financial calculations.
• Character Types:
  • Char: A single Unicode character.
  • String: A sequence of Unicode characters.
• Boolean Type:
  • Boolean: Can hold only two values: True or False.
• Date and Time Types:
  • Date: Stores date and time values.

Initializing Variables

Initialization is the process of assigning an initial value to a variable. You can declare and initialize a variable in the same statement or in separate statements.

Declaration and Initialization in One Statement:

Dim message As String = "Hello, World!"
Dim count As Integer = 10
Dim isActive As Boolean = True

Separate Declaration and Initialization:

Dim price As Decimal
price = 19.99

Module Module1
    Sub Main()
        ' Declare and initialize a string variable
        Dim userName As String = "Alice"

        ' Declare and initialize an integer variable
        Dim age As Integer = 30

        ' Declare and initialize a double variable
        Dim salary As Double = 55000.75

        ' Declare a boolean variable and assign a value later
        Dim isEmployed As Boolean
        isEmployed = True

        ' Display the values
        Console.WriteLine("User Name: " & userName)
        Console.WriteLine("Age: " & age.ToString()) ' Convert to string for display
        Console.WriteLine("Salary: " & salary.ToString("C")) ' Format as currency
        Console.WriteLine("Is Employed: " & isEmployed.ToString())

        ' Modify a variable
        age = age + 1
        Console.WriteLine("Next Year's Age: " & age.ToString())
    End Sub
End Module

Scope of Variables

The scope of a variable refers to the region of your program where the variable can be accessed. Common scopes include:

• Local Variables: Declared within a procedure or block. They exist only while the procedure is executing.
• Member Variables (Fields): Declared within a class or structure but outside any procedure. They are accessible by any procedure within that class or structure.
• Module Variables: Declared at the module level but outside any procedure. They are accessible from anywhere within the module.

Variable Naming Conventions

Consistent and meaningful variable names improve code readability. General guidelines:

• Start with a letter.
• Can contain letters, numbers, and underscores.
• Avoid using reserved keywords.
• Use descriptive names (e.g., customerName instead of cn).
• Camel casing is common (e.g., firstName, totalAmount).

Mastering variables is a key step in becoming proficient in Visual Basic .NET. They are the foundation upon which more complex programming concepts are built.