In general, Visual Basic statements begin anywhere on a line and end where the line ends. There are no semicolons, periods, or other punctuation at the end of a Visual Basic statement. Except within literals, any number of contiguous space or tab characters are equivalent to one space. Blank lines are irrelevant except for readability.

To continue a statement onto a second line, code a space and an underscore at the end of the continued line. The following code shows one statement continued across two lines:

lngZeta = lngAlpha + lngBeta + lngGamma _
    + lngDelta + lngEpsilon

With two exceptions, Visual Basic treats anything between an apostrophe and the end of a line as comments. The exceptions are as follows:

If you’re accustomed to using VBScript (the version of Visual Basic that classic ASP developers used), you’re accustomed to using only two data types: Variants and Objects. Well, in Visual Basic .NET, Microsoft has eliminated the Variant type, substituted Object as the default type, and then discouraged you from using the Object type. Instead, Microsoft encourages you to use the specific data types listed in the "Data Type Summary" table.

To declare a variable, use the Dim statement as shown:

Dim strDescription As String
Dim intQuantity As Integer = 0
Dim booAnswer As Boolean = False

Specifying a value is optional. If you don’t assign a value when you declare a variable, Visual Basic assigns an empty string, zero, or false, depending on the data type.

If you declare a variable without specifying a data type, Visual Basic makes the variable an Object. Later, when your code is running, an Object variable can refer to any of the other data types, but assigning or changing object types at run time (a practice called late binding or run-time binding) is a time-consuming operation. For this reason, it’s best to use specific data types when declaring variables.

In all previous versions of Visual Basic, you didn’t need to code Dim statements for each variable unless you began the program or Web page with the statement:

Option Explicit

This is another area where Visual Basic .NET has changed: Option Explicit is now in effect unless you specifically turn it off. Don’t do this! The time and trouble of coding a Dim statement for each variable is nothing compared to the grief of debugging program code when a misspelled variable name provides an empty value where you expected real data. In addition, all Visual Basic variables not defined with a Dim statement are defined as Objects, and therefore incur the performance penalty of late binding. For more information about turning the Explicit option on or off, refer to "Coding the @ Page Directive" in Responding to Web Form Events in Chapter 3.

The following data types warrant particular mention:

If you declare several variables with a single Dim statement, all the variables will be the same type. In the following statement, for example, the lngJohn, lngTime, and lngGone variables will all be Long:

Dim lngJohn, lngTime, lngGone As Long

Previous versions of Visual Basic would designate lngJohn and lngTime as Variants and lngGone as Long.

Like Visual Basic 6 (and unlike VBScript), Visual Basic .NET supports user-defined types. These are basically structures that contain several variables of other types. You can access the whole structure as a single unit, or you can access its members individually.

A structure declaration consists of a Structure statement, then one or more member definitions, and then an End Structure statement. (Visual Basic 6 used a Type statement rather than a Structure statement.) Here’s an example:

Structure stcAddress
  Dim strStreet As String
  Dim strCity As String
  Dim strState As String
  Dim strPostCode As String
  Dim strCountry As String
End Structure

Once you’ve defined this structure, you can use it to define other variables. Suppose, for example, that you coded

Dim adrMyAddress As stcAddress
Dim adrYourAddress As stcAddress

You could then code statements such as

adrMyAddress.strStreet = "1600 Pennsylvania Avenue"
adrMyAddress.strCity = "Washington"
adrMyAddress.strState = "DC"
adrMyAddress.strPostCode = "20500"
adrMyAddress.strCountry = "USA"
adrYourAddress = adrMyAddress

Here’s the complete syntax for declaring a structure:

[Public|Private|Protected] Structure structname
  {Dim|Public|Private|Friend} member1 As datatype1
  ...
  {Dim|Public|Private|Friend} memberN As datatypeN
End Structure

The keywords Public, Private, Protected, and Friend control the degree of access to structures you define within a class. The table in Chapter 8 later in this chapter explains these keywords. Variables you declare without these keywords—using only the Dim keyword—are available everywhere within the region that contains the Dim statement. If a Dim statement is within a subroutine, the variable is available only within that subroutine. If a Dim statement is within a module, class, or structure, the variable is available anywhere within that module, class, or structure. For more information about defining classes, refer to "Defining Subroutines, Functions, and Classes" later in this chapter.

The following table lists the built-in functions Visual Basic .NET provides for converting one data type to another. These functions accept arguments of almost any data type and convert them to the types listed. If the conversion isn’t possible, the function will raise an exception.

Like most programming languages, Visual Basic .NET supports the use of literals. A literal is a value, such as 503, 2.5, or "doughnut", that you code in place of a variable. Literal values are read-only. You can’t change the value of 2 by coding a statement such as the following:

2 = 1 + 1 + 1

Constants are read-only named values. The following statement, for example, defines a constant named PSWD that’s equal to "sesame":

CONST PSWD = "sesame"

