In most programming languages, variables must be declared in advance. Historically, the reason for doing this has been to help the compiler generate the most efficient code. If the compiler knows all the variables and their types ahead of time, it can produce the most compact and efficient, or optimized, code. For example, when you tell the compiler that the variable Discount will hold a number, the compiler sets aside a certain number of bytes for the Discount variable to use.

When programming in VB 2010, you should declare your variables because this is the default mode, and Microsoft recommends this practice strongly. If you attempt to use an undeclared variable in your code, VB 2010 will throw an exception. It will actually catch the error as soon as you type in the line that uses the undeclared variable, underlining it with a wiggly line. It is possible to change the default behavior and use undeclared variables the way most people did with earlier versions of VB, but all the examples in this book use explicitly declared variables. In any case, you're strongly encouraged to declare your variables.

You already know how to declare variables with the Dim statement and the As keyword, which introduces their type:

Dim meters As Integer
Dim greetings As String

The first variable, meters, will store integers, such as 3 or 1,002; the second variable, greetings, will store text. You can declare multiple variables of the same or different type in the same line, as follows:

Dim Qty As Integer, Amount As Decimal, CardNum As String

If you want to declare multiple variables of the same type, you need not repeat the type. Just separate all the variables of the same type with commas and set the type of the last variable:

Dim Length, Width, Height As Integer, Volume, Area As Double

This statement declares three Integer variables and two Double variables. Double variables hold fractional values (or floating-point values, as they're usually called) that are similar to the Single data type except that they can represent non-integer values with greater accuracy.

An important aspect of variables is their scope, a topic that's discussed in more detail later in this chapter. In the meantime, bear in mind that all variables declared with the Dim statement exist in the module in which they were declared. If the variable Count is declared in a subroutine (an event handler, for example), it exists only in that subroutine. You can't access it from outside the subroutine. Actually, you can have a Count variable in multiple procedures. Each variable is stored locally, and they don't interfere with one another.

Dim distance As Integer = 3045

Dim distance As Integer
distance = 3045

Dim quantity As Integer = 1, discount As Single = 0.25

You've learned how to declare variables and that all variables should have a type. But what data types are available? Visual Basic recognizes the following five categories of variables:

The two major variable categories are numeric and string. Numeric variables store numbers, and string variables store text. Object variables can store any type of data. Why bother to specify the type if one type suits all? On the surface, using object variables might seem like a good idea, but they have their disadvantages. Integer variables are optimized for storing integers, and date variables are optimized for storing dates. Before VB can use an object variable, it must determine its type and perform the necessary conversions. If the variable is declared with a specific type, these conversions are not necessary.

Text is stored in string variables, but numbers can be stored in many formats, depending on the size of the number and its precision. That's why there are many types of numeric variables. The String and Date data types are much richer in terms of the functionality they expose and are discussed in more detail in Chapter 11, "The Framework at Large."

Dim a As Single, b As Double

a = 1 / 3
Debug.WriteLine(a)

.3333333

a = a * 100000
Debug.WriteLine(a)

33333.34

0.3333334

b = 1 / 3
Debug.WriteLine(b)
b = b * 100000
Debug.WriteLine(b)

0.333333333333333
33333.3333333333

Dim a As Single, b As Double
a = 0.03007
b = 0.03007

Debug.WriteLine(a-b)

a = 3
b = 1 / a
Debug.WriteLine(a * b)

328.558 * 12.4051

328558 * 124051

Dim dblVar As Double = 999

Dim infVar as Double
infVar = dblVar / 0

MsgBox(infVar)

Dim largeVar As Double = 1E299
Dim smallVar As Double = 1E-299
Dim result As Double

result = largeVar / smallVar
MsgBox(result)

Dim var1, var2 As Double
Dim result As Double
var1 = 0
var2 = 0
result = var1 / var2
MsgBox(result)

result = result + result
result = 10 / result

result = result + 1E299
MsgBox(result)

Dim var1, var2 As Double
  Dim result As Double
  var1 = 0
  var2 = 0
  result = var1 / var2
  If Double.IsInfinity(result) Then
      If Double.IsPositiveInfinity(result) Then
          MsgBox("Encountered a very large number. Can't continue")
      Else
          MsgBox("Encountered a very small number. Can't continue")
      End If
  Else
      If Double.IsNaN(result) Then
          MsgBox("Unexpected error in calculations")
      Else
          MsgBox("The result is : " & result.ToString)
      End If
  End If

var1 = 1E+299
var2 = 1E-299

Dim n As Byte

Dim A As Byte, B As Byte
A = 233
B = 50

Debug.WriteLine(A + B)

Dim failure As Boolean

Dim failure As Boolean = False
" other statements ...
If failure Then MsgBox("Couldn't complete the operation")

running = Not running

Dim running As Boolean
If running = True Then
   running = False
Else
   running = True
End If

If ReadOnly Or Hidden Then
   MsgBox("Couldn't open the file")
Else
   " statements to open and process file...
End If

Dim someText As String

Dim aString As String
aString = "Now is the time for all good men to come "
            "to the aid of their country"
aString = ""
aString = "There are approximately 25,000 words in this chapter"
aString = "25,000"

Dim aNumber As Integer = 25000
Dim aString As String = "25,000"

Dim char1, char2 As Char

Dim char1 As Char = "a", char2 As Char = "ABC"
Debug.WriteLine(char1)
Debug.WriteLine(char2)

Dim char1 As Char = "a"c, char2 As Char = "A"c

Debug.WriteLine(Convert.ToInt32("a"))

Dim password As String, ch As Char
  Dim i As Integer
  Dim valid As Boolean = False
  While Not valid
     password = InputBox("Please enter your password")
     For i = 0 To password.Length - 1
        ch = password.Chars(i)
        If Not Char.IsLetterOrDigit(ch) Then
           valid = True
           Exit For
        End If
     Next
     If valid Then
        MsgBox("You new password will be activated immediately! ")
     Else
        MsgBox("Your password must contain at least one special symbol! ")
     End If
  End While

Dim expiration As Date

expiration = #01/01/2010#
expiration = #8/27/1998 6:29:11 PM#
expiration = "July 2, 2011"
expiration = Today()

Dim d1, d2 As Date
d1 = Now
d2 = #1/1/2004#Debug.WriteLine(d1 - d2)

Dim UK As New CultureInfo("en-GB")

Dim D1 As Date
D1 = DateTime.Parse("25/12/2011", UK)

Dim D1, D2 As Date
Dim UK As New CultureInfo("en-GB")
Dim US As New CultureInfo("en-US")
D1 = DateTime.Parse("27/8/2010", UK)
D2 = DateTime.Parse("8/27/2010", US)
If D1 = D2 Then
    MsgBox("Same date")
Else
    MsgBox("Different dates")
End If

Dim val1, val2 As Decimal
Dim IT As New CultureInfo("it-IT")
Dim US As New CultureInfo("en-US")
val1 = System.Decimal.Parse("19,999.99", IT)
val2 = System.Decimal.Parse("19,999.99", US)
If val1 = val2 Then
    MsgBox("Same values")
Else
    MsgBox("Different values")
End If

The Visual Basic compiler provides three options that determine how it handles variables:

These options have a profound effect on the way you declare and use variables, and you should understand what they do. By exploring these settings, you will also understand a little better how the compiler handles variables. It's recommended that you turn on all three, but old VB developers may not want to follow this advice.

VB 2010 doesn't require that you declare your variables, but the default behavior is to throw an exception if you attempt to use a variable that hasn't been previously declared. If an undeclared variable's name appears in your code, the editor will underline the variable's name with a wiggly line, indicating that it caught an error. The description of the error will appear in the Task List window below the code window. If you rest the cursor over the segment in question, you will see the description of the error in a ToolTip box.

To change the default behavior, you must insert the following statement at the beginning of the file:

Option Explicit Off

The Option Explicit statement must appear at the very beginning of the file. This setting affects the code in the current module, not in all files of your project or solution. You can turn on the Strict (as well as the Explicit) option for an entire solution. Open the project's properties page (right-click the project's name in Solution Explorer and select Properties), select the Compile tab, and set the Strict and Explicit options accordingly, as shown in Figure 2.1.

