Defining a class is very simple. If we want to create a class named cStudent, we use this code (right column):

Public - No restrictions. The class declared with public keyword can be accessed from anywhere!!

What to put in the class? What can we do in a class... Well, we know that a class represents an entity. We can program our class such that it behaves just like the real life entity. This is done through properties, methods and events that we can create within our class...

Now let us first write a simple method in our class and use the class so that it can be clear what exactly we are doing and why are we doing so.

I am sure that you have got this feeling developed in your mind and heart that what we call a class is nothing but virtual representation of a real world entity. When we write student class, we are defining a student!! Once this definition is complete, we can create as many students as we want (instances of student class - objects) and program any scenario in which students are involved... Each student will have its own life!! (Perhaps God created us like this and we are nothing but instances of class Human.... Matrix!!)

If the concept is not crystal clear still, no problem, keep moving, you will understand... or contact me.. :)

We have just taught our student to laugh. But this is not the student, this is just a definition for student, that is, it just defines how a student should be. In other words, all students created using this definition will be capable of doing anything defined here (they may not do, but will be capable of doing).

Line 1: When we create a student object, we would definitely want to access it. How would you access the object as it will be created in memory? The answer is that we will access the object through a name (reference variable) which will actually be a pointer to the object. The first line tells VB.NET that we want our object variable to be able to point to an object of cStudent (note that there is no object instantiated till this point). objStudent1 is a variable which can point to an object of cStudent class and no other class (well, not exactly..... we will discuss this special case in next article).

Line 2: New keyword is very important in VB.NET. It is used to create an object (in memory) of the specified class (using a specified constructor, to be discussed later) and return its reference. In this line, new keyword creates an object of class cStudent and returns its reference (memory address) to objStudent1. We have already declared objStudent1 as a variable which can hold reference of type cStudent. Now we can access the object through the name/variable objStudent1. This is called instantiation.

NOTE: These two lines can be combined into one:

    Dim objStudent1 As New cStudent()

Line 3: In third line we are calling Laugh method of the object through our reference variable objStudent1. Remember this method is there in the object because it was defined in the class of which this object is an instance. Similarly we can access any member (property, method, etc.) defined in a class using object variable name (objStudent1 in this example) followed by a dot (.) and member name.