Having coded this statement, you could use the name PSWD instead of the value "sesame" in your code, making it easier to find and update the password when necessary. Constants are also a good solution when you use the same value several times in your code and it’s important that you code this value exactly the same way in each instance.

You can also use simple expressions to define the value of constants. The declarations below illustrate this:

CONST ENOUGH = 100
CONST TOO_MUCH = ENOUGH + 1

However, you can use only expressions that the compiler can evaluate at compile time. The following declaration would produce a compiler error because the compiler can’t predict what the value of Now() will be when the Web page actually runs:

CONST THE_DATE = Now()

Constants can also be part of the object model for controls or components you’re working with. Importing a namespace, for example, typically makes a large number of constants available to your ASP.NET page. Your code will be easier to read, easier to debug, and more accurate if you use the constants supplied for use with a certain method or property, rather than hard-coding values that have no obvious meaning. The documentation for the namespace, property, or method will list these constants.

Constants and literals in Visual Basic .NET have data types, just as variables do. The table below lists the default data types for various kinds of literals. The default data type for a constant is the data type of its literal.

strText = "Tom said, ""Sorry,"" but Anne wasn't impressed."

If you wish, you can also code the data type of a constant explicitly. The possibilities are Boolean, Char, String, Byte, Integer, Short, Long, DateTime, Single, Double, and Decimal. Here’s an example:

Public Const NORM_TEMP As Single = 37

There are at least three reasons for coding constant and literal types explicitly:

There are two ways to force the data type of a literal. For some data types, you enclose the literal value with special enclosing characters. For others, you append a special type character to the value. The enclosing characters and type characters for each data type are shown below. The literal 5S, for example, indicates a Short with a value of 5.

Visual Basic .NET provides the built-in constants listed in the table "Visual Basic .NET Print and Display Contents." These are frequently useful when you need to include nonprintable characters in an output stream. The notation Chr(13) means ASCII character 13, the carriage return.

An operator is a symbol or keyword that tells Visual Basic to take action on one or more expressions. In the expression 1 + 2, for example, the + operator tells Visual Basic to add the two numbers. The next few sections describe the basic operators that Visual Basic.NET provides.

decTotalPrice = decTotalPrice + decUnitPrice

decTotalPrice += decUnitPrice

Let strThere = strLight

strThere = strLight

objEct1 = objEct2

objEct1 = New <object type> (<constructor params, if any>)

strResult = "Welcome to " + "my circus."
strResult = "Welcome to " & "my circus."

(lngOrderQty > 0) And (lngOnHandQty > 0)

IsNumeric(strQuantity) And (clng(strQuantity) > 0)

If IsNumeric(strQuantity) Then
    If (clng(strQuantity) > 0) Then
'       Code that does the work goes here.
    End If
End If

IsNumeric(strQuantity) AndAlso (clng(strQuantity) > 0)

Visual Basic .NET stores times and dates in the same way as all other .NET languages and components. Specifically, they’re 64-bit integers that count the number of 100-nanosecond "ticks" since midnight, Coordinated Universal Time, January 1 of the year 1 in the Gregorian calendar. The time value for one second after midnight on 1-Jan-0001 is 10,000,000.

Previous versions of Visual Basic stored dates as floating-point numbers. The integer part counted the number of days since December 30, 1899, and the fractional part represented a time of day. The number 2.25, for example, meant January 1, 1900, at 6:00 A.M. This system made it easy to determine the difference in days between two dates, to add 7 days to a certain date, and so forth. Unfortunately, these sorts of computations no longer produce meaningful results. Adding 7 to a date in the new DateTime format adds 700 nanoseconds.

DateTime comparisons such as greater than and less than still work reliably. Equality comparisons work too, provided that the margin of error is less than 100 nanoseconds.

You can specify DateTime values in code either by enclosing a suitably formatted string in number signs or by using the DateTime constructor method. The following pairs of statements are equivalent:

Dim dtmDateDue as DateTime = #12/31/2002#
Dim dtmDateDue as New DateTime(2002, 12, 31)

dtmDateDue = #12/31/2002#
dtmDateDue = New DateTime(2002, 12, 31)

dtmDateDue = #12/31/2002 1:30 PM#
dtmDateDue = New DateTime(2002, 12, 31, 13, 30, 0)

When you use the DateTime constructor method, you can specify one, three, six, or seven arguments. These have the following significance:

In addition to changing the date format, Visual Basic .NET drops support for several date functions that earlier versions of Visual Basic have supported for some time. These legacy functions, along with the comparable Visual Basic .NET functions, are listed in the table below.

Visual Basic .NET continues to support all the remaining date and time functions shown in the following table, taking the new DateTime format into account as necessary.

If none of these functions serve your needs, then perhaps one of the many date and time functions built into the .NET Framework will help. For starters, the following expressions return the minimum and maximum permissible date values:

DateTime.MaxValue
DateTime.MinValue

Using the methods listed in the table "DateTime Public Static (Shared) Methods" requires a similar notation. The following expression, for example, returns False because the year 2100 won’t be a leap year:

