Although many different programming languages exist, all share some common features, including the following:

In this hour we look at Visual Basic’s syntax and semantics for storing and performing operations on data.

The name and data type of a variable are immutable. That is, after the variable’s name and type have been specified, they cannot change during the program’s execution. The variable’s value, on the other hand, is mutable, meaning that it can change over the course of the program’s execution.

Variables alter their value through assignment statements. An assignment statement assigns a value to a variable using the = operator and has the following form:

variableName = value

This statement assigns value to the value of the variable variableName.

To use a variable, you must first declare the variable using the Visual Basic Dim statement. When declaring a variable, you must provide both the name and data type of the variable; you may optionally specify the value. For example, to create a variable named Age that accepts values of type Integer, you would use the following Dim statement:

Dim age as Integer

More generally, the Dim statement has the following form:

Dim variableName as type

We’ll examine the Dim statement in much greater detail in the “Examining the Dim Statement” section. First, though, we need to look at the rules for naming variables, as well as the available variable types.

Each programming language imposes its own set of rules for naming variables. Variable names in Visual Basic can start with an alphabetic character or an underscore character and be followed by zero to many underscores, alphabetic characters, or numeric characters.

Some examples of valid variable names are

Some examples of invalid variable names are

When you’re naming your variables, it is important to choose names that make sense given the information the variable will store. For example, if you are going to use a variable to store the product of two numbers, you might want to name that variable Product, or some other descriptive name, rather than using something ambiguous, like x or variable3.

Recall that the data type of a variable dictates what type of value can be stored in the variable. For example, a variable of type Integer can store only values that are integers (negative and positive whole numbers).

If you have worked with ASP, ASP.NET’s predecessor, you’ve likely had experience with VBScript, a watered-down version of Visual Basic 6.0, which was the version of Visual Basic that predated Microsoft’s .NET platform. With VBScript, variables were loosely typed.

Loosely typed variables are variables that are declared without an explicit data type. Their type is inferred by their assigned value. In VBScript you could write code that looked like so:

1: Dim x
2: x = "Hello, World!"
3: x = 4

Note that the Dim statement on line 1 does not contain a type (that is, it does not read: Dim x as String). The type of x is dynamically inferred by the value assigned to it. Therefore, on line 2, when x is assigned the value “Hello, World!”, which is a string, x’s type is considered to be of type String. On line 3, however, x is assigned the value 4, which is an integer. After line 3, x’s type now is considered to be of type Integer.

The opposite of loosely typed is strongly typed. In strongly typed programming languages, all variables must be declared to be of a certain type. After a variable has been declared to be a certain type, it can be assigned only values that correspond to that type.

Visual Basic is a strongly typed language. Therefore, all variables must be given an explicit data type, and the set of values that can be assigned to a given variable is limited by the variable’s type.

Because each type has a predefined set of values that can be assigned, it is important to give your variable an appropriate data type. For example, in Hour 4, “Designing, Creating, and Testing ASP.NET Web Pages,” we looked at an ASP.NET web page that calculated the monthly cost of a home loan. The variables used to hold the intermediary computations were of type Decimal, which is a numeric type that stores numbers with decimal places. Had we chosen to use variables of type Integer, the calculation would have come out incorrectly. Consider the interest rate involved in the calculation, which might be 0.065 (for a 6.5% interest rate). Such a number cannot be expressed as an integer. Rather, we would have to use 0 or 1 (or some other whole number), which would clearly produce an incorrect answer. For this reason, using the correct type is important.

Let’s take a look at some of the most commonly used data types in Visual Basic.

Dim variableName as Integer

Dim variableName as Long

Dim variableName as Short

Dim variableName as Single

Dim variableName as Double

Dim variableName as Decimal

Dim variableName as Boolean

Dim variableName as String

Dim variableName as DateTime

Dim catchall as Object
catchall = "Jisun"
catchall = 4
catchall = 3.14159

As we discussed earlier, you must declare a variable before you can use it. In declaring a variable in a strongly typed programming language, you must provide its name and data type. In Visual Basic, this is accomplished using the Dim statement.

In its simplest form, the Dim statement specifies the variable’s name and type:

Dim variableName as type

To declare three variables of type Integer, you can use three separate Dim statements, such as:

Dim a as Integer
Dim b as Integer
Dim c as Integer

Or you can use one Dim statement, separating each variable name and type with a comma, such as

Dim a as Integer, b as Integer, c as Integer

You can also supply a comma-delimited list of variable names and just one type. In this instance, all the variable names appearing before the data type will share the same type. That is, you can declare three variables, a, b, and c, all to be of type Integer using the following syntax:

Dim a, b, c as Integer

Dim a as Integer
a = 6

Dim a as Integer = 6

Dim variableName as type = value

The four most frequently used arithmetic operators in Visual Basic are +, –, *, and /, which perform addition, subtraction, multiplication, and division, respectively. These operators are referred to as binary operators because they operate on two variables.

For example, the following code adds the Integer variables b and c and assigns the sum to a:

Dim a, b, c as Integer
b = 15
c = 20
a = b + c

The – operator can be used both as a binary operator and as a unary operator. A unary operator is an operator that operates on just one variable. When the – operator is used as a unary operator, it performs the negation of a number. Consider the following code:

Dim a, b, c as Integer
b = 15
c = 20
a = –(b + c)

Here, a would be assigned the value –35. The - operator is used as a unary operator on the expression b + c, thereby negating the value returned by b + c.

a = –(b + c)

a = –b + c

The / operator always returns a nonintegral numeric value, even if the resulting quotient does not have a remainder. That is, the value returned by 4 / 2 is the nonintegral numeric value 2.0, not the integer value 2. Of course the / operator can also have a quotient with a decimal remainder; for example, the value returned by 3 / 4 is 0.75.

Comparison operators are binary operators that compare the value of two variables. The six comparison operators are listed in Table 5.1. Comparison operators always return a Boolean value—True or False—depending on the operator and the value of the two variables being compared.

The following statements evaluate to True:

4 < 8
3.14159 >= 2
"Bob" <> "Sue"
(10/2) = (20/4)
4 <= 4

The following statements evaluate to False:

7 > 100
"Bob" = "Frank"
(10/2) = 7.5
4 < 4

The concatenation operator concatenates two string variables. Concatenating two strings produces a string that consists of the contents of the second string appended to the contents of the first. The string concatenation operator in Visual Basic is the ampersand, &.

Let’s look at a quick code snippet to see how the concatenation operator works. Consider the following code:

Dim FirstWord as String = "ASP.NET"
Dim SecondWord as String = "is"
Dim ThirdWord as String = "neat"

Dim Sentence as String
Sentence = FirstWord & " " & SecondWord & " " & ThirdWord & "."

The variable Sentence will end up with the value “ASP.NET is neat.” The first three string variables—FirstWord, SecondWord, and ThirdWord—are each declared and assigned the value. Next, the string variable Sentence is declared and is assigned the value of each of the three words concatenated together, with a space between each word and a period at the end.

To accomplish this, we use the & operator to join together six strings. First, the string FirstWord and “ ” are concatenated, resulting in the temporary string “ASP.NET “. I use the word temporary here because this string is immediately concatenated with SecondWord, resulting in “ASP.NET is”, which is then concatenated with “ ”, resulting in “ASP.NET is”. Next, this is concatenated with ThirdWord, giving “ASP.NET is neat”, and finally this is concatenated with “.”, resulting in “ASP.NET is neat.”, which is then assigned to the variable Sentence.

Dim Output as String
Output = "Hello, " & UserFirstName

Dim output as String
output = "Hello, UserFirstName"

The most common assignment operator is the = operator, which takes the form

variableName = value

For example, to assign the value 5 to an integer variable, we can use the following code:

Dim Age as Integer
Age = 5

The value assigned to a variable can be things more complex than simple values like 5. The value can be an expression involving other operators. For example, we might want to add two numbers and store their sum in a variable. To accomplish this, we could use code like

'Create three integer variables
Dim sum, number1, number2 as Integer
number1 = 15
number2 = 20

'Assign the sum of number1 and number2 to sum
sum = number1 + number2

Dim SomeIntegerVariable as Integer = 0

...
SomeIntegerVariable = SomeIntegerVariable + 1
...

SomeIntegerVariable = SomeIntegerVariable + 1

SomeIntegerVariable = SomeIntegerVariable + 1

variableName += value

SomeIntegerVariable = SomeIntegerVariable + 1

SomeIntegerVariable += 1

Casting is the process of changing the type of a variable or value from one type to another. There are two types of casting: implicit casting and explicit casting.

Implicit casting is casting that occurs without any needed intervention or instructions by the programmer. In the previous code snippet, implicit casting is utilized because the integer variable 5 is cast to a nonintegral representation of 5.0 without any extra code provided by us, the programmers.

Explicit casting, on the other hand, requires that we, the programmers, explicitly indicate that a cast from one type to another should occur. To explicitly cast a variable from one type to another, use Visual Basic’s built-in CType function, which has the following syntax:

CType(variableName, typeToCastTo)

The CType function casts the variable variableName from its current type to the type specified by typeToCastTo. The following code snippet explicitly casts a value of type Integer to type Single:

Dim NonintegralVariable as Single
NonintegralVariable = CType(5, Single)

NonintegralVariable = Convert.ToSingle(5)

Rules for Implicit Casting

Considering that narrowing casts can result in a loss of data, should Visual Basic allow for implicit narrow casts, or would it be prudent for the language to require that an explicit cast be used if a narrowing cast is required?

Truly strongly typed programming languages would require that all narrowing casts be explicit. In this case, if you tried to use code that would invoke an implicit narrowing cast, an error would result. That is, in a truly strongly typed programming language, the following code would produce an error:

Dim Quotient as Integer
Quotient = 8 / 4

The reason this would result in an error is that the / operator returns a nonintegral number (2.0), which must be cast to an integer to assign it to Quotient. However, this cast is a narrowing cast. In a truly strongly typed language, you would have to provide an implicit cast, like so:

Dim Quotient as Integer
Quotient = CType(8 / 4, Integer)

or

Dim Quotient as Integer
Quotient = Convert.ToInteger(8 / 4)

Older versions of Visual Basic allowed for implicit narrowing casts, however. Consequently, if Visual Basic implemented the rules inherent to truly strong typed programming languages, old Visual Basic code could not be reused as is in programs created with today’s version of Visual Basic; rather, the programmer would have to alter the code to include explicit casting.

The designers of Visual Basic decided to take a middle-of-the-road approach. By default, implicit narrowing casts are permitted, meaning that the code

Dim x as Integer
x = 8 / 4

will run without error, assigning the integer value 2 to the variable x.

Watch Out!

Keep in mind that casting a nonintegral number to an integer drops the remainder portion of the nonintegral number. That is, after the following code is executed, the value of Quotient will be 0:

Dim Quotient as Integer
Quotient = 3 / 4

To disallow implicit narrow casting in an ASP.NET page’s source code portion, open the page’s source code file and add Option Strict On at the top. With this option turned on, Visual Basic reports any implicit narrowing casts as errors in Visual Web Developer.

Listing 5.1 shows the contents of an ASP.NET page’s source code file with Option Strict On (line 1). Because of this setting, Visual Web Developer reports that the implicit narrowing cast in the Page_Load event handler is an error (see Figure 5.2).

Example 5.1. Implicit Narrowing Casts Are Disallowed Because of the Option Strict On Setting

 1: Option Strict On
 2:
 3: Partial Class _Default
 4:     Inherits System.Web.UI.Page
 5:
 6:     Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
 7:         Dim Quotient As Integer
 8:         Quotient = 8 / 4    'An implicit narrowing cast!
 9:     End Sub
10: End Class

Figure 5.2. A compile-time error occurs if Option Strict On is set and an implicit narrowing cast is found.

By the Way

For this book, I will not be adding Option Strict On in the ASP.NET code files. In some code examples there may be implicit narrowing casts. If you choose to add Option Strict On, you will have to add the appropriate explicit cast syntax for these examples.

There are no exercises for this hour mainly because all that we know how to do in Visual Basic at this point is declare variables and assign values to these variables.

In the next hour we will look at Visual Basic control structures, which allows for code to be executed repeatedly or conditionally. After we have covered this material, you’ll be ready for some Visual Basic exercises.