Figure 2.1. Setting the variable-related options on the project's properties pages

You can also set default values for the Explicit option (as well as for Strict and Infer) for all projects through the Options dialog box of the IDE (Integrated Development Environment). To open this dialog box, choose the Options command from the Tools menu. When the dialog box appears, select the VB Defaults tab under Projects And Solutions, as shown in Figure 2.2. Here you can set the default values for all four options. You can still change the default values for specific projects through the project's properties pages.

The way undeclared variables are handled by VB 2010 is determined by the Explicit and Strict options, which can be either on or off. The Explicit option requires that all variables used in the code are declared before they're used. The Strict option requires that variables are declared with a specific type. In other words, the Strict option disallows the use of generic variables that can store any data type.

The default value of the Explicit statement is On. This is also the recommended value, and you should not make a habit of changing this setting. By setting the Explicit option to Off, you're telling VB that you intend to use variables without declaring them. As a consequence, VB can't make any assumption about the variable's type, so it uses a generic type of variable that can hold any type of information. These variables are called Object variables, and they're equivalent to the old variants.

Figure 2.2. Setting the variable-related options in the Visual Studio Options dialog box

While the option Explicit is set to Off, every time Visual Basic runs into an undeclared variable name, it creates a new variable on the spot and uses it. Visual Basic adjusts the variable's type according to the value you assign to it. With Explicit turned off, create two variables, var1 and var2, by referencing them in your code with statements like the following ones:

var1 = "Thank you for using Fabulous Software"
var2 = 49.99

The var1 variable is a string variable, and var2 is a numeric one. You can verify this with the GetType method, which returns a variable's type. The following statements print the highlighted types shown below each statement:

