All objects have attributes used to specify and return the state of the object. These attributes are properties, and you've already used some of them in previous hours using the Properties window. Indeed, every object exposes a specific set of properties, but not every object exposes the same set of properties. To illustrate this point, I will continue with the Pet object concept. Suppose you have an object, and the object is a dog. This Dog object has a certain set of properties that are common to all dogs. These properties include attributes such as the dog's name, the color of its hair, and even the number of legs it has. All dogs have these same properties; however, different dogs have different values for these properties. Figure 3.1 illustrates such a Dog object and its properties.
Figure 3.1. Properties are the attributes that describe an object.
Getting and Setting Properties
You've already seen how to read and change properties using the Properties window. The Properties window is available only at design time, however, and is used only for manipulating the properties of forms and controls. Most reading and changing of properties you'll perform will be done with Visual Basic code, not by using the Properties window. When referencing properties in code, you specify the name of the object first, followed by a period (.), and then the property name, as in the following syntax:
If you had a Dog object named Bruno, for example, you would reference Bruno's hair color this way:
This line of code would return whatever value was contained in the HairColor property of the Dog object Bruno. To set a property to some value, you use an equal (=) sign. For example, to change the Dog object Bruno's Weight property, you'd use a line of code such as the following:
Bruno.Weight = 90
A little later in this hour, I discuss instantiation, which is the process of creating an object based on a template. It's important to note here that Bruno is a named instance of an object derived from a template (called a class). Each object instance has its own set of data, such as property values. For example, you could also have a Dog object named Bonnie, which has a unique set of properties. In a more real-world example, consider how you can have two buttons on a form. Although they have different property values (such as Name), and they have different code within their Click events, they are both Button objects.
When you reference a property on the left side of an equal sign, you're setting the value. When you reference a property on the right side of the equal sign, you're getting (reading) the value. In the early days of BASIC, you actually used the word Let when setting values. This made the code easier to read for novices, but it was unnecessarily tedious. Nevertheless, using Let makes the statement clearer, so I'll show the same code statement as before with the word Let:
Let Bruno.Weight = 90
It's easier to see here that referencing the property on the left side of the equal sign indicates that you are setting the property to some value. The keyword Let is no longer a valid way to make variable assignments. If you enter a code statement using Let, you won't receive an error, but the code editor will automatically remove the word Let from the statement.
The following line of code places the value of the Weight property of the Dog object called Bruno into a temporary variable. This statement retrieves the value of the Weight property because the Weight property is referenced on the right side of the equal sign.
sngWeightVariable = Bruno.Weight
Variables are discussed in detail in Hour 12, "Using Constants, Data Types, Variables, and Arrays." For now, think of a variable as a storage location. When the processor executes this code statement, it retrieves the value in the Weight property of the Dog object Bruno and places it in the variable (storage location) titled sngWeightVariable. Assuming that Bruno's Weight is 90, as set in the previous example, the computer would process the code statement as
sngWeightVariable = 90
Just as in real life, some properties can be read but not changed. Suppose you had a Sex property to designate the gender of a Dog object. It's impossible for you to change a dog from a male to a female or vice versa (at least I think it is). Because the Sex property can be retrieved but not changed, it is a read-only property. You'll often encounter properties that can be set in Design view but become read-only when the program is running.
One example of a read-only property is the Height property of the combo box control. Although you can view the value of the Height property in the Properties window, you cannot change the valueno matter how hard you try. If you attempt to change the Height property using Visual Basic code, Visual Basic simply changes the value back to the default.
The best way to determine which properties of an object are read-only is to consult the online help for the object in question.
Working with an Object and Its Properties
Now that you know what properties are and how they can be viewed and changed, you're going to experiment with properties in a simple project. In Hour 1, you learned how to set the Height and Width properties of a form using the Properties window. Now, you're going to change the same properties using Visual Basic code.
The project you're going to create consists of a form with some buttons on it. One button will enlarge the form when clicked, whereas the other will shrink the form. This is a very simple project, but it illustrates rather well how to change object properties in Visual Basic code.
Start by creating a new Windows Application project (from the File menu, choose New, Project).
Name the project Properties Example.
Use the Properties window to change the name of the form to fclsDrinkMe. Then, right-click the project in the Solution Explorer, select properties from its shortcut menu, and then change the Startup Object property to fclsDrinkMe.
Next, change the Text property of the form to Grow and Shrink.
When the project first runs, the default form will have a Height and Width as specified in the Properties window. You're going to add buttons to the form that a user can click to enlarge or shrink the form at runtime.
Add a new button to the form by double-clicking the Button tool in the toolbox. Set the new button's properties as follows:
Now for the Shrink button. Again, double-click the Button tool in the toolbox to create a new button on the form. Set this new button's properties as follows:
Your form should now look like the one in shown in Figure 3.2.
To complete the project, you need to add the small amount of Visual Basic code necessary to modify the form's Height and Width properties when the user clicks a button. Access the code for the Enlarge button now by double-clicking the Enlarge button. Type the following statement exactly as you see it here. Do not hit the Enter key or add a space after you've entered this text.
When you typed the period, or "dot," as it's called, a small drop-down list appeared, like the one shown in Figure 3.3. Visual Basic is smart enough to realize that Me represents the current form (more on this in a moment), and to aid you in writing code for the object, it gives you a drop-down list containing all the properties and methods of the form. This feature is called IntelliSense, and it is relatively new to Visual Basic. Now that Visual Basic .NET is fully object-oriented, you'll come to rely on IntelliSense drop-down lists in a big way; I think I'd rather dig ditches than program without them.
Figure 3.2. Each button is an object, as is the form the buttons sit on.
Figure 3.3. IntelliSense drop-down lists, or auto-completion drop-down lists, make coding dramatically easier.
Use the Backspace key to completely erase the code you just entered and enter the following code in its place (press Enter at the end of each line):
Me.Width = Me.Width + 20 Me.Height = Me.Height + 20
You're probably wondering what you have to do with the width and height of the form. Actually the word Me doesn't refer to a person, it refers to the object to which the code belongs (in this case, the form). Me is a reserved word; it's a word that you cannot use to name objects or variables because Visual Basic has a specific meaning for it. When writing code within a form module, as you are doing here, you should always use the Me reserved word rather than using the name of the form. Me is much shorter than using the full name of the current form, and it makes the code more portable (you can copy and paste the code into another form module and not have to change the form name to make the code work). Also, should you change the name of the form at any time in the future, you won't have to change references to the old name.
Me works only in object-based modules such as form modules; you can't use Me in a standard module, which you'll learn about in Hour 11, "Creating and Calling Code Procedures."
The code you've entered simply sets the Width and Height properties of the form to whatever the current value of the Width and Height properties happens to be, plus 20 pixels.
Redisplay the form designer by selecting the tab title Form1.vb [Design]; then double-click the Shrink button to access its Click event and add the following code:
Me.Width = Me.Width - 20 Me.Height = Me.Height - 20
This code is very similar to the code in the Enlarge_Click event, except that it reduces the Width and Height properties of the form by 20 pixels. Your screen should now look like Figure 3.4.
As you create projects, it's a very good idea to save frequently. Save your project now by clicking the Save All button on the toolbar.
Again, display the form designer by clicking the tab Form1.vb [Design]. Your Properties Example is now ready to be run! Press F5 to put the project in Run mode (see Figure 3.5).
Figure 3.4. The code you've entered should look exactly like this.
Figure 3.5. What you see is what you getthe form you created should look just as you designed it.
Click the Enlarge button a few times and notice how the form gets bigger. Next, click the Shrink button to make the form smaller. When you've clicked enough to satisfy your curiosity (or until you get bored), end the running program and return to Design mode by clicking the Stop Debugging button on the toolbar.