Some basic data values, such as numbers and text strings, can be entered into your source code and used just as they are. For instance, the MsgBox procedure displays a window with a supplied text message. The statement:

MsgBox("The answer is " & 42)

includes a literal string, “The answer is,” and a literal integer value, 42. (The “&” symbol is an operator that connects two values together into a new string.) Literals are used once, and then they’re gone. If I wanted to show the same “The answer is 42” message again, I would have to once again type the same literal values into a different part of the source code.

Visual Basic supports several types of basic literals. String literals are always surrounded by quote marks. If you want to include a quote mark itself in the middle of a string, include two instead of one:

"This is ""literally"" an example."

String literals can be really, really long, up to about 2 billion characters in length; if you were to type just one character per second, it would take more than 63 years to reach the maximum string length. Visual Basic also includes a character literal that is exactly one character in length; if you were to type just one character per second, well, never mind. These character literals are recognized by the “c” trailing after the string. The character literal “A” is entered as:

"A"c

Date and time literals are surrounded by number signs instead of quote marks. The date or time (or both) that you include can be in any format recognized by Microsoft Windows in your specific region. If you are using Visual Studio, it will reformat your date when you type in the literal:

#7/4/1776#

Eleven different kinds of numeric data values—both integers and floating-point values—make up the “core” set of numeric teacups. And who needs more than 11? With these 11 teacups, you can manage numbers from zero all the way to 1 × 10³⁰⁰ and beyond. To use a numeric literal, type the number right in your code, like 27, or 3.1415926535. Visual Basic also lets you specify which of the 11 numeric teacups to use for a number, by appending a special character to the end of the number. Normally, 27 is an integer 27. To make it a currency-focused “decimal,” append an at sign (@):

27@

When I talk about data types in full detail in Chapter 6, I will list the different special characters, like @, that set the data type for literal numbers.

The fourth and final type of Visual Basic literal is the Boolean literal. Boolean values represent the simplest type of computer data: the bit. Boolean values are either true or false, on or off, yes or no, delicious or disgusting, cats or dogs, zero or nonzero. Booleans always represent any two opposite values or states. Back in the 1800s, George Boole invented Boolean algebra, a language he used to represent logic statements as mathematical equations. It just so happens that computers love Boolean algebra. All the basic operations of a computer, such as addition, are implemented using Boolean functionality.

Visual Basic includes the Boolean literals True and False. No quotes; no number signs—just the words True and False. Question: is Tim Patrick telling the truth about this? Answer:

True

In certain cases, you can treat numbers as Boolean values. I’ll talk about it more later on, but for now just know that False equates to zero (0), and True equates to everything else (although generally, −1 is used for “everything else”).

Literal data values are all well and good, but they are useful only once, and then they’re gone. Each time you want to use a literal value, you must retype it. It’s as though the data values are stored in disposable cups instead of fine china teacups. And besides, only programmers enter literal values, not users, so they are of limited use in managing user data.

Variables are not simply disposable cups; they are reusable. You can keep putting the same type of tea over and over into the teacup. A string variable teacup can hold a string for reuse over and over. For instance, in this block of code, response holds the various strings assigned to it:

01  response = "A"
02  MsgBox("Give me an 'A'!")
03  MsgBox(response)
04  MsgBox("Give me another 'A'!")
05  MsgBox(response)
06  MsgBox("What's that spell?")
07  response = StrDup(2, "A")
08  MsgBox(response)

The variable response is assigned twice with two different strings: an “A” (line 01) and then “AA” (line 07). It keeps whatever value was last assigned to it; both lines 03 and 05 display “A” in a message box window. And you don’t have to assign just literal strings to it; anything that generates a string can assign its result to response. Line 07 uses a built-in Visual Basic function, StrDup, to return the two-character string “AA” and assign it to response.

Using variables is a two-step process. First you must declare the variable, and then you assign a value to it. The Dim statement takes care of the declaration part; it lets you indicate both the name and the type of a variable. Its basic syntax is pretty straightforward:

Dim response As String

where response is the name of the variable and String is its type. Assignment occurs using the = assignment operator:

response = "The answer"