Debug.WriteLine "Variable var1 is " & var1.GetType().ToString
Variable var1 is System.String
Debug.WriteLine "Variable var2 is " & var2.GetType().ToString
Variable var2 is System.Double

Later in the same program, you can reverse the assignments:

var1 = 49.99
var2 = "Thank you for using Fabulous Software"

If you execute the preceding type-checking statements again, you'll see that the types of the variables have changed. The var1 variable is now a Double, and var2 is a String. The type of a generic variable is determined by the variable's contents, and it can change in the course of the application. Of course, changing a variable's type at runtime doesn't come without a performance penalty (a small one, but nevertheless some additional statements must be executed).

Another related option is the Strict option, which is off by default. The Strict option tells the compiler whether the variables should be strictly typed. A strictly typed (or strongly typed) variable must be declared with a specific type and it can accept values of the same type only. With the Strict option set to Off, you can use a string variable that holds a number in a numeric calculation:

Dim a As String = "25000"
Debug.WriteLine a / 2

The last statement will print the value 12500 in the Immediate window. Likewise, you can use numeric variables in string calculations:

Dim a As Double = 31.03
a = a + "1"

After the execution of the preceding statements, the a variable will still be a Double and will have the value 32.03. If you turn the Strict option on by inserting the following statement at the beginning of the file, you won't be able to mix and match variable types:

Option Strict On

If you attempt to execute any of the last two code segments while the Strict option is on, the editor will underline a segment of the statement to indicate an error. If you rest the cursor over the underlined segment of the code, the following error message will appear in a tip box:

Option strict disallows implicit conversions from String to Double

or any type conversion is implied by your code.

When the Strict option is set to On, the compiler will allow some implicit conversions between data types, but not always. For example, it will allow you to assign the value of an integer to a Long, but not the opposite. The Long value might exceed the range of values that can be represented by an Integer variable.

Dim count = 2999

Dim count As Integer = 2999

Debug.WriteLine(count.GetType.ToString)
System.Int32

Variants — variables without a fixed data type — were the bread and butter of VB programmers up to version 6. Variants are the opposite of strictly typed variables: They can store all types of values, such as integers, strings, characters, you name it. If you're starting with VB 2010, you should use strongly typed variables. However, variants are a major part of the history of VB, and most applications out there (the ones you may be called to maintain) use them. I will discuss variants briefly in this section and show you what was so good (and bad) about them.

