There are cases in which the complexity of software is just too much for a single person to grasp. System maintenance is becoming more important as software continues to evolve. Businesses depend on software for day-to-day work. The days of custom building monumental software systems are coming to an end, because such systems are impossible to maintain. The .NET Framework brings several languages and design tools together into a seamless whole so that people can focus on gathering the requirements for a system, building prototypes, and then completing their applications. The .NET Framework makes it possible to write huge Windows programs without needing a Windows API reference book handy. That is, essentially, the layman’s definition of .NET!

Microsoft, as well as many other software companies, has tried in earnest to come up with a standard for code reuse, such as the Component Object Model (COM). Microsoft’s COM pre-dates .NET. It allows developers to build custom user-interface controls and code component libraries that were reusable across many languages (such as Visual Basic and Borland Delphi—now owned by Embarcadero). The ability to write source code for a component using Visual Basic, and then reuse that component in Delphi was a significant step forward for software engineering. These two languages have very little in common! Visual Basic was originally based on the Basic language, while Delphi was based on Pascal. Many other products support COM as well, and this has only benefited their customers. The .NET Framework goes beyond COM by defining a standard collection of namespaces and classes for Windows development, and is similar to the C++ Standard Library.

The “engine” that works behind the scenes in a Visual Basic program interprets the Windows messaging system, which is how Windows tells your program when something happens to the user interface. The controls are part of theform and therefore have access to all of the messages that the operating system sends the program. For example, when you click a button on a form, Windows sends your program a special message that includes a header pointing to the form and the control that triggered the message. Visual Basic receives this special message from the operating system and routes it to the form containing the specific button that was clicked.

What happens at this point? The form engine—which is part of the runtime library (and also closely tied to the .NET Framework)—looks for a Click event for that button. If so, the event is called; otherwise, the message is discarded. From that point, it is up to you (the programmer) to decide what happens inside that event.

As you can imagine, there are thousands of messages streaming through the Windows operating system, which are being routed to operating system processes and running applications. Visual Basic handles all the details for you by breaking down the complexity into a number of events that are called automatically in your program through the common Windows Forms “engine” and .NET Framework. Visual Basic and Visual C# just tap into that engine.

Now it’s time to get down to business. Are you tired of theory already? I’m not! This stuff is fun. But theory means nothing without practice. I’ve watched a lot of Jackie Chan movies, but I still don’t know anything about Kung Fu. If you want to master something you have got to practice and start with the basics.

Start Visual Studio by opening Programs, Microsoft Visual Studio 2008, and then choose Microsoft Visual Studio 2008 from the list. The default Start Page should be the first thing that is displayed when Visual Studio starts running (shown in Figure 2.1). The Start Page shows all of the recent solutions that you have worked on (or it could be blank if this is the first time you have used it). There is a button on the Start Page called New Project that you will click in order to start a new project. If, for some reason, the Start Page does not show up by default when you run Visual Studio, just click the File menu at the top of the screen and select New, Project.

Figure 2.1. Start Page in Visual Studio 2008.

Using either method, the New Project dialog should appear. See Figure 2.2. Let’s dissect this New Project dialog before going any further. On the left side of the dialog is a list of Project Types, which will look different depending on the version of Visual Studio you are using. The version shown here is from Visual Studio 2008 Professional. If you are using the free version, Visual Basic 2008 Express, then you will see only Visual Basic project types. On the right side of the dialog is the list of Templates for each project type.

Figure 2.2. The Project Templates available in the New Project dialog.

You will notice that each language has its own set of icons for these templates, to make it easier to differentiate between them (usually when you have a large solution with multiple languages). Here is the list of templates for Visual Basic:

If you look at the top-right corner of the New Project dialog, you should see two small buttons that affect the layout of the items in the template list. You can switch between Large Icons and Small Icons by pressing either of these two buttons. The Small Icons view is sometimes more convenient because you can see more items in the list than you can when large icons are displayed. Regardless of the view you settle on, for this program you will want to select Console Application. Did you notice how the project name changed when you selected the Console Application template? The name was changed to ConsoleApplication1. Click on the Name field now and change the name of the program to Hello World or Greetings, as shown in Figure 2.3.