A single variable can have new values assigned to it over and over again. For those times when you want your variable to have some specific value immediately upon declaration, you can combine declaration and assignment into a single statement:

Dim response As String = "The answer"

Of course, you’re not limited to just a single declaration; you can create as many variables as you need in your code. Each one normally uses its own Dim statement:

Dim question As String
Dim answer As String

You also can combine these into a single statement, although I think it’s just plain ugly:

Dim question As String, answer As String

See, I told you it was ugly. This is just the start of what’s possible with the Dim statement. I’ll get into more details as the chapter progresses.

I talked about value types and reference types in Chapter 1. Value type variables store an actual value; the tea in a value type teacup is the content itself. All of the literal data values I mentioned previously, except for Strings, are value types.

Reference type variables store a “reference” to the actual data, data found somewhere else in memory. When you look into a reference type teacup, you have to read the tea leaves at the bottom to determine where the real data resides.

Either reference types have data or they don’t. In the absence of data, a reference type has a value of Nothing, a Visual Basic keyword that indicates no data. Value types are never Nothing; they always contain some value, possibly the default value for that type (such as zero for numeric types). A special “nullable” type does let you assign Nothing to a value type, allowing you to implement the same “is there any data here at all” logic that exists with reference types. I’ll talk about nullable types in Chapter 6.

The String data type is useful, but it’s only one of the teacup shapes at your disposal. The .NET Framework defines several core data types. Each data type is implemented as a specific class within the System namespace. The most basic data type, a large teacup that can hold any type of data, is called Object. More than just an object, this is object with a capital O. In the .NET Class Library namespace hierarchy, it’s located at System.Object. It’s the mother of all classes in .NET; all other classes, structures, enumerations, and delegates, no matter where they reside in the namespace hierarchy, whether they are written by Microsoft or by you, derive from System.Object. There’s no getting around it; you cannot create a type that ultimately derives from anything else.

So, back to these “core” data types I’ve been hinting at. They match the four types of literal data values I listed before: strings, dates, numbers, and Boolean values. Table 2-1 lists these core data types. Each type also has a Visual Basic-specific name that you can (and should) use instead.

The Microsoft developers in charge of Visual Basic data types lucked out on that job since all core Visual Basic data types are simply wrappers for specific data types implemented by .NET. The Visual Basic names given for each of these core data types are fully interchangeable with the .NET names. For example, Integer is fully equivalent to System.Int32. In fact, when writing Visual Basic code, it is better to use the Visual Basic synonyms, since most Visual Basic developers expect these data type names in the code they read and write.

Except for Object and String, all of these data types are value types. All value types are derived from System.ValueType (which in turn derives from System.Object).

The SByte, UInteger, ULong, and UShort data types were added to Visual Basic with its 2005 release, although their System namespace equivalents have been in .NET since its inception. Unlike the other core data types, these four types are not “CLS-compliant”; that is, they cannot be used to interact with .NET components and languages that limit themselves to just the very core required features of .NET. Generally this is not much of a limitation, but be on your guard when working with third-party components or languages.

When I mentioned the need for declaration and assignment of variables, I was really focusing on value types. Reference types require one additional step: instantiation. Consider the following declaration statements:

Dim defaultValue As Integer
Dim nonDefaultValue As Integer = 5
Dim defaultReference As Object

These lines declare three separate variables: two value types (the Integers) and one reference type (the Object). Although only one variable has an explicit data assignment, all three have actually been assigned something, either explicitly or implicitly. Let’s look at those statements again and see what is truly being assigned to each variable.

Dim defaultValue As Integer = 0
Dim nonDefaultValue As Integer = 5
Dim defaultReference As Object = Nothing

Both declaration and assignment already occurred for all the variables, just by using the Dim statement. The defaultValue variable, with its default assignment of 0, can be used immediately in equations. However, the reference type variable defaultReference is just an empty teacup, with no default data to manipulate. There are features in Visual Basic that let you compare a reference type with Nothing, and you could do this immediately, but it’s not really data. And remember, variables live to manage data.

Reference data values need instantiation, and instantiation needs the New keyword:

Dim defaultReference As Object = New Object

Now defaultReference points to a real object; now the defaultReference teacup has something consumable inside it, although since it is just System.Object, it doesn’t have much in the way of flavor. Strings are a little more interesting, and they also have more interesting constructors.