DateTime.IsLeapYear(2100)

If you still haven’t found a function that meets your needs, consider the DateTime properties listed in the "DateTime Public Instance Properties" table. These properties are available for every DateTime object. If the variable dtmDateDue is a DateTime value, the following expressions return its year, month, day, hour, and minute values:

dtmDateDue.Year
dtmDateDue.Month
dtmDateDue.Day
dtmDateDue.Hour
dtmDateDue.Minute

Visual Basic .NET aims to please. If, by some incredible chance, none of the preceding functions or properties meet your important date-processing needs, one of the methods listed in the next table might be just the ticket. To use these methods, code the name of a DateTime object, a period, the method name, and then (in parentheses) any required arguments. Both of the following statements, for example, add seven days to the DateTime variable dtmDateDue. To subtract an interval, use an Add method and specify a negative amount.

dtmDateDue.Add(TimeSpan.FromDays(7))
dtmDateDue.AddDays(7)

The ToLocalTime and ToUniversalTime methods warrant a bit of additional explanation. By default, the starting point for all DateTime values is midnight, Coordinated Universal Time. Using this starting point eliminates endless confusion when computers in different time zones exchange dates, particularly in real time over a network.

The fact that dates on your computer are actually in UTC is almost never apparent because all the standard date functions automatically convert UTC to your local time zone, based on settings in the Windows Control Panel. This behind-the-scenes step eliminates any need to use the ToLocalTime and ToUniversalTime methods in ordinary software applications. However, if you do find a need to make these conversions, the necessary methods are ready and waiting.

String handling is a major part of the processing that goes on in most Web pages. The simple reason is that most data consists of strings.

Previous sections described how to define string constants, literals, and variables; concatenate strings; and assign the value of a string expression to another. These are worthwhile operations, but they don’t address common requirements such as the need to split, join, and otherwise modify string data. For such operations, Visual Basic .NET provides the functions listed in the following table.

Like all previous versions of Visual Basic, Visual Basic .NET supports arrays. An array, in this sense, is a series of variables, each identified by the same name but a different index number. Arrays make it easy for a program to loop through and process each variable the array contains.

Unlike previous versions of Visual Basic, Visual Basic .NET supports arrays not with its own built-in code, but through the .NET Framework’s System.Array object. This change means, for example, that when you define an array in Visual Basic .NET, you’re actually defining a .NET System.Array object. When you write traditional Visual Basic statements and expressions that process the array, Visual Basic .NET works behind the scenes and invokes System.Array properties and methods.

The fact that Visual Basic .NET implements arrays as .NET objects makes it simple to pass arrays among Visual Basic .NET modules, modules written in different programming languages, and .NET objects and interfaces of all kinds. Of course, this ease comes at a price; compared to previous versions, there are quite a few differences in the way Visual Basic .NET handles arrays.

The statement that defines a normal array hasn’t changed unless you’re accustomed to working with VBScript. The following statement, for example, defines an array of 12 integers named Month:

Dim Month(12) As Integer

In Visual Basic .NET, the following forms of declaration are also permissible. All three statements produce the same results, except that the last statement also puts values into the array.

Dim Month() As Integer = New Integer(12) {}
Dim Month() As Integer = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}

If you’re accustomed to VBScript, you’re probably not accustomed to specifying the As keyword followed by a data type. This data type applies to each element of the array. Given that all other variable declarations require data types, however, the need to specify a data type for arrays should be no surprise. The permissible data types include

In earlier versions of Visual Basic, you could define arrays that started with a subscript other than zero. This is no longer possible. Another difference is that when you code a statement such as

Dim Month(12) As Integer

Visual Basic .NET creates an array with 12 elements (the number you specified) subscripted 0 through 11. Earlier versions created 13 elements subscripted 0 through 12. If you try to access Month(12) in your code, Visual Basic .NET will throw a fit (oh, all right: an exception).

Visual Basic .NET arrays can have from one to 60 dimensions. The number of dimensions determines the array’s rank. An array of rank 3 would have three dimensions and its index would have three subscripts, as in cubicle(2, 4, 6). Most arrays have one dimension, and arrays of more than three dimensions are extremely rare.

All Visual Basic .NET arrays are variable-length, which doesn’t mean Visual Basic .NET automatically creates array elements when you access an out-of-bounds subscript. It does mean you can use the ReDim statement on any array whenever you want. The only restrictions are as follows:

The following statement, for example, would expand the length of the Month table from 12 to 24. It would then support subscripts 0 through 23. It doesn’t matter which form of the Dim statement you used when you declared the array.

ReDim Preserve Month(24)

The fact that Visual Basic .NET array variables point to a System.Array object has the following implications:

When you assign one array variable to another, Visual Basic .NET will enforce the following rules during compilation and at run time:

