An enumeration is simply a data type that allows only specific values. The following code defines a ContactMethod enumeration that can hold the values None, Email, Phone, or SnailMail:

' Define possible contact methods.
Private Enum ContactMethod As Integer
    None = 0
    Email
    Phone
    SnailMail
End Enum

Internally, an enumeration is stored as an integral data type, by default an Integer. A number after a value tells Visual Basic explicitly which integer to assign to that value. In the preceding code, None is explicitly assigned the value 0.

If you don't specify a value for an enumeration's item (and often you don't care what these values are), its value is one greater than the previous item's value (the first item gets the value 0). In this example, None is 0, Email is 1, Phone is 2, and SnailMail is 3.

You create an instance of an enumerated type just as you make an instance of a primitive type such as Integer, Decimal, or String. The following code declares a variable of type ContactMethod, assigns it the value ContactMethod.Email, and then displays its value in a message box:

Dim method As ContactMethod = ContactMethod.Email
MessageBox.Show(method.ToString())

An enumeration's ToString method returns the value's name, in this case "Email."

Defining a structure is easy. The following code defines a simple structure named Address that holds name and address information:

' Define a structure to hold addresses.
Private Structure Address
    Public Name As String
    Public Street As String
    Public City As String
    Public State As String
    Public Zip As String
    Public Email As String
    Public Phone As String
    Public PreferredMethod As ContactMethod
End Structure

The structure begins with a Structure statement that defines the structure's name and ends with an End Structure statement. The lines in between define the pieces of data that the structure holds together. The Public keywords in this example mean that the fields inside the structure (Name, Street, and so on) are visible to any code that can see an Address.

Notice that the structure can use an enumeration. In this example, the Address structure's PreferredMethod field has type ContactMethod.

In many ways structures behave like simple built-in types such as Integer and Single. In particular, when you declare a variable with a structure type, the code not only declares it but also creates it. That means you don't need to use the New keyword to create a structure.

After defining a structure variable, you can access its fields using syntax similar to the way you access a control's properties. Start with the variable's name, follow it with a dot, and then add the field's name.

The following code creates and initializes a new Address structure named homeAddress:

Dim homeAddress As Address
homeAddress.Name = txtName.Text
homeAddress.Street = txtStreet.Text
homeAddress.City = txtCity.Text
homeAddress.State = txtState.Text
homeAddress.Zip = txtZip.Text
homeAddress.Email = txtEmail.Text
homeAddress.Phone = txtPhone.Text
homeAddress.PreferredMethod =
    CType(cboMethod.SelectedIndex, ContactMethod)

This code fills in the text fields using values entered by the user in textboxes.

The final field is a ContactMethod enumeration. The user selects a value for this field from the cboMethod ComboBox. The code takes the index of the ComboBox's selected item, uses CType to convert it from an integer into a ContactMethod, and saves the result in the structure's PreferredMethod field.

In many ways structures are very similar to classes. Lessons 23 through 30 say a lot more about classes and the sorts of things you can do with them, and many of the same techniques apply to structures.

For example, both can contain properties, methods, and events. Both can also have constructors, special methods that are executed when you use New to create a new one.

While structures and classes have many things in common, they also have many differences. A lot of these differences are outside the scope of this book, so I won't cover them here, but one very important difference that you should understand is that structures are value types, whereas classes are reference types.

One other important difference between value and reference types is that when you set a variable with a value type equal to another, the first variable receives a copy of the second variable's value. For example, if x and y are integers, then the statement x = y makes x hold the same value as y.

Similarly, if ann and ben are variables of the structure type Person, then ben = ann makes all of the fields in ben have the same values as all of the fields in ann, but they are still two separate Person structures.

In contrast, if you set a reference type variable equal to another, the first variable now refers to the same object as the other, not just a copy of that object. For example, suppose cindy and dan are two variables that hold references to Student objects. The statement dan = cindy makes the variable dan refer to the same object to which cindy refers. If you change one of dan's properties, cindy also sees the change because they point to the same object.

The StructureVersusClass example program that is available in the Lesson 17 download demonstrates this difference.

So which should you use, a structure or a class? In many programs the difference doesn't matter much. As long as you are aware of the relevant differences, you can often use either.

Microsoft's "Classes and Structs (C# Programming Guide)" web page at msdn.microsoft.com/library/ms173109.aspx gives the following advice (though that page is discussing C# programming, its advice also applies to Visual Basic):

In this Try It, you use an enumeration and a structure to make the address book shown in Figure 17-1. When the user clicks the Add button, the program saves the entered address values. If the user enters a name and clicks Find, the program retrieves the corresponding address data.

Figure 17.1. FIGURE 17-1