As you may recall from way back in Chapter 1, a constructor is a block of initialization code that runs when you create a new data value or object. Some objects allow you to supply extra information to a constructor, additional information that is used in the initialization process. A default constructor doesn’t allow you to supply any extra information; it just works on its own, initializing data like it was nobody’s business. There is no limit on the number of constructors in a class, but each one must vary in the type of extra information passed to it.

So, back to Strings. The default constructor for a string simply creates a blank, zero-length string:

Dim worldsMostBoringString As String = New String

Now, nobody ever does this, since the following statement works just as well:

Dim worldsMostBoringString As String = ""

That’s because Strings are treated specially by Visual Basic. String literals are actually instantiations of String data values; it’s as though you created a new String instance using the System.String class. At least that’s true when using the String data type’s default constructor. But String also has more interesting constructors. (I’ll delve into the details of constructors in Chapter 8.) One of the constructors creates a new String instance initialized with a specific character repeated a number of times. For instance, to create a String instance with a 25-character string of the letter M, use the following syntax:

Dim mmGood As String = New String("M"c, 25)

If you’re going to use the same data type just after the As keyword that you use right after the New keyword, you can use a collapsed syntax:

Dim mmGood As New String("M"c, 25)

As with value types, you can also break the statement into distinct declaration and assignment statements:

Dim mmGood As String
mmGood = New String("M"c, 25)

Literals don’t change, but you can use them only once in your code. Constants are a cross between a literal and a variable; they have a single, never-changing value just like data literals, but they also have a name that you can use over and over again, just like variables.

You declare constants using the Const keyword instead of the Dim keyword:

Const SpeedOfLight As Integer = 186000

Actual assignment of the value to the constant occurs in the statement itself, with the value following the = operator. Once your constant is declared and assigned, it’s available for use in actual statements of your actual code:

MsgBox("Lightspeed in miles/second: " & SpeedOfLight)

In the real world, you need to keep some data private, for your use only. Your neighbors have other juicy bits of data and information that they share among themselves. And then there is public data that isn’t hidden from anyone. But it’s not just this way in the real world; the fake world of Visual Basic has different levels of access and privacy for your data.

A little later in the chapter, we’ll see that your application’s logic code will always appear in procedures, named blocks of source code. You declare local variables (and constants) in these same procedures when you need a short-lived and personal variable that is only for use within a single procedure. Other variables (and constants) can appear outside procedures, but still within the context of a class or similar type. These fields, whether variable or constant, are immediately available to all the different procedures that also call the current class home.

You define all local variables using the Dim keyword. The Dim statement works for field definitions, but it’s more common to use special access modifier keywords instead. These modifiers determine what code can access the fields, from Private (used only by code inside the class) to Public (also available outside the class):

Private ForInClassUseOnly As Integer

There are five access modifiers in all. I’ll talk more about them and about fields in general in Chapter 6.

The most common conditional statement is the If statement. It is equivalent to English questions in the form “If such-and-such is true, then do so-and-so.” For instance, it can handle “If you have $20, then you can buy me dinner,” but not “If a train departs Chicago at 45 miles per hour, when will it run out of coal?”

If statements have syntax that spans multiple source code lines:

01  If (hadAHammer = True) Then
02     DoHammer(inTheMorning, allOverThisLand)
03     DoHammer(inTheEvening, allOverThisLand)
04  ElseIf (hadAShovel = True) Then
05     DoShovel(inTheNoontime, allOverThisLand)
06  Else
07     TakeNap(allDayLong, onMySofa)
08  End If

The If statement lets you define branches in your code based on conditions. It is built from three main components:

If statements are cool because they make your code more than just a boring set of linear step-by-step instructions that never deviate for any reason. Software is written to support some real-world process, and real-world processes are seldom linear. The If statement makes it possible for your code to react to different data conditions, taking the appropriate branch when necessary.

Once the entire If...End If block completes, processing continues with the next statement that follows the End If statement.

Sometimes you might write an If statement that tests a variable against one possible value, then another, then another, then another, and so on:

If (billValue = 1) Then
   presidentName = "Washington"