Like older versions of Visual Basic, Visual Basic .NET provides the array-related functions listed in the next table. The Ubound function in particular is worth noting because it always returns an up-to-date value for the maximum subscript of a table. Suppose, for example, that you defined the following table:

Dim strNames As String = {"Bill", "Mary", "Tom", "Wendy"}

If you assumed elsewhere in your code that this table contained four elements, the code would malfunction if some other part of your code changed the size of the array by using a ReDim or assignment statement. It’s much better to assume that the array contains Ubound(strNames) + 1 elements numbered 0 through Ubound(strNames).

Because Visual Basic .NET arrays inherit from the Array class in the System namespace, you can use System.Array methods and properties on any Visual Basic .NET array. The second statement in the following example displays the array’s rank. The third sorts the array based on the values in its elements.

Dim strAnimals() As String = {"Crocodile","Bison","Aardvark"}
Response.Write(strAnimals.Rank)
Array.Sort(strAnimals)

The following table lists a number of useful functions that the System.Array object provides. Note that these are methods of the System.Array object itself, and not of individual arrays. You specify the array you want to process as an argument.

To look up the calling sequence for these methods, as well as for properties and methods in the next two tables, search the MSDN Web site (msdn.microsoft.com/library) for the term NET Framework Class Library and then search within the results for the terms System, Array Class, and Members.

The "Common System.Arrray Properties" table lists the Rank property (already discussed) and the Length property, which returns a count of elements in all dimensions of an array. For most Visual Basic Web developers, the Length property of an array is something to avoid. To see why, consider the following array:

Dim TwoDim(10, 20)

The expression TwoDim.Length returns 231, which is the product of 11 × 21. The expressions Ubound(TwoDim, 1) and Ubound(TwoDim, 2), which return 10 and 20, are far more useful.

Each Visual Basic .NET array inherits the System.Array methods listed in the "Common System.Array Methods" table.

To use these methods, you append their names to the name of the array you want them to process. Here’s an example:

strVisitors.CopyTo(strHomeTeam,0)

This statement copies all the elements of the strVisitors array into the strHomeTeam array, starting at position 0 of the strHomeTeam array. Unlike the assignment statement strHomeTeam = strVisitors, the CopyTo method actually copies each element of the source array. The source and destination array variables don’t end up being aliases of the same physical table. However, the CopyTo method has its own quirks:

For the most part, the remaining methods perform functions that the Visual Basic .NET functions listed in the previous table also provide. In general, the Visual Basic .NET functions are more reliable and easier to use.

Arrays, which have been features of most programming languages since the early years of computing, provide an excellent way to process collections of data in a repetitive manner. For some jobs, however, the inherent structure of arrays makes them a poor fit. This is particularly true of collections that contain a continually variable number of items and collections where the natural identifier is alphabetic rather than numeric.

VBScript provides a Scripting.Dictionary object that meets these needs to a large extent. Basically, a programmer working in VBScript can add, update, and delete items in a Scripting.Dictionary object at will, and each item has an alphanumeric identifier. This object is often useful when using an array would be awkward, but it doesn’t keep its entries in order by key value. In other words, it doesn’t accommodate situations where you need a variable number of numeric keys or where you need alphanumeric keys kept in order.

To resolve these issues in Visual Basic .NET, Microsoft chose not to implement a .NET version of the Scripting.Dictionary object, but to implement the following objects instead:

Although tables and collections can both store structures and objects, the ADO.NET DataTable is much better suited to handling data records. For more information about DataTables, refer to Chapter 7.

To add one of these objects to your Web page, simply declare it as shown:

Dim arlNames As New ArrayList
Dim htbNames As New Hashtable
dim stlNames As New SortedList
dim queNames As New Queue
dim stkNames As New Stack

The table ".NET Collection Methods" summarizes the methods available for each object type, and ".NET Collection Properties" summarizes the properties. To the extent possible, Microsoft has implemented the same properties and methods for all five collections. All five objects, for example, have a Count property that reports the number of items the object currently stores.

The Add method adds an item to an ArrayList, Hashtable, or SortedList collection.

The Remove method removes one element from an ArrayList, Hashtable, or SortedList collection, based on a method argument you supply. An ArrayList removes the first element with a value that matches the Remove argument. Hashtables and SortedLists remove the element with a key value that matches the Remove argument.

The RemoveAt method removes an element of an ArrayList or SortedList collection based on its numeric index. The RemoveRange method removes a range of elements from an ArrayList.

For a Queue collection, the Enqueue and Dequeue methods add and remove items. For a Stack collection, the Push and Pop methods do the same.

For more information about any of these objects, their properties, or their methods, search the MSDN Web site (msdn.microsoft.com/library) for the term System.Collections.

In Visual Basic .NET, objects no longer have default properties. Instead, you must spell out the name of any property you want to use. Suppose, for example, your Web page contains the following Web Server Control:

<asp:label id="lblMessage" runat="server" />

You can’t assign a value to this control by coding a statement such as the following:

lblMessage = "Pounding the computer won't help."

