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

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.

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) AsSingle
    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) AsSingle
    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.

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 MessageBoxclass.

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

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 Handleskeyword. 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.