Most of the intrinsic types are used for working with numeric values (Byte, Short, Integer, Single, Double, Decimal, Long).

Another way to divide the types is into those used for integer (whole number) values, and those used for fractional values. The Short, Integer, and Long types all hold whole number values. Most of the time, you’ll just use Integer for these values, unless there is a good reason to do otherwise.

The Single and Double types hold fractional values (rational numbers). For most uses, Single will suffice, unless you need to hold a really big fractional number, in which case you might use a Double. The Decimal value type was added to the language to support accounting applications, and is described in Table 16-1.

Understanding types

When you create a program under Visual Basic 2005, you may choose to set Option Explicit and Option Strict to On, by writing these lines at the top of your source code:

Option Strict On
Option Explicit On

Tip

If you use Option Explicit or Option Strict, you must make them the first statements in your source code file.

Option Explicit requires that every variable be declared before it is used (variables are explained in the next section). Option Strict restricts the way you cast from one type to another. Both enable the compiler to help you find bugs in your program and together they make Visual Basic 2005 a strongly typed language; and that is a very good thing. This book assumes you will always set both Option Explicit and Option Strict on.

In a strongly typed language, every object you create or use must have a specific type (e.g., you must declare the object to be an Integer, a String, or a Dog). The type tells the compiler how big the object is and what it can do.

Tip

Confusingly, a perfectly legitimate type is type Object, though this type is rarely used and tends to undermine type safety.

The size of an object is measured in bytes. An Integer, for example, is four bytes big. User-defined types have a size as well, measured as the sum of all their member variables.

When programmers talk about what an object can do, they typically mean the methods of the object. User-defined types have many methods. Intrinsic types have implicit methods. For example, the numeric types have the ability to be added together, multiplied, and so forth.

The compiler will help you by complaining if you try to use a type improperly. The compiler complains in one of two ways: it issues a warning or it issues an error.

Tip

You are well advised to treat warnings as errors. That is, you ought to stop what you are doing and figure out why there is a warning and fix the problem. Never ignore a compiler warning.

Programmers talk about “design time,” “compile time,” and runtime.” Design time is when you are designing the program. Compile time is when you compile the program, and runtime is (surprise!) when you run the program.

The earlier you find a bug, the better. It is best (and cheapest) to discover a bug in your logic at design time. It is better (and cheaper) to find bugs in your program at compile time rather than at runtime. Not only is it better, it is more reliable. A compile-time bug will fail every time you run the compiler, but a runtime bug can hide. Runtime bugs slip under a crack in your code, and lurk there (sometimes for months) biding their time, waiting to come out when it will be embarrassing to you.

It is a constant theme of this book that you want the compiler to find bugs. The compiler is your friend. The more bugs the compiler finds, the fewer bugs your users will find. Setting Option Strict On helps the compiler find bugs in your code. Here’s how: suppose you tell the compiler that Milo is of type Dog. Some time later you try to use Milo to display text. Oops, Dog objects don’t display text. Your compiler will stop with an error.

Dog does not contain a definition for 'showText'

Very nice. Now you can go figure out if you used the wrong object or you called the wrong method.

Visual Studio 2005 actually finds the error even before the compiler does. When you try to add a method that does exist, IntelliSense pops up to help you, as shown in Figure 16-1.

When you try to add a method that does not exist, it won’t be in the list. That is a pretty good clue that you are not using the object properly.

Figure 16-1. IntelliSense

Visual Basic 2005 does not require that you initialize your variables (though it is a very good idea to discipline yourself to do so). If you do not initialize your variable, it will be set to a default value, as shown in Table 16-3.

Variables are a powerful tool, but there are times when you want to manipulate a defined value, one whose value you want to ensure remains constant. For example, you might need to work with the Fahrenheit freezing and boiling points of water in a program simulating a chemistry experiment. Your program will be clearer if you name the variables that store these values FreezingPoint and BoilingPoint, but you do not want to permit their values to be reassigned. How do you prevent reassignment? The answer is to use a constant. A constant is like a variable except that its value cannot be changed once it is initialized.