The variable lblMessage doesn’t contain the label control directly; instead, it contains a pointer to the label control object. The preceding statement tries to replace that pointer, and because a string value can’t point to an object, it will produce a type mismatch error. Here’s the correct statement:

lblMessage.Text = "Pounding the computer won't help."

Occasionally, Visual Basic .NET will let you retrieve the value of an object without specifying a property name—not because some objects have default properties but because type conversion happens to return the value you want. Remembering the cases where this works is usually harder than coding the exact property name you want.

Visual Basic .NET (and, for that matter, ASP.NET) is perfectly capable of using Component Object Model (COM) objects, very much as classic ASP pages have done for years. Here’s an example:

Dim cnOrderDb As Object
cnOrderDb = Server.CreateObject("ADODB.Connection")

Note the absence of a Set command at the beginning of the second statement. Set commands are neither required nor supported in Visual Basic .NET.

There is, however, a catch. Classic ASP pages use a so-called threading model called Single Threaded Apartment (STA). This model states that among all objects in a given apartment (and the apartment in this case is the Web page) only one object can execute at any given time. If two or three objects are all ready to execute, the first must end before the second can start, and so forth.

ASP.NET pages use the Multiple Threaded Apartment (MTA) threading model. If two or more objects are ready to execute, ASP.NET starts executing all of them simultaneously. This capability improves overall performance, but it requires special features in the implementation of each object. Under STA, for example, an object never has to worry about another object taking exclusive control of a resource or updating information unexpectedly. Under MTA, every object has to take these precautions. Otherwise, that object or another object might fail or produce incorrect results.

Fortunately, ASP.NET supports an operating mode that executes STA objects safely. To request this mode, simply code the AspCompat="True" attribute in a <%@Page> tag. Here’s an example:

<%@Page AspCompat="True" Language="VB"%>

Setting this attribute to True results in a slight performance penalty, so code it only if necessary.

Visual Basic .NET preserves support for all logic statements that worked in previous versions of Visual Basic. What a refreshing change! There are, however, only two such statements: If and Select. Here’s the general format of an If statement:

If [condition] Then
  [Your statements go here]
Else
  [Your statements go here]
End If

As always, the Else and its following statements are optional. In a change from previous versions, though, the End If terminator and the line ending after Then are required. The compiler will no longer accept statements such as

If txtAge.Text = "" Then lblAgeMsg.Text = "You must enter an age."

The If...ElseIf format is still supported as well, which is useful when you need to test a series of conditions until you find one that’s True. Here’s an example:

If strName = "Uang" Then
  strGift = "Bus"
ElseIf strName = "Uba" Then
  strGift = "Car"
ElseIf strName = "Uday" Then
  strGift = "Truck"
ElseIf strName = "Ugo" Then
  strGift = "Bus"
ElseIf strName = "Ujana" Then
  strGift = "Car"
End If

In such cases, the ElseIf form can be much easier than a more typical nesting of If...Else...End If statements.

The Case statement provides another way to test a series of conditions until one is true. The Case statement has this syntax:

Select Case [expression]
  Case [expression]
  Case [expression]
  Case Else
End Select

You can code as many Case statements as you like, and the Case Else statement is optional. Visual Basic .NET uses the Case expressions of Visual Basic 6, which are more flexible and powerful than those available in VBScript. The following statement, for example, is completely valid:

Select lngAge
  Case < 1
    lblDesc.Text = "Infant"
  Case 1 To 5
    lblDesc.Text = "Toddler"
  Case 6, 8
    lblDesc.Text = "Even Child"
  Case 7, 9
    lblDesc.Text = "Odd Child"
  Case 10 To 12
    lblDesc.Text = "Pre-teen"
  Case Else
    lblDesc.Text = "Trouble"
End Select

In the true spirit of progress, the following logical functions are obsolete. Visual Basic .NET no longer supports them. Goodbye.

IsEmpty, IsMissing, IsNull, IsObject

Visual Basic .NET does, however, support all the logical functions listed in the following table. Instead of using one of the stricken functions listed above, use IsDbNull for database fields and IsNothing for everything else.

The Choose function expects to receive an index value followed by a series of expressions. If the index value is 1, Choose evaluates and returns the first expression. If the index is 2, Choose evaluates the second expression, and so forth. Here’s an example:

strVolunteer = Choose(intNum, "Pablo", "Quinta", "Radwan")

The IIf function returns one of two expressions depending on whether an expression is True or False. Here’s a case in point:

strSize = IIf(intWaist > 30, "Large", "Small")

The Partition function is a weird one. Here are its syntax and a typical statement:

Partition(Number, Start, Stop, Interval)
Partition(lngAge, 0, 99, 20)

When Visual Basic .NET evaluates this statement, it sets up a series of numeric ranges such as the following:

The ranges start at the Start value and increase by Interval until they reach the Stop value. Visual Basic .NET then determines which range the given Number falls within and returns the name of that range as a string. For example, after Visual Basic .NET executes the following expression, strBracket will contain "20: 39".