Variants, or object variables, are the most flexible data type because they can accommodate all other types. A variable declared as Object (or a variable that hasn't been declared at all) is handled by Visual Basic according to the variable's current contents. If you assign an integer value to an object variable, Visual Basic treats it as an integer. If you assign a string to an object variable, Visual Basic treats it as a string. Variants can also hold different data types in the course of the same program. Visual Basic performs the necessary conversions for you.

To declare a variant, you can turn off the Strict option and use the Dim statement without specifying a type, as follows:

Dim myVar

You can use object variables in both numeric and string calculations. Suppose that the variable modemSpeed has been declared as Object with one of the following statements:

Dim modemSpeed            ' with Option Strict = Off
Dim modemSpeed As Object  ' with Option Strict = On

Later in your code, you assign the following value to it:

modemSpeed = "28.8"

You can treat the modemSpeed variable as a string and use it in statements such as the following:

MsgBox "We suggest a " & modemSpeed & " modem."

This statement displays the following message:

"We suggest a 28.8 modem."

You can also treat the modemSpeed variable as a numeric value, as in the following statement:

Debug.WriteLine "A " & modemSpeed & " modem can transfer " &
             modemSpeed * 1024 / 8 & " bytes per second."

This statement displays the following message:

"A 28.8 modem can transfer 3686.4 bytes per second."

The first instance of the modemSpeed variable in the preceding statement is treated as a string because this is the variant's type according to the assignment statement (we assigned a string to it). The second instance, however, is treated as a number (a single-precision number). The compiler sees that it's used in a numeric calculation and converts it to a double value before using it.

Another example of this behavior of variants can be seen in the following statements:

Dim I, S
I = 10
S = "11"
Debug.WriteLine(I + S)
Debug.WriteLine(I & S)

The first WriteLine statement will display the numeric value 21, whereas the second statement will print the string 1011. The plus operator (+) tells VB to add two values. In doing so, VB must convert the two strings into numeric values and then add them. The concatenation operator (&) tells VB to concatenate the two strings.

Visual Basic knows how to handle object variables in a way that makes sense. The result may not be what you had in mind, but it certainly is dictated by common sense. If you really want to concatenate the strings 10 and 11, you should use the concatenation operator (&), which tells Visual Basic exactly what to do. Quite impressive, but for many programmers, this is a strange behavior that can lead to subtle errors — and they avoid it. Keep in mind that if the value of the S variable were the string A1, then the code would compile fine but would crash at runtime. And this is what we want to avoid at all costs: an application that compiles without warnings but crashes at runtime. Using strongly typed variables is one of the precautions you can take to avoid runtime errors. Keep in mind that a program that prompts users for data, or reads it from a file, may work for quite a while, just because it's reading valid data, and crash when it encounters invalid data. It's up to you to decide whether to use variants and how far you will go with them. Sure, you can perform tricks with variants, but you shouldn't overuse them to the point that others can't read your code.

In many situations, you will need to convert variables from one type into another. Table 2.3 shows the methods of the Convert class that perform data-type conversions.

In addition to the methods of the Convert class, you can still use the data-conversion functions of VB (CInt() to convert a numeric value to an Integer, CDbl() to convert a numeric value to a Double, CSng() to convert a numeric value to a Single, and so on), which you can look up in the documentation. If you're writing new applications in VB 2010, use the new Convert class to convert between data types.

To convert the variable initialized as

Dim A As Integer

to a Double, use the ToDouble method of the Convert class:

Dim B As Double
B = Convert.ToDouble(A)

Suppose you have declared two integers, as follows:

Dim A As Integer, B As Integer
A = 23
B = 7

The result of the operation A / B will be a Double value. The statement

Debug.Write(A / B)

displays the value 3.28571428571429. The result is a Double value, which provides the greatest possible accuracy. If you attempt to assign the result to a variable that hasn't been declared as Double and the Strict option is on, the editor will generate an error message. No other data type can accept this value without loss of accuracy. To store the result to a Single variable, you must convert it explicitly with a statement like the following:

Dim C As Single = Convert.ToSingle(A / B)

You can also use the DirectCast() function to convert a variable or expression from one type to another. The DirectCast() function is identical to the CType() function. Let's say the variable A has been declared as String and holds the value 34.56. The following statement converts the value of the A variable to a Decimal value and uses it in a calculation:

Dim A As String = "34.56"
Dim B As Double
B = DirectCast(A, Double) / 1.14

The conversion is necessary only if the Strict option is on, but it's a good practice to perform your conversions explicitly. The following section explains what might happen if your code relies on implicit conversions.

Dim count As Integer = 99
Dim pi As Double = 3.1415926535897931

So far, you've seen how to use the basic data types. Let me digress here for a moment and mention that the basic data types are no longer part of the language (Visual Basic or C#). They're actually part of the Common Language Runtime (CLR), which is a basic component of Visual Studio (actually, it's the core of Visual Studio and it's shared by all languages that can be used with Visual Studio). You can treat this note as fine print for now, but don't be surprised when you read in the documentation that the basic data types are part of the CLR. All data types expose a ToString method, which returns the variable's value (a number or date) as a string so that it can be used with other strings in your code. The ToString method formats numbers and dates in many ways, and it's probably one of the most commonly used methods. You can call the ToString method without any arguments, as we have done so far, to convert any value to a string. With many types, the ToString method, however, accepts an optional argument, which determines how the value will be formatted as a string. For example, you can format a number as currency by prefixing it with the appropriate symbol (such as the dollar symbol) and displaying it with two decimal digits, and you can display dates in many formats. Some reports require that negative amounts are enclosed in parentheses. The ToString method allows you to display numbers and dates, and any other type, in any way you wish.

Notice that ToString is a method, not a property. It returns a value that you can assign to a string variable or pass as arguments to a function such as MsgBox(), but the original value is not affected. The ToString method can also format a value if called with an optional argument:

ToString(formatString)

The formatString argument is a format specifier (a string that specifies the exact format to be applied to the variable). This argument can be a specific character that corresponds to a predetermined format (a standard format string, as it's called) or a string of characters that have special meaning in formatting numeric values (a picture format string). Use standard format strings for the most common formatting options, and use picture strings to specify unusual formatting requirements. To format the value 9959.95 as a dollar amount, you can use the C format specifier, which stands for Currency:

Dim Amnt As Single = 9959.95
Dim strAmnt As String
strAmnt = Amnt.ToString("C")

Or use the following picture numeric format string:

strAmnt = Amnt.ToString("$#,###.00")

Both statements will format the value as $9,959.95. If you're using a non-U.S. version of Windows, the currency symbol will change accordingly. If you're in the United States, use the Regional And Language Options tool in Control Panel to temporarily change the current culture to a European one and the amount will be formatted with the Euro sign.

The picture format string is made up of literals and characters that have special meaning in formatting. The dollar sign has no special meaning and will appear as is. The # symbol is a digit placeholder; all # symbols will be replaced by numeric digits, starting from the right. If the number has fewer digits than specified in the string, the extra symbols to the left will be ignored. The comma tells the ToString method to insert a comma between thousands. The period is the decimal point, which is followed by two more digit placeholders. Unlike the # sign, the 0 is a special placeholder: If there are not enough digits in the number for all the zeros you've specified, a 0 will appear in the place of the missing decimal digits. If the original value had been 9959.9, for example, the last statement would have formatted it as $9,959.90. If you used the # placeholder instead, the string returned by the ToString method would have a single decimal digit.

Dim Amount As Decimal = 42492.45
Debug.WriteLine(Amount.ToString("$#,###.00"))
$42,492.45
Amount = 0.2678
Debug.WriteLine(Amount.ToString("0.000"))
0.268
Amount = −24.95
Debug.WriteLine(Amount.ToString("$#,###.00;($#,###.00)"))
($24.95)

In the previous sections, we used variables to store individual values (or scalar values, as they're called). As a matter of fact, most programs store sets of data of different types. For example, a program for balancing your checkbook must store several pieces of information for each check: the check's number, amount, date, and so on. All these pieces of information are necessary to process the checks, and ideally, they should be stored together.

What we need is a variable that can hold multiple related values of the same or different type. You can create custom data types that are made up of multiple values using Structures. A Structure allows you to combine multiple values of the basic data types and handle them as a whole. For example, each check in a checkbook-balancing application is stored in a separate Structure (or record), as shown in Figure 2.3. When you recall a given check, you need all the information stored in the Structure.

Figure 2.3. Pictorial representation of a structure

To define a Structure in VB 2010, use the Structure statement, which has the following syntax:

Structure structureName
   Dim variable1 As varType
   Dim variable2 As varType
   ...
   Dim variablen As varType
End Structure

varType can be any of the data types supported by the CLR or the name of another Structure that has been defined already. The Dim statement can be replaced by the Private or Public access modifiers. For Structures, Dim is equivalent to Public.

After this declaration, you have in essence created a new data type that you can use in your application. structureName can be used anywhere you'd use any of the base types (Integers, Doubles, and so on). You can declare variables of this type and manipulate them as you manipulate all other variables (with a little extra typing). The declaration for the CheckRecord Structure shown in Figure 2.3 is as follows:

Structure CheckRecord
   Dim CheckNumber As Integer
   Dim CheckDate As Date
   Dim CheckAmount As Single
   Dim CheckPaidTo As String
End Structure

This declaration must appear outside any procedure; you can't declare a Structure in a subroutine or function. Once declared, the CheckRecord Structure becomes a new data type for your application.

To declare variables of this new type, use a statement such as this one:

Dim check1 As CheckRecord, check2 As CheckRecord

To assign a value to one of these variables, you must separately assign a value to each one of its components (they are called fields), which can be accessed by combining the name of the variable and the name of a field separated by a period, as follows:

check1.CheckNumber = 275

Actually, as soon as you type the period following the variable's name, a list of all members to the CheckRecord Structure will appear, as shown in Figure 2.4. Notice that the Structure supports a few members on its own. You didn't write any code for the Equals, GetType, and ToString members, but they're standard members of any Structure object, and you can use them in your code. Both the GetType and ToString methods will return a string like ProjectName.FormName + CheckRecord. You can provide your own implementation of the ToString method, which will return a more meaningful string:

Public Overrides Function ToString() As String
    Return "CHECK # " & CheckNumber & " FOR " & CheckAmount.ToString("C")
End Function

I haven't discusses the Overrides keyword yet; it tells the compiler to override the default implementation of the ToString method. For the time being, use it as shown here to create your custom ToString method. This, as well as other object-related terms, are discussed in detail in Chapter 8.

As you understand, Structures are a lot like objects that expose their fields as properties and then expose a few members of their own. The following statements initialize a variable of the CheckRecord type:

check2.CheckNumber = 275
check2.CheckDate = #09/12/2010#

check2.CheckAmount = 104.25
check2.CheckPaidTo = "Gas Co."

Figure 2.4. Variables of custom types expose their members as properties.

Besides setting the types of variables and the functions for converting between types, Visual Basic provides the GetType method. GetType returns a string containing the name of the variable type (Int32, Decimal, and so on). All variables expose this method automatically, and you can call it like this:

Dim var As Double
Debug.WriteLine "The variable's type is " & var.GetType.ToString

There's also a GetType operator, which accepts as an argument a type and returns a Type object for the specific data type. The GetType method and GetType operator are used mostly in If structures, like the following one:

If var.GetType() Is GetType(Double) Then
   '  code to handle a Double value
End If

Notice that the code doesn't reference data type names directly. Instead, it uses the value returned by the GetType operator to retrieve the type of the class System.Double and then compares this value to the variable's type with the Is (or the IsNot) keyword. If you attempt to express this comparison with the equals operator (=), the editor will detect the error and suggest that you use the Is operator. This syntax is a bit arcane for BASIC developers; just make a note, and when you need to find out a variable's type in your application, use it as is.

In addition to a type, a variable has a scope. The scope (or visibility) of a variable is the section of the application that can see and manipulate the variable. If a variable is declared within a procedure, only the code in the specific procedure has access to that variable; the variable doesn't exist for the rest of the application. When the variable's scope is limited to a procedure, it's called local.

Suppose that you're coding the handler for the Click event of a button to calculate the sum of all even numbers in the range 0 to 100. One possible implementation is shown in Listing 2.3.

Private Sub Button1_Click(ByVal sender As Object, _
                 ByVal e As System.EventArguments) _
                 Handles Button1.Click
     Dim i As Integer
     Dim Sum As Integer = 0
     For i = 0 to 100 Step 2
        Sum = Sum + i
     Next
     MsgBox "The sum is " & Sum.ToString
  End Sub

The variables i and Sum are local to the Button1_Click() procedure. If you attempt to set the value of the Sum variable from within another procedure, Visual Basic will complain that the variable hasn't been declared. (Or, if you have turned off the Explicit option, it will create another Sum variable, initialize it to zero, and then use it. But this won't affect the variable Sum in the Button1_Click() subroutine.) The Sum variable is said to have procedure-level scope; it's visible within the procedure and invisible outside the procedure.

Sometimes, however, you'll need to use a variable with a broader scope: a variable that's available to all procedures within the same file. This variable, which must be declared outside any procedure, is said to have a module-level scope. In principle, you could declare all variables outside the procedures that use them, but this would lead to problems. Every procedure in the file would have access to any variable, and you would need to be extremely careful not to change the value of a variable without good reason. Variables that are needed by a single procedure (such as loop counters) should be declared in that procedure.

Another type of scope is the block-level scope. Variables introduced in a block of code, such as an If statement or a loop, are local to the block but invisible outside the block. Let's revise the previous code segment so that it calculates the sum of squares. To carry out the calculation, we first compute the square of each value and then sum the squares. The square of each value is stored to a variable that won't be used outside the loop, so we can define the sqrValue variable in the loop's block and make it local to this specific loop, as shown in Listing 2.4.

Private Sub Button1_Click(ByVal sender As Object, _
                 ByVal e As System.EventArguments) _
                 Handles Button1.Click
     Dim i, Sum As Integer
     For i = 0 to 100 Step 2
        Dim sqrValue As Integer
        sqrValue = i * i
        Sum = Sum + sqrValue
     Next
     MsgBox "The sum of the squares is " & Sum
  End Sub

The sqrValue variable is not visible outside the block of the For...Next loop. If you attempt to use it before the For statement or after the Next statement, the code won't compile.

The sqrValue variable maintains its value between iterations. The block-level variable is not initialized at each iteration, even though there's a Dim statement in the loop.

Finally, in some situations, the entire application must access a certain variable. In this case, the variable must be declared as Public. Public variables have a global scope; they are visible from any part of the application. To declare a public variable, use a Public statement in place of a Dim statement. Moreover, you can't declare public variables in a procedure. If you have multiple forms in your application and you want the code in one form to see a certain variable in another form, you can use the Public modifier.

So, why do we need so many types of scope? You'll develop a better understanding of scope and which type of scope to use for each variable as you get involved in larger projects. In general, you should try to limit the scope of your variables as much as possible. If all variables were declared within procedures, you could use the same name for storing a temporary value in each procedure and be sure that one procedure's variables wouldn't interfere with those of another procedure, even if you use the same name.

In addition to type and scope, variables have a lifetime, which is the period for which they retain their value. Variables declared as Public exist for the lifetime of the application. Local variables, declared within procedures with the Dim or Private statement, live as long as the procedure. When the procedure finishes, the local variables cease to exist, and the allocated memory is returned to the system. Of course, the same procedure can be called again, and then the local variables are re-created and initialized again. If a procedure calls another, its local variables retain their values while the called procedure is running.

You also can force a local variable to preserve its value between procedure calls by using the Static keyword. Suppose that the user of your application can enter numeric values at any time. One of the tasks performed by the application is to track the average of the numeric values. Instead of adding all the values each time the user adds a new value and dividing by the count, you can keep a running total with the function RunningAvg(), which is shown in Listing 2.5.

Function RunningAvg(ByVal newValue As Double) As Double
     CurrentTotal = CurrentTotal + newValue
     TotalItems = TotalItems + 1
     RunningAvg = CurrentTotal / TotalItems
  End Function

You must declare the variables CurrentTotal and TotalItems outside the function so that their values are preserved between calls. Alternatively, you can declare them in the function with the Static keyword, as shown in Listing 2.6.

Function RunningAvg(ByVal newValue As Double) As Double
     Static CurrentTotal As Double

Static TotalItems As Integer
     CurrentTotal = CurrentTotal + newValue
     TotalItems = TotalItems + 1
     RunningAvg = CurrentTotal / TotalItems
  End Function

The advantage of using static variables is that they help you minimize the number of total variables in the application. All you need is the running average, which the RunningAvg() function provides without making its variables visible to the rest of the application. Therefore, you don't risk changing the variable values from within other procedures.

Variables declared in a form module outside any procedure take effect when the form is loaded and cease to exist when the form is unloaded. If the form is loaded again, its variables are initialized as if it's being loaded for the first time.

Variables are initialized when they're declared, according to their type. Numeric variables are initialized to zero, string variables are initialized to a blank string, and object variables are initialized to Nothing.

Arrays must be declared with the Dim (or Public) statement followed by the name of the array and the index of the last element in the array in parentheses, as in this example:

Dim Salary(15) As Integer

Salary is the name of an array that holds 16 values (the salaries of the 16 employees) with indices ranging from 0 to 15. Salary(0) is the first person's salary, Salary(1) the second person's salary, and so on. All you have to do is remember who corresponds to each salary, but even this data can be handled by another array. To do this, you'd declare another array of 16 elements:

Dim Names(15) As String

Then assign values to the elements of both arrays:

Names(0) = "Joe Doe"
Salary(0) = 34000
Names(1) = "Beth York"
Salary(1) = 62000
...
Names(15) = "Peter Smack"
Salary(15) = 10300

This structure is more compact and more convenient than having to hard-code the names of employees and their salaries in variables.

All elements in an array have the same data type. Of course, when the data type is Object, the individual elements can contain different kinds of data (objects, strings, numbers, and so on).

Arrays, like variables, are not limited to the basic data types. You can declare arrays that hold any type of data, including objects. The following array holds colors, which can be used later in the code as arguments to the various functions that draw shapes:

Dim colors(2) As Color
colors(0) = Color.BurlyWood
colors(1) = Color.AliceBlue
colors(2) = Color.Sienna

The Color class represents colors, and among the properties it exposes are the names of the colors it recognizes.

A better technique for storing names and salaries is to create a structure and then declare an array of this type. The following structure holds names and salaries:

Structure Employee
   Dim Name As String
   Dim Salary As Decimal
End Structure

Insert this declaration in a form's code file, outside any procedure. Then create an array of the Employee type:

Dim Emps(15) As Employee

Each element in the Emps array exposes two fields, and you can assign values to them by using statements such as the following:

Emps(2).Name = "Beth York"
Emps(2).Salary = 62000

The advantage of using an array of structures instead of multiple arrays is that the related information will always be located under the same index. The code is more compact, and you need not maintain multiple arrays.

Just as you can initialize variables in the same line in which you declare them, you can initialize arrays, too, with the following constructor (an array initializer, as it's called):

Dim nameArray() As type = {entry0, entry1, ... entryN}

Here's an example that initializes an array of strings:

Dim Names() As String = {"Joe Doe", "Peter Smack"}

This statement is equivalent to the following statements, which declare an array with two elements and then set their values:

Dim Names(1) As String

Names(0) = "Joe Doe"
Names(1) = "Peter Smack"

The number of elements in the curly brackets following the array's declaration determines the dimensions of the array, and you can't add new elements to the array without resizing it. If you need to resize the array in your code dynamically, you must use the ReDim statement and supply the new size of the array in parentheses.

Dim Names(19) As Integer

Debug.WriteLine(Names.GetLowerBound(0))
0
Debug.WriteLine(Names.GetUpperBound(0))
19

Names(0) = "First entry"
Names(19) = "Last entry"

Dim i As Integer, myArray(19) As Integer
For i = 0 To myArray.GetUpperBound(0)
 myArray(i) = i * 1000
Next

Debug.WriteLine(myArray.Length)

One-dimensional arrays, such as those presented so far, are good for storing long sequences of one-dimensional data (such as names or temperatures). But how would you store a list of cities and their average temperatures in an array? Or names and scores, years and profits, or data with more than two dimensions, such as products, prices, and units in stock? In some situations, you will want to store sequences of multidimensional data. You can store the same data more conveniently in an array of as many dimensions as needed.

Figure 2.5 shows two one-dimensional arrays — one of them with city names, the other with temperatures. The name of the third city would be City(2), and its temperature would be Temperature(2).

Figure 2.5. Two one-dimensional arrays and the equivalent two-dimensional array

A two-dimensional array has two indices: The first identifies the row (the order of the city in the array), and the second identifies the column (city or temperature). To access the name and temperature of the third city in the two-dimensional array, use the following indices:

Temperatures(2, 0)     ' is the third city"s name
Temperatures(2, 1)     ' is the third city"s average temperature

The benefit of using multidimensional arrays is that they're conceptually easier to manage. Suppose you're writing a game and want to track the positions of certain pieces on a board. Each square on the board is identified by two numbers: its horizontal and vertical coordinates. The obvious structure for tracking the board's squares is a two-dimensional array, in which the first index corresponds to the row number and the second corresponds to the column number. The array could be declared as follows:

Dim Board(9, 9) As Integer

When a piece is moved from the square in the first row and first column to the square in the third row and fifth column, you assign the value 0 to the element that corresponds to the initial position:

Board(0, 0) = 0

And you assign 1 to the square to which it was moved to indicate the new state of the board:

Board(2, 4) = 1

To find out whether a piece is on the top-left square, you'd use the following statement:

If Board(0, 0) = 1 Then
   "  piece found
Else
   "  empty square
End If

This notation can be extended to more than two dimensions. The following statement creates an array with 1,000 elements (10 by 10 by 10):

Dim Matrix(9, 9, 9)

You can think of a three-dimensional array as a cube made up of overlaid two-dimensional arrays, such as the one shown in Figure 2.6.

Figure 2.6. Pictorial representations of one-, two-, and three-dimensional arrays

It is possible to initialize a multidimensional array with a single statement, just as you do with a one-dimensional array. You must insert enough commas in the parentheses following the array name to indicate the array's rank. The following statements initialize a two-dimensional array and then print a couple of its elements:

Dim a(,) As Integer = {{10, 20, 30}, {11, 21, 31}, {12, 22, 32}}
Console.WriteLine(a(0, 1))     " will print 20
Console.WriteLine(a(2, 2))     " will print 32

You should break the line that initializes the dimensions of the array into multiple lines to make your code easier to read:

Dim a(,) As Integer = {{10, 20, 30},
                       {11, 21, 31},
                       {12, 22, 32}}

If the array has more than one dimension, you can find out the number of dimensions with the Array.Rank property. Let's say you have declared an array for storing names and salaries by using the following statements:

Dim Employees(1,99) As Employee

To find out the number of dimensions, use the following statement:

Employees.Rank

When using the Length property to find out the number of elements in a multidimensional array, you will get back the total number of elements in the array (2 × 100 for our example). To find out the number of elements in a specific dimension, use the GetLength method, passing as an argument a specific dimension. The following expressions will return the number of elements in the two dimensions of the array:

Debug.WriteLine(Employees.GetLength(0))
2
Debug.WriteLine(Employees.GetLength(1))
100

Because the index of the first array element is zero, the index of the last element is the length of the array minus 1. Let's say you have declared an array with the following statement to store player statistics for 15 players and there are five values per player:

Dim Statistics(14, 4) As Integer

The following statements will return the highlighted values shown beneath them:

Debug.WriteLine(Statistics.Rank)
2                          ' dimensions in array
Debug.WriteLine(Statistics.Length)
75                         ' total elements in array
Debug.WriteLine(Statistics.GetLength(0))
15                         ' elements in first dimension
Debug.WriteLine(Statistics.GetLength(1))
5                          ' elements in second dimension
Debug.WriteLine(Statistics.GetUpperBound(0))
14                         ' last index in the first dimension
Debug.WriteLine(Statistics.GetUpperBound(1))
4                          ' last index in the second dimension

Multidimensional arrays are becoming obsolete because arrays (and other collections) of custom structures and objects are more flexible and convenient.

Historically, arrays are the primary structures for storing sets of data, and for years they were the primary storage mechanism for in-memory data manipulation. In this field, however, where technologies grow in and out of style overnight, arrays are being replaced by other, more flexible and more powerful structures, the collections. Collections are discussed in detail in Chapter 12, but I should mention them briefly in this chapter, not only for completeness, but also because collections are used a lot in programming and you will find many examples of collections in this book's chapters.

A collection is a dynamic data storage structure: You don't have to declare the size of a collection ahead of time. Moreover, the position of the items in a collection is not nearly as important as the position of the items in an array. New items are appended to a collection with the Add method, while existing items are removed with the Remove method. (Note that there's no simple method of removing an array element, short of copying the original array to a new one and skipping the element to be removed.) The collection I just described is the List collection, which is very similar to an array. To declare a List collection, use the New keyword:

Dim names As New List(Of String)

The New keyword is literally new to you; use it to create variables that are true objects (any variable that's not of a basic data type or structure). The New keyword tells the compiler to create a variable of the specified type and initialize it. The List collection must be declared with a specific data type, which is specified with the Of keyword in parentheses. All items stored in the example names list must be strings. A related collection is the ArrayList collection, which is identical to the List collection but you don't have to declare the type of variables you intend to store in it because you can add objects of any type to an ArrayList collection.

To create a collection of color values, use the following declaration:

Dim colors As New List(Of Color)

The following statements add a few items to the two collections:

names.Add("Richard")
names.Add("Nancy")
colors.Add(Color.Red)
colors.Add(TextBox1.BackColor)

Another collection is the Dictionary collection, which allows you to identify each element by a key instead of an index value. The following statement creates a new Dictionary collection for storing names and birth dates:

Dim BDays As New Dictionary(Of String, Date)

The first data type following the Of keyword is the data type of the keys, while the following argument is the data type of the values you want to store to the collection. Here's how you add data to a Dictionary collection:

BDays.Add("Manfred", #3/24/1972#)
BDays.Add("Alfred", #11/24/1959#)

To retrieve the birth date of Manfred, use the following statement:

BDays("Manfred")

Finally, you can use collections to store custom objects too. Let's say you have three variables that represent checks (they're of the CheckRecord custom type presented earlier in this chapter in the section "User-Defined Data Types"). You can add them to a List collection just as you would add integers or strings to a collection:

Dim Checks As New List(Of CheckRecord)
Checks.Add(check1)
Checks.Add(check2)
Checks.Add(check3)

A seasoned developer would store the same data to a Dictionary collection using the check number as an index value:

Dim Checks As New Dictionary(Of Integer, CheckRecord)
Checks.Add(check1.CheckNumber, check1)

An application that uses this structure can prompt the user for a specific check number, retrieve it by its index from the Checks collection and display it to the user. As you will see in Chapter 12, a big advantage of collections over arrays is that collections allow you to remove elements with the Remove method.