ElseIf (billValue = 2) Then
   presidentName = "Jefferson"
ElseIf (billValue = 5) Then
   presidentName = "Lincoln"
...

And on it goes, through many more ElseIf clauses. It’s effective, but a little tedious, as your code must specifically test every case. The Select Case statement provides a cleaner alternative for simple value comparisons against a list:

01  Select Case billValue
02     Case 1
03        presidentName = "Washington"
04     Case 2
05        presidentName = "Jefferson"
06     Case 5
07        presidentName = "Lincoln"
08     Case 20
09        presidentName = "Jackson"
10     Case 50
11        presidentName = "Grant"
12     Case 10, 100
13        presidentName = "!! Non-president"
14     Case > 100
15        presidentName = "!! Value too large"
16     Case Else
17        presidentName = "!! Invalid value"
18  End Select

Unlike the If statement, which checks for a Boolean result, Select Case compares a single value against a set of test case values. In the example, the billValue variable is compared against the different values identified by each Case clause. All code that follows a Case clause (until the next Case clause) is the branch that is processed when a match is found. An optional Case Else condition (line 16) catches anything that is not matched by any other Case. Normally, Case clauses list single values for comparison. They can also include a list of comma-separated comparison values (line 12), or simple range comparison expressions (line 14).

Visual Basic includes two variations of the If statement for “inline” use. Consider the following statement:

If (gender = "F") Then fullGender = "Female" _
   Else fullGender = "Male"

Using the IIf function, this statement compresses into a single assignment statement with an embedded condition:

fullGender = IIf(gender = "F", "Female", "Male")

The IIf function has three comma-delimited arguments. The first is the condition, which must result in a Boolean True or False value. The second argument is returned by the function if the condition is True; a condition result of False returns the third argument. For simple conditions that are destined to return single values to a common variable, it’s really a useful function. But with anything really useful, there are caveats. The caveat with IIf is that anything appearing inside the IIf statement will be processed, even if it is not returned as a result. Here’s a dangerous example:

purgeResult = IIf(level = 1, PurgeSet1(  ), PurgeSet2(  ))

The statement will correctly return the result of either PurgeSet1( ) or PurgeSet2( ) based on the value of level. The problem, or potential problem, is that both functions, PurgeSet1( ) and PurgeSet2( ), will be called; if level is 1, both PurgeSet1( ) and PurgeSet2( ) will be called, even though only the function result from PurgeSet1( ) will be returned.

To help avoid such side effects, Visual Basic 2008 added the new If operator. It looks just like the IIf function, except for the keyword If replacing the IIf keyword:

purgeResult = If(level = 1, PurgeSet1(  ), PurgeSet2(  ))

Now only PurgeSet1( ) or PurgeSet2( ) will be called based on the condition, but not both. Although the If operator looks like a function, it is actually a true operator, known as the ternary operator. At compile time, Visual Basic treats it and its arguments as operator and operands and generates the appropriate logic.

A variation of the If operator takes just two arguments, excluding the initial Boolean argument.

realObject = If(object1, object2)

In this version of the If operator, if the first argument evaluates to Nothing, the operator returns the second argument. If the first argument is not Nothing—that is, if it really is something—the operator returns that first argument instead. The goal is to return non-Nothing, although that’s a double negative.

The For...Next loop uses a numeric counter that increments from a starting value to an ending value, processing the code within the loop once for each incremented value.

Dim whichMonth As Integer
For whichMonth = 1 To 12
   ProcessMonthlyData(whichMonth)
Next whichMonth

This sample loops 12 times (1 To 12), once for each month. You can specify any starting and ending values you wish; this range can also be specified using variables or functions that return numeric values. Once the starting and ending values are obtained, they are not recalculated each time through the loop, even if a function call is used to obtain one or both limits.

' ----- Month(Today) returns the numeric month
'       for the current date.
For whichMonth = 1 To Month(Today)
   ProcessMonthlyData(whichMonth)
Next whichMonth

Normally, the loop increments by one (1) each time through. You can alter this default by attaching a Step clause to the end of the For statement line:

For countDown = 60 To 0 Step −1
   ...
Next countDown

One additional syntax variation allows you to declare the loop counter variable within the statement itself. Such variables are available only within the loop, and cease to exist once the loop exits.