strBracket = Partition(25, 0, 99, 20)

The Switch function interprets a list of paired expressions and values. If the first argument you pass to Switch is True, Switch evaluates and returns the second argument. If the third argument is true, Switch returns the fourth argument, and so forth. Here’s an example:

strCity = Switch(strEntree = "Kidney Pie", "London", _
                strEntree = "Wiener Schnitzel", "Munich", _
                strEntree = "Kielbasa", "Warsaw", _
                strEntree = "Chop Suey", "San Francisco")

If another part of your code set strEntree to "Wiener Schnitzel" (the third argument), this statement will assign the value "Munich" (the fourth argument) to the variable strCity, and so on.

Visual Basic .NET supports most of the same looping and logic constructs, itemized in the next table, that Visual Basic has supported for years. The GoTo and GoSub statements are notable omissions. Another change involves the While... Wend loop, which is now a While... End While loop.

Do [{While | Until} condition]

  [Exit Do]
Loop

Do
  [Exit Do]
Loop [{While | Until} condition]

For counter = start To end [Step step]
  [Exit For]
Next

For Each element In group
  [Exit For]
Next

While expression
End While

Visual Basic .NET supports the same subroutine and function features as other versions of Visual Basic. For your reference, the required syntaxes appear here:

Sub name [(argument As type, ...)]
    [statements]
    [Exit Sub]
    [statements]
End Sub

Function name [(argument As type, ...)] As type
    [statements]
    [Exit Function]
    [statements]
    name = expression
    [statements]
    return expression
End Function

The difference between a Sub and a Function is that only a Function returns a value. You can set the return value of a Function in two different ways:

The choice of method is up to you, and it will probably depend on the structure of your code. The Return statement immediately exits the function, but assigning a value to the function name doesn’t. If you invoke a function without using the return value in an expression, Visual Basic .NET discards it. The following invocation, for example, discards the return value:

Whatever("Hazel")

When you call a subroutine, Visual Basic .NET requires parentheses around the arguments. Thus, the first of the following statements will produce a compiler error. The second statement is correct.

Response.Write "This will happen often."
Response.Write("This will happen often.")

By default, past versions of Visual Basic passed all subroutine and function arguments by reference (ByRef). This means the subroutine or function received a pointer to the actual argument.

By default, Visual Basic .NET subroutines and functions receive arguments by value (ByVal). Visual Basic .NET copies the value in the calling procedure and gives the subroutine or function the address of the copy. This operation has two consequences:

To override the default and make a subroutine or function receive arguments by reference, code ByRef just before the argument name. Here’s an example:

Function Whatever(ByRef astrName As String) As String

Visual Basic .NET supports recursive subroutine and function calls, meaning that a subroutine or function can call itself any number of times. However, deeply nesting such calls can lead to stack or memory overflow. Don’t call a subroutine or function recursively more than a few times without exiting.

The syntax for defining a class has also changed. Here’s the new form:

Public Class name
[ Implements interfacename ]
  Public Property propertyname As type
    Get
      propertyname = InternalValue
    End Get
    Set
      InternalValue = propertyname
    End Set
  End Property

  Private Sub name [(argument, ...)]
    [statements]
  End Sub

  Public Function name [(argument, ...)]
    [statements]
  End Function
End Class

Note the Get...End Get and Set...End Set sequences within the property definition. These are both required unless you code ReadOnly or WriteOnly as follows:

Public ReadOnly Property Count As Long
Public WriteOnly Property Count As Long

In a Get procedure, you return a value to the calling procedure by assigning it to the property name. Here’s an example:

Public Property Height As Long
    Get
      Height = lngHeight
    End Get
  End Property

In a Set procedure, there are two different ways to retrieve the value that the calling procedure sent. If you coded arguments on the Set statement, you read those arguments as follows:

Set (alngHeight as long)
  mlngCurHeight = alngHeight
End Set

If you didn’t code arguments, then you read the implicit argument Value:

Set
  mlngCurHeight = Value
End Set

Although the examples in this chapter specify Public access, all the modifiers listed in the table below are available. In practice, most access modifiers are either Public (the property or method is accessible outside the current class) or Private (the property or method is accessible only within the current class). The default is Private.

Until now, if you didn’t want a serious error to terminate your Visual Basic code, the only alternative was to precede the risky statement with an On Error Resume Next statement. Doing so invoked an operating mode where serious errors updated an Err object rather than terminating the ASP.NET page, making it the Web developer’s responsibility to check the status of the Err object after each statement. To resume normal error checking, the developer coded On Error GoTo 0.

These facilities are still present in Visual Basic .NET, but so is a much better approach called structured exception handling. Using this approach involves coding the following structure:

Try
    [risky statements]
  Catch [optional filter]
    [statements]
  Catch [optional filter]
    [statements]
  ...
  Finally
    [statements]
End Try

