Beginning ASP.NET 2

Chapter 9

type called Date for dates and times, an Integer data type for whole numbers, and a Decimal or Double data type for floating-point numbers. Each has different characteristics; the Integer type can only store integer numbers, and trying to store any other type of data into an Integer will raise an exception. Likewise, the Date data type can only store dates and times. The full list of data types is as follows:

Boolean is used to store either True or False. The default value is False.

Byte is used for a single byte of data. This can be a single character or a number from 0 to 255. The default value is 0.

Char is used for two bytes of data. This can be a character or a number from 0 to 65,535. Because it is bigger than a Byte, Char can store double-byte characters like those used by foreign characters sets such as Chinese. The default value is 0.

Date is used to store a date and time. The default value is 0:00:00 (midnight) on January 1, 0001.

Decimal is used for decimal values. It supports up to 29 significant digits and is therefore the most accurate type for financial numbers. The default value is 0.

Double is used for floating-point numbers. Unlike the Decimal data type, Double has a smaller range and is less accurate. However, it is also faster in use, so it is the preferred data type for floating-point numbers unless a great depth of precision is required. The default value is 0.

Integer is used for whole numbers between –2,147,483,648 and 2,147,483,647. The default value is 0.

Long is used for whole numbers between –9,223,372,036,854,775,808 and 9,223,372,036,854,775,807. The default value is 0.

Object is used to represent objects. In VB, the default value is Nothing. In C#, the default value is null.

SByte is used to hold whole numbers between –128 and 127. The default value is 0.

Short is used for whole numbers between –32,768 and 32,767. The default value is 0.

Single is used for floating-point numbers that don’t require the full size of a Double. The default value is 0.

String is used for storing text (or string) data. The default value is Nothing in VB and null in C#.

UInteger is the unsigned equivalent of an Integer. Because it is unsigned it can only store positive numbers, giving a range of 0 to 4,294,967,295. The default value is 0.

ULong is the unsigned equivalent of a Long. Because it is unsigned it can only store positive numbers, giving a range of 0 to 18,446,774,073,709,551,615. The default value is 0.

UShort is the unsigned equivalent of a Short. Because it is unsigned it can only store positive numbers, giving a range of 0 to 65,535. The default value is 0.

Having different data types allows the type to provide features that only that type requires. For example, the DateTime type allows dates to be manipulated, the individual parts of the date or time to be extracted, and so on. Also, data types allow you to choose the most efficient way of storing data, so if you need to store a really long number, you would use a Long. A Long takes up more room in memory than a Short,

290

Code

so if you only ever needed to store numbers between 1 and 100, you wouldn’t use a Long. In essence the data type you choose depends not only on the type of data, but also its size.

Common Language Runtime Types

This may seem confusing, but there are different names for the same data types. This is because there are data types that the language uses, and data types that the Common Language Runtime (CLR) uses. Simply put, the CLR is the system that actually makes .NET run. You don’t need to know much about it now, although it’s definitely worth learning about as you become more experienced. The reason that the CLR has data types and the language has data types is that the CLR is common to all languages in

.NET. Whether you use Visual Basic .NET, C#, or even COBOL .NET, underneath you are using the CLR. However, languages have history (apart from C#, which was new for .NET, but C# has a C and C++ base in terms of the language syntax), and so have data types of their own. For compatibility reasons it makes sense to keep these specific language types. This enables users of the language to work with familiar data types, and the compiler takes care of using the actual CLR data type.

For much of what you do you’ll use the language data types, but there are times when you need to know what CLR data type a language data type maps onto, and the following table shows this:

When you look at converting between data types you’ll see why it might be important to know the underlying data type.

291

Chapter 9

Declaring Variables

There is a specific syntax for creating variables, which requires the name and data type. The name is up to you, but it’s always best to use a sensible name, something that represents what the variable holds. To define a variable you use the Dim statement, like so:

Dim VariableName As DataType

Replace the VariableName and DataType with your requirements:

Dim FirstName As String

Dim LastName As String

Dim Age As Integer

Dim Birthday as Date