A constant associates a name with a value, but you cannot change that value while the program runs. Hence, rather than varying, a constant is, well, constant.

Constants come in three flavors: literals , symbolic constants , and enumerations.

Dim myValue as Integer = 32  'assign the literal value 32 to the variable myValue

Dim myValue as Double = 32R 'assign literal value 32 as a Double

                     access-modifierConst identifieras type = value;

Public Const FreezingPoint As Integer = 32

   Sub Main()
      Const FreezingPoint As Integer = 32 ' degrees Farenheit
      Const BoilingPoint As Integer = 212

      Console.WriteLine("Freezing point of water: {0}", FreezingPoint)
      Console.WriteLine("Boiling point of water: {0}", BoilingPoint)
  
      'FreezingPoint = 0
   End Sub
End Module

Constant cannot be the target of an assignment

Enumerations provide a powerful alternative to constants . An enumeration is a distinct value type, consisting of a set of named constants (called the enumerator list).

If you created two related constants:

Const FreezingPoint As Integer = 32
Const BoilingPoint As Integer = 212

you might wish to add a number of other useful constants as well, such as:

const LightJacketWeather As Integer = 60;
const SwimmingWeather As Integer = 72;
const WickedCold As Integer = 0;

This process is somewhat cumbersome, and there is no logical connection among these various constants. Visual Basic 2005 provides the enumeration to solve these problems:

Enum Temperatures
   CelsiusMeetsFahrenheit = −40
   WickedCold = 0
   FreezingPoint = 32
   LightJacketWeather = 60
   SwimmingWeather = 72
   BoilingPoint = 212
End Enum

Every enumeration has an underlying type, which can be any integral type (Byte, Short, Integer, and Long). The technical specification of an enumeration is:

[access modifiers] Enum 
                  identifier [As type]
      membername [ = constant expression]
 end Enum

For now, let’s focus on the rest of this declaration. An enumeration begins with the keyword Enum, which is followed by an identifier, such as:

Enum Temperatures

The AS keyword defines the underlying type for the enumeration. That is, are you declaring constant Integers, or constant Longs? If you leave out this optional keyword (and often you will) the underlying type will be integer.

Example 16-3 rewrites Example 16-2 to use an enumeration.

   Enum Temperatures
      WickedCold = 0
      FreezingPoint = 32
      LightJacketWeather = 60
      SwimmingWeather = 72
      BoilingPoint = 212
   End Enum 'Temperatures

   Sub Main()
      System.Console.WriteLine( _
         "Freezing point of water: {0}", _
         Temperatures.FreezingPoint)

      System.Console.WriteLine( _
           "Boiling point of water: {0}", _
           Temperatures.BoilingPoint)
   End Sub
End Module
Output:
Freezing point of water: FreezingPoint
Boiling point of water: BoilingPoint

In Example 16-3, you declare enumerated constant Temperatures. Temperatures is an enumeration. The values of the enumeration must be qualified by the enumeration type. That means you cannot just refer to FreezingPoint, but you must use the prefix Temperatures followed by the dot operator. This is called qualifying the identifier FreezingPoint. Thus, to refer to the FreezingPoint you use the full identifier Temperatures.FreezingPoint.

Unfortunately, if you pass the name of an enumeration to WriteLine what is displayed is its name, not its value. To display the value of an enumerated constant, you must cast the constant to its underlying type (Integer), as shown in Example 16-4.

   Sub Main()
      System.Console.WriteLine( _
          "Freezing point of water: {0}", _
          CInt(Temperatures.FreezingPoint))

      System.Console.WriteLine( _
           "Boiling point of water: {0}", _
           CInt(Temperatures.BoilingPoint))
   End Sub
End Module