Line 4: Till this point, our reference variable objStudent1 holds reference of the object. This line assigns Nothing to objStudent1, that is, it makes it point to nothing!!! This makes our object inaccessible (can't access this object now as objStudent1 points to something else and no reference variable refers to this object) and such objects (which are of no use as we cannot access them) are removed from the memory automatically (that is a different story about Garbage Collection to be covered later...). It is a good practice to dereference the object after they have served their purpose so that they can be removed from the memory.

Write this code, run and see...

I am sure that now you have got the feeling of how things are happening, let us move further...

Properties

The solution is simple, we can create public variables in the class to store these properties of a student. 

See, I have used the prefix 'i' before the variable name. I use this to differentiate instance variables from other elements.

Our next step is to create a public property for Age:

Dim objStudent1 As New cStudent()
objStudent1.Age = 16
MsgBox("The present age is: " & objStudent1.Age)

A property has two parts: Get and Set.

The get part of a property is accessed when the value of property is read like in line 3 above. Therefore, we need to return a value (which we want our users to read) when get is invoked. In this case, we return the value of iAge.

Set part of the property is called when the user assigns some value to the property. The assigned value is passed to the Set code. Now see, we have decided to store the age in iAge variable. However, we do not want the users to set any age they want. Therefore, we have defined the criterion and applied it in the property. The value which users assign to the property is accessible to us through Value parameter. We can check the value and decide if we really want to assign it to iAge (as we have done above). This way we can maintain the integrity of our class.

One more thing. We have used Public and Private in our instance variable declaration to make it accessible or inaccessible to the code outside the class. Public and private are access types or access specifiers which define the scope of a variable. Please check the following to see the available access types and the scope defined for each one.

Private - available only to the code within our class
Friend - available only to the code within the project
Protected - available only to classes that inherit from our class
Public - available to code inside and outside our class or project
NOTE: See the diagram given above while discussing the scope of classes

Let's return back to properties. We have already learned how to create a property. What if you do not want the user to set or change a property but want to allow him/her to be able to get/see it. Yes, I am talking about readonly properties.

Please note in the above code that to make a property read only, we use the ReadOnly keyword in property declaration and remove the set part of the property (we do not need this anyway in a read only property).

Simple? Similarly, we can make a property write only by using the keyword WriteOnly instead of readonly and defining only the set portion.

If you have any questions or doubts  in this, mail me.

Now let us take one example. Suppose each student is evaluated on the basis of marks in VB, ASP and Java. To get or set these marks, we will have to create three private variables and three properties. Right?

Let us see a better way to do so. We will keep 3 variables to store the values (yes, we can use array also), however, we will define only one property to access these variables. But the problem is - how will we know which subject user wants to access? See the code:

I suppose code is quite self explanatory... Note that we have used a parameter (subj as string) to handle this case.

Private iMarksVB As Single
Private iMarksASP As Single
Private iMarksJava As Single

Public Property Marks(ByVal subj As String) As Single
    Get
        Select Case subj
            Case "VB"
                Return iMarksVB
            Case "ASP"
                Return iMarksASP
            Case "Java"
                Return iMarksJava
        End Select
    End Get

    Set(ByVal Value As Single)
        Select Case subj
            Case "VB"
                iMarksVB = Value
            Case "ASP"
                iMarksASP = Value
            Case "Java"
                iMarksJava = Value
        End Select
    End Set
End Property

To access this property, we will have to write something like this:
Line 1: Set Property - Marks
Line 2: Get Property - Marks

There is a problem in above code. User must know that there are three subjects (VB, ASP, Java) and must use strings to represent them. If the spelling or letter case is wrong, then? VB.NET provides a very beautiful construct to handle such cases and I like to use it as much as possible - Enumeration.

Have you ever noticed that while using the MsgBox function a list of all available buttons or icons appear automatically when you need to enter it? If not, then first of all do the following:

Open a project and write - Msgbox "something" - in it and then put a comma (,). Did you see a list of all available buttons.

Wouldn't it be nice if our class user gets a list like this (containing VB, ASP, Java, etc.) when he/she accesses the Marks property? And would you not like that when you are writing code for Get and Set, you also get the list while using Select Case statement?

This reduces chances of error many times and provides a quick and easy interface for us and our users to work.

Please see the code which demonstrates how to provide these features using enumeration.

In the code note the following things:

• Enumerations are created using the ENum keyword
• They can be used as type while declaring variables or parameters for methods or properties

Private iMarksVB As Single
Private iMarksASP As Single
Private iMarksJava As Single

Public Enum eMarks
    VB
    ASP
    Java
End Enum

Public Property Marks(ByVal subj As eMarks) As Single
    Get
        Select Case subj
            Case eMarks.VB
                Return iMarksVB
            Case eMarks.ASP
                Return iMarksASP
            Case eMarks.Java
                Return iMarksJava
        End Select
    End Get

    Set(ByVal Value As Single)
        Select Case subj
            Case eMarks.VB
                iMarksVB = Value
            Case eMarks.ASP
                iMarksASP = Value
            Case eMarks.Java
                iMarksJava = Value
        End Select
    End Set
End Property

Write this code and try it out yourself once...

Default Properties

We need to write the following to access Marks property:

objStudent1.Marks(cStudent.eMarks.VB)

If we make Marks property the default property, we will be able to access it like this:

objStudent1(cStudent.eMarks.VB)

Please note some obvious facts about properties:

• There can be only one default property in a class.
• Properties with no required parameters cannot be declared Default. Therefore, the property which we want to make default must have at least one parameter.

This was all about properties. Let us move to methods in detail now.

Note the keyword Public here. It is an access specifier. Public means that the scope of this method is public, that is, we can call it from anywhere. Private access type limits the scope to the class in which the method is defined and Friend limits the access to the project in which the method is defined. I hope this must be clear by now.

Methods can be of two types:

• Sub-routines: Methods which do not return any value; keyword used to define - Sub
• Functions: Methods that return some value; keyword used to define - Function

Note that we have used the keyword Function to define a function. The return type is specified in the definition itself. To return the result of the function, we use the Return keyword followed by the value we want to return.

Simple!! If you have any doubts, contact me.

Look at the function above. We have assumed that the maximum marks for each subject are 150. If we want to give the user a choice to specify the maximum marks and if the user does not want we want to use 150, then what is the solution? Solution is function with optional parameters. Check the code:

Note that in the code we have used an optional parameter MaxMarks. If a parameter is declared optional, the user may or may not enter a value for this. If the value is not specified by the user, default value is taken (150 in our case). It is compulsory to specify the default value for the optional parameters.

Class.SharedMember

An example of shared method is MessageBox.Show. Here, Show is the shared member of MessageBox class.

Now, how to define shared members. Very simple. Simply put the keyword 'Shared' after the access type while declaring variables, properties, methods and events.

I have not given any code example here because I am sure that you have already understood. However, if you want some example, please do not hesitate at all to contact me.

For more discussion, you may contact me friends... :)

