A Visual Basic class (and note that Form types are classes, too) contains three main kinds of scope: class scope, method scope, and block scope. (If you have trouble remembering what a class is, review Lesson 9's section "Understanding Classes and Instances.")

For example, consider the following code that defines a field, and some variables inside event handlers:

Public Class Form1
    ' A field.
    Dim a As Integer = 1

Private Sub btnClickMe_Click() Handles btnClickMe.Click
        ' A method variable.
        Dim b As Integer = 2
        MessageBox.Show("a = " & a.ToString() & ", b = " & b.ToString())
    End Sub

    Private Sub btnClickMeToo_Click() Handles btnClickMeToo.Click
        ' A method variable.
        Dim c As Integer = 3
        MessageBox.Show("a = " & a.ToString() & ", c = " & c.ToString())
    End Sub
End Class

The field a is declared outside of the two methods (btnClickMe_Click and btnClickMeToo_Click), so it has class scope. That means the code in any of the methods can see and use this variable. In this example, the two Click event handlers each display the value.

The variable b is declared within btnClickMe_Click, so it has method scope. Only the code within this method that comes after the declaration can use this variable. In particular, the code in the other methods cannot see it.

Similarly, the code in the btnClickMeToo_Click event handler that comes after the c declaration can see that variable.

Two variables with the same name cannot have the same scope. For example, you cannot create two variables named a at the class level, nor can you create two variables named b inside the same method.

Public Class Form1
    ' A field.
    Dim count As Integer = 0

    Private Sub btnClickMe_Click() Handles btnClickMe.Click
        ' A method variable.
        Dim count As Integer = 1
        MessageBox.Show(count.ToString())
    End Sub

    Private Sub btnClickMeToo_Click() Handles btnClickMeToo.Click
        ' A method variable.
        Dim count As Integer = 2
        MessageBox.Show(count.ToString())
    End Sub
End Class

' A method variable.
Dim count As Integer = 1
MessageBox.Show(count.ToString())
MessageBox.Show(Me.count.ToString())

Private Sub btnClickMe_Click() Handles btnClickMe.Click
    ' A method variable.
    Dim count As Integer = 0
    count += 1
    MessageBox.Show(count.ToString())
End Sub

' A field.
Dim count As Integer = 0

Private Sub btnClickMe_Click() Handles btnClickMe.Click
    ' A method variable.
    count += 1
    MessageBox.Show(count.ToString())
End Sub

Private Sub btnClickMeToo_Click() Handles btnClickMeToo.Click
    ' A method variable.
    Dim count As Integer = 1
    MessageBox.Show(count.ToString())

    If count = 1 Then
        Dim i As Integer = 2
        MessageBox.Show(i.ToString())
    Else
        Dim i As Integer = 3
        MessageBox.Show(i.ToString())
    End If
End Sub

A field's scope determines what parts of the code can see the variable. So far I've focused on the fact that all of the code in a class can see a field declared at the class level outside of any methods. In fact, a field may also be visible to code running in other classes depending on its accessibility.

A field's accessibility determines which code is allowed to access the field. For example, a class might contain a public field that is visible to the code in any other class. It may also define a private field that is visible only to code within the class that defines it. The following code shows how a class might declare a public variable named NumberOfUsers:

Public NumberOfUsers As Integer

Accessibility is not the same as scope, but the two work closely together to determine what code can access a field.

Table 13-1 summarizes the field accessibility values. Later when you learn how to build properties and methods, you'll be able to use the same accessibility values to determine what code can access them.

If you omit the accessibility value for a field, it defaults to Private. You can still include the Private keyword, however, to make the field's accessibility obvious. (In fact, I recommend always using an accessibility keyword to make the code easier to understand.)

The Private keyword sometimes causes confusion. A Private field is visible to any code in any instance of the same class, not just to the same instance of the class.

For example, suppose you build a Person class with a private field named Salary. Not only can all of the code in an instance see its own Salary value, but any Person object can see any other Person object's Salary value.

It's a good programming practice to restrict a field's scope and accessibility as much as possible to limit the code that can access it. For example, if a piece of code has no business using a form's field, there's no reason to give it the opportunity. This not only reduces the chances that you will use the variable incorrectly, but also removes the variable from IntelliSense so it's not there to clutter up your options and confuse things.

If you can use a variable declared locally inside an event handler or other method, do so. In fact, if you can declare a variable within a block of code inside a method, such as in an If Then statement, do so. That gives the variable very limited scope so it won't get in the way when you're working with unrelated code. It also keeps the variable's declaration closer to the code that uses it so it's easier to see the connection.

If you need multiple methods to share the same value or you need to preserve a value between method calls, use a private field. Only make a field public if code in another form (or other class) needs to use it.

In this Try It, you build the program shown in Figure 13-1. You use fields to allow two forms to communicate and to perform simple calculations. You also get to try out a new control: ListView.

Figure 13.1. FIGURE 13-1

Give the dialog the following features: