Basics of Visual Basic programming

Basics

In this part of the Visual Basic tutorial, we will cover basic programming concepts of the Visual Basic language. We introduce the very basic programs. We will work with variables, constants and basic data types. We will read and write to the console; we will mention variable interpolation.
The following is a simple Visual Basic program.

Option Strict On

Module Example

    Sub Main()

        Console.WriteLine("This is Visual Basic")

    End Sub

End Module 

We will explain the program line by line.

Option Strict On

Option Strict statement can be either On or Off. The default is Off, for backward compatibility with Older Visual Basic programs. This statement is recommended in all your new programs. When the statement is On, the compiler will detect various bad programming practices.

Module Example
    ...
End Module 

Each Visual Basic program should be properly structured. The source code is placed into modules. Within modules, the code is further divided into procedures and functions. A properly structured module is easier to maintain and is less error prone. In our case, we create a module called Example. For this, we use the Module keyword. A module definition is ended with the End Module statement.

Sub Main()
    ...
End Sub

With a Sub keyword, we create a procedure. Sub is derived from the subroutine word. Subroutines and procedures are synonyms. In Visual Basic, the preferred word is the procedure. A procedure is a block of Visual Basic code. This is to achieve modularity of the code.

Console.WriteLine("This is Visual Basic")

In this code line, we print the "This is Visual Basic" string literal to the console. To print a message to the console, we use the WriteLine() method of the Console class. It represents the standard input, output, and error streams for console applications.

$ ./simple.exe 
This is Visual Basic

Executing the program gives the above output.

---

We can use a Console class to read values as well.

Option Strict On

Module Example

    Dim name As String

    Sub Main()

        Console.WriteLine("Enter your name: ")
        name = Console.ReadLine()
        Console.WriteLine("Hello {0}", name)

    End Sub

End Module 

The second program will read a value from a console and print it.

Dim name As String

The Dim keyword is used to declare a variable. The variable is called 'name'. Unlike constants, which store only one value during the life of the program, variables may store various different values. The Askeyword defines the data type of the variable. Our variable will hold string values.

name = Console.ReadLine()

We read a line from the terminal. When we hit the Enter, the string is assigned to the name variable.

Console.WriteLine("Hello {0}", name)

In this code line, we perform variable interpolation. Variable interpolationis replacing variables with their values inside string literals. Another names for variable interpolation are: variable substitution and variable expansion.

$ ./readline.exe 
Enter your name: 
Jan
Hello Jan

This is the output of the second program.

Command line arguments

Visual Basic programs can receive command line arguments. There are several ways to retrieve arguments from the command line.

Option Strict On

Module Example

    Dim cline As String

    Sub Main()

        cline = Command()
        Console.WriteLine(cline)

    End Sub

End Module 

In the above program, we get the command line arguments and print them to the terminal.

cline = Command()

The Command() function is used to get the arguments.

Console.WriteLine(cline)

We print the command line arguments to the terminal.

$ ./commandargs.exe 1 2 3
/home/vronskij/programming/basic/basics/commandargs.exe 1 2 3

We execute the program followed by three numbers. The program prints the numbers as well as the program name. Program name is the first command line argument.
In Visual Basic 2008 Express Edition, select project properties. In the Debug tab, there is a text area for specifying the command line arguments.

Figure: Command line arguments

---

Option Strict On

Module Example

    Dim size As Integer

    Sub Main(ByVal cmdArgs() As String)

        size = cmdArgs.Length
        
        If size > 0 Then
            For i As Integer = 0 To size - 1
                Console.WriteLine(cmdArgs(i))
            Next
        End If

    End Sub

End Module 

Command line arguments can be passed to the Main procedure.

Sub Main(ByVal cmdArgs() As String)

This Main() procedure receives a string array of command line arguments.

size = cmdArgs.Length

We determine the size of the array.

If size > 0 Then
    For i As Byte = 0 To size - 1
        Console.WriteLine(cmdArgs(i))
    Next
End If

We go through the array and print all arguments to the console. Note that in this case, the name of the program is not included among the arguments.

$ ./cmdargs.exe 2 3 5
2
3
5

We provide three numbers as command line arguments and these are printed to the console.

Variables and Constants

A variable is a place to store data. A variable has a name and a data type. A data type determines, what values can be assigned to the variable. Integers, strings, boolean values etc. Over the time of the program, variables can obtain various values of the same data type. Variables are always initialized to the default value of their type before any reference to the variable can be made. Variables are declared with the Dimkeyword. Unlike variables, constants retain their values. Once initialized, they cannot be modified. Constants are created with the Const keyword.

Option Strict On

Module Example

    Sub Main()
    
        Dim city As String = "New York"

        Dim name As String = "Paul", age As Integer = 35, _
            nationality As String = "American"

        Console.WriteLine(city)
        Console.WriteLine(name)
        Console.WriteLine(age)
        Console.WriteLine(nationality)
        
        city = "London"
        Console.WriteLine(city)

    End Sub

End Module

In the above example, we work with four variables.

Dim city As String = "New York"

We declare a city variable of the String type and initialize it to the "New York" value.

Dim name As String = "Paul", age As Integer = 35, _
    nationality As String = "American"

We can declare and initialize more variables with one Dim keyword; they are separated with a comma character.

Console.WriteLine(city)
Console.WriteLine(name)
Console.WriteLine(age)
Console.WriteLine(nationality)

We print the values of the variables to the terminal.

city = "London"

We assign a new value to the city variable.

---

As we already said above, constants cannot change their initial values.

Option Strict On

Module Example

    Sub Main()
        
        Const WIDTH As Integer = 100
        Const HEIGHT As Integer = 150
        Dim var As Integer = 40

        var = 50

        Rem WIDTH = 110

    End Sub

End Module

In this example, we declare two constants and one variable.

Const WIDTH As Integer = 100
Const HEIGHT As Integer = 150

We use the Const keyword to inform the compiler, that we declare a constant. It is a convention to write constants in upper case letters.

Dim var As Integer = 40

var = 50

We declare and initialize a variable. Later, we assign a new value to the variable.

Rem WIDTH = 110

This is not possible with a constant. If we uncomment this line, we will get a compilation error.

Variable interpolation

Variable interpolation is replacing variables with their values inside string literals. Another names for variable interpolation are: variable substitution and variable expansion.

Option Strict On

Module Example
    
    Dim age As Byte = 34
    Dim name As String = "William"
    Dim output As String

    Sub Main()
        
        output = String.Format("{0} is {1} years old.", _
            name, age)
       
        Console.WriteLine(output)

    End Sub

End Module

In Visual Basic, strings are immutable. We cannot modify an existing string. Variable interpolation happens during string creation.

Dim age As Byte = 34
Dim name As String = "William"
Dim output As String

Here we declare three variables.

output = String.Format("{0} is {1} years old.", _
    name, age)

We use the Format() method of the built-in String module. The {0}, {1} are the places, where the variables are evaluated. The numbers represent the position of the variable. {0} evaluates to the first supplied variable, {1} to the second etc.

$ ./interpolation.exe 
William is 34 years old.

Output.
This chapter covered some basics of the Visual Basic language.