To understand the application of this concept, let us assume that our class has a Save method which saves some data into a file. When the data is saved we want to notify our class user and allow him/her to perform further action, that is, write code which he/she wants to execute when data is saved. This gives our user great independence in performing whatever action he/she wants when data is saved, like simply showing a message box to the end-user or calling another method or copy the file in which data is saved for backup, etc.

Did you note that there are a number of actions which user might want to perform when data is saved (the list can go up to infinity). Therefore, we cannot assume while designing a class that what action our class user might want to perform on some particular event and so it is wise to expose an event for the user to handle in a way he/she desires.

To use this event, we need to do two things:

• Use WithEvents keyword while declaring the object of the class (we can instantiate the class in the same line using New keyword). See code...
• Make the object global, that is, declare the object outside our method directly within the class.

To write the code to handle the event, we have to write an event procedure. An event procedure is nothing but a method which is called when the event is fired. But how can we associate a method with an event. One way is using Handles keyword. This is the way the events are normally handled (our click event procedure also uses this way).

Just write the method which you want to execute when event fires. Just add Handles objectName.EventName at the end of method declaration to associate that method with the event. However, this method must have the same number and type of arguments as declared in the event which the method has to handle (if the event has arguments)...

If you want .NET IDE to automatically generate the method declaration, you can select the object from object list and then select the event from the event list, just as you do to write event procedure for other objects like button, textbox, etc.

Now, let us assume that we want to perform the same action when two different events occur. That is, we want to associate the same method with more than one events. Well, this can be done very easily in VB.NET. Just write all the events a method has to handle saparated with comma (,). Keep in mind that the rules of using Handles statement remain the same.

If we want a method handleIt() to handle two events Saved and Loaded of object objStident1, we will use this code.

In all the examples above, we have associated a method with some event at design time. There can be situations in which you do not know which method handles which event, or, you create an object at run time and want to associate one of its event with some method. How can this be done? Before explaining this let us consider another case to feel the need to associate at run time.

I have one application which loads the images from a folder at run time and shows them as thumbnails in picture boxes. When user clicks on any of the image a form opens with that particular image in full size. When the user clicks on this new form, the form unloads. Did you understand what I want to say?

Now what I do to show the full view is, I create a form at run time, add picture box to it and show the selected picture in it. Remember all this is done through code at runtime. Now how to associate the method to unload this form with Picturebox's click event...

This is what we are trying to see here. To associate an event with some method at run time, we use AddHandler statement. And to dissociate any event with its handler method at run time, we use RemoveHandler statement.

Suppose we have a method XYZ(). To associate this method with objStudent1 object's Saved method at run time, we will use the following code:

AddHandler objStudent1.Saved, AddressOf XYZ

and to dissociate, we will use following line:

RemoveHandler objStudent1.Saved, AddressOf XYZ

As you can see, the first parameter used above is the event name and second parameter is address of the method!! Simple??
Well, we cannot discuss AddressOf in this series in detail....

I hope that events are clear now, however, if you have any concerns or queries, you are always welcome to contact me and ask or discuss.