For whichMonth As Integer = 1 To 12
   ProcessMonthlyData(whichMonth)
Next whichMonth

A variation of the For loop, the For Each...Next loop scans through a set of ordered and related items, from the first item until the last. Arrays and collection objects also work, as does any object that supports the IEnumerable interface (all these topics are covered in Chapter 6). The syntax is quite similar to the standard For statement:

For Each oneRecord In setOfRecords
   ProcessRecord(oneRecord)
Next oneRecord

Sometimes you want to repeat a block of code as long as a certain condition is true, or only until a condition is true. The Do...Loop structure performs both of these tasks. The statement includes a While or Until clause that specifies the conditions for continued loop processing. For instance, the following statement does some processing for a set of dates, from a starting date to an ending date:

Dim processDate As Date = #1/1/2000#
Do While (processDate < #2/1/2000#)
   ' ----- Perform processing for the current date.
   ProcessContent(processDate)

   ' ----- Move ahead to the next date.
   processDate = processDate.AddDays(1)
Loop

Processing in this sample will continue until the processDate variable meets or exceeds 2/1/2000, which indicates the end of processing. The Until clause version is somewhat similar, although with a reversed condition result:

Do Until (processDate >= #2/1/2000#)
   ...
Loop

Make the included condition as simple or as complex as you need. Putting the Until or While clause at the bottom of the loop guarantees that the statements inside the loop will always be processed at least once:

Do
   ...
Loop Until (processDate >= #2/1/2000#)

If the loop condition is never met, the loop will continue forever. So, if you want your loop to exit at some point (and usually you do), make sure the condition can eventually be met.

There is another loop that is similar to Do...Loop, called the While...End While loop. However, it exists for backward compatibility only. Use the Do...Loop statement instead.

Normally, when you enter a loop, you have every intention of looping for the full number of times specified by the initial conditions of the loop. For For loops, you expect to continue through the entire numeric range or collection of elements. In Do loops, you plan to keep the loop going as long as the exiting condition has not yet been met. But there may be loops that you want to exit early. You accomplish this using an Exit statement.

There are two loop-specific Exit statements:

Each Exit statement exits the loop that contains the statement; processing continues with the line immediately following the loop:

For whichMonth = 1 To 12
   If (ProcessMonthlyData(whichMonth) = False) Then Exit For
Next whichMonth
' ----- Code continues here no matter how the loop was exited.

The sample code is designed to loop through all 12 months. However, a processing failure for any of the 12 months will immediately exit the loop, abandoning all remaining month processing actions. The Exit Do statement similarly exits Do...Loop loops immediately.

In an Exit loop statement within nested loops (where one loop appears within another), only the matching loop that immediately contains the statement is exited:

For whichMonth = 1 To 12
   For whichDay = 1 to DaysInMonth(whichMonth)
      If (ProcessDailyData(whichMonth, whichDay) = False) _
         Then Exit For
   Next whichDay
   ' ----- The Exit For statement jumps to this line.
   '       Processing continues with the next month.
Next whichMonth

Since exiting a loop abandons all remaining passes through the loop, you may miss out on important processing that would have happened in subsequent passes. Visual Basic includes a Continue statement that lets you abandon only the current pass through the loop.

There are different Continue statement variations for each loop type:

Since the loop conditions are re-evaluated when using the Continue statements, there are times when Continue may cause the loop to exit, such as when it had been the final pass through the loop already.

In this example, the Continue For statement skips processing for months that have no data to process:

For whichMonth = 1 To 12
   If (DataAvailable(whichMonth) = False) Then Continue For
   RetrieveData(whichMonth)
   ProcessData(whichMonth)
   SaveData(whichMonth)
Next whichMonth

Subroutines begin with a Sub declaration statement and end with an End Sub statement. All of your subroutine’s logic appears in between these two mighty jaws.

01  Sub ShowIngredients(ByVal gender As Char)
02     Dim theMessage As String = "Unknown."
03     If (gender = "M"c) Then
04        theMessage = "Snips and snails and puppy dog tails."
05     ElseIf (gender = "F"c) Then
06        theMessage = "Sugar and spice and everything nice."
07     End If
08     MsgBox(theMessage)
09  End Sub

Line 01 shows the subroutine’s declaration line in its simplest form; throughout the book, you will find that there are additional keywords that decorate procedure declarations to change their behavior. The statement begins with the Sub keyword (for subroutine), followed by the name of the procedure, ShowIngredients.

The parentheses following this name contain the subroutine’s parameters. Parameters allow another block of code that will use this procedure to pass data into the procedure, and optionally receive data back. You can include any number of parameters in the subroutine definition; simply separate them by commas. Each parameter specifies the name as it will be used in the procedure (gender in the sample) and its data type (Char). The arguments are treated as declared variables within the procedure, as is done with gender on lines 03 and 05.

The values supplied by the calling code are known as arguments. All arguments are passed by value or by reference. In the sample code, the argument passed into gender will be passed by value, as specified through the ByVal keyword. The related ByRef keyword indicates an argument to be passed by reference. If you don’t include either keyword, ByVal is assumed. This passing method impacts whether changes made to the argument within the local procedure are propagated back to the calling code. However, the ability to update the original data is also influenced by whether the data is a value type or a reference type. Table 2-3 indicates the behavior for each combination of passing method and data type.

In most cases, if you are interested in modifying the value of a parameter and having the changes return to the caller, use ByRef; otherwise, use ByVal.

Lines 02 through 08 in the sample code comprise the body of the procedure, where all your logic appears. Any variables to be used solely in the routine are also defined here, as with the theMessage variable on line 02. The subroutine always concludes with an End Sub statement.

The syntax of a function differs only slightly from subroutines, to support a return value.

01  Function IsPrime(ByVal source As Long) As Boolean
02     ' ----- Determine whether source is a prime number.
03     Dim testValue As Long
04     If (source < 2) Then
05        Return False
06     ElseIf (source > 2) Then
07        For testValue = 2 To source  2&
08           If ((source Mod testValue) = 0) Then
09              Return False
10           End If
11        Next testValue
12     End If
13     Return True
14  End Function

As with subroutines, the function’s declaration line appears first (line 01), followed by the body (lines 02 through 13) and the closing End Function statement (line 14). The declaration line includes an extra data type definition after the parameter list. This is the data type of the final value to be returned to the calling code. Use this return value in the calling code just like any other value or variable. For example, the following line calls the IsPrime function and stores its Boolean result in a variable:

primeResult = IsPrime(23)

To indicate the value to return, use the Return statement (described later in the chapter). The sample code does this on lines 05, 09, and 13. (An older VB 6.0 syntax that lets you assign the return value to the name of the function still works.)

A little earlier I mentioned fields, which are variables or constants that appear within a class, but outside any procedure definition.

01  Class PercentRange
02     Public Percent As Integer
03  End Class

Properties are similar to fields; they are used like class-level variables or constants. But they are programmed like functions, accepting parameters, having return values, and including as much logic as you require.

Properties are often used to protect private class data with logic that weeds out inappropriate values. The following class defines a single property that provides access to the hidden related field:

01  Class PercentRange
02     ' ----- Stores a percent from 0 to 100 only.
03     Private savedPercent As Integer
04     Public Property Percent(  ) As Integer
05        Get
06           Return savedPercent
07        End Get
08        Set(ByVal value As Integer)
09           If (value < 0) Then
10              savedPercent = 0
11           ElseIf (value > 100) Then
12              savedPercent = 100
13           Else
14              savedPercent = value
15           End If
16        End Set
17     End Property
18  End Class

The Percent property (lines 04 to 17) protects access to the savedPercent field (line 03), correcting any caller-supplied values that exceed the 0 to 100 range. Properties include separate assignment and retrieval components, also called accessors. The Get accessor (lines 05 to 07) returns the property’s monitored value to the caller. The Set accessor (lines 08 to 16) lets the caller modify the value of the property.

The property declaration statement (line 04) includes a data type that matches the data type passed into the Set accessor (line 08). This is the data type of the value set or retrieved by the caller. To use this sample Percent property, create an instance of the PercentRange class, and then use the property:

Dim activePercent As New PercentRange
activePercent.Percent = 107    ' An out-of-range Integer
MsgBox(activePercent.Percent)  ' Displays "100", not "107"

You can create read-only or write-only properties by including the ReadOnly or WriteOnly keyword just before the Property keyword in the declaration statement (line 04), and leaving out the unneeded accessor.

Properties do not need to be tied to fields. You can use properties to get and set any type of value, and store it or act upon it in any manner you wish.

Back in the good ol’ days of Visual Basic 6.0, procedures could appear just about anywhere in your source code files. You would open a source file, type a function, and go; it was that easy. With the move to .NET, all Visual Basic procedures must now appear within a defined class (or a structure or module).

Class Employee
   Sub StartVacation(  )
      ...
   End Sub

   Function TotalVacationTaken(  ) As Double
      ...
   End Function
End Class

When you create instances of your class later in code, the methods can be called directly through the object instance.

Dim executive As New Employee
...
executive.StartVacation(  )

Chapter 8 shows you how to use and build classes.

The GoTo statement lets you jump immediately to some other location within the current procedure. The destination of a jump is always a line label, a named line position in the current procedure. All line labels appear at the start of a logical line, and end with a colon.

PromptUser:
   GetValuesFromUser(numerator, denominator)
   If (denominator = 0) Then GoTo PromptUser
   quotient = numerator / denominator

In this sample, the GoTo statement jumps back to the PromptUser label when the code detects invalid data. Processing continues with the line immediately following the PromptUser label. You can’t use the same label name twice in the same procedure, although you can reuse label names in different procedures. If you want, include another logic statement on the same line as your label, right after the colon, although your code will be somewhat easier to read if you keep labels on their own lines.

LabelAlone:
   MsgBox("It's all alone.")
LabelAndCode: MsgBox("Together again.")

It’s all right to include as many labels in your code as you need, but the GoTo statement is one of those elements of Visual Basic that is monitored closely by pesky international software agencies, such as the International Committee to Keep GoTo Always Gone (ICK-GAG). That group also scans computer books looking for derogatory references to its organization name—not that it would find anything like that in this book. But its core issue is that overuse of GoTo statements can lead to spaghetti code, such as the following:

Dim importantMessage As String = "Do"
GoTo Step2
Step6: importantMessage &= "AG!"
GoTo Step7
Step3: importantMessage &= "wit"
GoTo Step4
Step2: importantMessage &= "wn "
GoTo Step3
Step5: importantMessage &= "CK-G"
GoTo Step6
Step4: importantMessage &= "h I"
GoTo Step5
Step7: MsgBox(importantMessage)

Some people say that such code is hard to read. Others call it job security. No matter what you call it, it does make code very hard to maintain and review. You should probably keep an eye on your use of GoTo statements; if you don’t, someone else might.

Visual Basic itself places some limits on the use of GoTo. You cannot jump into or out of certain multiline statements that would result in improperly initialized code or data values. For instance, you cannot jump into the middle of a For...Next statement from outside the statement, since the loop counter variable and the starting and ending ranges would not be properly initialized.

' ----- This GoTo statement will fail.
GoTo InsideTheLoop
For counter = 1 to 10
InsideTheLoop:
   MsgBox("Loop number: " & counter)
Next counter

However, once you are inside the loop, you can jump to line labels that also appear in the loop, and it’s acceptable to jump out of the loop using GoTo. Some other multiline structures impose similar restrictions.

Not only can you jump around within a procedure using GoTo, but you can also jump right out of a procedure anytime you want using the Return statement. Normally, a procedure exits when processing reaches the last line of code in the procedure; processing then continues with the code that called the procedure. The Return statement provides a way to exit the procedure before reaching the end.

In subroutines, the Return statement appears by itself as a standalone statement:

Return

In functions, the statement must include the value to be returned to the calling code: a variable, a literal, or an expression that must match the specified return value data type of the function.

Return 25

Pre-.NET releases of Visual Basic used an Exit statement to immediately leave a procedure. These are still supported in .NET. There are three variations:

When exiting from a function, the Exit Function statement does not include a way to specify a return value. You must set the return value separately by assigning the return value to the name of the function.

Function SafeDivide(ByVal numerator As Double, _
      ByVal denominator As Double) As Double
   ' ----- The "#" sign makes a number a Double.
   If (denominator = 0#) Then
      ' ----- Return 0 on invalid division.
      SafeDivide = 0#
      Exit Function
   End If
   Return numerator / denominator
End Function

The End and Stop statements bring an immediate halt to your Visual Basic application. The End statement exits your program immediately, aborting all further code and data processing (although certain acquired resources are cleaned up).

The Stop statement suspends processing only when you are running your application within a debugger, such as the Visual Studio development environment. Stop returns control to the environment, allowing the developer to examine and possibly alter data and code before continuing on with the program. If a Stop is encountered in a standalone application running outside the debugger, it prompts the user to debug the application using any debugger installed on the workstation. Needless to say, the user will not be amused.

Before namespaces can be used in your code, they must be referenced and optionally imported. Referencing a namespace identifies the DLL assembly file that contains that namespace’s types. Perform both of these actions through the References tab of each project’s Properties form (see Figure 2-3).

Figure 2-3. References and imports for a project

Actually, you are not referencing the namespaces in the DLL, but rather the types, all of which happen to live in specific namespaces. However, for the core type DLLs supplied with the .NET Framework, it feels like the same thing. In fact, Microsoft even named many of the DLLs to match the namespaces they contain. System.dll contains types within the System namespace. System.Windows.Forms.dll includes types specific to Windows Forms applications, and all of these types appear in the System.Windows.Forms namespace or one of its subordinates.

If you don’t reference a DLL in your project, none of its types will be available to you in your code. Visual Studio loads several references into your project automatically based on the type of project you create. Figure 2-3 shows the nine default references included within a Windows Forms application: System, System.Core, System.Data, System.Data.DataSetExtensions, System.Deployment, System.Drawing, System.Windows.Forms, System.Xml, and System.Xml.Linq.

Once you have referenced a library of classes (or other types) in your code, access any of its classes by specifying the full namespace to that class. For instance, the class for an on-screen form is referenced by System.Windows.Forms.Form. That’s three levels down into the hierarchy, and some classes are even deeper. I hope that your health insurance plan covers carpal tunnel syndrome.

To avoid typing all those long namespaces over and over again, Visual Basic includes an imports feature. Imports are namespace-specific; once a namespace has been imported, you can access any of the types in that namespace without specifying the namespace name. If you import the System.Windows.Forms namespace, you only have to type “Form” to access the Form class. The bottom half of Figure 2-3 shows how to set these imports through the project’s properties. The “Imported namespaces” list shows all available referenced namespaces. Simply check the ones you wish to import; System.Windows.Forms is already checked for you by default in Windows Forms applications.

You can also import a namespace directly in your source code. Use the Imports statement at the very start of a source code file:

Imports System.Windows.Forms

The Imports statement supports namespace abbreviations, short names that represent the full namespace in your code. Using the statement:

Imports Fred = System.Windows.Forms

lets you reference the Form class as “Fred.Form.” Unlike the imports list in the project’s properties, which impacts the entire project, the Imports statement affects only a single source code file.

By default, all the classes and types in your project appear in a top-level namespace that takes on the name of your project. For a Windows Forms application, this default namespace is called WindowsApplication1. To specify a different top-level namespace, modify it through the Application tab of the project’s properties, in the “Root namespace” field. All the types in your project appear in this namespace; if you specify an existing Microsoft-supplied namespace as your project’s root namespace, all your types will appear in that specified namespace mixed in with the preexisting types. For standalone applications, this mixture will be visible only from your code.

From the root namespace, you can place types within subordinate namespaces by using the Namespace statement. Namespace is a block statement that ends with the End Namespace clause. Any types you create between the Namespace and End Namespace clauses will be contained in that subordinate namespace. For example, if your root namespace is WindowsApplication1, the following statements create a class whose full name is WindowsApplication1.WorkArea.BasicStuff.BusyData:

Namespace WorkArea.BasicStuff
   Class BusyData
      ...
   End Class
End Namespace

You can include as many Namespace statements in your code as needed. Nesting of namespaces is also supported:

Namespace WorkArea
   Namespace BasicStuff
      Class BusyData
         ...
      End Class
   End Namespace
End Namespace