Home > Articles

  • Print
  • + Share This
This chapter is from the book

Classes

Classes are programming definitions of an object. For example, the definition for a clock would be as follows: contains a second, minute, and hour hand; chimes on the hour, every hour; and can be set to different times. Similarly, classes define objects by telling other code what the object contains and what it can do.

Classes are essential in object-oriented programming (as well as ASP.NET). You define a class to wrap up some common code and properties, just like combining clock parts to build a clock. In fact, the .NET Framework consists of many, many classes that define objects, although you haven't learned about all of them yet. When you use Response.Write, you're calling the Write subroutine of the Response object, which is defined by the Response class. Even more remarkable is that when you create ASP.NET pages, you're actually creating objects based on the Page class in the .NET framework.

TIP

Note that classes are definitions, while objects are actual, usable items that are based on those definitions. It's very helpful to make this distinction, although sometimes the terms are used interchangeably.

Everything in the .NET Framework and VB.NET is represented by classes, so it's important that you get used to referring to things that way.

So how do you create your own classes? The syntax is simple:

'VB.NET
Class name
  subroutines, functions, and properties
End Class

//C#
class name {
  subroutines, functions, and properties
}

The key to creating classes is combining common code. Listing 3.15 contains a simple example in VB.NET, using your clock. Listing 3.16 shows the C# version.

Listing 3.15 An ASP.NET Clock Class

1:  <%@ Page Language="VB" %>
2:
3:  <script runat="server">
4:    Class Clock
5:     public Second as integer
6:     public Minute as integer
7:     public Hour as integer
8:
9:     sub SetTime(intSec as integer, intMin as integer, _
10:       intHour as integer)
11:       Second = intSec
12:       Minute = intMin
13:       Hour = intHour
14:     end sub
15:    End Class
16:
17:    sub Page_Load(Sender as object, e as EventArgs)
18:     dim objClock as new Clock
19:
20:     objClock.Second = 60
21:
22:    end sub
23:
24:  </script>
25:
26:  <html><body>
27:
28:  </body></html>

Listing 3.16 An ASP.NET Clock Class in C#

1:  <%@ Page Language="C#" %>
2:  
3:  <script runat="server">
4:    class Clock {
5:     public int Second;
6:     public int Minute;
7:     public int Hour;
8:  
9:     void SetTime(int intSec, int intMin, int intHour) {
10:       Second = intSec;
11:       Minute = intMin;
12:       Hour = intHour;
13:     }
14:    }
15:    
16:    void Page_Load(Object Sender, EventArgs e) {
17:     Clock objClock = new Clock();
18:     
19:     objClock.Second = 60;
20:     
21:    }
22:  
23:  </script>
24:  
25:  <html><body>
26:    
27:  </body></html>

Any variables declared in a class, as done on lines 5–7, are known as properties of the class. This class contains a Second property, a Minute property, and an Hour property, as well as a subroutine to set the time. On line 20, you set the Second property of the class to 60.

The public keyword tells ASP.NET that this item can be seen and modified by any code, whether it's inside or outside the class. This is called a global variable. Conversely, if you use the keyword private, the variable or subroutine can be used only inside the class. This is useful for preventing other code from modifying variables that you depend on. That's beyond the scope of this lesson, however—see a guide to object-oriented programming for more details.

The SetTime method sets the second, minute, and hour properties of the class to the input parameters. In your ASP.NET page, you could do the following:

'VB.NET
Dim objClock as new Clock
objClock.SetTime(60,4,12)
objClock.Second = 59

//C#
Clock objClock = new Clock();
objClock.SetTime(60,4,12);
objClock.Second = 59;

The first line declares an objClock variable that is a data type based on the Clock class. Note that both versions use the new keyword, but the C# version uses an equal sign to initialize the object—we'll examine this more tomorrow. You can then set the properties or call the methods of that class by using the objClock variable, as shown on the second and third lines. By wrapping up common code such as you've done, you can think of programming as simply manipulating objects.

NOTE

You put your class inside the code declaration block here, but typically it would be in another file to make the code easier to read. For VB.NET classes, this file usually ends with the extension .vb, and for C#, .cs. You'll learn more on that on Day 15, "Using Business Objects."

What's with New?

The keyword new is very important—it's used to initialize a new object. For example, the following sets a variable to the Clock data type, but it doesn't initialize the variable (that is, it doesn't give the variable a value):

'VB.NET
dim objClock as Clock

//C#
Clock objClock

You can't yet use these variables because they don't have any values assigned to them. The new keyword gives a value to the variable. Using the new keyword is similar to saying this:

'VB.NET
dim intNumber as Integer = 7

//C#
int intNumber = 7

To initialize an object variable, you can also use the following in VB.NET, which more closely resembles the C# syntax:

dim objClock as Clock = New Clock

This is identical to simply using the new keyword.

Inheritance

Inheritance is an important part of classes and object-oriented programming. It won't be discussed thoroughly here, but you should know the basics for your ASP.NET pages.

Suppose you create a Clock class. Later on, you learn that you have two different types of clocks: analog and digital. Rather than throwing away your Clock class and creating two new ones, you can simply create the new classes based on the existing Clock. The original Clock contains properties and methods that are common to all clocks, so the new clocks can simply add any properties or methods they need. This is known as inheritance.

Inheritance saves a lot of headaches when you're developing. You don't have to create entirely new classes when there's a similar one that already does what you want. Let's look at an example that uses your original Clock:

'VB.NET
Class AnalogClock : Inherits Clock
  private ClockWound as Boolean = false
  sub WindClock()
   ClockWound = true
  end sub 
End Class

//C#
class AnalogClock : Clock {
  private bool ClockWound = false;
  void WindClock() {
   ClockWound = true;
  }
}

You've created a new class, AnalogClock, that inherits from the original Clock class. This new class automatically inherits the Second, Minute, and Hour properties and the SetTime method, so you don't need to re-create them here. You only need to add the items that are specific to this class—a Boolean value, ClockWound, and a method to wind the clock. Your ASP.NET page could now look like this:

dim objAnalogClock as new AnalogClock
objAnalogClock.SetTime(60, 4, 12)

objAnalogClock.WindClock

Along with inheritance comes the ability to override the parent's methods. If the SetTime method should be different for the AnalogClock for some reason, you can just provide a different method with the same name:

Class AnalogClock : Inherits Clock
  private ClockWound as Boolean = false
  sub WindClock()
   ClockWound = true
  end sub 
  sub SetTime(intSec as integer, intMin as integer, _
   intHour as integer)
   Second = intSec
   Minute = intMin
   Hour = intHour - 12
  end sub
End Class

objAnalogClock.SetTime will now use the modified subroutine.

Inheritance is a wonderful mechanism, but it's too complex to get into in this book. You'll use it in your ASP.NET pages, especially in code-behind forms, which are discussed on Day 19, "Separating Code from Content."

  • + Share This
  • 🔖 Save To Your Account