You’ve used sensible names for the variables: two String types to hold the first and last names, an Integer to hold the age, and a Date to hold the birthday. In some documents and books you might see a prefix on the variable name, giving an indication of its data type. For example, the names and ages might be declared like so:

Dim strFirstName As String

Dim sLastName As String

Dim iAge As Integer

Dim dBirthday as Date

Here str or s has been used as a prefix for String types, i for Integer types, and d for Date data types. You may find this technique useful when learning how to use variables and data types, although it isn’t generally recommended and has dropped out of favor. A correctly named variable should give a good indication of its data type. Having said that, there are times when some form of prefix is useful, and you’ll see this when you look at classes a little later in the chapter.

Assigning Values

Once you declare a variable, you can assign values to it, and this is simply a matter of setting the variable equal to the required value. The syntax for this is as follows:

variable = value

This says give the variable named on the left of the equals sign the value on the right of the equals sign. For example:

FirstName = “Arthur”

LastName = “Arbuthnot”

Age = 24

Birthday = #10/25/1980#

As you can see, string values are enclosed in quotation marks, whereas numeric values aren’t. Notice that the date value is enclosed within hash marks (#), and the format is MM/DD/YYYY. This is a fixed format when assigning dates like this, and takes no account of the regional settings of your machine. You can also assign a time part, like so:

292

Code

Appointment = #10/25/1980 11:10 PM #

Alternatively, you can assign a time like this:

Appointment = #10/25/1980 23:10 #

Variables can also be initialized when they are declared, like so:

Dim FirstName As String = “Arthur”

Dim LastName As String = “Arbuthnot”

Dim Age As Integer = 24

Dim Birthday As Date = #10/25/1980#

These examples show the assignment using literal values, but you can also assign values to other variables or objects. For example, in ASP.NET pages it’s very common to assign values from user-entered data, perhaps from a text box:

FirstName = FirstNameTextBox.Text

LastName = LastNameTextBox.Text

Or vice versa:

FirstNameTextBox.Text = FirstName

LastNameTextBox.Text = LastName

The TextBox control has a property called Text that contains the text value, so you are simply copying that value into the String variable, or copying the string value into the property. This is fine for String types, but extra work needs to be done if the variable isn’t a String type; for example, allowing users to enter their age would require a text box and an Integer type variable. However, you can’t assign the values of differing types — you need to convert them.

Data Conversion

Visual Basic .NET does provide some automatic conversion of data types, but it’s best not to rely on this, otherwise you tend to forget that conversion is actually happening. Explicit conversion makes it clear exactly what your code does, a useful point when you (or others) look at your code later. There isn’t a single syntax for converting between types, but there is a lot of commonality in the different methods.

Converting to string values is the simplest, because every data type has a ToString method. For example, to convert the age to a TextBox you could use:

AgeTextBox.Text = Age.ToString()

For the Boolean type the conversion method is the same, but the string value will be either True or

False.

Converting from a string value to another type is slightly different, because no methods on the String type do this automatically. Instead you have to use a separate class to perform the conversion.

293

Chapter 9

Converting Data Types Using the Framework Classes

Two ways exist to convert from string values to other types using the framework classes, and it’s worth mentioning both in case you see them in code. The first is to use the Parse method that most data types supply. For example, to convert a number held in a TextBox control into an Integer data type, you could do this:

Dim Age As Integer

Age = Integer.Parse(AgeTextBox.Text)

What’s happening here is that the Parse method parses the value passed to it — that is, it reads the value, checks that it is an integer value, and converts it into an integer. The value to be converted is the value from the Text property of the AgeTextBox control, which is a string. So the string is passed into the Parse method, which converts it into an integer and returns the integer, which in turn is assigned to the Age variable.

All of the data types, apart from Object, support the Parse method, which means that even though you may be using a different data type the syntax is the same. For example:

Dim ANumber As Double

ANumber = Double.Parse(NumberTextBox.Text)

The second way to perform data conversion is to use the Convert class, which converts between types. It’s a very flexible class in that it can convert between all types, but it does require knowledge of the CLR type. For example, the preceding example using an integer could be written as follows:

Dim Age As Integer

Age = Convert.ToInt32(AgeTextBox.Text)

For the double example this would be:

Dim ANumber As Double

ANumber = Convert.ToDouble((NumberTextBox.Text)

In use there is no difference between the Convert class and the data type class when converting types. The only reason for using the Convert class is that it makes code easier to convert to another language. This was important when writing the Wrox United web site, but may not be important to you if you intend to stick with one language.

Converting Data Types with Casting

Another way of converting between types is by casting. Instead of explicitly converting the type, the value is forced into another type. Casting doesn’t work in the same way as converting, and isn’t always suitable. For example, you can’t use casting to convert from strings to numbers. You can, however,

use casting to convert between similar types. For example, you could cast between a Double and an Integer by using the following code:

Dim MyDouble As Double = 123.456

Dim MyInteger As Integer

MyInteger = CType(MyDouble, Integer)

294

Code

The CType function accepts two arguments. The first is the variable to be converted, and the second is the new type. What this does is to force the variable, MyDouble, into being something it’s not; it’s a bit like pushing a round block through a square hole. MyDouble is still a Double, but the value that CType returns is an Integer — the Double squashed into the space that an Integer holds.

Another way of casting is to use DirectCast, which has the same syntax as CType:

Dim MyDouble As Double = 123.456

Dim MyInteger As Integer

MyInteger = DirectCast(MyDouble, Integer)

One thing you should be aware of is that casting may change the value of the variable. In the preceding example this is obvious, because changing a floating-point number into an integer will lose the values after the decimal point. Converting between a Long and an Integer isn’t so obvious, but may result in changes. Because an Integer has a range half that of a Long, if the value in the Long exceeds that of the Integer, the value will be shortened when converted.

Null Values

All data types have default values, but there is also the concept of a null value. This doesn’t usually affect the standard types, and is more common on custom or complex types, and simply means that the object doesn’t exist. For example, consider a method that returns a DataSet object, filled with data from a database. What happens if, while fetching the data, there is some sort of error? There will probably be an exception thrown (these are covered in Chapter 15), but the method still might return, only there’s no data for you — the value returned might be null.

In Visual Basic .NET the null value is represented by the keyword Nothing. You’ll look at how you test for null values later.

Working with Strings

When working with strings it’s useful to know that the string class has a great number of methods that allow you to manipulate those strings, and any variable that is a string therefore has the ability to use those methods. You won’t see all of them here, but instead concentrate on some of the most common ones.

One of the most common requirements is being able to strip blank spaces (or white space as it’s sometimes called) from the beginning or end of strings. This is useful when taking input from a user and is especially important when trying to compare two string values. For example, consider the following code fragment:

If Name1 = Name2 Then

The If test would result in False, because the strings aren’t the same — Name2 has spaces at the end. Three methods can help here: TrimStart removes spaces from the start of the string, TrimEnd removes spaces from the end of a string, and Trim removes spaces from both the start and end of a string. If the preceding code were modified to include Trim, the result would be True:

295

Chapter 9

If Name1.Trim() = Name2.Trim() Then

Both strings have been trimmed so the If test would return True. The strings have only been trimmed as part of the comparison, though; the strings haven’t been modified themselves. Consider this code:

If Name1.Trim() = Name2.Trim() Then

‘ this would return True

End If

If Name1 = Name2 Then

‘ this would return False

End If

You can see that using Trim affects only that one instance, unless the underlying variable is changed:

Now that Name1 and Name2 have been reassigned with the trimmed values, subsequent comparisons work. The key point here is that using string methods affects only that particular use of the string, and the string variable will be changed only if assignment is done.

Another situation that can occur when comparing strings, especially those supplied by user input, is mismatched case. What if the user has the caps-lock key stuck on? Two methods can help with this: ToLower, which converts the string to lowercase, and ToUpper, which converts the string to uppercase. For example:

Dim Name1 As String = “dave”

Dim Name2 As String = “DAVE”

If Name1 = Name2 Then

This code would fail because the strings are different, even though we as humans know them to mean the same thing. To get around this you can change the case:

Dim Name1 As String = “dave”

Dim Name2 As String = “DAVE”

If Name1.ToLower() = Name2.ToLower() Then

296

Code

Now the test would succeed because the values being compared are lowercase. Plenty of other string methods exist, some of which are described in the following list:

EndsWith, which returns True if the string ends with a given string. For example:

If MyString.EndsWith(“ate”) Then

StartsWith, which returns True if the string starts with a given string. For example:

If MyString.StartsWith(“wha”) Then

IndexOf, which returns the position within the string of a given character or string, or -1 if the item isn’t found. For example:

If MyString.IndexOf(“abc”) > 0 Then

Insert, which inserts a string at a given position. For example, to insert the string new words at position 5 you would use:

MyString.Insert(5, “new words”)

LastIndexOf, which returns the last position within the string of a given character or string. This is similar to Indexof but is useful for finding the last instance of a character.

Length, which returns the length of a string.

PadLeft and PadRight perform the opposite of Trim, allowing you to pad strings to a given length. The padding defaults to a space but can be any character. For example, to pad a string to a total of 15 characters you would use the following:

MyNewString = MyString.PadLeft(15)

Remove, which removes a section of a string. For example, to remove five characters starting at position 4 you would use:

MyNewString = MyString.Remove(4, 5)

Replace, which replaces characters within the string. For example to replace abc with def you would use:

MyNewString = MyString.Replace(“abc”, “def”)

SubString, which returns a portion of a string. For example, to return five characters starting at position 4 you would use:

MyNewString = MyString.SubString(4, 5)

For a full list of string methods you should consult the documentation.

Working with Dates

In earlier code snippets you saw dates being assigned to a literal value in MM/DD/YYYY format. You may think this is fine, especially if you are used to that format, but seeing literal dates can be very confusing. If your code is used by someone not used to that format, whether they are across the world or at

297

Chapter 9

the desk next to yours, they might be unsure of your intentions. For example, take the date 03/05/2005; does this represent March 5 or May 3? You could easily assume the format, but that leads to potential errors.

Instead of using literals to initialize dates, it’s better to create a new instance on a date, like so:

Dim Birthday As New Date(2005, 3, 5)

The parameters are in year, month, and day order, and because you have IntelliSense (or at least the documentation if you aren’t using VWD), you know what the order should be. If required, the individual parts of the date can be accessed like so:

Birthday.Day

Birthday.Month

Birthday.Year

Other properties exist such as DayOfWeek and DayOfYear, as well as ones for dealing with the time and parts of the time. You can find more information about these additional properties in the documentation.

Dates behave just like numeric variables in that they allow addition, subtraction, and comparison. For example, you can add a number of days using the AddDays method:

NewDate = Birthday.AddDays(18)

There is also a Subtract method that subtracts one date from another. However, this method doesn’t return a Date type, but rather a TimeSpan, which is a data type used to define spans of time. For example:

Dim Date1 As New Date(2005, 3, 10)

Dim Date2 As New Date(2005, 3, 5)

Dim Difference As TimeSpan

Difference = Date1.Subtract(Date2)

Label1.Text = Difference.ToString()

This code creates two dates, March 10 and March 5, and then declares a variable of type TimeSpan, which will hold the difference between the dates. The difference is calculated by using the Subtract method of the date — because the Date1 variable is a Date type the Subtract method can be used, and Date2 is passed into this method. The result is that Date2 is subtracted from Date1, and in this case the result would be 5.00:00:00, which represents 5 days, 0 hours, 0 seconds, and 0 milliseconds.

Now that you have a good base of knowledge to work with, the following Try It Out has you work with simple data types.

1.Open the directory for the Chapter 9 samples, called C:\BegASPNET2\Chapters\Begin\ Chapter09 under the directory where you placed the sample code.

2.Create a new Web Form called SimpleTypes.aspx. Remember to make sure it uses a separate file for the code.

298