Visual Basic .NET executes statements after the opening Try statement and before the first Catch statement normally, unless and until an error occurs. If an error does occur, Visual Basic .NET examines each Catch statement until it finds one with a condition that matches that error.

If a Catch statement contains a matching condition, control transfers to the first line of code in that Catch block. If no Catch statement contains a matching condition, the search proceeds to the Catch statements of any Try...End Try block that contains the block where the exception occurred.

This process continues until Visual Basic .NET finds a matching Catch block or no more Try...End Try blocks remain. If no blocks remain, the error asserts itself.

Visual Basic .NET always executes the code in the Finally section last, regardless of whether it executed any Catch block code. Code in this section usually closes files, releases objects, and performs other kinds of cleanup.

You can code Catch block filters in either of two ways. In the first, Visual Basic .NET filters errors based on the class of the exception. The following is an example.

Try
    ["Try" statements]
  Catch e as ClassLoadException
    [error handling statements]
  Finally
    [cleanup statements]
End Try

If a ClassLoadException occurs while Visual Basic .NET is executing a statement you coded between Try and the first Catch, Visual Basic .NET executes the code within the specified Catch block (and then the code in the Finally block). You can write as many of these Catch statements (and thereby catch as many different kinds of exceptions) as you want.

Knowing what exception classes to catch is less of a problem than you might suspect. In many cases, the reason you’re coding the Try block is that your Web page has already blown up for a condition you’d rather handle internally. In this case, you can copy the name of the exception class out of the error message and paste it into your code. Otherwise, the documentation for each object in the .NET Framework lists the types of exceptions that are possible.

The second way of coding Catch block filters is to code any conditional expression. One common use of this form of Catch filter is to test for specific error numbers, as shown in the following code:

Try
  y = 0
  x /= y
   Catch ex As Exception When y = 0
     x = 0
     lblError.Text = "Divide by zero"
  Finally
    [cleanup statements]
End Try

To catch any and all exceptions, code:

Catch ex as Exception

As you might have noticed, Catch statements receive an Exception object. Some exceptions return specialized objects, but most of them inherit the properties shown in the table below. The majority of exceptions use the generic Exception object and return exactly these properties. The Message property is generally the most useful.

If the need arises, you can also throw your own exceptions. The syntax is

Throw New System.Exception()

Note that this syntax creates a new Exception object and passes it as an argument. Inside the parentheses, you can specify

Create a simple but bomb-proof calculator

The procedure that follows will develop a simple Web page that will add, subtract, multiply, or divide any two numbers the visitor types into a pair of text boxes. Of course, if the visitor enters a value that’s not a number, the calculation will fail. In this case, the Web page itself will display the error message rather than let ASP.NET display the system error message page. The graphic below shows this Web page in action:

Follow this procedure if you wish to create this Web page. If you’d rather look at the finished code, open the calc.aspx page in the ch05 folder of the sample files.

1. Create a new, blank Web page containing an @ Page directive, then a code declaration block, then the usual HTML tags.

2. Give the Web page a title by coding <title>Bomb-Proof Calculator</title> in the <head> section and <h1>Bomb-Proof Calculator</h1> just after the <body> tag. Insert any page formatting statements, such a links to style sheet files, that you like.

3. Create a Web Form after the <h1></h1> heading. That is, add the following tags:

   <form runat="server">
   </form>

4. Create three paragraphs between the <form> and </form> tags. To do this, add three lines, each containing <p></p>.

5. Add two text boxes, named txtOp1 and txtOp2, to the first paragraph. The paragraph will then look like this:

   <p>
   <asp:TextBox id="txtOp1" runat="server" />
   <asp:TextBox id="txtOp2" runat="server" />
   </p>

6. Add a drop-down list named ddlOper between the two text boxes. Make it offer choices of +, -, *, and /. Here’s the required code:

   <asp:DropDownList id="ddlOper" runat="server">
     <asp:ListItem>+</asp:ListItem>
     <asp:ListItem>-</asp:ListItem>
     <asp:ListItem>*</asp:ListItem>
     <asp:ListItem>/</asp:ListItem>
   </asp:DropDownList>

7. Add an equal sign and a label control named lblResult after the second text box. Here’s the code:

   =
   <asp:label id="lblResult" runat="server" />

8. Add a Submit button to the second paragraph. The following code will suffice. The <p> and </p> tags are some of those you entered in step 4.

   <p><asp:Button id="btnSub" Text="Submit" runat="server"/></p>

9. Add a Label control named lblMessage to the third paragraph. Here’s how the paragraph should look when you’re finished:

   <p><asp:label id="lblMessage" runat="server" /></p>

10. Save the Web page as calc.aspx and load it into your browser by means of an http:// URL. You should find that it resembles the previous figure but does nothing when you click Submit.

11. Add a Page_Load subroutine to the code declaration block you created in step 1. This requires the following statements:

    Sub Page_Load(sender As Object, e As EventArgs)
    End Sub

12. It would be pointless to perform a calculation the first time the Web page loads. The visitor, at that point, has had no opportunity to enter any numbers. Therefore, code an If statement that determines whether a postback is in effect. The Page_Load subroutine will then look like this:

    Sub Page_Load(sender As Object, e As EventArgs)
      If Page.IsPostBack Then
      End If
    End Sub

13. Between the two statements you added in step 12, code a Select Case statement that performs the requested operation on the two numbers.

    Select Case ddlOper.SelectedItem.Text
      Case "+"
        lblResult.Text = Cdbl(txtOp1.Text) + _
                         Cdbl(txtOp2.Text)
      Case "-"
        lblResult.Text = Cdbl(txtOp1.Text) - _
                         Cdbl(txtOp2.Text)
      Case "*"
        lblResult.Text = Cdbl(txtOp1.Text) * _
                         Cdbl(txtOp2.Text)
      Case Else
        lblResult.Text = Cdbl(txtOp1.Text) / _
                         Cdbl(txtOp2.Text)
      End Select

    The expression ddlOper.SelectedItem.Text returns the text of the list box item that the visitor selects.

    The four Case statements differentiate among the four possible values.

    The statement following each Case statement converts the two text box values to Doubles, performs the requested calculation, and stores the result in the lblResult label object you created in step 7.

14. If you save the Web page at this point and try performing calculations, you should find that all goes well as long as you enter two numeric operands. If you make an invalid entry, however, the page will fail and display an error page like the one shown here.

    

15. Add a Try statement before the Select statement you added in step 13 and an End Try statement after the End Select statement.

16. After the End Select statement you added in step 13, add the Catch statement that appears in the following code.

    Try
    '   Select statement from step 13
      Catch ex as Exception
    End Try

    This Catch statement will catch all exceptions. If an exception occurs, the variable ex will point to a relevant exception object.

17. After the Catch statement you added in the previous step, enter a statement that copies the current error message to the Label control you created in step 9. Visual Basic .NET will execute this statement only if an exception occurs.

      Catch ex as Exception
        lblMessage.Text = ex.Message
    End Try

18. Add the following statement after the End Select statement that terminates the Select Case block. This will erase any error message the lblMessage label control might contain.

    lblMessage.Text = ""

    The presence of this statement also proves that if an exception occurs, the rest of the code in the Try block doesn’t execute. If the rest of the code in the Try block did execute, this statement would wipe out the error message.

19. This completes the code for the calc.aspx page. Save the page and try running it again. You should no longer be able to bomb it by entering invalid values; the page will simply display an error message as shown in this graphic. The code listing for the entire page follows.

    

    <%@Page Language="VB" Debug="True"%>
    <script runat="server">
    Sub Page_Load(sender As Object, e As EventArgs)
      If Page.IsPostBack Then
        Try
          Select Case ddlOper.SelectedItem.Text
            Case "+"
              lblResult.Text = Cdbl(txtOp1.Text) + _
                               Cdbl(txtOp2.Text)
            Case "-"
              lblResult.Text = Cdbl(txtOp1.Text) - _
                               Cdbl(txtOp2.Text)
            Case "*"
              lblResult.Text = Cdbl(txtOp1.Text) * _
                               Cdbl(txtOp2.Text)
            Case Else
              lblResult.Text = Cdbl(txtOp1.Text) / _
                               Cdbl(txtOp2.Text)
            End Select
          lblMessage.Text = ""
        Catch ex as Exception
          lblMessage.Text = ex.Message
        End Try
      End If
    End Sub
    </script>
    <html>
    <head>
    <title>Bomb-Proof Calculator</title>
    <link rel="stylesheet" type="text/css" href="../normal.css">
    </head>
    <body>
    <h1>Bomb-Proof Calculator</h1>
    <form runat="server">
    <p>
    <asp:TextBox id="txtOp1" runat="server" />
    <asp:DropDownList id="ddlOper" runat="server">
      <asp:ListItem>+</asp:ListItem>
      <asp:ListItem>-</asp:ListItem>
      <asp:ListItem>*</asp:ListItem>
      <asp:ListItem>/</asp:ListItem>
    </asp:DropDownList>
    <asp:TextBox id="txtOp2" runat="server" />
     =
     <asp:label id="lblResult" runat="server" />
    </p>
    <p><asp:Button id="btnSub" Text="Submit" runat="server"/></p>
    <p><asp:label id="lblMessage" runat="server" /></p>
    </form>
    </body>
    </html>

This chapter explained the basic structure of Visual Basic .NET by examining the syntax and capabilities of its literals, variables, statements, operators, functions, and other elements. Although Visual Basic .NET is an easy programming language to learn, it’s also a broad and comprehensive language suitable for complex projects.

The need for Visual Basic to operate with the common language runtime has imposed a variety of changes on the language. For the most part, these changes are worthwhile and modernizing, but they do require study, even for experienced Visual Basic programmers.

The next chapter will introduce a number of database concepts and terms you’ll need for developing database-driven Web sites.