When you cast a value (in this case, using the CInt function), you tell the compiler, “I know that this value is really of the indicated type.” In this case, you are saying, “Treat this enumerated constant as an Integer.” Since the underlying type is Integer, this is safe to do. See the section "Casting.”

Objects of one type can be converted into objects of another type. This is called casting , and casting can be either narrowing or widening.

A widening conversion or cast is one in which the conversion is to a type that can accommodate every possible value in the existing variable type. For example, an Integer can accommodate every possible value held by a Short. Casting from Short to Integer is, thus, a widening conversion.

A narrowing cast is one in which the conversion is to a type that may not be able to accommodate every possible value in the existing variable type. For example, a Short can accommodate only some of the values that an Integer variable might hold. Casting from an Integer to a Short is thus a narrowing conversion.

Visual Basic 2005 conversions are either implicit or explicit. In an implicit conversion, the compiler makes the conversion, with no special action by the developer. With an explicit conversion, the developer must use a special function to signal the cast. For example, in Example 16-4 you use the Cint function to explicitly cast the enumerated value to an Integer.

The semantics of an explicit conversion are “Hey! Compiler! I know what I’m doing.” This is sometimes called “hitting it with the big hammer” and can be very useful or very painful, depending on whether your thumb is in the way of the nail.

Whether a cast is implicit or explicit is affected by the Option Strict setting. If Option Strict is On (as it always should be) only widening casts can be implicit.

The explicit cast functions are:

the value of First will be 0, Second will be 1, Third will be 20, and Fourth will be 21.

It is nearly impossible to write a Visual Basic 2005 program without creating strings . A string object holds a string of characters.

You declare a string variable using the String keyword much as you would create an instance of any object:

Dim myString as String

A string literal is created by placing double quotes around a string of letters:

"Hello World"

It is common to initialize a string variable with a string literal:

Dim myString as String = "Hello World"

The most common way to branch is by calling a method. This is an unconditional branch.

You call a method by writing its name. For example:

Method1()  'invokes Method1

call Method1()

Every time the compiler encounters a method call, it stops execution in the current method and branches to the newly called method. When that method returns, execution picks up in the original method on the line just below the method call, as illustrated schematically in Figure 16-2.

Figure 16-2. Branching schematic

In Figure 16-2, execution begins in Main. Statements 1 and 2 execute and then the compiler sees a call to Method1. Program execution branches to the start of Method1, where its first three statements are executed. At the call to Method1A execution again branches, this time to the start of Method1A.

The four statements in Method1A are executed and Method1A returns. Execution resumes on the first statement after the method call in Method1 (Statement 4). Execution continues until Method1 ends, at which time execution resumes back in Main at Statement 3. At the call to Method2, execution again branches; all the statements in Method2 execute and then Main resumes at Statement 4. When Main ends, the program itself ends.

You can see the effect of method calls in Example 16-5. Execution begins in Main, but branches to a method named SomeMethod. The WriteLine statements in each method assist you in seeing where you are in the code as the program executes.

Option Strict On
Option Explicit On

Module Module1
   Sub Main()
      Console.WriteLine("In Main! Calling SomeMethod...")
      SomeMethod()
      Console.WriteLine("Back in Main.")
   End Sub 'Main

   Sub SomeMethod()
      Console.WriteLine("Greetings from SomeMethod!")
   End Sub 'SomeMethod

End Module

Output:
In Main! Calling SomeMethod...
Greetings from SomeMethod!
Back in Main.