Figure 2.3. Choosing the Console Application project template.

The next thing that you might want to do is select where the new project files will be stored on your hard drive. Select the folder by typing it into the Location field or locate an existing folder using the Browse button. You can store the project anywhere you like, although it makes sense to organize your projects under a main folder. You are now ready to create the new project by pressing the OK button.

When you click OK to close the New Project dialog, Visual Studio creates a new solution and a new project for you, as shown in Figure 2.4. Because this is a console application, there’s no form or controls available in this program. What this means is that when you compile the program, you can run it from a Command Prompt. When you run the program from within Visual Studio, a new Command Prompt window automatically appears.

Figure 2.4. The new Console Application project is ready for your source code.

Now let’s add some code to make this program actually do something useful. This program needs to display a line of text and then wait for the user to press Enter to continue. Add the following two lines of code inside Sub Main:

Console.WriteLine("Welcome to Visual Basic!")
Console.ReadLine()

It should be pretty obvious that the first line displays the message “Welcome to Visual Basic!”, but what about the second line? ReadLine is a function that reads a line of characters from the keyboard and is ended with the Enter key.

So this means that you can type in a line of characters, and ReadLine will grab them out of the console. You can see what was typed in because ReadLine returns the characters as a string. In order to receive the string, you need to copy the value returned by ReadLine into a string variable.

Variables must be declared before they are used in Basic. To declare a new variable, you must use the Dim keyword, which is short for “dimension,” referring to the process of reserving memory for the new variable. The process no longer even remotely resembles the Basic language of old (from which Visual Basic was based), but Dim has been around for a long time now. As I mentioned a moment ago, ReadLine returns a string. So this program needs a string variable. Declare the variable like this:

Dim name As String

How about that? You can create any variable you need using Dim. Here is the rest of the source code for the Greeting program. Type the lines in bold between the two existing lines of the program.

Console.WriteLine("Welcome to Visual Basic!")
Console.Write("Please type your name: ")
Dim name As String
name = Console.ReadLine()
Console.WriteLine("Hello, {0}!", name)
Console.WriteLine()
Console.WriteLine("Press Enter to quit...")
Console.ReadLine()

After you have made the changes to the source code, the program should look like Figure 2.5. (The new lines have been highlighted in the code editor window.)

Figure 2.5. The new Greeting program in the Visual Basic editor.

After you type in the new code, save the project by clicking File, Save All (or click the Save All icon on the toolbar). Now go ahead and run the program by pressing F5. Figure 2.6 shows the output of the Greeting program.

Figure 2.6. The Greeting program uses console input/output.

There is one line of this program that displays the characters typed into the console (the user’s name), and it looks kind of funny:

Console.WriteLine("Hello, {0}!'', name)

It’s probably obvious to you what this line of code does from looking at the output, but how does it work? The curly braces surround a number that refers to the variable that follows. This is a feature of the WriteLine function. WriteLine allows you to display the contents of variables in whatever order you want. Just separate each variable by a comma and then refer to them as {0}, {1}, {2}, and so on.

Congratulations, you have successfully run your first Visual Basic program! This program might be simple, but it helped to show you some key features of the Basic language and gave you some experience creating new projects and working with the editor. You can now close the Greeting program by selecting File, Close Solution.

The Dim command is used to create new variables. The syntax of Dim looks like this:

Dim Variable_Name As Data_Type

Here’s an example of a real Dim statement:

Dim Counter As Integer

This statement creates an Integer variable, which is capable of holding a number that has no decimal point.

In addition to the Dim statement, there are two other ways to declare variables. The Public command causes a variable to be visible to other modules in the program, whereas the Private command prevents other modules from seeing a variable (and is the default when using Dim).

A data type is the attribute of a variable, which determines what kind of data it represents. There are many data types in Visual Basic, as shown in Table 2.1. I have rounded off the values in order to make them easier to comprehend. In my experience, the extreme range of a data type should not be an issue; just declare variables that are certain to be large enough to hold the value.

In actual practice, don’t be overly concerned about memory usage, just use the most obvious data type to handle the information it will need to remember. Most of the time, I use Integer, Double, or String, which keeps the code simple and gives programs plenty of room to breathe. If you feel comfortable using the more specific data types, by all means use them!

The String data type is the most frequently used type in Visual Basic and deserves special recognition. Without strings, Visual Basic would be hobbled by difficult string-handling functions. The String data type is versatile in that it can contain up to two billion characters. Although it is definitely a possibility, I have never personally seen a two-gigabyte text file! Humorous as that may sound, a string could conceivably grow to that size, although I suspect that Windows would run out of memory before the string was filled to capacity. Most strings rarely exceed a few hundred characters. The String data type requires two bytes for each character (because Visual Basic strings use Unicode to store characters). To create a new String, simply use the Dim statement (or the affiliated Public or Private statements):

Dim FirstName As String

Simple string handling can be accomplished by setting a string equal to a value or another variable. There are two ways to combine strings: using the plus sign (+), or using the ampersand sign (&). Prior versions of Visual Basic required the ampersand when combining strings, but Visual Basic can use either.

Dim String1 As String = "This is String1"
Dim String2 As String = " and this is String2."
Dim String3 As String
String3 = String1 + String2
Console.WriteLine("String3 = {0}", String3);

The result of this snippet of code looks like this:

String3 = This is String1 and this is String2.

We’re going to create a new Visual Basic project to display the current time by simulating a digital clock. First, create a new project as a Windows Forms Application, as shown in Figure 2.7. Set the Form1.Text property to “Digital Clock,” as this will be how we identify the program in the Windows Taskbar and Task Manager.

Figure 2.7. A new Windows Form project.

Next, open the Toolbox and double-click the Timer control to add one to our form, as shown in Figure 2.8. The Timer control is located in the Components group in the Toolbox. The new Timer control is automatically named Timer1.

Figure 2.8. Adding a Timer to the project.

Next, take a look at the properties for the Timer1 control. (If you don’t see the Properties window, press Alt+Enter to bring it up.) Set the Enabled property to True, and Interval to 100, as shown in Figure 2.9.

Figure 2.9. The Properties window is used to customize a control.

Label Control

Open the Toolbox again, and look in the Common Controls group for a control called Label—and double-click Label to add a new label to the form. New controls are automatically named, so this one will be called Label1. Set the following properties for Label1, after which the control will resemble the one in Figure 2.10.

Figure 2.10. The form now contains a Label with a big red font.

Dock	Fill
Font	Arial, 48pt, style=Bold
ForeColor	Red
TextAlign	MiddleCenter

Private Sub Timer1_Tick(ByVal sender As System.Object, _
    ByVal e As System.EventArgs) Handles Timer1.Tick
    REM get the time
    Dim time As String
    time = Format$(Now, "Long Time")
    REM display the time
    Label1.Text = time
End Sub

The most common branching statement used in programming languages is the If. . .Then statement, which is often called the If. . .Then. . .Else statement. Here is the general syntax of the de-facto logic statement as it is used in Visual Basic:

If "condition is true" Then
    "perform commands based on true result"
Else
    "perform commands based on false result"
End If

Figure 2.12 is an example of an If. . .Then. . .Else statement and shows how input is tested for a true or false condition, whereupon program execution continues down the chosen path.

Figure 2.12. Illustration of a branching statement showing how program logic works.

If "condition" Then "true statement" Else "false statement"

If HoursWorked > 40 Then
    PayRate = 1.5
Else
    PayRate = 1.0
End If

There are times when the If...Then statement is just too unwieldy, particularly when a large number of conditions must be tested. In such circumstances, the Select...Case statement is a good alternative. In fact, you may feel free to use this branching statement instead of If.. .Then at any time; it’s entirely up to you. Some prefer Select...Case because it is easier to add new cases to the condition in the future. I use it anytime there are more than two conditions to be tested. Here is the general format of the Select...Case statement:

Select Case "evaluation"
    Case value-1 [To value-2][, value-3]
        "perform condition-1 statements"
    Case value-1 [To value-2][, value-3]
        "perform condition-2 statements"
    Case value-1 [To value-2][, value-3]
        "perform condition-n statements"
    Case Else
        "perform alternate statements"
End Select

The Select...Case branching statement is versatile in that it is easy to add new cases (as you can see). It is also easier to read than in an If. . .Then statement when dealing with a lot of cases. To demonstrate how Select...Case works, let’s rewrite the previous If...Then code as a Select...Case.

Select Case HoursWorked
    Case Is > 40
        Console.WriteLine("You worked over time.")
    Case Is = 40
        Console.WriteLine ("You worked regular time.")
    Case Else
        Console.WriteLine ("You worked part time.")
End Select

If you type that Select...Case statement into Visual Basic, you will notice that the editor adds the word Is before each condition. For example, if you type Case > 40, the editor will fill in Case Is > 40. This is simply the syntax required in Select...Case statements for Boolean evaluations. If you need only compare a range of values or a single value, the Is isn’t needed. For example:

Select Case Mileage

    Case Is < 10
        Console.WriteLine ("The mileage is terrible.")
    Case 11, 12, 13, 14, 15
        Console.WriteLine ("The mileage is poor.")
    Case 16, 17, 18 To 20
        Console.WriteLine ("The mileage is average.")
    Case 21 To 30
        Console.WriteLine ("The mileage is good.")
    Case 31 To 50
        Console.WriteLine ("The mileage is great.")
    Case Is > 50
        Console.WriteLine ("The mileage is amazing!")
End Select

We’ll get some experience with conditional logic by making a simple but fun game. The Guessing Game project’s form is shown in Figure 2.13. There are just three controls on the form, which I will let you add on your own without any help. If you use default names for the controls, then the label will be called Label1, the textbox will be TextBox1, and the button will be Button1. You may position the controls on the form as you wish.

Figure 2.13. The Guessing Game form.

We need two global variables declared just below the “Windows Form Designer generated code” section.

REM declare the number variable
Dim answer As Integer
Dim rand As Random

Next, the Form_Load function, which is the first thing that runs when a program starts up:

Private Sub Form1_Load(ByVal sender As Object, _
    ByVal e As System.EventArgs) Handles MyBase.Load

    rand = New Random()
    answer = rand.Next(1, 100)

End Sub

Lastly, the Button1_Click function. To automatically generate this function, double-click the Button1 control on the form.

Private Sub Button1_Click(ByVal sender As System.Object, _
    ByVal e As System.EventArgs) Handles Button1.Click

    Dim num As Integer
    REM make sure the TextBox contains a number
    Try
        num = Integer.Parse(TextBox1.Text)
    Catch ex As Exception
        MessageBox.Show("Please enter a number between 1 and 100!")
        Exit Sub
    End Try

    REM make sure the number is between 1 and 10
    If num < 1 Or num > 100 Then
        MessageBox.Show("Please enter a number between 1 and 100!")
        Exit Sub
    End If
    REM check for high answer
    If num > answer Then
        MessageBox.Show("That number is too high")
    ElseIf num < answer Then
        MessageBox.Show("That number is too low")
    Else
        MessageBox.Show("That number is CORRECT!")

        End
    End If
End Sub

The conditional logic in this program tests the number entered into the textbox (when the button is pressed), and pops up a message box to tell the user whether the number is too low or too high. When the correct number is entered, then the program ends.

Basic supports two types of subroutines: Sub and Function. Here is the syntax for a Sub:

[Public/Private] Sub SubName([Parameters])
End Sub

Here is an example of a Sub that does not have a parameter:

Private Sub PrintHello()
    Console.WriteLine("Hello!")
End Sub

Here is an example of a Sub that includes a String parameter:

Private Sub PrintHello(Name As String)
    Console.WriteLine("Hello, " + Name.ToString() + "!")
End Sub

A Function is similar to a Sub, but a Function will return a value while a Sub does not. Here is the syntax for a Function:

[Public/Private] Function FunctionName([Parameters]) As DataType
End Function

Here is an example of a Function that does not have a parameter:

Private Function One() As Integer
      return 1
End Function

Strange as it may appear, this is a legal function! Do you see how the value is returned using the return statement? Note the As Integer part after the function name: this determines the type of value returned. Here is another example of a Function, this time with a parameter:

Private Function TimesTen(Num As Integer) As Integer
      return Num * 10
End Function

The TimesTen function is a little more interesting because you can have it return a value that is based on a parameter! The possibilities are utterly endless on what you can do with the power of subroutines. The return value of a function is determined by the data type of the function, which can be any data type that you use when creating variables, as well as custom data types that you create. Functions can also return an Object, which means that it can return any data type or even a user interface control (odd as that may sound).

Basic can perform number conversion on the fly using functions such as CInt(), based on the result of the operation. Technically, these numeric conversion functions are unique to Basic and not part of the .NET Framework, holdovers from Visual Basic 6.0 that are available via the Microsoft.VisualBasic namespace.

The other, and perhaps recommended way to convert data types is with the Convert class. Convert.ToInt32() and Convert.ToDouble() are common. In the code editor, typing Convert. will bring up the IntelliSense list of conversion functions available in the Convert class. For example:

Dim A As String = "10"
Dim B As Integer = CInt(A)

is equivalent to this:

Dim A As String = "10"
Dim B As Integer = Convert.ToInt32(A)

Since the Convert class is part of the .NET Framework, and therefore also likely to be used with the C# language, I recommend using it instead of the older intrinsic Basic conversion functions.

The plus sign and minus sign are used to add and subtract numbers. This includes variable assignment and formulas used in branching statements. Addition is commonly used to increment the value of a counter variable. For example:

Dim N As Integer = 0
N = N + 10

Note the use of an initializer for the variable, N. Although Visual Basic automatically sets numbers to zero upon initialization, it is sometimes convenient to include the explicit initializer. The second line, N = N + 10, is called a formula, because the variable is receiving the value of an addition operation. You could just as easily use a function to return a number that is assigned to the variable. For example:

Private Function Twelve() As Integer
    return 12
End Function


Dim N As Integer = 0
N = 10 + Twelve()

Visual Basic provides another way to add a number to a variable, called a shortcut operator, which looks like this: += and -=. Here is an example:

Dim N As Integer = 0
N += 10

Multiplication was invented to make adding and subtracting easier, because it allows you to add or subtract many numbers quite easily. Like most programming languages, Visual Basic uses the asterisk (*) for multiplication. Here is an example:

Dim A As Integer = 9
Dim B As Integer = 6
Console.WriteLine("{0} times {1} = {2}", A, B, A * B)

Here is what the Console message looks like:

9 times 6 = 54

As you might have guessed, there is also a shortcut operator for multiplication, and I’ll wager that you can guess what it looks like! If you guessed *=, then you are right!

Dim A As Integer = 12
A *= 12

How about a real-world example? The circumference of a circle is two times the radius times pi, or C = 2πr. Expressed in Visual Basic source code, here is how you can calculate it (note: the last line is a comment showing the result you should get by running this mini program):

Dim Radius As Integer = 10
Dim Circumference As Decimal
Circumference = 2 * System.Math.PI * Radius
Rem the answer is 62.8318530717959

Here is an example of integer division:

Dim A As Integer = 12
Dim B As Integer = 4
Dim C As Integer
C = A  B

There are two ways to divide numbers in Visual Basic. First, standard division uses the forward slash character (/). This is below the question mark on a U.S. keyboard. Second, the backslash character (), which is above the Enter key on a U.S. keyboard, is designed to return just an integer as an answer, dropping any remainder. Be sure to learn the difference between these characters, because the latter one doesn’t work for floating-point numbers (such as Decimal, Single, and Double). Use Table 2.2 as a reference.

Here is another example of a division operation, this time using a floating-point number:

Dim A As Decimal = 973.65
Dim B As Decimal = 18.50
Dim C As Decimal
C = A / B

Dim A As Integer = 10
Dim B As Integer = 3
Dim C As Integer
C = A Mod B

If A Mod B = 0 Then

If A Mod 2 = 0 Then
     Console.WriteLine("The variable is a whole number")
Else
   Console.WriteLine ("The variable is a floating-point number")
End If

The Math Quiz project demonstrates some of the math operators in the context of a little form-based quiz program. This program has a form with several Label controls, a TextBox, and two Buttons—see Figure 2.14 for the layout.

Figure 2.14. Control layout on the Math Quiz form.

I will let you design the form on your own using this figure as a guide. Figure 2.15 shows the controls as they appear in the example. Note that the “+” and “=” signs are just Labels as well, and both Label2 and Label3 have their BorderStyle property set to Fixed3D to give them a beveled look (similar to a TextBox).

Figure 2.15. Finished form for the Math Quiz program.

Here is the source code for the Math Quiz program, which should follow the “Windows Form Designer generated code” section in the source code listing.

Dim Answer As Integer
Private Sub Form1_Load(ByVal sender As System.Object, _
    ByVal e As System.EventArgs) Handles MyBase.Load
    REM seed the random number generator
    Randomize()
    REM initialize the game
    CreateMathProblem()
End Sub

Private Sub Button1_Click(ByVal sender As System.Object, _
    ByVal e As System.EventArgs) Handles Button1.Click
    REM make sure answer is a number
    If IsNumeric(TextBox1.Text) = False Then
        REM display error message
        MsgBox("Please enter a number.")
    Else
        REM check the answer
        If Val(TextBox1.Text) = Answer Then
            MsgBox("You got the answer right!", , "CORRECT")
        Else
            MsgBox("Oh no, you missed that one!", , "WRONG")
        End If
    End If
    REM create a new math problem
    CreateMathProblem()
    REM clear the answer field
    TextBox1.Text = ""
End Sub

Private Sub Button2_Click(ByVal sender As System.Object, _
    ByVal e As System.EventArgs) Handles Button2.Click
    REM quit button ends the program
    End
End Sub

Private Sub CreateMathProblem()
    Dim First As Integer
    Dim Second As Integer

    REM randomize the first field
    First = Int(Rnd() * 10)
    Label2.Text = First
    REM randomize the second field
    Second = Int(Rnd() * 10)
    Label3.Text = Second
    REM set the math operator and answer
    Select Case Int(Rnd() * 3)
        Case 0
            REM addition problem
            Label4.Text = "+"
            Answer = First + Second
        Case 1
            REM subtraction problem
            Label4.Text = "-"
            Answer = First - Second
        Case 2
            REM multiplication problem
            Label4.Text = "x"
            Answer = First * Second
    End Select
End Sub

The Visual Basic For Loop looks like this:

For variable = start To finish
    repeating commands
Next variable

The Do Loop is another form of looping command built into Visual Basic. Whereas For Loops are adept at handling number sequences, Do Loops excel when it comes to relational looping, in which a process will repeatedly loop until some Boolean condition is satisfied. There are four variations of the Do Loop.

The first form of the Do Loop is the Do While...Loop. This version causes the enclosed commands to repeat as long as the condition is true. You can paraphrase it like this: “While the condition is true, continue repeating the commands.” Because of this wording format, it’s possible that the repeating commands might never execute if the condition is false from the start. Here is the format for this version of the Do Loop:

Do While condition
    repeating commands
Loop

The Do While...Loop command is more versatile than the For Loop because you can have multiple conditions applied to the loop through every iteration. For example:

Do While EndOfFile = False
    'process the file
Loop

The Do...Loop While command is the reverse of the Do While...Loop command. The format of the condition and the way this loop handles repetition are similar, but there is one difference.

Here is the format of the command:

Do
     repeating commands
Loop While condition

The third type of Do Loop is the Do Until... Loop command. This one is also similar to the other Do Loops, but this format differs from the Do While...Loop in that it continues to repeat until the condition is met, rather than while the condition is met. It is the negative version of the Do Loop that continues as long as the condition is false. Here is the general format of the Do Until...Loop command:

Do Until condition
     repeating commands
Loop

The fourth version of the Do Loop is Do...Loop Until. This is the late conditional form of the Do Until...Loop, in which the condition is checked at the end of the loop rather than at the beginning. Therefore, this loop is guaranteed to process the repeating commands at least once.

Do
    repeating commands
Loop Until condition

Here is an example:

Do
    'process the file
Loop Until FileOpen = False

Encapsulation is the process of pulling all the data, and source code that manipulates that data, inside a self-contained entity (which is easier to refer to as just an object). By keeping all the data inside the object, as well as all the subroutines and functions that work with the data, you prevent others from using the data incorrectly. In addition, encapsulation enables you to design the format of the data, as well as the processes, so that everything follows the object model—if properly designed, it’s a blueprint for the system.

Suppose you have an apple tree in your backyard. You are a kindly neighbor; therefore, you offer free apples to anyone who comes by for a visit. Soon, however, your neighbors begin to help themselves to the apples without even bothering to knock on the door and say hello. They have ignored you completely and helped themselves to the goodies.

To prevent this, what you really need to do is add a layer of control between your neighbors and your apple tree—for instance, a fence with a locked gate. But ideally, you need to pass out the apples yourself. So you do just that; every time a neighbor stops by for an apple, you select a ripe and healthy apple and present it to your neighbor. The neighbor thanks you and goes on his way. You have interfered with the neighbor’s ability to gain direct access to the source of the apples, but in doing so, you made sure the neighbor received only good apples, because you threw out any bad apples beforehand.

This analogy aptly describes encapsulation of data. You want other processes in the program to have access to certain information, but you want to make sure that those processes don’t do something incorrect with the information, possibly causing a bug in the program. Does encapsulation limit or slow down a program? Not really. It takes the outside process just as much time to grab the information stored in a variable as it takes for your own custom process to provide the information to that outside process.

Let me give you an example to help clarify the matter. Figure 2.16 shows the difference between a procedural program (that exposes data and processes) and an object-oriented program (that protects data and processes).

Figure 2.16. Procedural versus object-oriented.

Inheritance is another key component of an OOP program. Inheritance is the ability of one object to borrow things from another object. Inheritance is a play on words; it is more like cloning than receiving money from a departed loved one. I suspect reproduction and cloning sounded too biological, so the word inheritance was used instead. Regardless, the concept is that one object receives the attributes of another object. When the new object is used, it has a copy of the older object inside itself, which is very similar to the way genetics works. The parent passes down genes to offspring. See Figure 2.17.

Figure 2.17. The Dog, Cat, and Bird classes all inherit data and processes from the Animal class.

Polymorphism is the last of the three concepts that comprise an OOP program. Polymorphism as a word means “many shapes” and refers to the ability for the traits inside an object to change in response to different inputs or outputs.

Polymorphism is probably not as important to the overall OOP scheme as encapsulation and inheritance are, but it does play an important role in aiding the other two with multipurpose attributes that can accommodate many different situations. Polymorphism is arguably the least important of the three major traits of an object-oriented program, but it does provide a powerful and useful set of features that are difficult to do without once you have gotten used to them.

Without getting into too much detail at this point, I’d like to show you how to start using OOP. The true power of OOP comes from using classes. A property is a special type of function that behaves like a variable, so you can read and write data to a property as if it were a variable—when, in fact, it is a miniature class that protects its data. Properties can be a very powerful form of encapsulation, allowing you to hide variables and processes behind a simple interface. Here is an example property:

Dim decCirc As Decimal
Property Circumference() As Decimal
    Get
        Return decCirc
    End Get
    Set(ByVal value As Decimal)

        decCirc = value
    End Set
End Property

Note the use of the statements Get and Set—they allow a property to be accessed like a variable. Then, in your program, you can set the Circumference property like this:

Circumference = 100.0

Or you can retrieve the value of the Circumference property like so:

Dim circ as decimal = Circumference

Classes make object-oriented programming possible. A class is a source code blueprint for an object that is created at runtime (when the program is running). An object is a self-contained, functional component in a program, which accomplishes a single task, regardless of whether that task is simple or complex. A well-designed OOP program will utilize many different and versatile objects that work together to accomplish the goals of the program. The real power of this is that over time a programmer (or programming team) will be able to use these objects in more than one project. A professional programming shop will have an assortment of classes collected over time in a class library. The class library may be comprised of many smaller libraries of classes.

Public Class MyClassName
    Private intVariable As Integer

    REM this is the constructor

    Sub New()
        intVariable = 0
    End Sub

    REM this is a property
    Property Variable() As Integer
        Get
            Return intVariable
        End Get
        Set(ByVal Value As Integer)
            intVariable = Value
        End Set
    End Property
End Class