Chapter 3: VB and C# Programming Basics

This is just a simple example to help you visualize what OOP is all about. In the next few sections, we’ll cover properties and methods in greater detail, and talk about classes and class instances, scope, events, and inheritance.

Properties

As we’ve seen, properties are characteristics shared by all objects of a particular class. In the case of our example, the following properties might be used to describe any given dog:

color

height

length

In the same way, the more useful ASP.NET Button class exposes properties including:

Width

Height

ID

Text

ForeColor

BackColor

Unfortunately for me, if I get sick of Rayne’s color, I can’t change it in real life. However, if Rayne was a .NET object, we could change any of his properties in the same way that we set variables (although a property can be read-only or writeonly). For instance, we could make him brown very easily:

Visual Basic

rayne.Color = "Brown"

C#

rayne.Color = "Brown";

80

Methods

In this example, we’re using an instance of our Dog class called rayne. We use the dot operator (.) to access the property Color that the object exposes and set it to the string "Brown."

Methods

With our dog example, we can make a particular dog do things by calling commands. If I want Rayne to sit, I tell him to sit. If I want Rayne to lie down, I tell him to lie down. In object oriented terms, I tell him what I want him to do by calling a predefined command or method, and an action results. For example, to make Rayne sit, we would use the following code to call his Sit method:

Visual Basic

rayne.Sit()

C#

rayne.Sit();

Given that rayne is an instance of our Dog class, we say that the Sit method is exposed by the Dog class.

Classes

You can think of a class as a template for building as many objects of a particular type as you like. When you create an instance of a class, you are creating an object of that class, and the new object has all the characteristics and behaviors (properties and methods) defined by the class.

In our dog example, rayne was an instance of the Dog class, as Figure 3.6 illustrated. In our code, we’d create a new instance of the Dog class called rayne, as shown below:

Visual Basic

Dim rayne As New Dog()

C#

Dog rayne = new Dog();

Constructors

Constructors are special kinds of method are that used to initialize the object. In OOP, when we create new instances of a class, we say we’re instantiating

81

Chapter 3: VB and C# Programming Basics

that class. The constructor is a method of a class that’s executed automatically when a class is instantiated.

At least one constructor will be defined for most of the classes you will write (though we can define more than one constructor for a class, as we’ll see shortly), since it’s likely that some data will need to be initialized for each class at creation time.

In C# and VB, the constructor is defined as a method that has the same name as the class, and has no return type.

Scope

You should now understand programming objects to be entities that exist in a program and are manipulated through the methods and properties they expose. However, in some cases, we want to create for use inside our class methods that are not available to code outside that class.

Imagine we’re writing the Sit method inside this class, and we realize that before the dog can sit, it has to shuffle its back paws forward a little (bear with me on this one!). We could create a method called ShufflePaws, then call that method from inside the Sit method. However, we don’t want code in an ASP.NET page or in some other class to call this method—it’d just be silly. We can prevent it by controlling the scope of the ShufflePaws method.

Carefully controlling which members of a class are accessible from outside that class is fundamental to the success of object oriented programming. You can control the visibility of a class member using a special set of keywords called access modifiers:

Public Defining a property or method of a class as public allows that property or method to be called from outside the class itself. In other words, if an instance of this class is created inside another object (remember, too, that ASP.NET pages themselves are objects), public methods and properties are freely available to the code that created that instance of the class. This is the default scope for VB and C# classes.

Private If a property or method of a class is private, it cannot be used from outside the class itself. So, if an instance of this class is created inside an object of a different class, the creating object has no access to private methods or properties of the created object.

82

Events

Protected A protected property or method sits somewhere between public and private. A protected member is accessible from the code within its class, or to the classes derived from it. We’ll learn more about derived classes a bit later.

Deciding which access modifier to use for a given class member can be a very difficult decision—it affects not only your class, but also the other classes and programs that use your class. Of special importance are the class’s public members, which together form the class’s public interface. The public interface acts like a contract between your class and the users of your class, and if it’s designed properly, it shouldn’t change over time. If, for example, you mark the Sit method as public, and later decide to make it private, all the other classes that use this method will have to change accordingly, which is not good. For an extreme scenario, imagine that in a year, Microsoft decided to remove the ToString method from its classes—obviously, this would wreak havoc with your code.

Keep Everything Private until you Need It

As a simple guideline for designing your classes, remember that it’s often easier just to make all the members private, and make public only those that really need to be public. It’s much easier to add to a public interface than it is to remove from it.

Events

We’ve covered events in some depth already. To sum up, events occur when a control object sends a message as a result of some change that has been made to it. Generally, these changes occur as the result of user interaction with the control via the browser. For instance, when a button is clicked, a Click event is raised, and we can handle that event to perform some action. The object that triggers the event is referred to as the event sender, while the object that receives the event is referred to as the event receiver. You’ll learn more about these objects in Chapter 4.

Understanding Inheritance

The term inheritance refers to the ability of a specialized class to refine the properties and methods exposed by another, more generalized class.

In our dog example, we created a class called Dog, then created instances of that class to represent individual dogs such as Rayne. However, dogs are types of animals, and many characteristics of dogs are shared by all (or most) animals. For

83