Program flow begins in Main and proceeds until SomeMethod is invoked (invoking a method is sometimes referred to as “calling " the method). At that point, program flow branches to the method. When the method completes, program flow resumes at the next line after the call to that method.

While method calls cause unconditional branching, often you will want to branch within a method depending on a condition that you evaluate while the program is running. This is known as conditional branching.

Conditional branching statements allow you to write logic, such as “If you are over 25, then you may rent a car.”

If expressionThen
   statements
End If

If expression Then statement

Option Strict On
Module Module1

   Sub Main()

      Dim valueOne As Integer = 10
      Dim valueTwo As Integer = 20
      Dim valueThree As Integer = 30

      Console.WriteLine("Testing valueOne against valueTwo...")
      If valueOne > valueTwo Then
         Console.WriteLine( _
             "ValueOne: {0} larger than ValueTwo: {1}", _
              valueOne, valueTwo)
      End If

      Console.WriteLine("Testing valueThree against valueTwo...")
      If valueThree > valueTwo Then
         Console.WriteLine( _
             "ValueThree: {0} larger than ValueTwo: {1}", _
              valueThree, valueTwo)
      End If

      Console.WriteLine("Testing is valueTwo > 15 (one line)...")
      If valueTwo > 15 Then Console.WriteLine("Yes it is")

   End Sub 'Main

End Module
Output:
Testing valueOne against valueTwo...
Testing valueThree against valueTwo...
ValueThree: 30 larger than ValueTwo: 20
Testing is valueTwo > 15 (one line)...
Yes it is

If valueOne > valueTwo Then
   Console.WriteLine( _
       "ValueOne: {0} larger than ValueTwo: {1}", valueOne, valueTwo)
End If

If valueThree > valueTwo Then
   Console.WriteLine( _
       "ValueThree: {0} larger than ValueTwo: {1}", valueThree, valueTwo)
End If

If valueTwo > 15 Then Console.WriteLine("Yes it is")

Testing valueOne against valueTwo...
Testing valueThree against valueTwo...
ValueThree: 30 larger than ValueTwo: 20
Testing is valueTwo > 15 (one line)...
Yes it is

Option Strict On
Option Explicit On
Module Module1

   Sub Main()

      Dim valueOne As Integer = 10
      Dim valueTwo As Integer = 20
      Dim valueThree As Integer = 30

      Console.WriteLine("Testing valueOne against valueTwo...")
      If valueOne > valueTwo Then
         Console.WriteLine( _
             "ValueOne: {0} larger than ValueTwo: {1}", valueOne, valueTwo)
      Else
         Console.WriteLine( _
            "Nope, ValueOne: {0} is NOT larger than valueTwo: {1}", _
             valueOne, valueTwo)
      End If
   End Sub 'Main
End Module
Output:
Testing valueOne against valueTwo...
Nope, ValueOne: 10 is NOT larger than valueTwo: 20

Nested If statements and long sequences of ElseIf statements are hard to read, maintain, and debug. When you have a complex set of choices to make, the Select Case statement is a more powerful alternative. The logic of a Select Case statement is to “pick a matching value and act accordingly.”

Select [ Case ] testExpression
[ Case expressionList
   [ statements ] ]
[ Case Else
   [ else statements] ]
End Select

It is easiest to understand this construct in the context of an example, as shown in Example 16-8.

Option Strict On
Module Module1

   Sub Main()
      Dim targetInteger As Integer = 15

      Select Case targetInteger
         Case 5
            Console.WriteLine("5")
         Case 10
            Console.WriteLine("10")
         Case 15
            Console.WriteLine("15!")
         Case Else
            Console.WriteLine("Value not found")
      End Select
   End Sub 'Main
End Module
Output:
15!

In Example 16-8, a value (15) is assigned to targetInteger. The Select Case statement tests for the values 5, 10 and 15. If one matches, the associated statement is executed. The output shows that the value 15 matched, and the associated statement was executed, displaying the value. If none of the values matched, the Else select statement would be executed.

Case "Fred", "Joe", Is < "Alpha"
   Console.WriteLine("Joe or Fred or < Alpha")

The semantics of a Do loop are “Do this work while a condition is true” or “Do this work until a condition becomes true.” You can test the condition either at the top or at the bottom of the loop. If you test at the bottom of the loop, the loop will execute at least once.

The Do loop can even be written with no conditions; in which case, it will execute indefinitely, until it encounters an Exit Do statement.

Do loops come in the following flavors:

Do While BooleanExpression
   statements
Loop

Do Until BooleanExpression
    statements
Loop

Do
    statements
Loop while BooleanExpression

Do
   statements
Loop until BooleanExpression

Do
    statements
Loop

In each case, the BooleanExpression can be any expression that evaluates to a Boolean value of True or False.

Option Strict On
Module Module1

   Sub Main()
      Dim counterVariable As Integer = 0

      Do While counterVariable < 10
         Console.WriteLine("counterVariable: {0}", counterVariable)
         counterVariable = counterVariable + 1
      Loop ' While counterVariable < 10

   End Sub 'Main
End Module

Output:
counterVariable: 0
counterVariable: 1
counterVariable: 2
counterVariable: 3
counterVariable: 4
counterVariable: 5
counterVariable: 6
counterVariable: 7
counterVariable: 8
counterVariable: 9

 Do Until BooleanExpression
    statements
Loop

Do
    statements
Loop while BooleanExpression

Do
   statements
Loop until BooleanExpression

Do
    statements
Loop

As further proof that there are many ways to accomplish the same thing, VB.NET also offers a While loop construct that is closely related to the Do...While loops. The syntax is:

while BooleanExpression
  statements
End While

When you need to iterate over a loop a specified number of times, you can use a For loop with a counter variable. The syntax of the For loop is:

For variable= expressionto expression [ step expression]
   statements
Next [ variable-list ]

The simplest and most common form of this statement creates a loop variable to count through the iterations of the loop. For example, you might create an integer variable loopCounter that you will use to step through a loop ten times, as shown in Example 16-10.

Option Strict On
Module Module1

   Sub Main()

      Dim loopCounter As Integer
      For loopCounter = 0 To 9
         Console.WriteLine("loopCounter: {0}", loopCounter)
      Next

   End Sub 'Main

End Module
Output:
loopCounter: 0
loopCounter: 1
loopCounter: 2
loopCounter: 3
loopCounter: 4
loopCounter: 5
loopCounter: 6
loopCounter: 7
loopCounter: 8
loopCounter: 9

The variable (loopCounter) can be of any numeric type. For example, you might initialize a Single rather than an Integer, and step up through the loop from 0.5 to 9.

You can also modify multiple variables on each Next statement. This allows you to nest one For loop within another. You might use an outer and an inner loop to iterate through the contents of collections. A simple example of this technique is shown in Example 16-11.

Option Strict On
Module Module1

   Sub Main()

      Dim outer As Integer
      Dim inner As Integer

      For outer = 3 To 6
         For inner = 10 To 12
            Console.WriteLine("{0} * {1} = {2}", _
                outer, inner, outer * inner)
      Next 
 inner, outer

   End Sub 'Main

End Module

3 * 10 = 30
3 * 11 = 33
3 * 12 = 36
4 * 10 = 40
4 * 11 = 44
4 * 12 = 48
5 * 10 = 50
5 * 11 = 55
5 * 12 = 60
6 * 10 = 60
6 * 11 = 66
6 * 12 = 72

As an alternative to updating both counters in the same Next statement, you can provide each nested For loop with its own Next statement:

For outer = 3 To 6
    For inner = 10 To 12
       Console.WriteLine("{0} * {1} = {2}", _
           outer, inner, outer * inner)
    Next inner
 Next outer

When you update a single value in a Next statement, you are free to leave off the variable you are updating. Thus, the previous code is identical to this code:

For outer = 3 To 6
    For inner = 10 To 12
       Console.WriteLine("{0} * {1} = {2}", _
           outer, inner, outer * inner)
    Next
 Next

VB.NET uses seven arithmetic operators , six for standard calculations (+, −, *, ^, /, and ) and a seventh to return the remainder when dividing integers.

VB.NET offers two division operators: / and . The right-facing division operator (/) returns a floating-point answer. If you divide 12/5, the answer is 2.4, as you would expect. This answer is returned as a Double. If you assign the returned value to an Integer, the decimal part is lopped off, and the result will be 2. If Option Strict is On (as it should be), you cannot assign the result to an Integer without explicitly casting, because you would lose the decimal portion of the answer.

The left-facing division operator () returns an Integer value. If you divide 125, the result is returned with a truncated integer: 2. No cast is needed (even with Option Strict On) because you’ve explicitly asked for the integer value.

2^8 = 1024 ' 2 to the 8th power is 1,024.

Relational operators are used to compare two values, and then return a Boolean (True or False). The greater-than operator (>), for example, returns True if the value on the left of the operator is greater than the value on the right. Thus, 5 > 2 returns the value True, while 2 > 5 returns the value False.

The relational operators for VB.NET are shown in Table 16-5. This table assumes two variables: bigValue and smallValue, in which bigValue has been assigned the value 100 and smallValue the value 50.

Notice that some operators are composed of two characters. For example, greater than or equal to is created with the greater-than symbol (>) and the equal sign (=). You may place these symbols in either order (>= or =>)

The VB.NET equality operator (=) and assignment operator (=) use the same symbol.

When you write:

If myX = 5 Then myX = 7

the first use of the = symbol is the equality operator (if myX is equal to 5), the second use is the assignment operator (set myX to the value 7). The compiler figures out which is meant by context. (Eat your heart out, C# programmers!)

If statements test whether a condition is True. Often you will want to test if two conditions are both True, only one is True, or none is True. VB.NET provides a set of logical operators for this, as shown in Table 16-6. This table assumes two variables, x and y, in which x has the value 5 and y the value 7.

The And operator tests whether two statements are both True. The first line in Table 16-6 includes an example that illustrates the use of the And operator:

x = 3 And y = 7

The entire expression evaluates False because one side (x = 3) is False.

With the Or operator, either or both sides must be True; the expression is False only if both sides are False. So, in the example in Table 16-6:

x = 3 Or y = 7

the entire expression evaluates to True because one side (y = 7) is True.

The Xor logical operator is used to test if one (and only one) of the two statements is correct. Thus:

x = 5 Xor y = 7

evaluates to False, because both statements are True. The Xor statement is False if both statements are True, or if both statements are False; it is True only if one and only one statement is True.

With a Not operator, the statement is True if the expression is False, and vice versa. So, in the accompanying example:

Not x = 3

the entire expression is True because the tested expression (x = 3) is False. (The logic is: “it is True that it is not True that x is equal to 3.”)

The compiler must know the order in which to evaluate a series of operators. For example, if I write:

myVariable = 5 + 7 * 3

there are three operators for the compiler to evaluate (=, +, and *). It could, for example, operate left to right, which would assign the value 5 to myVariable, then add 7 to the 5 (12) and multiply by 3 (36). Since we’re evaluating left to right, the assignment has been done, so the value 36 is thrown away. This is clearly not what is intended.

The rules of precedence tell the compiler which operators to evaluate first. As is the case in algebra, multiplication has higher precedence than addition, so 5 + 7 * 3 is equal to 26 rather than 36. Both addition and multiplication have higher precedence than assignment, so the compiler will do the math, and then assign the result (26) to myVariable only after the math is completed.

In VB.NET, parentheses are used to change the order of precedence much as they are in algebra. Thus, you can change the result by writing:

myVariable = (5+7) * 3

Grouping the elements of the assignment in this way causes the compiler to add 5 + 7, multiply the result by 3, and then assign that value (36) to myVariable.

Within a single line of code, operators are evaluated in the following order:

Comparison operators are evaluated left to right. Arithmetic operators are evaluated in this order:

The logical operators are evaluated in this order: