Visual Basic provides a set of functions for explicitly converting values into new data types. For example, the following code uses the CDec function to convert the text entered by the user in the txtCost TextBox into a Decimal and then saves it in the variable cost:

Dim cost As Decimal = CDec(txtCost.Text)

Table 11-2 lists Visual Basic's conversion functions.

The integer functions round floating-point values off to the nearest integer. For example, CInt(1.7) returns 2.

Another function, Int, truncates floating-point values. For example, Int(1.7) returns 1. Note that the result returned by Int has the same data type as its parameter; so, for example, if you pass Int a Double, it returns a Double. Often you will want to use CInt to convert that result into an Integer.

The Fix function is similar to Int except it truncates towards 0. That means for negative numbers Int decreases the value (Int(-8.5) = −9.0) but Fix increases the value (Fix(-8.5) = −8.0).

Each of these functions causes an error if it cannot convert the value. For example, ("1x3") causes an error because "1x3" is not a valid number.

Visual Basic also includes a special-purpose Val function that converts a value into a Double. If Val cannot convert the value into a Double, it silently returns 0. For example, if you use Val to convert a value typed by the user into a number and the user types "six," then Val ignores the error and returns 0.

This makes Val useful for converting values typed by the user into numbers if 0 is a reasonable default value. If 0 is not a reasonable default value, then your program should use some other method for converting the string into a number, such as parsing, which is described shortly.

The CType function takes a value and a data type as parameters and returns the value converted into the data type. For example, the following code converts the text entered by the user in the txtCost TextBox into a Decimal and saves it in the variable cost:

Dim cost As Decimal = CType(txtCost.Text, Decimal)

Like the Visual Basic conversion functions, CType works only if the conversion is possible. For example, if the user types "eleven" in the TextBox, CType will cause an error.

The DirectCast operator converts an object from one type to another. For example, event handlers have a sender parameter of type Object that holds a reference to the control that raised the event. If you know that the control is actually a Button, you can use DirectCast to convert sender into a variable of type Button as shown in the following code:

Private Sub btnSetColor_Click()
    Dim btn As Button = DirectCast(sender, Button)
    ...
End Sub

This is particularly handy when you want one event handler to catch events raised by multiple controls. After converting sender into a Button, the program can use the Button's properties to decide how to proceed.

The DirectCast operator fails if the object you are trying to convert doesn't have the correct data type. For example, if the preceding event handler were invoked by a PictureBox, then sender would not be a Button so the call to DirectCast would fail.

The TryCast operator attempts to convert an object from one data type to another much as DirectCast does but if there is a problem TryCast returns Nothing instead of throwing an exception. The following code shows the previous event handler rewritten so it doesn't crash if the sender that raised the event isn't a Button.

Private Sub btnSetColor_Click()
    Dim btn As Button = TryCast(sender, Button)
    If btn IsNot Nothing Then
        ...
    End If
    ...
End Sub

This code uses TryCast to convert sender into a Button. It then uses IsNot to see if the result is Nothing. (The IsNot operator is described later in the section "Comparison Operators.") If the result isn't Nothing, the code executes whatever is inside the If Then block.

The Convert class provides methods that convert from one data type to another. For example, the following code converts the text entered by the user in the txtCost TextBox into a Decimal and saves it in the variable cost:

Dim cost As Decimal = Convert.ToDecimal(txtCost.Text)

Table 11-3 lists the Convert class's conversion methods.

One drawback to the Convert methods is that they require you to remember how long the integer data types are in bits. For example, you need to use ToInt32 to convert to a 32-bit Integer.

Trying to find structure and meaning in text is called parsing. All the simple data types (Integer, Double, Decimal) provide a Parse method that converts text into that data type. For example, the Integer data type's Parse method takes a string as a parameter and returns an Integer; at least it does if the string contains an integer value.

For example, the following code parses the text entered by the user in the txtCost TextBox to get a Decimal value and saves it in the variable cost:

Dim cost As Decimal = Decimal.Parse(txtCost.Text)

Like the previous methods, this works only if the text can reasonably be converted into a decimal. If the user types "12,345.67," the parsing works. If the user types "ten" or "1.2.3," the parsing fails.

Dim cost As Decimal =
  Decimal.Parse(txtCost.Text,
  System.Globalization.NumberStyles.Any)

All the parsing methods described so far have one really big problem: if the value they are converting cannot be converted into the desired data type, they cause an error that crashes your program (at least until you read Lesson 21 on handling errors).

One way to avoid this problem is to use TryParse. A data type's TryParse method is a lot like Parse except it returns a Boolean value indicating whether it succeeded. It takes a second parameter to hold the parsed value.

For example, consider the following code:

Dim cost As Decimal
If Decimal.TryParse(txtCost.Text, cost) Then
    ' Perform some calculations...
Else
    MessageBox.Show("Please enter a valid cost.")
End If

The first statement calls TryParse, passing it the value to convert (txtCost.Text) and the variable (cost) that should receive the Decimal value. TryParse attempts to convert the user's text into a Decimal and returns True if it succeeds. The code then uses an If Then Else statement to either process the value or display an error message.

Like Parse, TryParse doesn't automatically understand text with a currency format. To make it allow currency formats, you can add extra parameters as shown in the following code:

Dim cost As Decimal
If Decimal.TryParse(txtCost.Text,
 System.Globalization.NumberStyles.Any, Nothing, cost) Then
    MessageBox.Show("OK")
Else
    MessageBox.Show("Failed")
End If

This syntax is the most cumbersome of the conversion methods described here, but it is also the most robust.

The arithmetic operators perform calculations on numbers. Table 11-4 summarizes these operators. The Example column shows sample results.

Integer division drops any remainder and returns the integer quotient. The modulus operator does the opposite: It drops the quotient and returns the remainder. For example, 17 Mod 5 returns 2 because 17 divided by 5 is 3 with a remainder of 2.

The logical operators perform calculations on Boolean (True or False) values. They let you combine logical statements to form new ones.

Lesson 18 explains how to use these values to perform tests that let a program take action only under certain circumstances. For example, a program might pay an employee overtime if the employee is paid hourly and works more than 40 hours in a week.

Table 11-5 summarizes these operators.

The exclusive or operator Xor is perhaps the most confusing. It returns True if one of its operands is True and the other is False. For example, you and Ann will get a single lunch check and pay each other back later if either Ann forgot her money and you brought yours, or Ann remembered her money and you forgot yours. If neither of you forgot your money, you can get separate checks. If you both forgot your money, you're both going hungry today.

singleCheck = annForgotMoney Xor youForgotMoney;

AndAlso and OrElse are called conditional operators or short-circuit operators. They work just like the regular And and Or operators except they don't evaluate their second operand unless necessary. For example, consider the following AndAlso statement:

mustBuyLunch = isLunchTime AndAlso forgotToBringLunch

Suppose it's only 9:00 a.m., so isLunchTime is false. When the program sees this expression, evaluates isLunchTime, and sees the AndAlso operator, it already knows that mustBuyLunch must be false no matter what value follows the AndAlso (in this case forgotToBringLunch), so it doesn't bother to evaluate forgotToBringLunch, which saves a tiny amount of calculation time.

Similarly, consider the following "or" statement:

canAffordLunch = haveEnoughMoney OrElse haveCreditCard

If you have enough money, haveEnoughMoney is True, so the program doesn't need to evaluate haveCreditCard to know that the result canAffordLunch is also True.

Because the conditional AndAlso and OrElse operators are slightly faster, most developers use them when they can instead of And and Or.

The only string operator Visual Basic provides is &. This operator concatenates (joins) two strings together. For example, suppose the variable username contains the user's name. The following code concatenates the text "Hello " (note the trailing space) with the user's name and displays the result in a message box:

MessageBox.Show("Hello " & username)

Lesson 14 explains methods that you can use to manipulate strings: find substrings, replace text, check length, and so forth.

String greeting = txtUserName.Text
greeting = "Hello" + username

The comparison operators compare two values and return True or False depending on the values' relationship. For example, x < y returns True if x is less than y.

Table 11-6 summarizes these operators.

The Is and IsNot operators are a bit unusual because they work only on reference variables that refer to objects not on more ordinary data types such as Integers and Doubles.

These operators compare variables to see if they refer to the same object. They don't compare the values in two different objects. For example, suppose you have two Person objects, person1 and person2, that happen to have the same FirstName, LastName, and other property values. Even if their properties are identical, they are two distinct objects so person1 Is person2 would return False.

The assignment operators set a variable (or property or whatever) equal to something else. The simplest of these is the = operator, which you have seen several times before. This operator simply assigns whatever value is on the right to the variable on the left.

The other assignment operators, known as compound assignment operators, combine the variable's current value in some way with whatever is on the right. For example, the following code adds 3 to whatever value x currently holds:

x += 3

This has the same effect as the following statement that doesn't use the += operator:

x = x + 3

Table 11-7 summarizes these operators.

There are no compound assignment operators for Mod or the logical operators.

The bitwise operators enable you to manipulate the individual bits in integer values. For example, the bitwise Or operator combines the bits in two values, so the result has a bit equal to 1 wherever either of the two operands has a bit equal to one.

For example, suppose x and y are the byte values, with bits 10000000 and 00000001. Then x Or y has bits 10000001.

These are fairly advanced operators so I'm not going to do much with them, but Table 11-8 summarizes them. The shift operators are not "bitwise" because they don't compare two operands one bit at a time, but they are bit-manipulation operators so they're included here.

If the operand has a signed type (SByte, Integer, Long), then >> makes new bits on the left copies of the value's sign bit (its leftmost bit). If the operand has an unsigned type (Byte, UInteger, ULong), then >> makes new bits 0.

The shift operators also have corresponding compound assignments operators <<= and >>=.